create-pl1-omp 0.0.0-stage → 1.0.0

package/PL1/PL1.c

@@ -0,0 +1,87 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <omp.h>
+#include <time.h>
+
+#define MIN_SIZE 1000
+
+void merge(int arr[], int left, int mid, int right) {
+    int i, j, k;
+    int n1 = mid - left + 1;
+    int n2 = right - mid;
+    int *L = (int *)malloc(n1 * sizeof(int));
+    int *R = (int *)malloc(n2 * sizeof(int));
+
+    for (i = 0; i < n1; i++) L[i] = arr[left + i];
+    for (j = 0; j < n2; j++) R[j] = arr[mid + 1 + j];
+
+    i = 0; j = 0; k = left;
+    while (i < n1 && j < n2) {
+        if (L[i] <= R[j]) arr[k++] = L[i++];
+        else arr[k++] = R[j++];
+    }
+    while (i < n1) arr[k++] = L[i++];
+    while (j < n2) arr[k++] = R[j++];
+    free(L);
+    free(R);
+}
+
+void mergeSortSequential(int arr[], int left, int right) {
+    if (left < right) {
+        int mid = left + (right - left) / 2;
+        mergeSortSequential(arr, left, mid);
+        mergeSortSequential(arr, mid + 1, right);
+        merge(arr, left, mid, right);
+    }
+}
+
+void mergeSortParallel(int arr[], int left, int right) {
+    if ((right - left + 1) <= MIN_SIZE) {
+        mergeSortSequential(arr, left, right);
+        return;
+    }
+    if (left < right) {
+        int mid = left + (right - left) / 2;
+        #pragma omp parallel sections
+        {
+            #pragma omp section
+            { mergeSortParallel(arr, left, mid); }
+            #pragma omp section
+            { mergeSortParallel(arr, mid + 1, right); }
+        }
+        merge(arr, left, mid, right);
+    }
+}
+
+int main() {
+    int n = 100000;
+    int *arr_seq = (int *)malloc(n * sizeof(int));
+    int *arr_par = (int *)malloc(n * sizeof(int));
+
+    srand(time(0));
+    for (int i = 0; i < n; i++) {
+        arr_par[i] = arr_seq[i] = rand() % 10000;
+    }
+
+    printf("Sorting %d elements...\n\n", n);
+    double start_time = omp_get_wtime();
+    mergeSortSequential(arr_seq, 0, n - 1);
+    double time_seq = omp_get_wtime() - start_time;
+    printf("Sequential Merge Sort Time: %f seconds\n", time_seq);
+
+    start_time = omp_get_wtime();
+    mergeSortParallel(arr_par, 0, n - 1);
+    double time_par = omp_get_wtime() - start_time;
+    printf("Parallel Merge Sort Time:   %f seconds\n", time_par);
+    
+    printf("\nDifference (Sequential - Parallel): %f seconds\n", time_seq - time_par);
+    if (time_par > 0) printf("Speedup: %.2fx\n", time_seq / time_par);
+
+    printf("\nVerification: First 20 elements of the sorted array:\n");
+    for (int i = 0; i < (n < 20 ? n : 20); i++) printf("%d ", arr_par[i]);
+    printf("\n");
+
+    free(arr_seq);
+    free(arr_par);
+    return 0;
+}

package/index.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const fs = require('fs-extra');
+const prompts = require('prompts');
+
+async function run() {
+  const response = await prompts({
+    type: 'select',
+    name: 'program',
+    message: 'Select the lab program to generate:',
+    choices: [
+      { title: 'PL1 - Parallel Merge Sort (OpenMP)', value: 'PL1' }
+      // We will add PL2, PL3, etc. here one by one
+    ],
+    initial: 0,
+  });
+
+  if (!response.program) {
+    console.log('Action cancelled.');
+    return;
+  }
+
+  const targetDir = process.cwd();
+  const templateBase = path.join(__dirname, 'template');
+
+  const srcFolder = path.join(templateBase, response.program);
+  const destFolder = path.join(targetDir, response.program);
+
+  try {
+    await fs.copy(srcFolder, destFolder, { overwrite: true });
+    console.log(`\n✅ Generated folder: ./${response.program}/`);
+    console.log(`\nTo run it:`);
+    console.log(`  cd ${response.program}`);
+    console.log(`  gcc -fopenmp ${response.program}.c -o ${response.program}`);
+    console.log(`  ./${response.program}\n`);
+  } catch (err) {
+    console.error('❌ Failed to copy template folder:', err);
+    process.exit(1);
+  }
+}
+
+run();

package/package.json

@@ -1,6 +1,15 @@
 {
   "name": "create-pl1-omp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "description": "Scaffolds OpenMP lab programs",
+  "main": "index.js",
+  "bin": {
+    "create-pl1-omp": "./index.js"
+  },
+  "keywords": ["create", "openmp", "lab"],
+  "license": "MIT",
+  "dependencies": {
+    "fs-extra": "^11.2.0",
+    "prompts": "^2.4.2"
+  }
 }

package/template/PL1/PL1.c

@@ -0,0 +1,87 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <omp.h>
+#include <time.h>
+
+#define MIN_SIZE 1000
+
+void merge(int arr[], int left, int mid, int right) {
+    int i, j, k;
+    int n1 = mid - left + 1;
+    int n2 = right - mid;
+    int *L = (int *)malloc(n1 * sizeof(int));
+    int *R = (int *)malloc(n2 * sizeof(int));
+
+    for (i = 0; i < n1; i++) L[i] = arr[left + i];
+    for (j = 0; j < n2; j++) R[j] = arr[mid + 1 + j];
+
+    i = 0; j = 0; k = left;
+    while (i < n1 && j < n2) {
+        if (L[i] <= R[j]) arr[k++] = L[i++];
+        else arr[k++] = R[j++];
+    }
+    while (i < n1) arr[k++] = L[i++];
+    while (j < n2) arr[k++] = R[j++];
+    free(L);
+    free(R);
+}
+
+void mergeSortSequential(int arr[], int left, int right) {
+    if (left < right) {
+        int mid = left + (right - left) / 2;
+        mergeSortSequential(arr, left, mid);
+        mergeSortSequential(arr, mid + 1, right);
+        merge(arr, left, mid, right);
+    }
+}
+
+void mergeSortParallel(int arr[], int left, int right) {
+    if ((right - left + 1) <= MIN_SIZE) {
+        mergeSortSequential(arr, left, right);
+        return;
+    }
+    if (left < right) {
+        int mid = left + (right - left) / 2;
+        #pragma omp parallel sections
+        {
+            #pragma omp section
+            { mergeSortParallel(arr, left, mid); }
+            #pragma omp section
+            { mergeSortParallel(arr, mid + 1, right); }
+        }
+        merge(arr, left, mid, right);
+    }
+}
+
+int main() {
+    int n = 100000;
+    int *arr_seq = (int *)malloc(n * sizeof(int));
+    int *arr_par = (int *)malloc(n * sizeof(int));
+
+    srand(time(0));
+    for (int i = 0; i < n; i++) {
+        arr_par[i] = arr_seq[i] = rand() % 10000;
+    }
+
+    printf("Sorting %d elements...\n\n", n);
+    double start_time = omp_get_wtime();
+    mergeSortSequential(arr_seq, 0, n - 1);
+    double time_seq = omp_get_wtime() - start_time;
+    printf("Sequential Merge Sort Time: %f seconds\n", time_seq);
+
+    start_time = omp_get_wtime();
+    mergeSortParallel(arr_par, 0, n - 1);
+    double time_par = omp_get_wtime() - start_time;
+    printf("Parallel Merge Sort Time:   %f seconds\n", time_par);
+    
+    printf("\nDifference (Sequential - Parallel): %f seconds\n", time_seq - time_par);
+    if (time_par > 0) printf("Speedup: %.2fx\n", time_seq / time_par);
+
+    printf("\nVerification: First 20 elements of the sorted array:\n");
+    for (int i = 0; i < (n < 20 ? n : 20); i++) printf("%d ", arr_par[i]);
+    printf("\n");
+
+    free(arr_seq);
+    free(arr_par);
+    return 0;
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.