Upload New File

pthwithcuda/utils/performancetest.cpp

+#include "performancetest.h"
+#include <iostream>
+
+PerformanceTest::PerformanceTest() {}
+
+// Bestehende Implementierungen für CPU und OpenMP
+
+double PerformanceTest::runSingleTest(Dijkstra* algorithm, int graphSize) {
+    // Graph generieren
+    auto graph = graphGenerator.generateRandomGraph(graphSize);
+
+    // Startknoten festlegen
+    int src = 0;
+
+    // Zeit messen
+    auto start = std::chrono::high_resolution_clock::now();
+
+    // Algorithmus ausführen
+    algorithm->run(graph, src);
+
+    auto end = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = end - start;
+
+    return elapsed.count();
+}
+
+double PerformanceTest::runSingleTest(AStar* algorithm, int graphSize) {
+    // Graph und Heuristik generieren
+    auto graph = graphGenerator.generateRandomGraph(graphSize);
+    auto heuristic = graphGenerator.generateHeuristic(graphSize);
+
+    // Start- und Zielknoten festlegen
+    int start = 0;
+    int goal = graphSize - 1;
+
+    // Zeit messen
+    auto startTime = std::chrono::high_resolution_clock::now();
+
+    // Algorithmus ausführen
+    algorithm->run(graph, heuristic, start, goal);
+
+    auto endTime = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = endTime - startTime;
+
+    return elapsed.count();
+}
+
+double PerformanceTest::runSingleTest(ALT* algorithm, int graphSize) {
+    // Graph generieren
+    auto graph = graphGenerator.generateRandomGraph(graphSize);
+
+    // Start- und Zielknoten festlegen
+    int start = 0;
+    int goal = graphSize - 1;
+
+    // Zeit messen
+    auto startTime = std::chrono::high_resolution_clock::now();
+
+    // Algorithmus ausführen
+    algorithm->run(graph, start, goal);
+
+    auto endTime = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = endTime - startTime;
+
+    return elapsed.count();
+}
+
+double PerformanceTest::runSingleTestWithNodes(Dijkstra* algorithm, int graphSize, int start, int goal) {
+    // Graph generieren
+    auto graph = graphGenerator.generateRandomGraph(graphSize);
+
+    // Zeit messen
+    auto startTime = std::chrono::high_resolution_clock::now();
+
+    // Algorithmus ausführen
+    algorithm->run(graph, start);
+
+    auto endTime = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = endTime - startTime;
+
+    return elapsed.count();
+}
+
+double PerformanceTest::runSingleTestWithNodes(AStar* algorithm, int graphSize, int start, int goal) {
+    // Graph und Heuristik generieren
+    auto graph = graphGenerator.generateRandomGraph(graphSize);
+    auto heuristic = graphGenerator.generateHeuristic(graphSize);
+
+    // Zeit messen
+    auto startTime = std::chrono::high_resolution_clock::now();
+
+    // Algorithmus ausführen
+    algorithm->run(graph, heuristic, start, goal);
+
+    auto endTime = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = endTime - startTime;
+
+    return elapsed.count();
+}
+
+double PerformanceTest::runSingleTestWithNodes(ALT* algorithm, int graphSize, int start, int goal) {
+    // Graph generieren
+    auto graph = graphGenerator.generateRandomGraph(graphSize);
+
+    // Zeit messen
+    auto startTime = std::chrono::high_resolution_clock::now();
+
+    // Algorithmus ausführen
+    algorithm->run(graph, start, goal);
+
+    auto endTime = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = endTime - startTime;
+
+    return elapsed.count();
+}
+
+// Neue Implementierungen für CUDA
+
+double PerformanceTest::runSingleTestCUDA(DijkstraCUDA* algorithm, int graphSize) {
+    // Graph generieren
+    auto graph = graphGenerator.generateRandomGraph(graphSize);
+
+    // Startknoten festlegen
+    int src = 0;
+
+    // Zeit messen
+    auto start = std::chrono::high_resolution_clock::now();
+
+    // Algorithmus ausführen
+    algorithm->run(graph, src);
+
+    auto end = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = end - start;
+
+    return elapsed.count();
+}
+
+double PerformanceTest::runSingleTestCUDA(AStarCUDA* algorithm, int graphSize) {
+    // Graph und Heuristik generieren
+    auto graph = graphGenerator.generateRandomGraph(graphSize);
+    auto heuristic = graphGenerator.generateHeuristic(graphSize);
+
+    // Start- und Zielknoten festlegen
+    int start = 0;
+    int goal = graphSize - 1;
+
+    // Zeit messen
+    auto startTime = std::chrono::high_resolution_clock::now();
+
+    // Algorithmus ausführen
+    algorithm->run(graph, heuristic, start, goal);
+
+    auto endTime = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = endTime - startTime;
+
+    return elapsed.count();
+}
+
+double PerformanceTest::runSingleTestCUDA(ALTCUDA* algorithm, int graphSize) {
+    // Graph generieren
+    auto graph = graphGenerator.generateRandomGraph(graphSize);
+
+    // Start- und Zielknoten festlegen
+    int start = 0;
+    int goal = graphSize - 1;
+
+    // Zeit messen
+    auto startTime = std::chrono::high_resolution_clock::now();
+
+    // Algorithmus ausführen
+    algorithm->run(graph, start, goal);
+
+    auto endTime = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = endTime - startTime;
+
+    return elapsed.count();
+}
+
+double PerformanceTest::runSingleTestWithNodesCUDA(DijkstraCUDA* algorithm, int graphSize, int start, int goal) {
+    // Graph generieren
+    auto graph = graphGenerator.generateRandomGraph(graphSize);
+
+    // Zeit messen
+    auto startTime = std::chrono::high_resolution_clock::now();
+
+    // Algorithmus ausführen
+    algorithm->run(graph, start);
+
+    auto endTime = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = endTime - startTime;
+
+    return elapsed.count();
+}
+
+double PerformanceTest::runSingleTestWithNodesCUDA(AStarCUDA* algorithm, int graphSize, int start, int goal) {
+    // Graph und Heuristik generieren
+    auto graph = graphGenerator.generateRandomGraph(graphSize);
+    auto heuristic = graphGenerator.generateHeuristic(graphSize);
+
+    // Zeit messen
+    auto startTime = std::chrono::high_resolution_clock::now();
+
+    // Algorithmus ausführen
+    algorithm->run(graph, heuristic, start, goal);
+
+    auto endTime = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = endTime - startTime;
+
+    return elapsed.count();
+}
+
+double PerformanceTest::runSingleTestWithNodesCUDA(ALTCUDA* algorithm, int graphSize, int start, int goal) {
+    // Graph generieren
+    auto graph = graphGenerator.generateRandomGraph(graphSize);
+
+    // Zeit messen
+    auto startTime = std::chrono::high_resolution_clock::now();
+
+    // Algorithmus ausführen
+    algorithm->run(graph, start, goal);
+
+    auto endTime = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = endTime - startTime;
+
+    return elapsed.count();
+}