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();
}