如何将 QueryThreadCycleTime() 转换为秒？

Question

Windows 函数QueryThreadCycleTime() 给出了给定线程使用的“CPU 时钟周期”数。 Windows 手册大胆指出

不要尝试将 QueryThreadCycleTime 返回的 CPU 时钟周期转换为经过的时间。

我想对大多数 Intel 和 AMD x86_64 CPU 执行此操作。 它不需要非常准确，因为无论如何你不能期望像RDTSC 这样的循环计数器完美。 我只需要一些笨拙的方法来获取 CPU 的时间因子 seconds / QueryThreadCycleTime。

首先，我想QueryThreadCycleTime 在内部使用 RDTSC。 我想在某些 CPU 上使用恒定速率 TSC，因此更改实际时钟速率（例如，使用可变频率 CPU 电源管理）不会影响 time/TSC 因素。 在其他 CPU 上，该速率可能会发生变化，因此我必须定期查询该因素。

我为什么需要这个？

在有人引用XY Problem 之前，我应该指出我对替代解决方案并不真正感兴趣。 这是因为我有两个其他方法无法满足的分析硬性要求。

• 它应该只测量线程时间，所以sleep(1) 应该不返回 1 秒，而是持续 1 秒的繁忙循环应该。换句话说，分析器不应该说一个任务运行了 10 毫秒，而它的线程只活动了 1 毫秒。这就是我不能使用QueryPerformanceCounter() 的原因。
• 需要一个优于1/64秒的精度，这是GetThreadTimes()给出的精度。我正在分析的任务可能只运行几微秒。

最小的可重现示例

按照@Ted Lyngmo 的要求，目标是实现computeFactor()。

#include <stdio.h>
#include <windows.h>

double computeFactor();

int main() {
    uint64_t start, end;
    QueryThreadCycleTime(GetCurrentThread(), &start);
    // insert task here, such as an actual workload or sleep(1)
    QueryThreadCycleTime(GetCurrentThread(), &end);
    printf("%lf\n", (end - start) * computeFactor());
    return 0;
}

Answer 1

不要尝试将 QueryThreadCycleTime 返回的 CPU 时钟周期转换为经过的时间。

我也想这样做。

你的愿望显然被拒绝！

一种解决方法，可以做一些接近你想要的事情，可能是创建一个带有steady_clock 的线程，该线程以某个指定的频率对QueryThreadCycleTime 和/或GetThreadTimes 进行采样。这是一个示例，说明如何使用采样线程每秒对两者进行一次采样。

#include <algorithm>
#include <atomic>
#include <chrono>
#include <cstdint>
#include <iostream>
#include <iomanip>
#include <thread>
#include <vector>

#include <Windows.h>

using namespace std::literals::chrono_literals;

struct FTs_t {
    FILETIME CreationTime, ExitTime, KernelTime, UserTime;
    ULONG64 CycleTime;
};

using Sample = std::vector<FTs_t>;

std::ostream& operator<<(std::ostream& os, const FILETIME& ft) {
    std::uint64_t bft = (std::uint64_t(ft.dwHighDateTime) << 16) + ft.dwLowDateTime;
    return os << bft;
}

std::ostream& operator<<(std::ostream& os, const Sample& smp) {
    size_t tno = 0;
    for (const auto& fts : smp) {
        os << " tno:" << std::setw(3) << tno << std::setw(10) << fts.KernelTime
           << std::setw(10) << fts.UserTime << std::setw(16) << fts.CycleTime << "\n";
        ++tno;
    }
    return os;
}

// the sampling thread
void ft_sampler(std::atomic<bool>& quit, std::vector<std::thread>& threads, std::vector<Sample>& samples) {
    auto tp = std::chrono::steady_clock::now(); // for steady sampling

    FTs_t fts;
    while (quit == false) {
        Sample s;
        s.reserve(threads.size());
        for (auto& th : threads) {
            if (QueryThreadCycleTime(th.native_handle(), &fts.CycleTime) &&
                GetThreadTimes(th.native_handle(), &fts.CreationTime,
                               &fts.ExitTime, &fts.KernelTime, &fts.UserTime)) {
                s.push_back(fts);
            }
        }
        samples.emplace_back(std::move(s));

        tp += 1s; // add a second since we last sampled and sleep until that time_point
        std::this_thread::sleep_until(tp);
    }
}

// a worker thread
void worker(std::atomic <bool>& quit, size_t payload) {
    volatile std::uintmax_t x = 0;
    while (quit == false) {
        for (size_t i = 0; i < payload; ++i) ++x;
        std::this_thread::sleep_for(1us);
    }
}

int main() {
    std::atomic<bool> quit_sampling = false, quit_working = false;
    std::vector<std::thread> threads;
    std::vector<Sample> samples;
    size_t max_threads = std::thread::hardware_concurrency() > 1 ? std::thread::hardware_concurrency() - 1 : 1;

    // start some worker threads
    for (size_t tno = 0; tno < max_threads; ++tno) {
        threads.emplace_back(std::thread(&worker, std::ref(quit_working), (tno + 100) * 100000));
    }

    // start the sampling thread
    auto smplr = std::thread(&ft_sampler, std::ref(quit_sampling), std::ref(threads), std::ref(samples));

    // let the threads work for some time
    std::this_thread::sleep_for(10s);

    quit_sampling = true;
    smplr.join();

    quit_working = true;
    for (auto& th : threads) th.join();

    std::cout << "Took " << samples.size() << " samples\n";

    size_t s = 0;
    for (const auto& smp : samples) {
        std::cout << "Sample " << s << ":\n" << smp << "\n";
        ++s;
    }
}