(2)Parallel Basisversion erstellt

CMakeLists.txt

@@ -19,6 +19,8 @@ set(SRC_FILES
         ${CMAKE_CURRENT_LIST_DIR}/src/main.cpp
         ${CMAKE_CURRENT_LIST_DIR}/src/gamecube.cpp
         src/gamematrix.cpp
+        parallel/parallel_measurements.cpp
+        parallel/matrizenmultiplikation.cpp
 )
 
 ##Tom: prev: ${CMAKE_CURRENT_LIST_DIR}/linux -> now /include
@@ -50,3 +52,4 @@ if (APPLE)
     target_link_libraries(Prog3B "-framework Cocoa")
     target_link_libraries(Prog3B "-framework OpenGL")
 endif()
+

parallel/matrizenmultiplikation.cpp

@@ -0,0 +1,91 @@
+#include <iostream>
+#include <vector>
+#include <chrono>
+#include <omp.h>
+
+
+// Funktion erzeugt zwei Matrizen A und B der Größe n x n mit Zufallswerten
+void generateRandomMatrices(int n,
+                            std::vector<std::vector<double>>& A,
+                            std::vector<std::vector<double>>& B,
+                            double min_val = 0.0,
+                            double max_val = 10.0)
+{
+    // Zufallsgenerator initialisieren
+    std::srand(static_cast<unsigned int>(std::time(nullptr)));
+
+    A.resize(n, std::vector<double>(n));
+    B.resize(n, std::vector<double>(n));
+
+    for (int i = 0; i < n; ++i)
+        for (int j = 0; j < n; ++j)
+        {
+            double r1 = static_cast<double>(std::rand()) / RAND_MAX; // 0..1
+            double r2 = static_cast<double>(std::rand()) / RAND_MAX; // 0..1
+            A[i][j] = min_val + r1 * (max_val - min_val);
+            B[i][j] = min_val + r2 * (max_val - min_val);
+        }
+}
+
+std::vector<std::vector<double>> matmul_serial(
+    const std::vector<std::vector<double>>& A,
+    const std::vector<std::vector<double>>& B)
+{
+    int n = A.size();
+    int m = B[0].size();
+    int p = B.size();
+
+    std::vector<std::vector<double>> C(n, std::vector<double>(m, 0.0));
+
+    for (int i = 0; i < n; ++i)
+        for (int j = 0; j < m; ++j)
+            for (int k = 0; k < p; ++k)
+                C[i][j] += A[i][k] * B[k][j];
+
+    return C;
+}
+
+std::vector<std::vector<double>> matmul_parallel(
+    const std::vector<std::vector<double>>& A,
+    const std::vector<std::vector<double>>& B)
+{
+    int n = A.size();
+    int m = B[0].size();
+    int p = B.size();
+
+    std::vector<std::vector<double>> C(n, std::vector<double>(m, 0.0));
+
+    #pragma omp parallel for
+    for (int i = 0; i < n; ++i)
+        for (int j = 0; j < m; ++j)
+            for (int k = 0; k < p; ++k)
+                C[i][j] += A[i][k] * B[k][j];
+
+    return C;
+}
+
+int main()
+{
+    int N = 500;
+
+    std::vector<std::vector<double>> A, B;
+    generateRandomMatrices(N, A, B);
+
+    // Serielle Version
+    auto start = std::chrono::high_resolution_clock::now();
+    auto C_serial = matmul_serial(A, B);
+    auto end = std::chrono::high_resolution_clock::now();
+    std::cout << "Serielle Laufzeit: "
+              << std::chrono::duration<double>(end - start).count()
+              << " Sekunden\n";
+
+    // Parallele Version
+    start = std::chrono::high_resolution_clock::now();
+    auto C_parallel = matmul_parallel(A, B);
+    end = std::chrono::high_resolution_clock::now();
+    std::cout << "Parallele Laufzeit: "
+              << std::chrono::duration<double>(end - start).count()
+              << " Sekunden\n";
+
+    return 0;
+}

parallel/parallel_measurements.cpp

@@ -0,0 +1,83 @@
+
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <thread>
+#include <chrono>
+#include <string>
+
+void readFile(const std::string& filename, std::vector<int>& data) {
+    std::ifstream file(filename);
+    if (!file) {
+        std::cerr << "Fehler: Datei '" << filename << "' konnte nicht geöffnet werden!\n";
+        return;
+    }
+    int v;
+    while (file >> v) data.push_back(v);
+}
+
+int countIncreasesSerial(const std::vector<int>& data) {
+    if (data.size() < 2) return 0;
+    int increases = 0;
+    for (size_t i = 1; i < data.size(); ++i)
+        if (data[i] > data[i - 1]) ++increases;
+    return increases;
+}
+
+int countIncreasesParallel(const std::vector<int>& messungen, int numThreads = 4) {
+    int totalComparisons = static_cast<int>(messungen.size()) - 1;
+    if (totalComparisons <= 0) return 0;
+
+    std::vector<int> results(numThreads, 0);
+    std::vector<std::thread> threads;
+    threads.reserve(numThreads);
+
+    int base = totalComparisons / numThreads;
+    int remainder  = totalComparisons % numThreads;
+
+    int idx = 1;
+    for (int t = 0; t < numThreads; t++) {
+        int startIdx = idx;
+        int count = base + (t < remainder ? 1 : 0);
+        int endIdx = idx + count - 1;
+        idx = endIdx + 1;
+
+        if (count <= 0) {
+            results[t] = 0;
+            continue;
+        }
+
+        threads.emplace_back([&, t, startIdx, endIdx]() {
+            int localCount = 0;
+            for (int i = startIdx; i <= endIdx; ++i)
+                if (messungen[i] > messungen[i - 1])
+                    ++localCount;
+            results[t] = localCount;
+        });
+    }
+
+    for (auto& th : threads) th.join();
+
+    int total = 0;
+    for (int r : results) total += r;
+    return total;
+}
+
+int main() {
+    std::vector<int> messungen;
+    readFile("parallel/measurements.txt", messungen);
+    std::cout << "Gelesene Werte: " << messungen.size() << "\n";
+
+    auto t0 = std::chrono::steady_clock::now();
+    int s = countIncreasesSerial(messungen);
+    auto t1 = std::chrono::steady_clock::now();
+
+    auto p0 = std::chrono::steady_clock::now();
+    int p = countIncreasesParallel(messungen, 4);
+    auto p1 = std::chrono::steady_clock::now();
+
+    std::cout << "Seriell:   " << s << "  Dauer: " << std::chrono::duration<double>(t1 - t0).count() << "s\n";
+    std::cout << "Parallel:  " << p << "  Dauer: " << std::chrono::duration<double>(p1 - p0).count() << "s\n";
+
+    return 0;
+}