SDL vs std::chrono for Timing

While SDL's timing functions are useful, std::chrono from the C++ standard library offers several advantages:

Portability

std::chrono is part of the C++ standard library, making it available on any platform with a C++11 (or later) compliant compiler. This means you can use the same timing code across different projects, even those not using SDL.

Type Safety

std::chrono provides strong type safety through its use of templates. This helps prevent errors related to unit conversions:

1#include <chrono>
2#include <iostream>
3
4int main() {
5  using namespace std::chrono;
6
7  auto start{high_resolution_clock::now()};
8
9  // Simulate some work
10  for (int i{0}; i < 1000; ++i) {
11    std::cout << "Working...\n";
12  }
13
14  auto end{high_resolution_clock::now()};
15
16  auto durationMs{
17    duration_cast<milliseconds>(end - start)};
18  auto durationUs{
19    duration_cast<microseconds>(end - start)};
20
21  std::cout << "Duration in milliseconds: " <<
22    durationMs.count() << "ms\n";
23  std::cout << "Duration in microseconds: " <<
24    durationUs.count() << "us\n";
25
26  return 0;
27}

1Working...
2Working...
3Working...
4Duration in milliseconds: 32ms
5Duration in microseconds: 32581us

Flexibility

std::chrono offers a range of clock types and duration representations, allowing you to choose the most appropriate for your needs:

1#include <chrono>
2#include <iostream>
3
4int main() {
5  using namespace std::chrono;
6
7  // High-resolution clock (similar
8  // to SDL_GetPerformanceCounter)
9  auto highResStart{
10    high_resolution_clock::now()};
11
12  // System clock (wall clock time)
13  auto sysClockStart{system_clock::now()};
14
15  // Steady clock (monotonic time)
16  auto steadyStart{steady_clock::now()};
17
18  // Simulate some work
19  for (int i{0}; i < 1000; ++i) {
20    std::cout << "Working...\n";
21  }
22
23  auto highResEnd{high_resolution_clock::now()};
24  auto sysClockEnd{system_clock::now()};
25  auto steadyEnd{steady_clock::now()};
26
27  std::cout << "High-res duration: "
28    << duration_cast<nanoseconds>(
29      highResEnd - highResStart).count()
30    << "ns\n";
31
32  std::cout << "System clock duration: "
33    << duration_cast<microseconds>(
34      sysClockEnd - sysClockStart).count()
35    << "us\n";
36
37  std::cout << "Steady clock duration: "
38    << duration_cast<nanoseconds>(
39      steadyEnd - steadyStart).count()
40    << "ns\n";
41
42  return 0;
43}

1Working...
2Working...
3Working...
4High-res duration: 36367300ns
5System clock duration: 36367us
6Steady clock duration: 36368000ns

Integration with Standard Library

std::chrono integrates well with other parts of the C++ standard library, such as <thread> for sleep operations:

1#include <chrono>
2#include <iostream>
3#include <thread>
4
5int main() {
6  using namespace std::chrono;
7  auto start{high_resolution_clock::now()};
8
9  std::this_thread::sleep_for(
10    milliseconds(100));
11
12  auto end{high_resolution_clock::now()};
13
14  std::cout << "Slept for " << duration_cast<
15      milliseconds>(end - start).count()
16    << "ms\n";
17
18  return 0;
19}

1Slept for 107ms

While SDL's timing functions are straightforward and work well within SDL-based projects, std::chrono offers more flexibility, type safety, and integration with the broader C++ ecosystem.

In many cases, using std::chrono can lead to more robust and maintainable code, especially in projects that aren't exclusively tied to SDL.