std::this_thread::sleep_until 时间完全偏离了大约 2 倍，莫名其妙

Question

好吧，我真的不知道为什么会这样。我目前正在实现一个线程容器，它以分离的方式运行无限循环，每次迭代之间限制为一定的速度。

标题：

class timeloop
{
public:
    std::thread thread = { };
    bool state = true;

    void (*function_pointer)() = nullptr;

    double ratio = 1.0f;
    std::chrono::nanoseconds elapsed = { };

    timeloop(
        void (*function_pointer)() = nullptr
    );

    void function();
};

定义：

void timeloop::start()
{
    this->thread = std::thread(
        &loop::function,
        this
    );
}

void timeloop::function()
{
    std::chrono::steady_clock::time_point next;

    std::chrono::steady_clock::time_point start;
    std::chrono::steady_clock::time_point end;

    while (
        this->state
        )
    {
        start = std::chrono::high_resolution_clock::now();
        next = start + std::chrono::nanoseconds(
            (long long) (this->ratio * (double) std::chrono::nanoseconds::period::den)
        );

        if (
            this->function_pointer != nullptr
            )
        {
            this->function_pointer();
        }

        /***************************
            this is the culprit
        ***************************/
        std::this_thread::sleep_until(
            next
        );

        end = std::chrono::high_resolution_clock::now();
        this->elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(
            end - start
            );
    }
}

调用代码：

timeloop* thread_draw = new timeloop(
    &some_void_function
);
thread_draw->ratio = 1.0 / 128.0;

thread_draw->start();
thread_draw->thread.detach();

定义代码的行为很奇怪，特别是std::this_thread::sleep_until。对于this->ratio = 1.0 / 128.0，我预计帧速率约为128，start 和next 的计算值强化了这一点，但它莫名其妙地徘徊在60 左右。是的，我尝试将next 除以2，但是这实际上使它下降到 40 左右。

验证正常睡眠时间的额外代码：

auto diff = std::chrono::nanoseconds(
    next - start
).count() / (double) std::chrono::nanoseconds::period::den;
auto equal = diff == this->ratio;

其中 equal 的计算结果为 true。

帧率计算：

double time = (double) thread_draw->elapsed.count() / (double) std::chrono::nanoseconds::period::den;
double fps = 1.0 / time;

虽然我也使用外部 FPS 计数器来验证（NVIDIA ShadowPlay 和 RivaTuner/MSI Afterburner），但它们在计算值的大约 +-5 范围内。

而且我知道它是std::this_thread::sleep_until，因为一旦我将其注释掉，帧速率就会跃升至 2000 左右。是的...

我真的对此感到困惑，尤其是看到我找不到任何其他人曾经遇到过这个问题的证据。是的，我知道睡眠功能并不完全准确，而且肯定会时不时地出现打嗝，但持续睡眠几乎是预定时间的两倍是荒谬的。

我是否可能错误配置了编译器选项或其他什么？这绝对不是性能问题，而且我有理由确定这也不是逻辑错误（查看所有计算结果如何）[除非我在某处滥用 chrono]。

Answer 1

我认为您的问题是您没有使用 absolute 时间，因为您一直在相对于当前时间 now() 重置 absolute 时间点 next。

尝试改变这个：

while (
    this->state
    )
{
    start = std::chrono::high_resolution_clock::now();
    next = start + std::chrono::nanoseconds(
        (long long) (this->ratio * (double) std::chrono::nanoseconds::period::den)
    );
// ...

到这里

// before the loop
next = std::chrono::high_resolution_clock::now();

while (
    this->state
    )
{
    // keep the timing absolute by adding to the absolute time point
    next = next + std::chrono::nanoseconds(
        (long long) (this->ratio * (double) std::chrono::nanoseconds::period::den)
    );

// ...

这样你只调用一次now()，然后你所有的后续时间都是绝对（而不是相对）从那个点计算的。

编辑添加：

另外，我会避免使用std::chrono::high_resolution_clock。它通常只是std::chrono::system_clock 的别名，它会随着系统时钟尝试与互联网时间保持同步而随机更改时间。

使用std::chrono::steady_clock。

Answer 2

不保证sleep_until的分辨率，你只能保证线程不会在时间点之前被唤醒。如果您正在实现主游戏循环，请阅读Fix your timestep。

使用睡眠来保证时间是一种糟糕的方法。您受到操作系统调度程序的摆布，例如我相信 Windows 的最小睡眠时间约为 10 毫秒。 （如果实现实际上要求操作系统使线程进入睡眠状态并且操作系统决定进行上下文切换。）

如果您调用glfwSwapBuffers 或类似名称，则绘图线程中的垂直同步也可能导致延迟。这可以解释为什么你的速度限制在 60FPS，但不能解释为什么评论 sleep 可以解决问题。

所以我的猜测是操作系统在上面的睡眠。我建议取消睡眠并依赖垂直同步，无论如何这都是您想要绘制的正确频率。与逻辑线程同步会很痛苦……但情况总是如此。