使用时间戳计数器和时钟获取缓存未命中时间

作为后续行动 topic ,为了计算内存丢失延迟,我使用 _mm_clflush , __rdtsc 和 _mm_lfence (基于此代码) question/answer ).

正如您在代码中看到的,我首先将数组加载到缓存中。然后刷新一个元素,因此缓存线将从所有缓存级别中逐出。我把 _恩斯 为了在 -O3

接下来,我使用时间戳计数器计算延迟或读取 array[0] . 正如你在两个时间戳之间所看到的,有三条指令:两条 lfence 还有一个 read . 所以,我必须减去 lfence公司 头顶上。代码的最后一部分计算该开销。

在代码末尾,将打印开销和未命中延迟。但是,结果是无效的!

#include <stdio.h>
#include <stdint.h>
#include <x86intrin.h>
int main()
{
    int array[ 100 ];
    for ( int i = 0; i < 100; i++ )
            array[ i ] = i;
    uint64_t t1, t2, ov, diff;

    _mm_lfence();
    _mm_clflush( &array[ 0 ] );
    _mm_lfence();

    _mm_lfence();
    t1 = __rdtsc();
    _mm_lfence();
    int tmp = array[ 0 ];
    _mm_lfence();
    t2 = __rdtsc();
    _mm_lfence();

    diff = t2 - t1;
    printf( "diff is %lu\n", diff );

    _mm_lfence();
    t1 = __rdtsc();
    _mm_lfence();
    _mm_lfence();
    t2 = __rdtsc();
    _mm_lfence();
    ov = t2 - t1;
    printf( "lfence overhead is %lu\n", ov );
    printf( "miss cycles is %lu\n", diff-ov );

    return 0;
}

$ gcc -O3 -o flush1 flush1.c
$ taskset -c 0 ./flush1
diff is 161
lfence overhead is 147
miss cycles is 14
$ taskset -c 0 ./flush1
diff is 161
lfence overhead is 154
miss cycles is 7
$ taskset -c 0 ./flush1
diff is 147
lfence overhead is 154
miss cycles is 18446744073709551609

有什么想法吗?

接下来,我试着 clock_gettime 函数计算未命中延迟,如下所示

    _mm_lfence();
    _mm_clflush( &array[ 0 ] );
    _mm_lfence();

    struct timespec start, end;
    clock_gettime(CLOCK_MONOTONIC, &start);
    _mm_lfence();
    int tmp = array[ 0 ];
    _mm_lfence();
    clock_gettime(CLOCK_MONOTONIC, &end);
    diff = 1000000000 * (end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec;
    printf("miss elapsed time = %lu nanoseconds\n", diff);

输出是 miss elapsed time = 578 nanoseconds

更新1:

多亏了彼得和哈迪,总结到现在为止的回答,我发现

1-优化阶段省略了未使用的变量,这就是我在输出中看到的奇怪值的原因。多亏了彼得的答复,有办法解决这个问题。

2个- 时钟时间 不适用于这种分辨率,该函数用于较大的延迟。

作为解决方法,我尝试将数组引入缓存,然后刷新所有元素,以确保所有元素都从所有缓存级别中逐出。然后我测量了 然后 array[20] . 因为每个元素是4字节,所以距离是80字节。我希望有两个缓存未命中。然而 阵列[20] 类似于缓存命中。一个安全的猜测是缓存线不是80字节。所以,也许 阵列[20]

    for ( int i = 0; i < 100; i++ ) {
            _mm_lfence();
            _mm_clflush( &array[ i ] );
            _mm_lfence();
    }

    _mm_lfence();
    t1 = __rdtsc();
    _mm_lfence();
    int tmp = array[ 0 ];
    _mm_lfence();
    t2 = __rdtsc();
    _mm_lfence();
    diff1 = t2 - t1;
    printf( "tmp is %d\ndiff1 is %lu\n", tmp, diff1 );

    _mm_lfence();
    t1 = __rdtsc();
    tmp = array[ 20 ];
    _mm_lfence();
    t2 = __rdtsc();
    _mm_lfence();
    diff2 = t2 - t1;
    printf( "tmp is %d\ndiff2 is %lu\n", tmp, diff2 );

    _mm_lfence();
    t1 = __rdtsc();
    _mm_lfence();
    _mm_lfence();
    t2 = __rdtsc();
    _mm_lfence();
    ov = t2 - t1;
    printf( "lfence overhead is %lu\n", ov );
    printf( "TSC1 is %lu\n", diff1-ov );
    printf( "TSC2 is %lu\n", diff2-ov );

输出为

$ ./flush1
tmp is 0
diff1 is 371
tmp is 20
diff2 is 280
lfence overhead is 147
TSC1 is 224
TSC2 is 133
$ ./flush1
tmp is 0
diff1 is 399
tmp is 20
diff2 is 280
lfence overhead is 154
TSC1 is 245
TSC2 is 126
$ ./flush1
tmp is 0
diff1 is 392
tmp is 20
diff2 is 840
lfence overhead is 147
TSC1 is 245
TSC2 is 693
$ ./flush1
tmp is 0
diff1 is 364
tmp is 20
diff2 is 140
lfence overhead is 154
TSC1 is 210
TSC2 is 18446744073709551602

那么,“HW prefetcher带来其他块”的说法大约正确80%。那是怎么回事?还有更准确的说法吗?