Question

我正在寻找具有高分辨率，高精度和相对低性能影响的跨平台时钟（按重要性排序）。

我试过了：

//using namespace std::chrono;
//typedef std::chrono::high_resolution_clock Clock;

using namespace boost::chrono;
typedef boost::chrono::high_resolution_clock Clock;
auto now = Clock::now().time_since_epoch();
std::size_t secs = duration_cast<seconds>(now).count();
std::size_t nanos = duration_cast<nanoseconds>(now).count() % 1000000000;
std::time_t tp = (std::time_t) secs;
std::string mode;
char timestamp[] = "yyyymmdd HH:MM:SS";
char format[] = "%Y%m%d %H:%M:%S";

strftime(timestamp, 80, format, std::localtime(&tp)); // Takes 12 microseconds
std::string output = timestamp + "." + std::to_string(nanos);

经过一些试验和测试：原始的std :: chrono :: high_resolution_clock是typedef到system_clock，精度大约为1毫秒。 boost :: chrono :: high_resolution_clock使用Windows上的Query_Performance_Counter，具有高分辨率和高精度。不幸的是，Clock :: now（）返回自启动以来的时间和now（）。time_since_epoch（）不返回纪元时间（也返回启动后的时间）。

不介意在不同平台上使用防护用于不同的解决方案（想要VS2013和Linux）。可能会存储现在并在单独/低优先级线程中进行处理。

是否存在跨平台，高分辨率，高精度，性能友好的计时器？

boost :: chrono :: high_resolution_clock :: now（）。time_since_epoch（）是否按预期工作？自上一纪元以来它没有给出时间。它只提供自上次启动以来的时间。有没有办法将此现在（）转换为自纪元以来的秒数。

Answer 1

我认为最好的方法是实现一种新的时钟类型，用于模拟c ++ 11/14标准中的Clock要求。

windows函数GetSystemTimePreciseAsFileTime可以用作windows时钟的基础。我相信这个函数以窗口纪元开始以100纳秒为单位返回时间。如果我对此错了，只需改变period的定义以适应。

struct windows_highres_clock
{
    // implement Clock concept
    using rep = ULONGLONG;
    using period = std::ratio<1, 10000000>;
    using duration = std::chrono::duration<rep, period>;
    using time_point = std::chrono::time_point<windows_highres_clock, duration>;

    static constexpr const bool is_steady = true;

    static time_point now() noexcept {
        FILETIME ft = { 0, 0 };
        GetSystemTimePreciseAsFileTime(&ft);
        ULARGE_INTEGER stamp { { ft.dwLowDateTime, ft.dwHighDateTime } };
        return time_point { duration { stamp.QuadPart } };
    }
};

如果你想继续在它上面实现TrivalClock概念，那应该可行。只需按照http://cppreference.com

上的说明操作即可

提供from_time_t和to_time_t成员函数将完成图片并允许您将此时钟用于计时和日期时间表示。

使用示例：

windows_highres_clock clock;
auto t0 = clock.now();
sleep(1);
auto t1 = clock.now();
auto diff = t1 - t0;
auto ms = std::chrono::duration_cast<chrono::milliseconds>(diff);
cout << "waited for " << ms.count() << " milliseconds\n";

示例输出：

waited for 1005 milliseconds

对于非Windows系统，system_clock通常就足够了，但您可以使用适当的本机计时机制编写类似的每系统时钟。

供参考：

这是一段便携式代码，可用于检查时钟分辨率。 any_clock类是一个多态容器，可以容纳任何类似Clock的对象。它总是以自纪元以来的微秒返回其时间戳。

// create some syntax to help specialise the any_clock
template<class Clock> struct of_type {};

// polymorphic clock container
struct any_clock
{

    template<class Clock>
    any_clock(of_type<Clock>)
    : _ptr { new model<Clock> {} }
    {}

    std::chrono::microseconds now() const {
        return _ptr->now();
    }

    using duration = std::chrono::microseconds;

private:
    struct concept {
        virtual ~concept() = default;
        virtual duration now() const noexcept = 0;
    };
    template<class Clock>
    struct model final : concept {
        duration now() const noexcept final {
            return std::chrono::duration_cast<std::chrono::microseconds>(Clock::now().time_since_epoch());
        }
    };
    unique_ptr<concept> _ptr;
};

int main(int argc, const char * argv[])
{
    any_clock clocks[] = {
         { of_type<windows_highres_clock>() },
         { of_type<std::chrono::high_resolution_clock>() },
         { of_type<std::chrono::system_clock>() }
    };

    static constexpr size_t nof_clocks = std::extent<decltype(clocks)>::value;
    any_clock::duration t0[nof_clocks];
    any_clock::duration t1[nof_clocks];

    for (size_t i = 0 ; i < nof_clocks ; ++i) {
        t0[i] = clocks[i].now();
    }
    sleep(1);
    for (size_t i = 0 ; i < nof_clocks ; ++i) {
        t1[i] = clocks[i].now();
    }
    for (size_t i = 0 ; i < nof_clocks ; ++i) {
        auto diff = t1[i] - t0[i];
        auto ms = std::chrono::duration_cast<chrono::microseconds>(diff);
        cout << "waited for " << ms.count() << " microseconds\n";
    }
    return 0;
}

VS2013中的高分辨率时钟

1 个答案: