clock_gettime() 是否足以满足亚微秒计时？

Question

我需要一个高分辨率计时器，用于我们应用程序的 Linux 构建中的嵌入式分析器。我们的分析器测量的范围小到单个函数，因此它需要优于 25 纳秒的计时器精度。

以前我们的实现使用内联汇编和rdtsc 操作直接从CPU 查询高频定时器，但是this is problematic 并且需要经常重新校准。

所以我尝试使用clock_gettime 函数来查询CLOCK_PROCESS_CPUTIME_ID。文档声称这给了我纳秒级的时间，但我发现单次调用 clock_gettime() 的开销超过 250ns。这使得对事件进行 100ns 长的计时是不可能的，并且在计时器功能上具有如此高的开销会严重拖累应用程序的性能，使配置文件失真超出价值。 （我们每秒有数十万个分析节点。）

有没有一种方法可以调用 clock_gettime() 的开销小于 ¼μs？ 或者有没有其他方法可以可靠地获得具有 rdtsc？

下面是我用来计时clock_gettime()的代码。

// calls gettimeofday() to return wall-clock time in seconds:
extern double Get_FloatTime();
enum { TESTRUNS = 1024*1024*4 };

// time the high-frequency timer against the wall clock
{
    double fa = Get_FloatTime();
    timespec spec; 
    clock_getres( CLOCK_PROCESS_CPUTIME_ID, &spec );
    printf("CLOCK_PROCESS_CPUTIME_ID resolution: %ld sec %ld nano\n", 
            spec.tv_sec, spec.tv_nsec );
    for ( int i = 0 ; i < TESTRUNS ; ++ i )
    {
        clock_gettime( CLOCK_PROCESS_CPUTIME_ID, &spec );
    }
    double fb = Get_FloatTime();
    printf( "clock_gettime %d iterations : %.6f msec %.3f microsec / call\n",
        TESTRUNS, ( fb - fa ) * 1000.0, (( fb - fa ) * 1000000.0) / TESTRUNS );
}
// and so on for CLOCK_MONOTONIC, CLOCK_REALTIME, CLOCK_THREAD_CPUTIME_ID.

结果：

CLOCK_PROCESS_CPUTIME_ID resolution: 0 sec 1 nano
clock_gettime 8388608 iterations : 3115.784947 msec 0.371 microsec / call
CLOCK_MONOTONIC resolution: 0 sec 1 nano
clock_gettime 8388608 iterations : 2505.122119 msec 0.299 microsec / call
CLOCK_REALTIME resolution: 0 sec 1 nano
clock_gettime 8388608 iterations : 2456.186031 msec 0.293 microsec / call
CLOCK_THREAD_CPUTIME_ID resolution: 0 sec 1 nano
clock_gettime 8388608 iterations : 2956.633930 msec 0.352 microsec / call

这是在标准的 Ubuntu 内核上。该应用程序是 Windows 应用程序的一个端口（我们的 rdtsc 内联汇编工作得很好）。

附录：

x86-64 GCC 是否有一些与__rdtsc() 等效的内在属性，所以我至少可以避免内联汇编？

Answer 1

没有。您必须使用特定于平台的代码来执行此操作。在 x86 和 x86-64 上，您可以使用 'rdtsc' 读取 Time Stamp Counter。

只需移植您正在使用的 rdtsc 程序集。

__inline__ uint64_t rdtsc(void) {
  uint32_t lo, hi;
  __asm__ __volatile__ (      // serialize
  "xorl %%eax,%%eax \n        cpuid"
  ::: "%rax", "%rbx", "%rcx", "%rdx");
  /* We cannot use "=A", since this would use %rax on x86_64 and return only the lower 32bits of the TSC */
  __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
  return (uint64_t)hi << 32 | lo;
}

Answer 2

您正在使用控制参数调用clock_getttime，这意味着api正在通过if-else树分支来查看您想要什么样的时间。我知道你不能通过这个调用来避免这种情况，但是看看你是否可以深入研究系统代码并调用内核最终直接调用的内容。另外，我注意到您包括循环时间（i++ 和条件分支）。

Answer 3

我需要一个高分辨率计时器，用于我们应用程序的 Linux 版本中的嵌入式分析器。我们的分析器测量的范围小到单个函数，因此它需要优于 25 纳秒的计时器精度。

您考虑过oprofile 还是perf？您可以使用 CPU 上的性能计数器硬件来获取分析数据，而无需向代码本身添加检测。您可以查看每个函数甚至每行代码的数据。 “唯一”的缺点是它不会测量所消耗的挂钟时间，它会测量消耗的 CPU 时间，因此它并不适合所有调查。

Answer 4

试试clockid_t CLOCK_MONOTONIC_RAW？

CLOCK_MONOTONIC_RAW（从 Linux 2.6.28 开始；特定于 Linux） 类似于 CLOCK_MONOTONIC，但提供对 不受 NTP 约束的基于硬件的原始时间 调整或由执行的增量调整 调整时间（3）。

来自Man7.org

Answer 5

我在我的系统上运行了一些基准测试，这是一个四核 E5645 Xeon，支持运行内核 3.2.54 的恒定 TSC，结果是：

clock_gettime(CLOCK_MONOTONIC_RAW)       100ns/call
clock_gettime(CLOCK_MONOTONIC)           25ns/call
clock_gettime(CLOCK_REALTIME)            25ns/call
clock_gettime(CLOCK_PROCESS_CPUTIME_ID)  400ns/call
rdtsc (implementation @DavidSchwarz)     600ns/call

所以看起来在一个相当现代的系统上，（接受的答案）rdtsc 是最糟糕的路线。

Answer 6

很难给出一个全球适用的答案，因为硬件和软件的实现会有很大差异。

但是，是的，大​​多数现代平台都会有一个合适的 clock_gettime 调用，该调用完全使用 VDSO 机制在用户空间中实现，根据我的经验，完成需要 20 到 30 纳秒（但请参阅 Wojciech's comment below 关于争用）。

在内部，这是使用 rdtsc 或 rdtscp 进行计时的细粒度部分，加上调整以使其与挂钟时间同步（取决于您选择的时钟）和乘法将您平台上 rdtsc 的任何单位转换为纳秒。

clock_gettime 提供的时钟并非所有都会实现这种快速方法，obvious 并不总是会实现。通常CLOCK_MONOTONIC 是一个不错的选择，但您应该在自己的系统上测试它。

Answer 7

当您调用 clock_gettime() 函数时会发生这种情况。

根据您选择的时钟，它将调用相应的函数。 （来自内核的 vclock_gettime.c 文件）

int clock_gettime(clockid_t, struct __kernel_old_timespec *)
    __attribute__((weak, alias("__vdso_clock_gettime")));

notrace int
__vdso_clock_gettime_stick(clockid_t clock, struct __kernel_old_timespec *ts)
{
    struct vvar_data *vvd = get_vvar_data();

switch (clock) {
case CLOCK_REALTIME:
    if (unlikely(vvd->vclock_mode == VCLOCK_NONE))
        break;
    return do_realtime_stick(vvd, ts);
case CLOCK_MONOTONIC:
    if (unlikely(vvd->vclock_mode == VCLOCK_NONE))
        break;
    return do_monotonic_stick(vvd, ts);
case CLOCK_REALTIME_COARSE:
    return do_realtime_coarse(vvd, ts);
case CLOCK_MONOTONIC_COARSE:
    return do_monotonic_coarse(vvd, ts);
}
/*
 * Unknown clock ID ? Fall back to the syscall.
 */
    return vdso_fallback_gettime(clock, ts);
}

CLOCK_MONITONIC 更好（虽然我使用CLOCK_MONOTONIC_RAW），因为它不受 NTP 时间调整的影响。

这就是do_monotonic_stick 在内核中的实现方式：

notrace static __always_inline int do_monotonic_stick(struct vvar_data *vvar,
                              struct __kernel_old_timespec *ts)
{
    unsigned long seq;
    u64 ns;

    do {
        seq = vvar_read_begin(vvar);
        ts->tv_sec = vvar->monotonic_time_sec;
        ns = vvar->monotonic_time_snsec;
        ns += vgetsns_stick(vvar);
        ns >>= vvar->clock.shift;
    } while (unlikely(vvar_read_retry(vvar, seq)));

    ts->tv_sec += __iter_div_u64_rem(ns, NSEC_PER_SEC, &ns);
    ts->tv_nsec = ns;

    return 0;
}

而提供纳秒分辨率的vgetsns_stick()函数实现为：

notrace static __always_inline u64 vgetsns(struct vvar_data *vvar)
{
    u64 v;
    u64 cycles;

    cycles = vread_tick();
    v = (cycles - vvar->clock.cycle_last) & vvar->clock.mask;
    return v * vvar->clock.mult;
}

函数vread_tick()根据CPU从寄存器中读取周期：

notrace static __always_inline u64 vread_tick(void)
{
    register unsigned long long ret asm("o4");

    __asm__ __volatile__("rd %%tick, %L0\n\t"
                 "srlx %L0, 32, %H0"
                 : "=r" (ret));
    return ret;
}

对clock_gettime() 的一次调用大约需要 20 到 100 纳秒。读取rdtsc 寄存器并将周期转换为时间总是更快。

我在这里对CLOCK_MONOTONIC_RAW 做了一些实验：Unexpected periodic behaviour of an ultra low latency hard real time multi threaded x86 code