SDL Performance Frequency Explained

When using SDL_GetPerformanceCounter() for timing, we divide by SDL_GetPerformanceFrequency() to convert the raw counter values into meaningful time units (typically seconds).

This process is necessary because SDL_GetPerformanceCounter() returns platform-specific "ticks" that don't directly correspond to standard time units.

SDL_GetPerformanceFrequency() returns the number of "ticks" per second for the high-resolution counter. This value varies depending on the system's hardware and OS, but it remains constant for the duration of your program's execution.

For example, if SDL_GetPerformanceFrequency() returns 1,000,000, it means there are one million ticks per second, or each tick represents one microsecond.

To convert the difference between two SDL_GetPerformanceCounter() values into seconds, we divide by the frequency:

1#include <SDL.h>
2#include <iostream>
3
4int main(int argc, char** argv) {
5  SDL_Init(SDL_INIT_TIMER);
6
7  Uint64 start{SDL_GetPerformanceCounter()};
8
9  // Simulate some work
10  for (int i{0}; i < 1000; ++i) {
11    std::cout << "Working...\n";
12  }
13
14  Uint64 end{SDL_GetPerformanceCounter()};
15
16  Uint64 counterDelta{end - start};
17  double secondsElapsed{
18    static_cast<double>(counterDelta) /
19    SDL_GetPerformanceFrequency()};
20
21  std::cout << "Counter delta: "
22    << counterDelta
23    << "\nSeconds elapsed: "
24    << secondsElapsed;
25
26  SDL_Quit();
27  return 0;
28}

1Working...
2Working...
3Working...
4Counter delta: 448647
5Seconds elapsed: 0.0448647

In this example, counterDelta represents the number of ticks that passed between start and end. By dividing this by the frequency, we convert it to seconds.

By adjusting the division, we can easily obtain different time units:

1#include <SDL.h>
2#include <iostream>
3
4int main(int argc, char** argv) {
5  SDL_Init(SDL_INIT_TIMER);
6
7  Uint64 start{SDL_GetPerformanceCounter()};
8
9  // Simulate some work
10  for (int i{0}; i < 1000; ++i) {
11    std::cout << "Working...\n";
12  }
13
14  Uint64 end{SDL_GetPerformanceCounter()};
15
16  Uint64 counterDelta{end - start};
17  double frequency{
18    static_cast<double>(
19      SDL_GetPerformanceFrequency())};
20
21  double secondsElapsed{
22    counterDelta / frequency};
23  double millisecondsElapsed{
24    (counterDelta * 1000.0) / frequency};
25  double microsecondsElapsed{
26    (counterDelta * 1000000.0) / frequency};
27
28  std::cout << "Seconds: " << secondsElapsed
29    << "\nMilliseconds: " << millisecondsElapsed
30    << "\nMicroseconds: " << microsecondsElapsed;
31
32  SDL_Quit();
33  return 0;
34}

1Working...
2Working...
3Working...
4Seconds: 0.0405826
5Milliseconds: 40.5826
6Microseconds: 40582.6

You might wonder why we don't just use the raw counter values. The problem is that these values are not standardized across different systems. On one computer, 1000 ticks might represent one millisecond, while on another, it could be one microsecond.

By dividing by the frequency, we normalize these differences, ensuring our timing calculations are consistent across different hardware and operating systems.

This approach allows us to write portable code that behaves consistently regardless of the underlying system's timer resolution, making it crucial for cross-platform development.