最快的时序解析系统

Question

C/C++ 程序员可以使用的最快的计时系统是什么？

例如：
time() 将给出自 1970 年 1 月 1 日 00:00 以来的秒数。
Windows 上的 GetTickCount() 将给出自系统启动以来的时间（以毫秒为单位），但仅限于 49.7 天（之后它会简单地回零）。

我想获取当前时间，或自系统/应用启动时间以来的滴答声，以毫秒为单位。

最大的担忧是方法的开销 - 我需要最轻的一个，因为我将每秒多次调用它。

我的情况是我有一个工作线程，我向该工作线程发布待处理的作业。每个作业都有一个“执行时间”。所以，我不在乎时间是当前的“真实”时间还是系统正常运行以来的时间——它必须是线性的和轻量级的。

编辑：

unsigned __int64 GetTickCountEx()
{
    static DWORD dwWraps = 0;
    static DWORD dwLast = 0;

    DWORD dwCurrent = 0;

    timeMutex.lock();

    dwCurrent = GetTickCount();
    if(dwLast > dwCurrent)
        dwWraps++;

    dwLast = dwCurrent;

    unsigned __int64 timeResult = ((unsigned __int64)0xFFFFFFFF * dwWraps) + dwCurrent;

    timeMutex.unlock();

    return timeResult;
}

Answer 1

对于计时，current Microsoft recommendation 是使用QueryPerformanceCounter & QueryPerformanceFrequency。

这将为您提供优于毫秒的时间。如果系统不支持高分辨率计时器，则默认为毫秒（与GetTickCount 相同）。

Here is a short Microsoft article with examples of why you should use it :)

Answer 2

我最近有这个问题并做了一些研究。好消息是所有三个主要操作系统都提供了某种高分辨率计时器。坏消息是它在每个系统上都有不同的 API 调用。对于 POSIX 操作系统，您要使用 clock_gettime()。但是，如果您使用的是 Mac OS X，则不支持此功能，您必须使用 mach_get_time()。对于 Windows，请使用 QueryPerformanceCounter。或者，对于支持 OpenMP 的编译器，您可以使用 omp_get_wtime()，但它可能无法提供您正在寻找的分辨率。

我还发现 fftw.org (www.fftw.org/cycle.h) 中的 cycle.h 很有用。

这里有一些代码在每个操作系统上调用一个计时器，使用一些丑陋的#ifdef 语句。用法很简单：定时器t； t.tic();一些操作（）； t.toc("消息");它会以秒为单位打印出经过的时间。

#ifndef TIMER_H
#define TIMER_H

#include <iostream>
#include <string>
#include <vector>

# if  (defined(__MACH__) && defined(__APPLE__))
#   define _MAC
# elif (defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(_WIN64))
#   define _WINDOWS
#   ifndef WIN32_LEAN_AND_MEAN
#     define WIN32_LEAN_AND_MEAN
#   endif
#endif

# if defined(_MAC)
#    include <mach/mach_time.h>
# elif defined(_WINDOWS)
#    include <windows.h>
# else
#    include <time.h>
# endif


#if defined(_MAC)
  typedef uint64_t timer_t;
  typedef double   timer_c;

#elif defined(_WINDOWS)
  typedef LONGLONG      timer_t;
  typedef LARGE_INTEGER timer_c;

#else
  typedef double   timer_t;
  typedef timespec timer_c;
#endif

  //==============================================================================
  // Timer
  // A quick class to do benchmarking.
  // Example: Timer t;  t.tic();  SomeSlowOp(); t.toc("Some Message");

  class Timer {
  public:
    Timer();

    inline void tic();
    inline void toc();
    inline void toc(const std::string &msg);

    void print(const std::string &msg);
    void print();
    void reset();
    double getTime();

  private:
    timer_t start;
    double duration;
    timer_c ts;
    double conv_factor;
    double elapsed_time;
  };



  Timer::Timer() {

#if defined(_MAC)
    mach_timebase_info_data_t info;
    mach_timebase_info(&info);

    conv_factor = (static_cast<double>(info.numer))/
                  (static_cast<double>(info.denom));
    conv_factor = conv_factor*1.0e-9;

#elif defined(_WINDOWS)
    timer_c freq;
    QueryPerformanceFrequency(&freq);
    conv_factor = 1.0/(static_cast<double>freq.QuadPart);

#else
    conv_factor = 1.0;
#endif

    reset();
  }

  inline void Timer::tic() {

#if defined(_MAC)
    start = mach_absolute_time();

#elif defined(_WINDOWS)
    QueryPerformanceCounter(&ts);
    start = ts.QuadPart;

#else
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts);
    start = static_cast<double>(ts.tv_sec) + 1.0e-9 *
            static_cast<double>(ts.tv_nsec);

#endif
  }

  inline void Timer::toc() {
#if defined(_MAC)
    duration =  static_cast<double>(mach_absolute_time() - start);

#elif defined(_WINDOWS)
    QueryPerformanceCounter(&qpc_t);
    duration = static_cast<double>(qpc_t.QuadPart - start);

#else
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts);
    duration = (static_cast<double>(ts.tv_sec) + 1.0e-9 *
                static_cast<double>(ts.tv_nsec)) - start;

#endif

    elapsed_time = duration*conv_factor;
  }

  inline void Timer::toc(const std::string &msg) { toc(); print(msg); };

  void Timer::print(const std::string &msg) {
    std::cout << msg << " "; print();
  }

  void Timer::print() {
    if(elapsed_time) {
      std::cout << "elapsed time: " << elapsed_time << " seconds\n";
    }
  }

  void Timer::reset() { start = 0; duration = 0; elapsed_time = 0; }
  double Timer::getTime() { return elapsed_time; }


#if defined(_WINDOWS)
# undef WIN32_LEAN_AND_MEAN
#endif

#endif // TIMER_H

Answer 3

GetSystemTimeAsFileTime 是最快的资源。可以得到它的粒度 通过调用GetSystemTimeAdjustment 填充lpTimeIncrement。作为文件时间的系统时间有 100ns 单位，并以 TimeIncrement 递增。 TimeIncrement 会有所不同，具体取决于多媒体定时器界面的设置。

致电timeGetDevCaps 将披露时间服务的功能。它返回 支持的最小中断周期的值 wPeriodMin。使用 wPeriodMin 作为参数调用timeBeginPeriod 将设置系统以可能的最高中断频率（通常为~1ms）运行。这将也强制GetSystemTimeAsFileTime 返回的系统文件时间的时间增量更小。其粒度将在 1ms 范围内（10000 100ns 单位）。

出于您的目的，我建议采用这种方法。

QueryPerformanceCounter 的选择是有问题的，因为它的频率不是 通过两种方式准确：首先，它与QueryPerformanceFrequency 给出的值相差一个硬件特定的偏移量。这个偏移量可以很容易地 几百 ppm，这意味着转换为时间将包含每秒数百微秒的误差。其次，它具有热漂移。这种设备的漂移很容易达到几 ppm。这样另一个 - 热依赖 - 错误 添加了几个 us/s。

所以只要~1ms的分辨率就足够了，主要问题是开销， GetSystemTimeAsFileTime 是迄今为止最好的解决方案。

当微秒很重要时，您必须走更远的路才能看到更多细节。亚毫秒时间服务在Windows Timestamp Project

Answer 4

如果你只是担心GetTickCount() 溢出，那么你可以像这样包装它：

DWORDLONG GetLongTickCount(void)
{
    static DWORDLONG last_tick = 0;
    DWORD tick = GetTickCount();

    if (tick < (last_tick & 0xffffffff))
        last_tick += 0x100000000;

    last_tick = (last_tick & 0xffffffff00000000) | tick;
    return last_tick;
}

如果您想从多个线程调用它，您需要锁定对last_tick 变量的访问。只要您每 49.7 天至少调用一次GetLongTickCount()，它就会检测到溢出。

Answer 5

如果您专门针对 Windows，我建议您使用 GetSystemTimeAsFileTime API。它通常比GetSystemTime 更快，并且具有相同的精度（大约 10-15 毫秒 - 不要看分辨率）；几年前我在 Windows XP 下进行基准测试时，它的速度提高了 50-100 倍。

唯一的缺点是您可能必须使用例如将返回的 FILETIME 结构转换为时钟时间。 FileTimeToSystemTime 如果您需要以更人性化的格式访问返回的时间。另一方面，只要您不需要实时转换的时间，您始终可以离线或以“懒惰”的方式执行此操作（例如，仅转换您需要显示/处理的时间戳，并且仅当您真正需要它们时）。

QueryPerformanceCounter 可能是其他人提到的一个不错的选择，但根据底层硬件支持，开销可能会相当大。在我上面提到的基准测试中，QueryPerformanceCounter 调用比对 GetSystemTimeAsFileTime 的调用慢 25-200 倍。此外，还有一些可靠性问题，例如举报here。

因此，总而言之：如果您可以处理 10-15 毫秒的精度，我建议您使用 GetSystemTimeAsFileTime。如果您需要比这更好的东西，我会选择 QueryPerformanceCounter。

免责声明：我没有在 XP SP3 之后的 Windows 版本下执行任何基准测试。我建议你自己做一些基准测试。

Answer 6

在 Linux 上你得到微秒：

struct timeval tv;
int res = gettimeofday(&tv, NULL);
double tmp = (double) tv.tv_sec + 1e-6 * (double) tv.tv_usec;

在 Windows 上，只有毫秒可用：

SYSTEMTIME st;
GetSystemTime(&st);
tmp += 1e-3 * st.wMilliseconds;

return tmp;

这来自R's datetime.c（为简洁起见已被删减）。

当然还有Boost's Date_Time，它在某些系统上可以达到纳秒级分辨率（详情here 和here）。

Answer 7

如果您的目标是足够晚的操作系统版本，那么您可以使用GetTickCount64()，它的环绕点比GetTickCount() 高得多。您也可以在GetTickCount() 之上简单地构建GetTickCount64() 的版本。

Answer 8

您查看过这篇 MSDN 文章中的代码吗？

http://msdn.microsoft.com/en-us/magazine/cc163996.aspx

我在使用 VC2005 和 C++ Builder XE 的 Windows 7 64 位机器上编译了这段代码，但是在执行时，它锁定了我的机器；还没有调试到足以找出原因。似乎过于复杂。 UG的模板模板...

Answer 9

在 Mac OS X 上，您可以简单地使用 UInt32 TickCount (void) 来获取刻度。

Answer 10

POSIX 支持clock_gettime()，它使用具有纳秒分辨率的struct timespec。您的系统是否真的支持细粒度的分辨率更有争议，但我相信这是具有最高分辨率的标准调用。并非所有系统都支持它，而且它有时被很好地隐藏（Solaris 上的库“-lposix4”，IIRC）。

---

更新（2016-09-20）：

• Mac OS X 10.6.4 不支持clock_gettime()，任何其他版本的 Mac OS X 也不支持（包括 Mac OS X 10.11.6 El Capitan）。但是，从 macOS Sierra 10.12（2016 年 9 月发布）开始，macOS 终于有了函数clock_gettime() 和它的手册页。实际分辨率（CLOCK_MONOTONIC）仍然是微秒；较小的单位全为零。 clock_getres() 证实了这一点，报告分辨率为 1000 纳秒，即 1 µs。

macOS Sierra 上 clock_gettime() 的手册页提到 mach_absolute_time() 作为获得高分辨率计时的一种方式。有关更多信息，请参阅Technical Q&A QA1398: Mach Absolute Time Units 和（在 SO）What is mach_absolute_time() based on on iPhone?