キャッシュレイテンシの測定

Question

したがって、Cを使用してL1、L2、L3キャッシュのレイテンシを測定しようとしています。それらのサイズはわかっており、概念的にその方法を理解しているように感じますが、実装で問題が発生しています。プリフェッチのような他のハードウェアの複雑さが問題を引き起こしているのではないかと思います。

#include <time.h> #include <stdio.h> #include <string.h> int main(){ srand(time(NULL)); // Seed ONCE const int L1_CACHE_SIZE = 32768/sizeof(int); const int L2_CACHE_SIZE = 262144/sizeof(int); const int L3_CACHE_SIZE = 6587392/sizeof(int); const int NUM_ACCESSES = 1000000; const int SECONDS_PER_NS = 1000000000; int arrayAccess[L1_CACHE_SIZE]; int arrayInvalidateL1[L1_CACHE_SIZE]; int arrayInvalidateL2[L2_CACHE_SIZE]; int arrayInvalidateL3[L3_CACHE_SIZE]; int count=0; int index=0; int i=0; struct timespec startAccess, endAccess; double mainMemAccess, L1Access, L2Access, L3Access; int readValue=0; memset(arrayAccess, 0, L1_CACHE_SIZE*sizeof(int)); memset(arrayInvalidateL1, 0, L1_CACHE_SIZE*sizeof(int)); memset(arrayInvalidateL2, 0, L2_CACHE_SIZE*sizeof(int)); memset(arrayInvalidateL3, 0, L3_CACHE_SIZE*sizeof(int)); index = 0; clock_gettime(CLOCK_REALTIME, &startAccess); //start clock while (index < L1_CACHE_SIZE) { int tmp = arrayAccess[index]; //Access Value from L2 index = (index + tmp + ((index & 4) ? 28 : 36)); // on average this should give 32 element skips, with changing strides count++; //divide overall time by this } clock_gettime(CLOCK_REALTIME, &endAccess); //end clock mainMemAccess = ((endAccess.tv_sec - startAccess.tv_sec) * SECONDS_PER_NS) + (endAccess.tv_nsec - startAccess.tv_nsec); mainMemAccess /= count; printf("Main Memory Access %lf
", mainMemAccess); index = 0; count=0; clock_gettime(CLOCK_REALTIME, &startAccess); //start clock while (index < L1_CACHE_SIZE) { int tmp = arrayAccess[index]; //Access Value from L2 index = (index + tmp + ((index & 4) ? 28 : 36)); // on average this should give 32 element skips, with changing strides count++; //divide overall time by this } clock_gettime(CLOCK_REALTIME, &endAccess); //end clock L1Access = ((endAccess.tv_sec - startAccess.tv_sec) * SECONDS_PER_NS) + (endAccess.tv_nsec - startAccess.tv_nsec); L1Access /= count; printf("L1 Cache Access %lf
", L1Access); //invalidate L1 by accessing all elements of array which is larger than cache for(count=0; count < L1_CACHE_SIZE; count++){ int read = arrayInvalidateL1[count]; read++; readValue+=read; } index = 0; count = 0; clock_gettime(CLOCK_REALTIME, &startAccess); //start clock while (index < L1_CACHE_SIZE) { int tmp = arrayAccess[index]; //Access Value from L2 index = (index + tmp + ((index & 4) ? 28 : 36)); // on average this should give 32 element skips, with changing strides count++; //divide overall time by this } clock_gettime(CLOCK_REALTIME, &endAccess); //end clock L2Access = ((endAccess.tv_sec - startAccess.tv_sec) * SECONDS_PER_NS) + (endAccess.tv_nsec - startAccess.tv_nsec); L2Access /= count; printf("L2 Cache Acces %lf
", L2Access); //invalidate L2 by accessing all elements of array which is larger than cache for(count=0; count < L2_CACHE_SIZE; count++){ int read = arrayInvalidateL2[count]; read++; readValue+=read; } index = 0; count=0; clock_gettime(CLOCK_REALTIME, &startAccess); //sreadValue+=read;tart clock while (index < L1_CACHE_SIZE) { int tmp = arrayAccess[index]; //Access Value from L2 index = (index + tmp + ((index & 4) ? 28 : 36)); // on average this should give 32 element skips, with changing strides count++; //divide overall time by this } clock_gettime(CLOCK_REALTIME, &endAccess); //end clock L3Access = ((endAccess.tv_sec - startAccess.tv_sec) * SECONDS_PER_NS) + (endAccess.tv_nsec - startAccess.tv_nsec); L3Access /= count; printf("L3 Cache Access %lf
", L3Access); printf("Read Value: %d", readValue); }

まず、データを取得する配列の値にアクセスします。これは最初のアクセスであるため、明らかにメインメモリから取得されます。配列は小さい（ページサイズよりも小さい）ため、L1、L2、L3にコピーする必要があります。同じ配列から値にアクセスします。これでL1になります。次に、L1キャッシュと同じサイズの配列からすべての値にアクセスして、アクセスしたいデータを無効にします（これで、L2/3になるはずです）。次に、このプロセスをL2とL3について繰り返します。しかし、アクセス時間は明らかにずれています。つまり、私は何か間違ったことをしています...

クロックにかかる時間に問題があるかもしれないと思います（開始と停止にはnsの時間がかかり、それらがキャッシュされているかどうかが変わると変化します）

誰かが私が間違っているかもしれないことについていくつかの指針を教えてもらえますか？

UPDATE1：そこで、大量のアクセスを行うことでタイマーのコストを償却し、キャッシュのサイズを修正しました。また、修正されたストライドを回避するために、より複雑なインデックススキーマを作成するようアドバイスしました。残念ながら、時代はまだオフです。彼らはすべてL1に来るようです。問題はアクセスするのではなく無効にすることであると考えています。ランダムvs LRUスキームは無効化されるデータに影響しますか？

UPDATE2：memset（L3のデータを無効にするためにL3 memsetを追加して、最初のアクセスがメインメモリで開始されるように修正）とインデックス作成スキームを修正しましたが、まだうまくいきません。

UPDATE3：この方法を機能させることはできませんでしたが、いくつかの良い提案された回答があり、自分でいくつかの解決策を投稿しました。

Cachegrindを実行してヒット/ミスを表示しました

 ==6710== I refs: 1,735,104 ==6710== I1 misses: 1,092 ==6710== LLi misses: 1,084 ==6710== I1 miss rate: 0.06% ==6710== LLi miss rate: 0.06% ==6710== ==6710== D refs: 1,250,696 (721,162 rd + 529,534 wr) ==6710== D1 misses: 116,492 ( 7,627 rd + 108,865 wr) ==6710== LLd misses: 115,102 ( 6,414 rd + 108,688 wr) ==6710== D1 miss rate: 9.3% ( 1.0% + 20.5% ) ==6710== LLd miss rate: 9.2% ( 0.8% + 20.5% ) ==6710== ==6710== LL refs: 117,584 ( 8,719 rd + 108,865 wr) ==6710== LL misses: 116,186 ( 7,498 rd + 108,688 wr) ==6710== LL miss rate: 3.8% ( 0.3% + 20.5% ) Ir I1mr ILmr Dr D1mr DLmr Dw D1mw DLmw . . . . . . . . . #include <time.h> . . . . . . . . . #include <stdio.h> . . . . . . . . . #include <string.h> . . . . . . . . . 6 0 0 0 0 0 2 0 0 int main(){ 5 1 1 0 0 0 2 0 0 srand(time(NULL)); // Seed ONCE 1 0 0 0 0 0 1 0 0 const int L1_CACHE_SIZE = 32768/sizeof(int); 1 0 0 0 0 0 1 0 0 const int L2_CACHE_SIZE = 262144/sizeof(int); 1 0 0 0 0 0 1 0 0 const int L3_CACHE_SIZE = 6587392/sizeof(int); 1 0 0 0 0 0 1 0 0 const int NUM_ACCESSES = 1000000; 1 0 0 0 0 0 1 0 0 const int SECONDS_PER_NS = 1000000000; 21 2 2 3 0 0 3 0 0 int arrayAccess[L1_CACHE_SIZE]; 21 1 1 3 0 0 3 0 0 int arrayInvalidateL1[L1_CACHE_SIZE]; 21 2 2 3 0 0 3 0 0 int arrayInvalidateL2[L2_CACHE_SIZE]; 21 1 1 3 0 0 3 0 0 int arrayInvalidateL3[L3_CACHE_SIZE]; 1 0 0 0 0 0 1 0 0 int count=0; 1 1 1 0 0 0 1 0 0 int index=0; 1 0 0 0 0 0 1 0 0 int i=0; . . . . . . . . . struct timespec startAccess, endAccess; . . . . . . . . . double mainMemAccess, L1Access, L2Access, L3Access; 1 0 0 0 0 0 1 0 0 int readValue=0; . . . . . . . . . 7 0 0 2 0 0 1 1 1 memset(arrayAccess, 0, L1_CACHE_SIZE*sizeof(int)); 7 1 1 2 2 0 1 0 0 memset(arrayInvalidateL1, 0, L1_CACHE_SIZE*sizeof(int)); 7 0 0 2 2 0 1 0 0 memset(arrayInvalidateL2, 0, L2_CACHE_SIZE*sizeof(int)); 7 1 1 2 2 0 1 0 0 memset(arrayInvalidateL3, 0, L3_CACHE_SIZE*sizeof(int)); . . . . . . . . . 1 0 0 0 0 0 1 1 1 index = 0; 4 0 0 0 0 0 1 0 0 clock_gettime(CLOCK_REALTIME, &startAccess); //start clock 772 1 1 514 0 0 0 0 0 while (index < L1_CACHE_SIZE) { 1,280 1 1 768 257 257 256 0 0 int tmp = arrayAccess[index]; //Access Value from L2 2,688 0 0 768 0 0 256 0 0 index = (index + tmp + ((index & 4) ? 28 : 36)); // on average this should give 32 element skips, with changing strides 256 0 0 256 0 0 0 0 0 count++; //divide overall time by this . . . . . . . . . } 4 0 0 0 0 0 1 0 0 clock_gettime(CLOCK_REALTIME, &endAccess); //end clock 14 1 1 5 1 1 1 1 1 mainMemAccess = ((endAccess.tv_sec - startAccess.tv_sec) * SECONDS_PER_NS) + (endAccess.tv_nsec - startAccess.tv_nsec); 6 0 0 2 0 0 1 0 0 mainMemAccess /= count; . . . . . . . . . 6 1 1 2 0 0 2 0 0 printf("Main Memory Access %lf
", mainMemAccess); . . . . . . . . . 1 0 0 0 0 0 1 0 0 index = 0; 1 0 0 0 0 0 1 0 0 count=0; 4 1 1 0 0 0 1 0 0 clock_gettime(CLOCK_REALTIME, &startAccess); //start clock 772 1 1 514 0 0 0 0 0 while (index < L1_CACHE_SIZE) { 1,280 0 0 768 240 0 256 0 0 int tmp = arrayAccess[index]; //Access Value from L2 2,688 0 0 768 0 0 256 0 0 index = (index + tmp + ((index & 4) ? 28 : 36)); // on average this should give 32 element skips, with changing strides 256 0 0 256 0 0 0 0 0 count++; //divide overall time by this . . . . . . . . . } 4 0 0 0 0 0 1 0 0 clock_gettime(CLOCK_REALTIME, &endAccess); //end clock 14 1 1 5 0 0 1 1 0 L1Access = ((endAccess.tv_sec - startAccess.tv_sec) * SECONDS_PER_NS) + (endAccess.tv_nsec - startAccess.tv_nsec); 6 1 1 2 0 0 1 0 0 L1Access /= count; . . . . . . . . . 6 0 0 2 0 0 2 0 0 printf("L1 Cache Access %lf
", L1Access); . . . . . . . . . . . . . . . . . . //invalidate L1 by accessing all elements of array which is larger than cache 32,773 1 1 24,578 0 0 1 0 0 for(count=0; count < L1_CACHE_SIZE; count++){ 40,960 0 0 24,576 513 513 8,192 0 0 int read = arrayInvalidateL1[count]; 8,192 0 0 8,192 0 0 0 0 0 read++; 16,384 0 0 16,384 0 0 0 0 0 readValue+=read; . . . . . . . . . } . . . . . . . . . 1 0 0 0 0 0 1 0 0 index = 0; 1 1 1 0 0 0 1 0 0 count = 0; 4 0 0 0 0 0 1 1 0 clock_gettime(CLOCK_REALTIME, &startAccess); //start clock 772 1 1 514 0 0 0 0 0 while (index < L1_CACHE_SIZE) { 1,280 0 0 768 256 0 256 0 0 int tmp = arrayAccess[index]; //Access Value from L2 2,688 0 0 768 0 0 256 0 0 index = (index + tmp + ((index & 4) ? 28 : 36)); // on average this should give 32 element skips, with changing strides 256 0 0 256 0 0 0 0 0 count++; //divide overall time by this . . . . . . . . . } 4 1 1 0 0 0 1 0 0 clock_gettime(CLOCK_REALTIME, &endAccess); //end clock 14 0 0 5 1 0 1 1 0 L2Access = ((endAccess.tv_sec - startAccess.tv_sec) * SECONDS_PER_NS) + (endAccess.tv_nsec - startAccess.tv_nsec); 6 1 1 2 0 0 1 0 0 L2Access /= count; . . . . . . . . . 6 0 0 2 0 0 2 0 0 printf("L2 Cache Acces %lf
", L2Access); . . . . . . . . . . . . . . . . . . //invalidate L2 by accessing all elements of array which is larger than cache 262,149 2 2 196,610 0 0 1 0 0 for(count=0; count < L2_CACHE_SIZE; count++){ 327,680 0 0 196,608 4,097 4,095 65,536 0 0 int read = arrayInvalidateL2[count]; 65,536 0 0 65,536 0 0 0 0 0 read++; 131,072 0 0 131,072 0 0 0 0 0 readValue+=read; . . . . . . . . . } . . . . . . . . . 1 0 0 0 0 0 1 0 0 index = 0; 1 0 0 0 0 0 1 0 0 count=0; 4 0 0 0 0 0 1 1 0 clock_gettime(CLOCK_REALTIME, &startAccess); //sreadValue+=read;tart clock 772 1 1 514 0 0 0 0 0 while (index < L1_CACHE_SIZE) { 1,280 0 0 768 256 0 256 0 0 int tmp = arrayAccess[index]; //Access Value from L2 2,688 0 0 768 0 0 256 0 0 index = (index + tmp + ((index & 4) ? 28 : 36)); // on average this should give 32 element skips, with changing strides 256 0 0 256 0 0 0 0 0 count++; //divide overall time by this . . . . . . . . . } 4 0 0 0 0 0 1 0 0 clock_gettime(CLOCK_REALTIME, &endAccess); //end clock 14 1 1 5 1 0 1 1 0 L3Access = ((endAccess.tv_sec - startAccess.tv_sec) * SECONDS_PER_NS) + (endAccess.tv_nsec - startAccess.tv_nsec); 6 0 0 2 0 0 1 0 0 L3Access /= count; . . . . . . . . . 6 1 1 2 0 0 2 0 0 printf("L3 Cache Access %lf
", L3Access); . . . . . . . . . 6 0 0 1 0 0 1 0 0 printf("Read Value: %d", readValue); . . . . . . . . . 3 0 0 3 0 0 0 0 0 }

Sergey L. · Accepted Answer

むしろハードウェアクロックを目安にしてみたいと思います。 rdtsc命令は、CPUに電源が投入されてからの現在のサイクルカウントを通知します。また、asmを使用して、測定とドライランの両方で常に同じ命令が使用されるようにすることをお勧めします。それと私がずっと前にこれを作ったいくつかの賢い統計を使用します：

#include <stdlib.h> #include <stdio.h> #include <stdint.h> #include <fcntl.h> #include <unistd.h> #include <string.h> #include <sys/mman.h> int i386_cpuid_caches (size_t * data_caches) { int i; int num_data_caches = 0; for (i = 0; i < 32; i++) { // Variables to hold the contents of the 4 i386 legacy registers uint32_t eax, ebx, ecx, edx; eax = 4; // get cache info ecx = i; // cache id asm ( "cpuid" // call i386 cpuid instruction : "+a" (eax) // contains the cpuid command code, 4 for cache query , "=b" (ebx) , "+c" (ecx) // contains the cache id , "=d" (edx) ); // generates output in 4 registers eax, ebx, ecx and edx // taken from http://download.intel.com/products/processor/manual/325462.pdf Vol. 2A 3-149 int cache_type = eax & 0x1F; if (cache_type == 0) // end of valid cache identifiers break; char * cache_type_string; switch (cache_type) { case 1: cache_type_string = "Data Cache"; break; case 2: cache_type_string = "Instruction Cache"; break; case 3: cache_type_string = "Unified Cache"; break; default: cache_type_string = "Unknown Type Cache"; break; } int cache_level = (eax >>= 5) & 0x7; int cache_is_self_initializing = (eax >>= 3) & 0x1; // does not need SW initialization int cache_is_fully_associative = (eax >>= 1) & 0x1; // taken from http://download.intel.com/products/processor/manual/325462.pdf 3-166 Vol. 2A // ebx contains 3 integers of 10, 10 and 12 bits respectively unsigned int cache_sets = ecx + 1; unsigned int cache_coherency_line_size = (ebx & 0xFFF) + 1; unsigned int cache_physical_line_partitions = ((ebx >>= 12) & 0x3FF) + 1; unsigned int cache_ways_of_associativity = ((ebx >>= 10) & 0x3FF) + 1; // Total cache size is the product size_t cache_total_size = cache_ways_of_associativity * cache_physical_line_partitions * cache_coherency_line_size * cache_sets; if (cache_type == 1 || cache_type == 3) { data_caches[num_data_caches++] = cache_total_size; } printf( "Cache ID %d:
" "- Level: %d
" "- Type: %s
" "- Sets: %d
" "- System Coherency Line Size: %d bytes
" "- Physical Line partitions: %d
" "- Ways of associativity: %d
" "- Total Size: %zu bytes (%zu kb)
" "- Is fully associative: %s
" "- Is Self Initializing: %s
" "
" , i , cache_level , cache_type_string , cache_sets , cache_coherency_line_size , cache_physical_line_partitions , cache_ways_of_associativity , cache_total_size, cache_total_size >> 10 , cache_is_fully_associative ? "true" : "false" , cache_is_self_initializing ? "true" : "false" ); } return num_data_caches; } int test_cache(size_t attempts, size_t lower_cache_size, int * latencies, size_t max_latency) { int fd = open("/dev/urandom", O_RDONLY); if (fd < 0) { perror("open"); abort(); } char * random_data = mmap( NULL , lower_cache_size , PROT_READ | PROT_WRITE , MAP_PRIVATE | MAP_ANON // | MAP_POPULATE , -1 , 0 ); // get some random data if (random_data == MAP_FAILED) { perror("mmap"); abort(); } size_t i; for (i = 0; i < lower_cache_size; i += sysconf(_SC_PAGESIZE)) { random_data[i] = 1; } int64_t random_offset = 0; while (attempts--) { // use processor clock timer for exact measurement random_offset += Rand(); random_offset %= lower_cache_size; int32_t cycles_used, edx, temp1, temp2; asm ( "mfence
	" // memory fence "rdtsc
	" // get cpu cycle count "mov %%edx, %2
	" "mov %%eax, %3
	" "mfence
	" // memory fence "mov %4, %%al
	" // load data "mfence
	" "rdtsc
	" "sub %2, %%edx
	" // substract cycle count "sbb %3, %%eax" // substract cycle count : "=a" (cycles_used) , "=d" (edx) , "=r" (temp1) , "=r" (temp2) : "m" (random_data[random_offset]) ); // printf("%d
", cycles_used); if (cycles_used < max_latency) latencies[cycles_used]++; else latencies[max_latency - 1]++; } munmap(random_data, lower_cache_size); return 0; } int main() { size_t cache_sizes[32]; int num_data_caches = i386_cpuid_caches(cache_sizes); int latencies[0x400]; memset(latencies, 0, sizeof(latencies)); int empty_cycles = 0; int i; int attempts = 1000000; for (i = 0; i < attempts; i++) { // measure how much overhead we have for counting cyscles int32_t cycles_used, edx, temp1, temp2; asm ( "mfence
	" // memory fence "rdtsc
	" // get cpu cycle count "mov %%edx, %2
	" "mov %%eax, %3
	" "mfence
	" // memory fence "mfence
	" "rdtsc
	" "sub %2, %%edx
	" // substract cycle count "sbb %3, %%eax" // substract cycle count : "=a" (cycles_used) , "=d" (edx) , "=r" (temp1) , "=r" (temp2) : ); if (cycles_used < sizeof(latencies) / sizeof(*latencies)) latencies[cycles_used]++; else latencies[sizeof(latencies) / sizeof(*latencies) - 1]++; } { int j; size_t sum = 0; for (j = 0; j < sizeof(latencies) / sizeof(*latencies); j++) { sum += latencies[j]; } size_t sum2 = 0; for (j = 0; j < sizeof(latencies) / sizeof(*latencies); j++) { sum2 += latencies[j]; if (sum2 >= sum * .75) { empty_cycles = j; fprintf(stderr, "Empty counting takes %d cycles
", empty_cycles); break; } } } for (i = 0; i < num_data_caches; i++) { test_cache(attempts, cache_sizes[i] * 4, latencies, sizeof(latencies) / sizeof(*latencies)); int j; size_t sum = 0; for (j = 0; j < sizeof(latencies) / sizeof(*latencies); j++) { sum += latencies[j]; } size_t sum2 = 0; for (j = 0; j < sizeof(latencies) / sizeof(*latencies); j++) { sum2 += latencies[j]; if (sum2 >= sum * .75) { fprintf(stderr, "Cache ID %i has latency %d cycles
", i, j - empty_cycles); break; } } } return 0; }

Core2Duoでの出力：

Cache ID 0: - Level: 1 - Type: Data Cache - Total Size: 32768 bytes (32 kb) Cache ID 1: - Level: 1 - Type: Instruction Cache - Total Size: 32768 bytes (32 kb) Cache ID 2: - Level: 2 - Type: Unified Cache - Total Size: 262144 bytes (256 kb) Cache ID 3: - Level: 3 - Type: Unified Cache - Total Size: 3145728 bytes (3072 kb) Empty counting takes 90 cycles Cache ID 0 has latency 6 cycles Cache ID 2 has latency 21 cycles Cache ID 3 has latency 168 cycles

Leeor · Answer

わかりました、あなたのコードのいくつかの問題：

おっしゃるように、測定には時間がかかります。実際、それらは単一アクセス自体よりも時間がかかる可能性が非常に高いため、有用なものを測定していません。これを緩和するには、複数の要素にアクセスし、償却します（全体の時間をアクセス数で割ります。レイテンシを測定するには、これらのアクセスをシリアル化する必要があります。それ以外の場合は、並行して実行でき、スループットのみを測定します。関連のないアクセスの数。これを実現するには、アクセス間に誤った依存関係を追加するだけです。

たとえば、配列をゼロに初期化し、次のようにします。
```
_clock_gettime(CLOCK_REALTIME, &startAccess); //start clock for (int i = 0; i < NUM_ACCESSES; ++i) { int tmp = arrayAccess[index]; //Access Value from Main Memory index = (index + i + tmp) & 1023; } clock_gettime(CLOCK_REALTIME, &endAccess); //end clock _
```
..もちろん、時間を_NUM_ACCESSES_で割ることを忘れないでください。
これで、プリフェッチャーをトリガーする可能性のある固定ストライドを回避するために、インデックスを意図的に複雑にしました（少しやり過ぎですが、影響を気づく可能性は低いですが、デモンストレーションのためです） ...）。おそらく、128k（2つのキャッシュライン）のストライドを与える単純な_index += 32_で解決し、最も単純な隣接するライン/単純なストリームプリフェッチャーの「利点」を回避できます。 _% 1000_も_& 1023_で置き換えましたが、これは_&_の方が高速ですが、同じように機能させるには2の累乗である必要があるため、_ACCESS_SIZE_を1024に増やすだけです。そしてそれはうまくいくはずです。
何かをロードしてL1を無効にするのは良いことですが、サイズがおかしく見えます。システムを指定しませんでしたが、L1では_256000_はかなり大きいようです。 L2は、多くの一般的な最新のx86 CPUでは通常256kです。また、256kはnot _256000_ではなく_256*1024=262144_であることにも注意してください。同じことが2番目のサイズにも当てはまります。1Mは_1024000_ではなく、_1024*1024=1048576_です。それが実際にL2サイズであると仮定します（おそらくL3ですが、おそらくそれには小さすぎます）。
無効化する配列のタイプはintであるため、各要素は1バイト（システムによっては4バイト）よりも長くなります。実際にはL1_CACHE_SIZE*sizeof(int)相当のバイトを無効化しています（L2無効化ループについても同様です）。

更新：

memsetはサイズをバイト単位で受け取り、サイズはsizeof(int)で除算されます
無効化読み取りは使用されず、最適化される可能性があります。この可能性を回避するために、読み取り値をいくつかの値に蓄積し、最後にそれを印刷するようにしてください。
最初のmemsetもデータにアクセスしているため、最初のループはL3のデータにアクセスしています（他の2つのmemsetはL1 + L2からの追い出しに効果的でしたが、サイズエラーのために部分的にしか発生していません）。
ストライドが小さすぎる可能性があるため、同じキャッシュラインに2回アクセスできます（L1ヒット）。 32要素（x4バイト）を追加して、十分に分散されていることを確認します。これは2つのキャッシュラインです。これにより、隣接するキャッシュラインプリフェッチの利点も得られません。
NUM_ACCESSESはACCESS_SIZEよりも大きいので、基本的に同じ要素を繰り返しており、おそらくそれらの要素に対してL1ヒットを取得します（したがって、平均時間はL1アクセスレイテンシを優先してシフトします）。代わりにL1サイズを使用して、L1全体（スキップを除く）に1回だけアクセスできるようにしてください。たとえばこのような -
```
_index = 0; while (index < L1_CACHE_SIZE) { int tmp = arrayAccess[index]; //Access Value from L2 index = (index + tmp + ((index & 4) ? 28 : 36)); // on average this should give 32 element skips, with changing strides count++; //divide overall time by this } _
```

arrayAccessをL1サイズに増やすことを忘れないでください。

さて、上記の変更（多かれ少なかれ）で、私はこのようなものを得ます：

_L1 Cache Access 7.812500 L2 Cache Acces 15.625000 L3 Cache Access 23.437500 _

それはまだ少し長いようですが、おそらく算術演算への追加の依存関係が含まれているためです

osgx · Answer

キャッシュレイテンシに対して広く使用されているクラシックテストは、リンクされたリストに対して繰り返し行われます。最新のスーパースカラー/スーパーパイプラインCPU、およびARM Cortex-A9 +やIntel Core 2/ixなどのアウトオブオーダーコアでも機能します。この方法は、オープンソースのlmbenchで使用されます-テストlat_mem_rd（ man page ）およびCPU-Zレイテンシ測定ツール： http://cpuid.com/medias/files/softwares/misc/latency.Zip （native Windowsバイナリ）

Lmbenchからのlat_mem_rdテストのソースがあります： https://github.com/foss-for-synopsys-dwc-arc-processors/lmbench/blob/master/src/lat_mem_rd.c

そして主なテストは

#define ONE p = (char **)*p; #define FIVE ONE ONE ONE ONE ONE #define TEN FIVE FIVE #define FIFTY TEN TEN TEN TEN TEN #define HUNDRED FIFTY FIFTY void benchmark_loads(iter_t iterations, void *cookie) { struct mem_state* state = (struct mem_state*)cookie; register char **p = (char**)state->p[0]; register size_t i; register size_t count = state->len / (state->line * 100) + 1; while (iterations-- > 0) { for (i = 0; i < count; ++i) { HUNDRED; } } use_pointer((void *)p); state->p[0] = (char*)p; }

したがって、マクロを解読した後、次のような多くの線形演算を実行します。

 p = (char**) *p; // (in intel syntax) == mov eax, [eax] p = (char**) *p; p = (char**) *p; .... // 100 times total p = (char**) *p;

ポインタで満たされたメモリ上で、すべてのstride要素が前方を指します。

マニュアルページにあるように http://www.bitmover.com/lmbench/lat_mem_rd.8.html

ベンチマークは2つのネストされたループとして実行されます。外側のループはストライドサイズです。内側のループは配列サイズです。配列サイズごとに、ベンチマークは1歩進んでいるポインターのリングを作成します。配列のトラバースは、

 p = (char **)*p;

forループ内（forループのオーバーヘッドは重要ではありません。ループは、1000ロード長のアンロールループです）。ループは、100万回のロード後に停止します。アレイのサイズは、512バイトから（通常）8メガバイトまでさまざまです。サイズが小さい場合、キャッシュが効果を発揮し、ロードがはるかに速くなります。これは、データがプロットされると、より明確になります。

POWERの例を含むより詳細な説明は、IBMのwikiから入手できます。 ntangling memory access測定-lat_mem_rd -by Jenifer Hopper 2013

Lat_mem_rdテスト（ http://www.bitmover.com/lmbench/lat_mem_rd.8.html ）は、配列サイズ（MB）とストライドサイズの2つの引数を取ります。ベンチマークは、2つのループを使用して配列をトラバースし、ストライドをインクリメントとして使用して、1つのストライドを指すポインターのリングを作成します。このテストでは、メモリサイズの範囲について、メモリの読み取りレイテンシをナノ秒単位で測定します。出力は2つの列で構成されます。1つ目は配列サイズ（MB単位）（浮動小数点値）で、2つ目は配列のすべてのポイントでの読み込み待ち時間です。結果をグラフ化すると、各キャッシュレベルのレイテンシの高速化やメインメモリのレイテンシなど、メモリ階層全体の相対的なレイテンシを明確に確認できます。

PS：lat_mem_rdの実行例が記載されたIntelからの紙（ありがとう Eldar Abusalimov ）があります： ftp://download.intel.com/design/intarch/PAPERS/321074.pdf -申し訳ありませんが、正しいURLは http://www.intel.com/content/dam/www/public/us/en/documents/white-papers/ia-cache-latency-bandwidth-paper.pdf 2008年12月のJoshua Ruggieroによる「キャッシュとメモリのレイテンシとCPUからメモリへの帯域幅の測定-Intelアーキテクチャで使用する場合」：

Spektre · Answer

実際には答えではありませんが、とにかく、他の回答やコメントですでに言及されているものがあります

さて先日私はこの質問に答えます：

システムのキャッシュサイズの見積もり？

_L1/L2/.../L?/MEMORY_転送速度の測定についてです。問題のより良い開始点については、それを見てください

[メモ]

時間測定にはRDTSC命令を使用することを強くお勧めします

特にL1の場合は、他のものが遅すぎるためです。すべてのコアには独自のカウンターがあり、カウントが異なるため、プロセスアフィニティを単一[〜＃〜] cpu [〜＃〜]に設定することを忘れないでください。同じ入力クロックでもたくさん!!!

[〜＃〜] cpu [〜＃〜]クロックを可変クロックコンピューターの最大に調整し、使用する場合はRDTSCオーバーフローを考慮することを忘れないでください32ビット部分のみ（最新のCPUオーバーフロー32ビットカウンター1秒）。時間の計算にはCPUクロックを使用します（測定するか、レジストリ値を使用します）
```
_t0 <- RDTSC Sleep(250); t1 <- RDTSC CPU f=(t1-t0)<<2 [Hz] _
```
単一のCPUにプロセスアフィニティを設定する

すべての[〜＃〜] cpu [〜＃〜]コアは通常、独自のL1、L2マルチタスクでキャッシュをキャッシュする[〜＃〜] os [〜＃〜]しないと、混乱しているものを測定できますこれを行う
グラフィック出力を行います（図）

次に、上記のリンクで実際に何が起こるかを確認します
OSで利用可能な最高のプロセス優先度を使用します

PandaRaid · Answer

興味のある方にとっては、最初のコードセットを機能させることができなかったため、適切な結果が得られる別の方法をいくつか試しました。

最初に使用されたリンクリストでは、ノードが連続したメモリ空間でストライドバイト離れて割り当てられています。ノードの逆参照はプリフェッチャーの効果を軽減し、複数のキャッシュラインがプルインされる場合、キャッシュヒットを回避するためにストライドを大幅に大きくしました。割り当てられたリストのサイズが大きくなると、それが保持されるキャッシュまたはメモリ構造にジャンプし、レイテンシの明確な区分を示します。

#include <time.h> #include <stdio.h> #include <string.h> #include <stdlib.h> #include <math.h> //MACROS #define ONE iterate = (char**) *iterate; #define FIVE ONE ONE ONE #define TWOFIVE FIVE FIVE FIVE FIVE FIVE #define HUNDO TWOFIVE TWOFIVE TWOFIVE TWOFIVE //prototype void allocateRandomArray(long double); void accessArray(char *, long double, char**); int main(){ //call the function for allocating arrays of increasing size in MB allocateRandomArray(.00049); allocateRandomArray(.00098); allocateRandomArray(.00195); allocateRandomArray(.00293); allocateRandomArray(.00391); allocateRandomArray(.00586); allocateRandomArray(.00781); allocateRandomArray(.01172); allocateRandomArray(.01562); allocateRandomArray(.02344); allocateRandomArray(.03125); allocateRandomArray(.04688); allocateRandomArray(.0625); allocateRandomArray(.09375); allocateRandomArray(.125); allocateRandomArray(.1875); allocateRandomArray(.25); allocateRandomArray(.375); allocateRandomArray(.5); allocateRandomArray(.75); allocateRandomArray(1); allocateRandomArray(1.5); allocateRandomArray(2); allocateRandomArray(3); allocateRandomArray(4); allocateRandomArray(6); allocateRandomArray(8); allocateRandomArray(12); allocateRandomArray(16); allocateRandomArray(24); allocateRandomArray(32); allocateRandomArray(48); allocateRandomArray(64); allocateRandomArray(96); allocateRandomArray(128); allocateRandomArray(192); } void allocateRandomArray(long double size){ int accessSize=(1024*1024*size); //array size in bytes char * randomArray = malloc(accessSize*sizeof(char)); //allocate array of size allocate size int counter; int strideSize=4096; //step size char ** head = (char **) randomArray; //start of linked list in contiguous memory char ** iterate = head; //iterator for linked list for(counter=0; counter < accessSize; counter+=strideSize){ (*iterate) = &randomArray[counter+strideSize]; //iterate through linked list, having each one point stride bytes forward iterate+=(strideSize/sizeof(iterate)); //increment iterator stride bytes forward } *iterate = (char *) head; //set tailf to point to head accessArray(randomArray, size, head); free(randomArray); } void accessArray(char *cacheArray, long double size, char** head){ const long double NUM_ACCESSES = 1000000000/100; //number of accesses to linked list const int SECONDS_PER_NS = 1000000000; //const for timer FILE *fp = fopen("accessData.txt", "a"); //open file for writing data int newIndex=0; int counter=0; int read=0; struct timespec startAccess, endAccess; //struct for timer long double accessTime = 0; char ** iterate = head; //create iterator clock_gettime(CLOCK_REALTIME, &startAccess); //start clock for(counter=0; counter < NUM_ACCESSES; counter++){ HUNDO //macro subsitute 100 accesses to mitigate loop overhead } clock_gettime(CLOCK_REALTIME, &endAccess); //end clock //calculate the time elapsed in ns per access accessTime = (((endAccess.tv_sec - startAccess.tv_sec) * SECONDS_PER_NS) + (endAccess.tv_nsec - startAccess.tv_nsec)) / (100*NUM_ACCESSES); fprintf(fp, "%Lf	%Lf
", accessTime, size); //print results to file fclose(fp); //close file }

これにより、最も一貫した結果が得られ、さまざまな配列サイズを使用してそれぞれのレイテンシをプロットすると、存在するさまざまなキャッシュサイズを非常に明確に区別できます。

次のメソッドは、以前に割り当てられた増加するサイズの配列と同様です。しかし、メモリアクセスにリンクリストを使用する代わりに、各インデックスをそれぞれの番号で埋め、ランダムに配列をシャッフルします。次に、これらのインデックスを使用して、アクセスのために配列内をランダムに移動し、プリフェッチャーの影響を軽減しました。ただし、隣接する複数のキャッシュラインが引き込まれてヒットした場合、アクセス時間に大きなずれが生じることがあります。

#include <time.h> #include <stdio.h> #include <string.h> #include <stdlib.h> #include <math.h> //prototype void allocateRandomArray(long double); void accessArray(int *, long int); int main(){ srand(time(NULL)); // Seed random function int i=0; for(i=2; i < 32; i++){ allocateRandomArray(pow(2, i)); //call latency function on arrays of increasing size } } void allocateRandomArray(long double size){ int accessSize = (size) / sizeof(int); int * randomArray = malloc(accessSize*sizeof(int)); int counter; for(counter=0; counter < accessSize; counter ++){ randomArray[counter] = counter; } for(counter=0; counter < accessSize; counter ++){ int i,j; int swap; i = Rand() % accessSize; j = Rand() % accessSize; swap = randomArray[i]; randomArray[i] = randomArray[j]; randomArray[j] = swap; } accessArray(randomArray, accessSize); free(randomArray); } void accessArray(int *cacheArray, long int size){ const long double NUM_ACCESSES = 1000000000; const int SECONDS_PER_NS = 1000000000; int newIndex=0; int counter=0; int read=0; struct timespec startAccess, endAccess; long double accessTime = 0; clock_gettime(CLOCK_REALTIME, &startAccess); //start clock for(counter = 0; counter < NUM_ACCESSES; counter++){ newIndex=cacheArray[newIndex]; } clock_gettime(CLOCK_REALTIME, &endAccess); //end clock //calculate the time elapsed in ns per access accessTime = (((endAccess.tv_sec - startAccess.tv_sec) * SECONDS_PER_NS) + (endAccess.tv_nsec - startAccess.tv_nsec)) / (NUM_ACCESSES); printf("Access time: %Lf for size %ld
", accessTime, size); }

多くの試験で平均すると、この方法でも比較的正確な結果が得られました。最初の選択は間違いなく2つのうちの方が優れていますが、これは正常に機能する代替アプローチです。