clflush для аннулирования строки кэша через функцию C
Я пытаюсь использовать clflush вручную вытеснить строку кэша, чтобы определить размеры кэша и строки. Я не нашел никакого руководства о том, как использовать эту инструкцию. Все, что я вижу, - это некоторые коды, которые используют функции более высокого уровня для этой цели.
Есть функция ядра void clflush_cache_range(void *vaddr, unsigned int size), но я все еще не знаю, что включить в мой код и как его использовать. Я не знаю что это size в этой функции.
Более того, как я могу быть уверен, что строка выселена, чтобы проверить правильность моего кода?
ОБНОВИТЬ:
Вот исходный код того, что я пытаюсь сделать.
#include <immintrin.h>
#include <stdint.h>
#include <x86intrin.h>
#include <stdio.h>
int main()
{
int array[ 100 ];
/* will bring array in the cache */
for ( int i = 0; i < 100; i++ )
array[ i ] = i;
/* FLUSH A LINE */
/* each element is 4 bytes */
/* assuming that cache line size is 64 bytes */
/* array[0] till array[15] is flushed */
/* even if line size is less than 64 bytes */
/* we are sure that array[0] has been flushed */
_mm_clflush( &array[ 0 ] );
int tm = 0;
register uint64_t time1, time2, time3;
time1 = __rdtscp( &tm ); /* set timer */
time2 = __rdtscp( &array[ 0 ] ) - time1; /* array[0] is a cache miss */
printf( "miss latency = %lu \n", time2 );
time3 = __rdtscp( &array[ 0 ] ) - time2; /* array[0] is a cache hit */
printf( "hit latency = %lu \n", time3 );
return 0;
}
Перед запуском кода я хотел бы вручную проверить, что это правильный код. Я на правильном пути? Я использовал _mm_clflush правильно?
ОБНОВИТЬ:
Благодаря комментарию Питера я исправил код следующим образом
time1 = __rdtscp( &tm ); /* set timer */
time2 = __rdtscp( &array[ 0 ] ) - time1; /* array[0] is a cache miss */
printf( "miss latency = %lu \n", time2 );
time1 = __rdtscp( &tm ); /* set timer */
time2 = __rdtscp( &array[ 0 ] ) - time1; /* array[0] is a cache hit */
printf( "hit latency = %lu \n", time1 );
Запустив код несколько раз, я получаю следующий вывод
$ ./flush
miss latency = 238
hit latency = 168
$ ./flush
miss latency = 154
hit latency = 140
$ ./flush
miss latency = 252
hit latency = 140
$ ./flush
miss latency = 266
hit latency = 252
Первый запуск кажется разумным. Но второй прогон выглядит странно. Запустив код из командной строки, каждый раз, когда массив инициализируется значениями, а затем я явно вытесняю первую строку.
UPDATE4:
Я попробовал код Хади-Брейса и вот результаты
naderan@webshub:~$ ./flush3
address = 0x7ffec7a92220
array[ 0 ] = 0
miss section latency = 378
array[ 0 ] = 0
hit section latency = 175
overhead latency = 161
Measured L1 hit latency = 14 TSC cycles
Measured main memory latency = 217 TSC cycles
naderan@webshub:~$ ./flush3
address = 0x7ffedbe0af40
array[ 0 ] = 0
miss section latency = 392
array[ 0 ] = 0
hit section latency = 231
overhead latency = 168
Measured L1 hit latency = 63 TSC cycles
Measured main memory latency = 224 TSC cycles
naderan@webshub:~$ ./flush3
address = 0x7ffead7fdc90
array[ 0 ] = 0
miss section latency = 399
array[ 0 ] = 0
hit section latency = 161
overhead latency = 147
Measured L1 hit latency = 14 TSC cycles
Measured main memory latency = 252 TSC cycles
naderan@webshub:~$ ./flush3
address = 0x7ffe51a77310
array[ 0 ] = 0
miss section latency = 364
array[ 0 ] = 0
hit section latency = 182
overhead latency = 161
Measured L1 hit latency = 21 TSC cycles
Measured main memory latency = 203 TSC cycles
Немного разные задержки допустимы. Однако латентность попадания 63 по сравнению с 21 и 14 также наблюдается.
UPDATE5:
Когда я проверял Ubuntu, функция энергосбережения не включена. Возможно изменение частоты отключено в биосе, или есть конфигурация промаха
$ cat /proc/cpuinfo | grep -E "(model|MHz)"
model : 79
model name : Intel(R) Xeon(R) CPU E5-2620 v4 @ 2.10GHz
cpu MHz : 2097.571
model : 79
model name : Intel(R) Xeon(R) CPU E5-2620 v4 @ 2.10GHz
cpu MHz : 2097.571
$ lscpu | grep MHz
CPU MHz: 2097.571
В любом случае, это означает, что частота установлена на максимальное значение, и это то, что мне нужно. Работая несколько раз, я вижу несколько разных значений. Это нормально?
$ taskset -c 0 ./flush3
address = 0x7ffe30c57dd0
array[ 0 ] = 0
miss section latency = 602
array[ 0 ] = 0
hit section latency = 161
overhead latency = 147
Measured L1 hit latency = 14 TSC cycles
Measured main memory latency = 455 TSC cycles
$ taskset -c 0 ./flush3
address = 0x7ffd16932fd0
array[ 0 ] = 0
miss section latency = 399
array[ 0 ] = 0
hit section latency = 168
overhead latency = 147
Measured L1 hit latency = 21 TSC cycles
Measured main memory latency = 252 TSC cycles
$ taskset -c 0 ./flush3
address = 0x7ffeafb96580
array[ 0 ] = 0
miss section latency = 364
array[ 0 ] = 0
hit section latency = 161
overhead latency = 140
Measured L1 hit latency = 21 TSC cycles
Measured main memory latency = 224 TSC cycles
$ taskset -c 0 ./flush3
address = 0x7ffe58291de0
array[ 0 ] = 0
miss section latency = 357
array[ 0 ] = 0
hit section latency = 168
overhead latency = 140
Measured L1 hit latency = 28 TSC cycles
Measured main memory latency = 217 TSC cycles
$ taskset -c 0 ./flush3
address = 0x7fffa76d20b0
array[ 0 ] = 0
miss section latency = 371
array[ 0 ] = 0
hit section latency = 161
overhead latency = 147
Measured L1 hit latency = 14 TSC cycles
Measured main memory latency = 224 TSC cycles
$ taskset -c 0 ./flush3
address = 0x7ffdec791580
array[ 0 ] = 0
miss section latency = 357
array[ 0 ] = 0
hit section latency = 189
overhead latency = 147
Measured L1 hit latency = 42 TSC cycles
Measured main memory latency = 210 TSC cycles
2 ответа
У вас есть несколько ошибок в коде, которые могут привести к бессмысленным измерениям, которые вы видите. Я исправил ошибки, и вы можете найти объяснение в комментариях ниже.
/* compile with gcc at optimization level -O3 */
/* set the minimum and maximum CPU frequency for all cores using cpupower to get meaningful results */
/* run using "sudo nice -n -20 ./a.out" to minimize possible context switches, or at least use "taskset -c 0 ./a.out" */
/* you can optionally use a p-state scaling driver other than intel_pstate to get more reproducable results */
/* This code still needs improvement to obtain more accurate measurements,
and a lot of effort is required to do that—argh! */
/* Specifically, there is no single constant latency for the L1 because of
the way it's designed, and more so for main memory. */
/* Things such as virtual addresses, physical addresses, TLB contents,
code addresses, and interrupts may have an impact that needs to be
investigated */
/* The instructions that GCC puts unnecessarily in the timed section are annoying AF */
/* This code is written to run on Intel processors! */
#include <stdint.h>
#include <x86intrin.h>
#include <stdio.h>
int main()
{
int array[ 100 ];
/* this is optional */
/* will bring array in the cache */
for ( int i = 0; i < 100; i++ )
array[ i ] = i;
printf( "address = %p \n", &array[ 0 ] ); /* guaranteed to be aligned within a single cache line */
_mm_mfence(); /* prevent clflush from being reordered by the CPU or the compiler in this direction */
/* flush the line containing the element */
_mm_clflush( &array[ 0 ] );
//unsigned int aux;
uint64_t time1, time2, msl, hsl, osl; /* initial values don't matter */
/* rdtscp is not suitbale for measuing very small sections of code because
the write to its parameter occurs after sampling the TSC and it impacts
compiler optimizations and code gen, thereby perturbing the measurement */
_mm_mfence(); /* this properly orders both clflush and rdtscp*/
_mm_lfence(); /* mfence and lfence must be in this order + compiler barrier for rdtscp */
time1 = __rdtsc(); /* set timer */
_mm_lfence(); /* serialize __rdtscp with respect to trailing instructions + compiler barrier for rdtscp and the load */
int temp = array[ 0 ]; /* array[0] is a cache miss */
/* measring the write miss latency to array is not meaningful because it's an implementation detail and the next write may also miss */
/* no need for mfence because there are no stores in between */
_mm_lfence(); /* mfence and lfence must be in this order + compiler barrier for rdtscp and the load*/
time2 = __rdtsc();
_mm_lfence(); /* serialize __rdtscp with respect to trailing instructions */
msl = time2 - time1;
printf( "array[ 0 ] = %i \n", temp ); /* prevent the compiler from optimizing the load */
printf( "miss section latency = %lu \n", msl ); /* the latency of everything in between the two rdtscp */
_mm_mfence(); /* this properly orders both clflush and rdtscp*/
_mm_lfence(); /* mfence and lfence must be in this order + compiler barrier for rdtscp */
time1 = __rdtsc(); /* set timer */
_mm_lfence(); /* serialize __rdtscp with respect to trailing instructions + compiler barrier for rdtscp and the load */
temp = array[ 0 ]; /* array[0] is a cache hit as long as the OS, a hardware prefetcher, or a speculative accesses to the L1D or lower level inclusive caches don't evict it */
/* measring the write miss latency to array is not meaningful because it's an implementation detail and the next write may also miss */
/* no need for mfence because there are no stores in between */
_mm_lfence(); /* mfence and lfence must be in this order + compiler barrier for rdtscp and the load */
time2 = __rdtsc();
_mm_lfence(); /* serialize __rdtscp with respect to trailing instructions */
hsl = time2 - time1;
printf( "array[ 0 ] = %i \n", temp ); /* prevent the compiler from optimizing the load */
printf( "hit section latency = %lu \n", hsl ); /* the latency of everything in between the two rdtscp */
_mm_mfence(); /* this properly orders both clflush and rdtscp*/
_mm_lfence(); /* mfence and lfence must be in this order + compiler barrier for rdtscp */
time1 = __rdtsc(); /* set timer */
_mm_lfence(); /* serialize __rdtscp with respect to trailing instructions + compiler barrier for rdtscp */
/* no need for mfence because there are no stores in between */
_mm_lfence(); /* mfence and lfence must be in this order + compiler barrier for rdtscp */
time2 = __rdtsc();
_mm_lfence(); /* serialize __rdtscp with respect to trailing instructions */
osl = time2 - time1;
printf( "overhead latency = %lu \n", osl ); /* the latency of everything in between the two rdtscp */
printf( "Measured L1 hit latency = %lu TSC cycles\n", hsl - osl ); /* hsl is always larger than osl */
printf( "Measured main memory latency = %lu TSC cycles\n", msl - osl ); /* msl is always larger than osl and hsl */
return 0;
}
Настоятельно рекомендуется: измерение задержки памяти со счетчиком меток времени.
Связанный: Как я могу создать призрачный гаджет на практике?,
Вы знаете, что можете запросить размер строки с cpuid, право? Сделайте это, если вы действительно хотите найти это программно. (В противном случае, предположим, что это 64 байта, потому что это на всем после PIII.)
Но уверен, если хотите использовать clflush или же clflushopt из C по любой причине, используйте void _mm_clflush(void const *p) или же void _mm_clflushopt(void const *p), от #include <immintrin.h>, (См. Руководство Intel по установке insn set ref дляclflush или же clflushopt).
GCC, Clang, ICC и MSVC все поддерживают Intel <immintrin.h>. встроенные функции
Вы также можете найти это, выполнив поиск по руководству Intel по внутреннимclflush чтобы найти определения для этой инструкции.
см. также https://stackru.com/tags/x86/info для получения дополнительных ссылок на руководства, документы и справочные руководства.
Более того, как я могу быть уверен, что строка выселена, чтобы проверить правильность моего кода?
Посмотрите на вывод asm компилятора или пошагово в отладчике. Если когда clflush выполняет, что строка кэша высвобождается в этот момент в вашей программе.