C++ 使用std::chrono计时事件 c++类的定义与使用

std::chrono 库提供了测量和报告时间和间隔的工具。

这些类和函数中的许多是在 C++11 中引入的。C++20 对此进行了重大更改和更新，但在撰写本文时，我所测试的系统上许多更新尚未实施。

使用 chrono 库，本食谱探索了计时事件的技术。

如何做到这一点…

system_clock 类用于报告当前日期和时间。steady_clock 和 high_resolution_clock 类用于计时事件。让我们来看看这些时钟之间的区别：

因为这些名称可能又长又笨拙，我们将在本食谱中使用一些类型别名：

using std::chrono::system_clock;
using std::chrono::steady_clock;
using std::chrono::high_resolution_clock;
using std::chrono::duration;
using seconds = duration<double>;
using milliseconds = duration<double, std::milli>;
using microseconds = duration<double, std::micro>;
using fps24 = duration<unsigned long, std::ratio<1, 24>>;

duration 类表示两个时间点之间的间隔。这些别名方便使用不同的间隔。

我们可以通过使用 system_clock 类来获取当前时间和日期：

auto t = system_clock::now();
cout << format("system_clock::now is {:%F %T}\n", t);

system_clock::now() 函数返回一个 time_point 对象。<chrono> 库包括 time_point 的 format() 特化，使用 strftime() 格式说明符。

输出是：

system_clock::now is 2022-02-05 13:52:15

<iomanip> 头文件包括 put_time()，它为 ostream 工作，就像 strftime() 一样：

std::time_t now_t = system_clock::to_time_t(t);
cout << "system_clock::now is "
    << std::put_time(std::localtime(&now_t), "%F %T")
    << '\n';

put_time() 接受指向 C 风格的 time_t* 值的指针。system_clock::to_time_t 将 time_point 对象转换为 time_t。

这给出了与我们的 format() 示例相同的输出：

system_clock::now is 2022-02-05 13:52:15

我们还可以使用 system_clock 计时事件。首先，我们需要计时的东西。这里有一个计算素数的函数：

constexpr uint64_t MAX_PRIME{ 0x1FFFF }
uint64_t count_primes() {
    constexpr auto is_prime = [](const uint64_t n) {
        for(uint64_t i{ 2 }; i < n / 2; ++i) {
            if(n % i == 0) return false;
        }
        return true;
    };
    uint64_t count{ 0 };
    uint64_t start{ 2 };
    uint64_t end{ MAX_PRIME };
    for(uint64_t i{ start }; i <= end ; ++i) {
        if(is_prime(i)) ++count;
   }
   return count;
}

这个函数计算 2 到 0x1FFFF（131,071）之间的素数，这在大多数现代系统上应该需要几秒钟。

现在，我们编写一个计时器函数来计时我们的 count_primes()：

seconds timer(uint64_t(*f)()) {
    auto t1{ system_clock::now() };
    uint64_t count{ f() };
    auto t2{ system_clock::now() };
    seconds secs{ t2 - t1 };
    cout << format("there are {} primes in range\n",
      count);
    return secs;
}

这个函数接受一个函数 f 并返回 duration<double>。我们使用 system_clock::now() 标记 f() 调用前后的时间。我们取两个时间之间的差并将其以 duration 对象的形式返回。

我们可以像这样从 main() 调用我们的 timer()：

int main() {
    auto secs{ timer(count_primes) };
    cout << format("time elapsed: {:.3f} seconds\n",
        secs.count());
    ...
}

这将 count_primes() 函数传递给 timer() 并将 duration 对象存储在 secs 中。

输出：

there are 12252 primes in range
time elapsed: 3.573 seconds

duration 对象的 count() 方法以指定的单位返回持续时间——在这种情况下，double，表示持续时间的秒数。

这是在运行 Debian 的 VM 上使用 GCC 进行的。不同系统上的确切时间会有所不同。

system_clock 类旨在提供当前的墙上时钟时间。虽然其分辨率可能支持计时目的，但不能保证是单调的。换句话说，它可能不总是提供一致的滴答声（计时间隔）。

chrono 库在 steady_clock 中提供了一个更合适的时钟。它具有与 system_clock 相同的接口，但为计时目的提供了更可靠的滴答声：

seconds timer(uint64_t(*f)()) {
    auto t1{ steady_clock::now() };
    uint64_t count{ f() };
    auto t2{ steady_clock::now() };
    seconds secs{ t2 - t1 };
    cout << format("there are {} primes in range\n",
      count);
    return secs;
}

steady_clock 旨在提供可靠一致的单调滴答声，适用于计时事件。它使用相对时间参考，因此不适用于墙上时钟时间。虽然 system_clock 从固定时间点（1970年1月1日，00:00 UTC）开始测量，但 steady_clock 使用相对时间。

另一个选项是 high_resolution_clock，它提供了给定系统上可用的最短滴答声周期，但在不同实现中并不一致。它可能是 system_clock 或 steady_clock 的别名，可能是也可能不是单调的。不建议将 high_resolution_clock 用于一般用途。

我们的 timer() 函数返回 seconds，这是 duration<double> 的别名：

using seconds = duration<double>;

duration 类采用一个可选的第二个模板参数，std::ratio 类：

template<class Rep, class Period = std::ratio<1>>
class duration;

<chrono> 头文件为许多小数比率提供了便利类型，包括毫微秒：

using milliseconds = duration<double, std::milli>;
using microseconds = duration<double, std::micro>;

如果我们需要其他东西，我们可以提供自己的：

using fps24 = duration<unsigned long, std::ratio<1, 24>>;

fps24 表示以每秒 24 帧的标准拍摄的电影帧数。比率是每秒 1/24。

这允许我们轻松地在不同的持续时间范围内进行转换：

cout << format("time elapsed: {:.3f} sec\n", secs.count());
cout << format("time elapsed: {:.3f} ms\n",
    milliseconds(secs).count());
cout << format("time elapsed: {:.3e} μs\n",
    microseconds(secs).count());
cout << format("time elapsed: {} frames at 24 fps\n",
    floor<fps24>(secs).count());

输出：

time elapsed: 3.573 sec
time elapsed: 3573.077 ms
time elapsed: 3.573e+06 μs
time elapsed: 85 frames at 24 fps

因为 fps24 别名使用 unsigned long 而不是 double，所以需要类型转换。floor 函数通过丢弃小数部分提供此功能。round() 和 ceil() 也在这种情况下可用。

为了方便，chrono 库为标准持续时间比率提供了 format() 特化：

cout << format("time elapsed: {:.3}\n", secs);
cout << format("time elapsed: {:.3}\n", milliseconds(secs));
cout << format("time elapsed: {:.3}\n", microseconds(secs));

输出：

time elapsed: 3.573s
time elapsed: 3573.077ms
time elapsed: 3573076.564μs

这些结果在不同的实现中会有所不同。

它是如何工作的…

chrono 库有两个主要部分，时钟类和持续时间类。

时钟类

时钟类包括：

system_clock – 提供墙上时钟时间。

steady_clock – 提供持续时间测量的保证单调滴答声。

high_resolution_clock – 提供最短可用滴答声周期。在某些系统上，它可能是 system_clock 或 steady_clock 的别名。

我们使用 system_clock 显示当前时间和日期。我们使用 steady_clock 测量间隔。

每个时钟类都有一个 now() 方法，返回代表时钟当前值的 time_point。now() 是一个静态成员函数，因此它在不实例化对象的情况下在类上调用：

auto t1{ steady_clock::now() };

std::duration 类

duration 类用于保存时间间隔——即两个 time_point 对象之间的差异。它通常使用 time_point 对象的减法（-）运算符构造。

duration<double> secs{ t2 - t1 };

time_point 减法运算符兼作 duration 的构造函数：

template<class C, class D1, class D2>

constexpr duration<D1,D2>

operator-( const time_point<C,D1>& pt_lhs,

    const time_point<C,D2>& pt_rhs );

duration 类有几个模板参数，用于类型表示和比率对象：

template<class Rep, class Period = std::ratio<1>>
class duration;

Period 模板参数默认为 1:1 的比率，即秒。

库提供了比率别名（如 micro 和 milli），用于从阿托（1/1,000,000,000,000,000,000）到艾克萨（1,000,000,000,000,000,000/1）的 10 的幂。这允许我们像在示例中那样创建标准持续时间：

using milliseconds = duration<double, std::milli>;
using microseconds = duration<double, std::micro>;

count() 方法以 Rep 类型给出持续时间：

constexpr Rep count() const;

这允许我们轻松地访问持续时间以进行显示或其他目的：

cout << format("duration: {}\n", secs.count());

std::chrono 库的时钟类和 duration 类共同提供了一套强大的工具，用于测量和报告程序中的时间和间隔。通过这些工具，我们可以精确地计时函数调用、事件和其他性能相关的测量，从而更好地优化和理解我们的代码。