Add files via upload

Author: gauravgorane

add.cu

@@ -0,0 +1,52 @@
+#include <iostream>
+#include <vector>
+#include <cuda.h>
+
+// CUDA Kernel for vector addition
+__global__ void vectorAdd(float *A, float *B, float *C, int n) {
+    int id = blockIdx.x * blockDim.x + threadIdx.x;
+    if (id < n) C[id] = A[id] + B[id];
+}
+
+int main() {
+    int n;
+    std::cout << "Enter the number of elements: ";
+    std::cin >> n;
+
+    // Allocate host memory
+    std::vector<float> h_A(n), h_B(n), h_C(n);
+
+    // Take user inputs for vectors
+    std::cout << "Enter elements for vector A:\n";
+    for (int i = 0; i < n; i++) std::cin >> h_A[i];
+    std::cout << "Enter elements for vector B:\n";
+    for (int i = 0; i < n; i++) std::cin >> h_B[i];
+
+    // Allocate device memory
+    float *d_A, *d_B, *d_C;
+    cudaMalloc(&d_A, n * sizeof(float));
+    cudaMalloc(&d_B, n * sizeof(float));
+    cudaMalloc(&d_C, n * sizeof(float));
+
+    // Copy data to device
+    cudaMemcpy(d_A, h_A.data(), n * sizeof(float), cudaMemcpyHostToDevice);
+    cudaMemcpy(d_B, h_B.data(), n * sizeof(float), cudaMemcpyHostToDevice);
+
+    // Launch kernel
+    vectorAdd<<<(n + 255) / 256, 256>>>(d_A, d_B, d_C, n);
+
+    // Copy result back
+    cudaMemcpy(h_C.data(), d_C, n * sizeof(float), cudaMemcpyDeviceToHost);
+
+    // Print the result
+    std::cout << "Result vector C:\n";
+    for (int i = 0; i < n; i++) std::cout << h_C[i] << " ";
+    std::cout << "\n";
+
+    // Free memory
+    cudaFree(d_A);
+    cudaFree(d_B);
+    cudaFree(d_C);
+
+    return 0;
+}

bfsdfs.cpp

@@ -0,0 +1,105 @@
+#include <iostream>
+#include <vector>
+#include <queue>
+#include <stack>
+#include <omp.h>
+
+using namespace std;
+
+void parallelBFS(const vector<vector<int>>& graph, int startNode) {
+    int n = graph.size();
+    vector<bool> visited(n, false);
+    queue<int> q;
+    
+    q.push(startNode);
+    visited[startNode] = true;
+    
+    cout << "\nParallel BFS: ";
+    while (!q.empty()) {
+        int node = q.front();
+        q.pop();
+        cout << node << " ";
+        
+        #pragma omp parallel for
+        for (int i = 0; i < graph[node].size(); ++i) {
+            int neighbor = graph[node][i];
+            if (!visited[neighbor]) {
+                #pragma omp critical
+                {
+                    if (!visited[neighbor]) {
+                        visited[neighbor] = true;
+                        q.push(neighbor);
+                    }
+                }
+            }
+        }
+    }
+    cout << endl;
+}
+
+void parallelDFS(const vector<vector<int>>& graph, int startNode) {
+    int n = graph.size();
+    vector<bool> visited(n, false);
+    stack<int> s;
+    
+    s.push(startNode);
+    visited[startNode] = true;
+    
+    cout << "\nParallel DFS: ";
+    while (!s.empty()) {
+        int node = s.top();
+        s.pop();
+        cout << node << " ";
+        
+        #pragma omp parallel for
+        for (int i = 0; i < graph[node].size(); ++i) {
+            int neighbor = graph[node][i];
+            if (!visited[neighbor]) {
+                #pragma omp critical
+                {
+                    if (!visited[neighbor]) {
+                        visited[neighbor] = true;
+                        s.push(neighbor);
+                    }
+                }
+            }
+        }
+    }
+    cout << endl;
+}
+
+int main() {
+    int n, m;
+    cout << "Enter the number of nodes: ";
+    cin >> n;
+    cout << "Enter the number of edges: ";
+    cin >> m;
+    
+    vector<vector<int>> graph(n);
+    cout << "Enter the edges (node1 node2):\n";
+    for (int i = 0; i < m; ++i) {
+        int u, v;
+        cin >> u >> v;
+        graph[u].push_back(v);
+        graph[v].push_back(u); // For undirected graph
+    }
+    
+    int startNode;
+    cout << "Enter the start node for BFS and DFS: ";
+    cin >> startNode;
+    
+    parallelBFS(graph, startNode);
+    parallelDFS(graph, startNode);
+    
+    return 0;
+}
+
+// 5
+// 4
+// 0 1
+// 0 2
+// 1 3
+// 1 4
+// 0
+// Parallel BFS: 0 1 2 3 4 
+// Parallel DFS: 0 2 1 4 3 

boston.csv

@@ -0,0 +1,165 @@
+#include <iostream>
+#include <vector>
+#include <omp.h>
+#include <chrono>
+#include <cstdlib>
+
+using namespace std;
+using namespace std::chrono;
+
+// Sequential Bubble Sort
+void bubbleSortSequential(vector<int> &arr)
+{
+    int n = arr.size();
+    for (int i = 0; i < n - 1; i++)
+    {
+        for (int j = 0; j < n - i - 1; j++)
+        {
+            if (arr[j] > arr[j + 1])
+            {
+                swap(arr[j], arr[j + 1]);
+            }
+        }
+    }
+}
+
+// Parallel Bubble Sort using OpenMP
+void bubbleSortParallel(vector<int> &arr)
+{
+    int n = arr.size();
+#pragma omp parallel for
+    for (int i = 0; i < n - 1; i++)
+    {
+        for (int j = 0; j < n - i - 1; j++)
+        {
+            if (arr[j] > arr[j + 1])
+            {
+                swap(arr[j], arr[j + 1]);
+            }
+        }
+    }
+}
+
+// Merge function for Merge Sort
+void merge(vector<int> &arr, int left, int mid, int right)
+{
+    int n1 = mid - left + 1;
+    int n2 = right - mid;
+
+    vector<int> L(n1), R(n2);
+
+    for (int i = 0; i < n1; i++)
+        L[i] = arr[left + i];
+    for (int i = 0; i < n2; i++)
+        R[i] = arr[mid + 1 + i];
+
+    int 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++];
+}
+
+// Sequential Merge Sort
+void mergeSortSequential(vector<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);
+    }
+}
+
+// Parallel Merge Sort using OpenMP
+void mergeSortParallel(vector<int> &arr, int left, int right)
+{
+    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);
+    }
+}
+
+// Generate a random array of a given size
+vector<int> generateRandomArray(int size)
+{
+    vector<int> arr(size);
+    for (int i = 0; i < size; i++)
+        arr[i] = rand() % 100000;
+    return arr;
+}
+
+int main()
+{
+    srand(time(0));
+
+    // int arraySize = 100;
+    // vector<int> arr = generateRandomArray(arraySize);
+
+    int arraySize = 7;
+    vector<int> arr = {2, 6, 7, 32, 3, 1, 9};
+    for (int i = 0; i < arraySize; i++)
+    {
+        cout << arr[i] << " ";
+    }
+    cout << endl;
+
+    // Time Sequential Bubble Sort
+    vector<int> arrCopy = arr;
+    auto start = high_resolution_clock::now();
+    bubbleSortSequential(arrCopy);
+    auto stop = high_resolution_clock::now();
+    auto duration = duration_cast<microseconds>(stop - start);
+    cout << "Sequential Bubble Sort: " << duration.count() << " microseconds" << endl;
+
+    // Time Parallel Bubble Sort
+    arrCopy = arr;
+    start = high_resolution_clock::now();
+    bubbleSortParallel(arrCopy);
+    stop = high_resolution_clock::now();
+    duration = duration_cast<microseconds>(stop - start);
+    cout << "Parallel Bubble Sort: " << duration.count() << " microseconds" << endl;
+
+    // Time Sequential Merge Sort
+    arrCopy = arr;
+    start = high_resolution_clock::now();
+    mergeSortSequential(arrCopy, 0, arrCopy.size() - 1);
+    stop = high_resolution_clock::now();
+    duration = duration_cast<microseconds>(stop - start);
+    cout << "Sequential Merge Sort: " << duration.count() << " microseconds" << endl;
+
+    // Time Parallel Merge Sort
+    arrCopy = arr;
+    start = high_resolution_clock::now();
+    mergeSortParallel(arrCopy, 0, arrCopy.size() - 1);
+    stop = high_resolution_clock::now();
+    duration = duration_cast<microseconds>(stop - start);
+    cout << "Parallel Merge Sort: " << duration.count() << " microseconds" << endl;
+
+    for (int i = 0; i < arraySize; i++)
+    {
+        cout << arrCopy[i] << " ";
+    }
+    cout << endl;
+
+    return 0;
+}