Вот мой модифицированный код. Он каждый раз выполняет STEP байт, обновляя память. Я выбрал STEP в соответствии с размером строки кеша моего процессора (64 байта). Он повторяет цикл заполнения REPEAT раз. Он записывает один байт в каждую строку кэша.
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#define ARRAYSIZE(arr) (sizeof(arr)/sizeof(arr[0]))
#define STEP (64)
#define REPEAT (1000)
inline void
clflush(volatile void *p)
{
asm volatile ("clflush (%0)" :: "r"(p));
}
inline uint64_t
rdtsc()
{
unsigned long a, d;
asm volatile ("cpuid; rdtsc" : "=a" (a), "=d" (d) : : "ebx", "ecx");
return a | ((uint64_t)d << 32);
}
//volatile int i;
volatile unsigned char data[1 << 26]; // 64MB
void sequentialAccess(int bytes)
{
for (int j = 0; j < REPEAT; j++)
for (int i = 0; i < bytes; i += STEP)
data[i] = i;
}
int rangeArr[] = {16, 32, 64, 128, 256, 512, 1024, 2048, 3072, 4096, 6144, 8192, 10240, 12*1024, 14*1024, 16*1024};
inline void test()
{
for (int i = 0; i < ARRAYSIZE(rangeArr); i++)
{
uint64_t start, end;
int kilobytes = rangeArr[i];
start = rdtsc();
sequentialAccess(kilobytes * 1024);
end = rdtsc();
double ticksPerAccess = 1.0 * (end - start)/(kilobytes * 1024/STEP)/REPEAT;
printf("%d kB took %lf ticks per access\n", kilobytes, ticksPerAccess);
}
}
int
main(int ac, char **av)
{
test();
return 0;
}
На моем "AMD Phenom (TM) II X4 965 Processor" (строка из /proc/cpuinfo), я получил следующие результаты:
16 kB took 9.148758 ticks per access
32 kB took 8.855980 ticks per access
64 kB took 9.008148 ticks per access
128 kB took 17.197035 ticks per access
256 kB took 14.416313 ticks per access
512 kB took 15.845552 ticks per access
1024 kB took 21.394375 ticks per access
2048 kB took 21.379112 ticks per access
3072 kB took 21.399206 ticks per access
4096 kB took 21.630234 ticks per access
6144 kB took 23.907972 ticks per access
8192 kB took 46.306525 ticks per access
10240 kB took 49.292271 ticks per access
12288 kB took 49.575894 ticks per access
14336 kB took 49.758874 ticks per access
16384 kB took 49.660779 ticks per access
Это выглядит немного больше похоже на кривой Ульриха.
Редактировать: При ближайшем рассмотрении первоначального ориентира Ульриха Drepper, я понял, что он строит связанный список вне области измерения, а затем измерения стоимости чеканки, что связанный список. Это измеряет параметр, называемый «load to use latency», и это очень полезный параметр для извлечения из системы памяти.
Следующий код, который, я считаю, ближе подходит к этому оригинальному идеалу. Он также набрал количество итераций значительно, чтобы гарантировать, что функции энергосбережения на моем процессоре не попадают.
В приведенном ниже коде вы можете настроить NPAD в соответствии с размером строки кеша вашего процессора. Вы можете настроить ACCESSES, чтобы контролировать количество повторений цикла эталонных тестов. Общее количество итераций полностью не зависит от размера набора данных.
Код:
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#define NPAD (64 - sizeof(void *))
#define ACCESSES (1 << 28)
inline void
clflush(volatile void *p)
{
asm volatile ("clflush (%0)" :: "r"(p));
}
inline uint64_t
rdtsc()
{
unsigned long a, d;
asm volatile ("cpuid; rdtsc" : "=a" (a), "=d" (d) : : "ebx", "ecx");
return a | ((uint64_t)d << 32);
}
struct l
{
l *next;
char pad[NPAD];
};
l array[ (1 << 26)/sizeof(l) ];
void init_sequential(int bytes)
{
int elems = bytes/sizeof(l);
for (int i = 1; i < elems; i++)
{
array[i - 1].next = &array[i];
}
array[elems - 1].next = &array[0];
}
void measure_baseline(int accesses)
{
volatile l *ptr = &array[0];
while (accesses-- > 0)
ptr = ptr->next;
}
int rangeArr[] = {16, 32, 64, 128, 256, 512, 1024, 2048, 3072, 4096, 6144, 8192, 10240, 12*1024, 14*1024, 16*1024};
inline void test()
{
for (int i = 0; i < sizeof(rangeArr)/sizeof(rangeArr[0]); i++)
{
uint64_t start, end;
int kilobytes = rangeArr[i];
init_sequential(kilobytes * 1024);
start = rdtsc();
measure_baseline(ACCESSES);
end = rdtsc();
double ticksPerAccess = 1.0 * (end - start)/ACCESSES;
printf("%d kB took %lf ticks per access\n", kilobytes, ticksPerAccess);
}
}
int
main(int ac, char **av)
{
test();
return 0;
}
А вот данные, собранные от моего процессора:
16 kB took 3.062668 ticks per access
32 kB took 3.002012 ticks per access
64 kB took 3.001376 ticks per access
128 kB took 9.204764 ticks per access
256 kB took 9.284414 ticks per access
512 kB took 15.848642 ticks per access
1024 kB took 22.645605 ticks per access
2048 kB took 22.698062 ticks per access
3072 kB took 23.039498 ticks per access
4096 kB took 23.481494 ticks per access
6144 kB took 37.720315 ticks per access
8192 kB took 55.197783 ticks per access
10240 kB took 55.886692 ticks per access
12288 kB took 56.262199 ticks per access
14336 kB took 56.153559 ticks per access
16384 kB took 55.879395 ticks per access
Это показывает нагрузку 3 цикла использовать задержку для данных в L1D, что я ожидаю для этого процессор (и большинство основных высокопроизводительных процессоров с ПК).
Это, безусловно, похоже на предварительную выборку, это хорошая работа. Какой процессор, BTW? Intel? AMD? Модель? –
x86_64, intel i5 – sud03r
Я только что запустил ваш код на своем процессоре AMD Phenom x4 и получил аналогичные результаты. Мне нужно было внести некоторые незначительные изменения, чтобы скомпилировать его. (Например, я удалил 'volatile int i', и я положил' for (j = 0; j <10000; j ++) 'вокруг цикла последовательного доступа.) –