diff --git a/pthwithcuda/utils/performancetest.cpp b/pthwithcuda/utils/performancetest.cpp new file mode 100644 index 0000000000000000000000000000000000000000..cea08b19d038ec610eaa2a0c3c955ea23ef71f42 --- /dev/null +++ b/pthwithcuda/utils/performancetest.cpp @@ -0,0 +1,226 @@ +#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(); +}