Skip to content
Related Articles
Open in App
Not now

Related Articles

Measure execution time of a function in C++

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 14 Feb, 2022
Improve Article
Save Article

We can find out the time taken by different parts of a program by using the std::chrono library introduced in C++ 11. We have discussed at How to measure time taken by a program in C. The functions described there are supported in C++ too but they are C specific. For clean and robust C++ programs we should strive to use C++ specific language constructs only.
std::chrono has two distinct objects–timepoint and duration. A timepoint as the name suggests represents a point in time whereas a duration represents an interval or span of time. The C++ library allows us to subtract two timepoints to get the interval of time passed in between. Using provided methods we can also convert this duration to appropriate units.
The std::chrono provides us with three clocks with varying accuracy. The high_resolution_clock is the most accurate and hence it is used to measure execution time.
Step 1: Get the timepoint before the function is called


#include <chrono>
using namespace std::chrono;
// Use auto keyword to avoid typing long
// type definitions to get the timepoint
// at this instant use function now()
auto start = high_resolution_clock::now();

Step 2: Get the timepoint after the function is called 


#include <chrono>
using namespace std::chrono;
// After function call
auto stop = high_resolution_clock::now();

Step 3: Get the difference in timepoints and cast it to required units 


// Subtract stop and start timepoints and
// cast it to required unit. Predefined units
// are nanoseconds, microseconds, milliseconds,
// seconds, minutes, hours. Use duration_cast()
// function.
auto duration = duration_cast<microseconds>(stop - start);
// To get the value of duration use the count()
// member function on the duration object
cout << duration.count() << endl;

A complete C++ program demonstrating the procedure is given below. We fill up a vector with some random numbers and measure the time taken by sort() function to sort this vector.


// C++ program to find out execution time of
// of functions
#include <algorithm>
#include <chrono>
#include <iostream>
using namespace std;
using namespace std::chrono;
// For demonstration purpose, we will fill up
// a vector with random integers and then sort
// them using sort function. We fill record
// and print the time required by sort function
int main()
    vector<int> values(10000);
    // Generate Random values
    auto f = []() -> int { return rand() % 10000; };
    // Fill up the vector
    generate(values.begin(), values.end(), f);
    // Get starting timepoint
    auto start = high_resolution_clock::now();
    // Call the function, here sort()
    sort(values.begin(), values.end());
    // Get ending timepoint
    auto stop = high_resolution_clock::now();
    // Get duration. Substart timepoints to
    // get duration. To cast it to proper unit
    // use duration cast method
    auto duration = duration_cast<microseconds>(stop - start);
    cout << "Time taken by function: "
         << duration.count() << " microseconds" << endl;
    return 0;

Output: (Machine Dependent) 

Time taken by function: 3062 microseconds


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!