Keep track of time in a game loop in C++

Question

How can I keep track of time in seconds and milliseconds since my game/program started? I can use the clock() function but I hear it is not that accurate. Is there a better way?

Answer 1

You can use the chrono library in C++ Here is a code sample:

#include <chrono>
#include <iostream>
using namespace std;
using namespace std::chrono;
int main() {                         
    high_resolution_clock::time_point t1 = high_resolution_clock::now(); 
    high_resolution_clock::time_point t2 = high_resolution_clock::now();  
    duration<double> time_span = duration_cast<duration<double>>(t2 - t1);      
    cout << time_span.count() << " seconds\n";
    return 0; 
} 

Note that this c++11, so to compile it you should use the flag -std=c++11

$ g++ -std=c++11 test.cpp -o test

This exact piece of code gave 4e-07 seconds on my PC.

Hope that helps.

Answer 2

A cross-platform and easy solution would be to use the chrono library

Example:

#include <iostream>
#include <chrono>

void gameFunction()
{
    // start()
    // end()
}

int main()
{
    auto t1 = std::chrono::high_resolution_clock::now();
    gameFunction();
    auto t2 = std::chrono::high_resolution_clock::now();

    auto elapsed_time = std::chrono::duration_cast<std::chrono::microseconds>( t2 - t1 ).count();

    std::cout << elapsed_time << std::endl;
    return 0;
}

Finally note that you will need a at least C++11 for this to work, so set the -std= flag to at least c++11. For example:

g++ -std=c++11 game.cpp -o game

Answer 3

I highly recommend you look at Handmade Hero. Casey records creating an entire game in a series of video episodes. In one of the early episodes he discusses determining wall-clock time on windows using QueryPerformanceCounter and QueryPerformanceFrequency

He also discusses using cpu cycle counts although those are useful only assuming a constant processor clock speed.

He talks about these issues again in later episodes: https://hero.handmade.network/episode/game-architecture/day113 and https://hero.handmade.network/episode/game-architecture/day177

Since you are looking for a solution in a game loop, these videos will probably be of interest at least even if you use the cross-platform solution from @Pranshu. You are likely ok for a game using a platform dependent method to get a more accurate clock.

I'll point out that high_resolution_clock provides the highest resolution clock available by the system that the library knows about so it might not be any more accurate than using system_clock or steady_clock. (It uses steady_clock on my OSX box.)