Comparing the performance of different algorithms with std::chrono

20 Oct 2023

References

When working with algorithms, it is often necessary to compare their performance in order to select the most efficient one for a specific task. Luckily, the C++ standard library provides a useful utility called std::chrono that allows for precisely measuring time.

Using std::chrono to Measure Execution Time

std::chrono provides a flexible and accurate way to measure time in C++. Here’s a basic example of how to use std::chrono to measure the execution time of an algorithm:

#include <iostream>
#include <chrono>

// Function to measure the execution time of an algorithm
template<typename Func>
void measureExecutionTime(Func func) {
    auto start = std::chrono::high_resolution_clock::now();
    func();
    auto end = std::chrono::high_resolution_clock::now();
    
    std::chrono::duration<double> duration = end - start;
    std::cout << "Execution time: " << duration.count() << " seconds" << std::endl;
}

// Example algorithm to measure execution time
void exampleAlgorithm() {
    // Perform some complex calculations or operations
    // ...
}

int main() {
    std::cout << "Measuring execution time of exampleAlgorithm:" << std::endl;
    measureExecutionTime(exampleAlgorithm);

    return 0;
}

In this example, we define a generic function measureExecutionTime that takes a function as an argument and measures its execution time using std::chrono::high_resolution_clock. We use std::chrono::high_resolution_clock::now() to get the current time before and after calling the function, and then calculate the duration between the two using std::chrono::duration.

Comparing Algorithms

To compare the performance of multiple algorithms, you can simply use measureExecutionTime to measure the execution time of each algorithm and then compare the results. Here’s an example:

void algorithm1() {
    // First algorithm implementation
    // ...
}

void algorithm2() {
    // Second algorithm implementation
    // ...
}

void algorithm3() {
    // Third algorithm implementation
    // ...
}

int main() {
    std::cout << "Measuring execution time of different algorithms:" << std::endl;
    std::cout << "Algorithm 1: ";
    measureExecutionTime(algorithm1);

    std::cout << "Algorithm 2: ";
    measureExecutionTime(algorithm2);

    std::cout << "Algorithm 3: ";
    measureExecutionTime(algorithm3);

    return 0;
}

In this example, we define three different algorithms (algorithm1, algorithm2, and algorithm3) and measure their execution time using measureExecutionTime. By comparing the output, we can determine which algorithm performs the best for our specific use case.

Conclusion

Using std::chrono in C++, we can accurately measure the execution time of different algorithms and compare their performance. This allows us to select the most efficient algorithm for a given task, leading to improved overall performance. Remember to always benchmark your code on different inputs and consider the complexity of each algorithm to make an informed decision.

#References