Меры ЦП (пропуски / попадания в кэш), которые не имеют смысла

я использую Intel PCM для мелкозернистых измерений процессора. В своем коде я пытаюсь измерить эффективность кэша.

По сути, я сначала помещаю небольшой массив в кэш L1 (перебирая его много раз), затем запускаю таймер, перебираю массив еще раз (который, мы надеемся, используем кэш), а затем отключаю таймер.

PCM показывает мне, что у меня довольно высокий коэффициент промаха L2 и L3. Я также проверил с rdtscp и число циклов на операцию массива равно 15 (что намного выше, чем 4-5 циклов для доступа к кэш-памяти L1).

Я ожидал бы, что массив будет полностью помещен в кэш L1, и у меня не будет высокого коэффициента пропадания L1, L2 и L3.

Моя система имеет 32K, 256K и 25M для L1, L2 и L3 соответственно.
Вот мой код:

static const int ARRAY_SIZE = 16;

struct MyStruct {
struct MyStruct *next;
long int pad;
}; // each MyStruct is 16 bytes

int main() {
PCM * m = PCM::getInstance();
PCM::ErrorCode returnResult = m->program(PCM::DEFAULT_EVENTS, NULL);
if (returnResult != PCM::Success){
std::cerr << "Intel's PCM couldn't start" << std::endl;
exit(1);
}

MyStruct *myS = new MyStruct[ARRAY_SIZE];

// Make a sequential liked list,
for (int i=0; i < ARRAY_SIZE - 1; i++){
myS[i].next = &myS[i + 1];
myS[i].pad = (long int) i;
}
myS[ARRAY_SIZE - 1].next = NULL;
myS[ARRAY_SIZE - 1].pad = (long int) (ARRAY_SIZE - 1);

// Filling the cache
MyStruct *current;
for (int i = 0; i < 200000; i++){
current = &myS[0];
while ((current = current->n) != NULL)
current->pad += 1;
}

// Sequential access experiment
current = &myS[0];
long sum = 0;

SystemCounterState before = getSystemCounterState();

while ((current = current->n) != NULL) {
sum += current->pad;
}

SystemCounterState after = getSystemCounterState();

cout << "Instructions per clock: " << getIPC(before, after) << endl;
cout << "Cycles per op: " << getCycles(before, after) / ARRAY_SIZE << endl;
cout << "L2 Misses:     " << getL2CacheMisses(before, after) << endl;
cout << "L2 Hits:       " << getL2CacheHits(before, after) << endl;
cout << "L2 hit ratio:  " << getL2CacheHitRatio(before, after) << endl;
cout << "L3 Misses:     " << getL3CacheMisses(before_sstate,after_sstate) << endl;
cout << "L3 Hits:       " << getL3CacheHits(before, after) << endl;
cout << "L3 hit ratio:  " << getL3CacheHitRatio(before, after) << endl;

cout << "Sum:   " << sum << endl;
m->cleanup();
return 0;
}

Это вывод:

Instructions per clock: 0.408456
Cycles per op:        553074
L2 Cache Misses:      58775
L2 Cache Hits:        11371
L2 cache hit ratio:   0.162105
L3 Cache Misses:      24164
L3 Cache Hits:        34611
L3 cache hit ratio:   0.588873

РЕДАКТИРОВАТЬ:
Я также проверил следующий код и по-прежнему получаю те же коэффициенты промаха (которые я бы ожидал получить почти нулевые коэффициенты промаха):

SystemCounterState before = getSystemCounterState();
// this is just a comment
SystemCounterState after = getSystemCounterState();

РЕДАКТИРОВАТЬ 2: Как отмечается в одном комментарии, эти результаты могут быть связаны с накладными расходами самого профилировщика. Таким образом, я вместо одного раза менял код, пересекающий массив много раз (200 000 000 раз), чтобы амортизировать накладные расходы профилировщика. Я по-прежнему получаю очень низкие коэффициенты кэша L2 и L3 (% 15).