Previously, we introduced the SDL_GetTicks() function, which returns the number of milliseconds that have passed since SDL was initialized.

However, in some situations, milliseconds are not granular enough. We need to use timers that use smaller units, such as microseconds and nanoseconds.

Timers that use these smaller units are typically called high-resolution timers. How they work and how we access them is something that varies from platform to platform, but SDL provides some utilities that can help us.

Starting Point

If you want to follow along, this lesson uses the same architecture we built earlier in the chapter. We set up a basic World and GameObject hierarchy and used SDL_GetTicks() to pass a time delta to our Tick() functions.

This starting point contains the Window, GameObject, World, and Goblin classes from the previous lesson. Compared to the previous lesson, we've removed our frame-rate capping logic:

Files

src

Select a file to view its content

Getting a High Resolution Timer

SDL provides access to a high-resolution timer using SDL_GetPerformanceCounter(). The values returned from this function should be accurate enough to detect even tiny changes in time:

1#include <SDL3/SDL.h>
2#include <SDL3/SDL_main.h>
3#include <iostream>
4
5int main(int, char**) {
6  SDL_Init(SDL_INIT_VIDEO);
7
8  std::cout << "\nPerformance Counter: "
9    << SDL_GetPerformanceCounter();
10  std::cout << "\nPerformance Counter: "
11    << SDL_GetPerformanceCounter();
12  std::cout << "\nPerformance Counter: "
13    << SDL_GetPerformanceCounter();
14
15  SDL_Quit();
16  return 0;
17}

1Performance Counter: 23369230619011
2Performance Counter: 23369230624712
3Performance Counter: 23369230627816

The values returned from this function are useful when compared to other values returned by that same function. That is, we'd call SDL_GetPerformanceCounter() twice, and compare the difference. One of the main uses for this is to compare the performance of different approaches to solving a problem in part of our code where performance is important.

Below, our program is creating a large array, and we use SDL_GetPerformanceCounter() to determine whether reserving the required memory ahead of time reduces the performance cost:

1#include <SDL3/SDL.h>
2#include <SDL3/SDL_main.h>
3#include <iostream>
4#include <vector>
5
6int main(int, char**) {
7  SDL_Init(SDL_INIT_VIDEO);
8
9  // Option A
10  std::vector<int> A;
11  Uint64 StartA{SDL_GetPerformanceCounter()};
12  for (int i{0}; i < 1'000'000'000; ++i) {
13    A.emplace_back(i);
14  }
15  Uint64 EndA{SDL_GetPerformanceCounter()};
16  std::cout << "\nA Cost: " << EndA - StartA;
17
18  // Option B
19  std::vector<int> B;
20  Uint64 StartB{SDL_GetPerformanceCounter()};
21  B.reserve(1'000'000'000);
22  for (int i{0}; i < 1'000'000'000; ++i) {
23    B.emplace_back(i);
24  }
25  Uint64 EndB{SDL_GetPerformanceCounter()};
26  std::cout << "\nB Cost: " << EndB - StartB;
27
28  SDL_Quit();
29  return 0;
30}

We'd likely find option B to be faster, so we'd go with that approach in our program:

1A Cost: 38112382
2B Cost: 13096310

High Resolution Ticking

Let's use SDL_GetPerformanceCounter() to calculate high resolution time deltas for our Tick() functions:

src/main.cpp

1#include <SDL3/SDL.h>
2#include <SDL3/SDL_main.h>
3#include <iostream>
4#include "Window.h"
5#include "World.h"
6
7int main(int, char**) {
8  SDL_Init(SDL_INIT_VIDEO);
9  Window GameWindow;
10  World GameWorld;
11  GameWorld.SpawnGoblin("Goblin Rogue", 100, 200);
12
13  SDL_Event Event;
14  bool IsRunning{true};
15  Uint64 PreviousFrame{
16    SDL_GetPerformanceCounter()};
17
18  while (IsRunning) {
19    while (SDL_PollEvent(&Event)) {
20      if (Event.type == SDL_EVENT_QUIT) {
21        IsRunning = false;
22      }
23      GameWorld.HandleEvent(Event);
24    }
25
26    Uint64 ThisFrame{SDL_GetPerformanceCounter()};
27    Uint64 TimeDelta{ThisFrame - PreviousFrame};
28    PreviousFrame = ThisFrame;
29    std::cout << "\nTimeDelta: " << TimeDelta;
30    
31    // TimeDelta was previously in seconds but,
32    // with this new technique, we nore longer know
33    // what units are being used here
34    // We'll address this in the next section
35    GameWorld.Tick(TimeDelta);
36
37    GameWindow.Render();
38    GameWorld.Render(GameWindow.GetSurface());
39    GameWindow.Update();
40  }
41
42  SDL_Quit();
43  return 0;
44}

1TimeDelta: 1032
2TimeDelta: 932
3TimeDelta: 980

However, when we do this, we also need to consider what unit of time SDL_GetPerformanceCounter() uses.

It returns values in the smallest unit the platform supports, however, that unit varies from platform to platform. It could be milliseconds; it could be nanoseconds; it could be something else entirely.

`SDL_GetPerformanceFrequency()`

The SDL_GetPerformanceFrequency() function can help us understand what unit is being used on the platform our program is running on. It does this by returning an integer representing how many of those units there are in a second:

src/main.cpp

1#include <SDL3/SDL.h>
2#include <SDL3/SDL_main.h>
3#include <iostream>
4
5int main(int, char**) {
6  SDL_Init(SDL_INIT_VIDEO);
7  std::cout << SDL_GetPerformanceFrequency();
8  SDL_Quit();
9  return 0;
10}

110000000

For example:

A return value of 1,000 would mean it uses milliseconds
A return value of 1,000,000 would mean it uses microseconds
A return value of 1,000,000,000 would mean it uses nanoseconds

We can use this to convert our time delta to a standard, known unit of time such that our Tick() functions can behave consistently across different platforms. Below, we deliver the time delta in seconds:

src/main.cpp

1#include <SDL3/SDL.h>
2#include <SDL3/SDL_main.h>
3#include <iostream>
4#include "Window.h"
5#include "World.h"
6
7int main(int, char**) {
8  SDL_Init(SDL_INIT_VIDEO);
9  Window GameWindow;
10  World GameWorld;
11  GameWorld.SpawnGoblin("Goblin Rogue", 100, 200);
12
13  SDL_Event Event;
14  bool IsRunning{true};
15  Uint64 PreviousFrame{SDL_GetPerformanceCounter()};
16  const float PerformanceFrequency{
17    static_cast<float>(
18      SDL_GetPerformanceFrequency()
19    )
20  };
21
22  while (IsRunning) {
23    while (SDL_PollEvent(&Event)) {
24      if (Event.type == SDL_EVENT_QUIT) {
25        IsRunning = false;
26      }
27      GameWorld.HandleEvent(Event);
28    }
29
30    Uint64 ThisFrame{SDL_GetPerformanceCounter()};
31    float TimeDelta{(ThisFrame - PreviousFrame)
32      / PerformanceFrequency
33    };
34    PreviousFrame = ThisFrame;
35    std::cout << "\nTimeDelta: " << TimeDelta;
36    
37    // This is now back to using seconds again
38    GameWorld.Tick(TimeDelta);
39
40    GameWindow.Render();
41    GameWorld.Render(GameWindow.GetSurface());
42    GameWindow.Update();
43  }
44
45  SDL_Quit();
46  return 0;
47}

1TimeDelta: 0.0001639
2TimeDelta: 0.0001633
3TimeDelta: 0.0001631

High-Resolution Timers using `std::chrono`

The standard library also provides access to high resolution-timers using std::chrono. We may prefer to use it as an alternative to SDL's functions, or on projects where SDL is not available.

High-resolution timers are available through std::chrono::high_resolution_clock, alongside utilities like std::chrono::duration and std::chrono::duration_cast to convert time deltas to specific units like seconds or nanoseconds.

Below, we have an example of profiling the performance of a function using std::chrono:

1#include <chrono>
2#include <iostream>
3
4void DoWork() {/* ... */}
5
6int main() {
7  using namespace std::chrono;
8
9  auto start{high_resolution_clock::now()};
10  DoWork();
11  auto end{high_resolution_clock::now()};
12  duration<double> TimeDelta{end - start};
13
14  std::cout << "TimeDelta: "
15    << TimeDelta.count()
16    << " Seconds ("
17    << duration_cast<nanoseconds>(end - start)
18    << ')';
19}

1TimeDelta: 0.000065 Seconds (65100ns)

In this example, we update our application loop to provide high-resolution time deltas to Tick() functions using std::chrono instead of SDL's functions:

src/main.cpp

1#include <SDL3/SDL.h>
2#include <SDL3/SDL_main.h>
3#include <chrono>
4#include <iostream>
5
6#include "Window.h"
7#include "World.h"
8
9int main(int, char**) {
10  using namespace std::chrono;
11
12  SDL_Init(SDL_INIT_VIDEO);
13  Window GameWindow;
14  World GameWorld;
15  GameWorld.SpawnGoblin("Goblin Rogue", 100, 200);
16
17  SDL_Event Event;
18  bool IsRunning{true};
19  auto PreviousFrame{high_resolution_clock::now()};
20
21  while (IsRunning) {
22    while (SDL_PollEvent(&Event)) {
23      if (Event.type == SDL_EVENT_QUIT) {
24        IsRunning = false;
25      }
26      GameWorld.HandleEvent(Event);
27    }
28
29    auto ThisFrame{high_resolution_clock::now()};
30    duration<float> TimeDelta{
31      ThisFrame - PreviousFrame};
32    PreviousFrame = ThisFrame;
33
34    std::cout << "\nTimeDelta: "
35      << TimeDelta.count() << " Seconds";
36    GameWorld.Tick(TimeDelta.count());
37
38    GameWindow.Render();
39    GameWorld.Render(GameWindow.GetSurface());
40    GameWindow.Update();
41  }
42
43  SDL_Quit();
44  return 0;
45}

1TimeDelta: 0.0001155 Seconds
2TimeDelta: 0.0001091 Seconds
3TimeDelta: 0.0001031 Seconds

We cover std::chrono in more detail in our .

Summary

We've covered several key concepts related to high-resolution timing:

Using SDL_GetPerformanceCounter() to measure time intervals.
Understanding timer precision with SDL_GetPerformanceFrequency().
Calculating time deltas for game loops.
Exploring std::chrono as an alternative to SDL timing functions.

These tools are useful for creating smooth, responsive game experiences and optimizing performance.

High-Resolution Timers

Starting Point

Files

Getting a High Resolution Timer

High Resolution Ticking

src/main.cpp

`SDL_GetPerformanceFrequency()`

src/main.cpp

src/main.cpp

High-Resolution Timers using `std::chrono`

src/main.cpp

Summary

Callbacks and Function Pointers

Game Development with SDL3

High-Resolution Timers

Starting Point

Files

Getting a High Resolution Timer

High Resolution Ticking

src/main.cpp

SDL_GetPerformanceFrequency()

src/main.cpp

src/main.cpp

High-Resolution Timers using std::chrono

src/main.cpp

Summary

Callbacks and Function Pointers

`SDL_GetPerformanceFrequency()`

High-Resolution Timers using `std::chrono`