La Mesure De Cache Latences

Donc je suis en train d'essayer de mesurer les temps de latence de L1, L2, L3 cache à l'aide de C. je sais que la taille d'eux et j'ai l'impression de comprendre conceptuellement comment faire, mais je suis en cours d'exécution dans des problèmes avec ma mise en œuvre. Je me demande si certains des autres matériels subtilités comme la pré-extraction sont à l'origine de problèmes.

#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\n", 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\n", 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\n", 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\n", L3Access);
printf("Read Value: %d", readValue);
}

Je commence par l'accès à une valeur dans le tableau, je veux données. Cela devrait évidemment venir de la mémoire principale, car il en est le premier accès. Le tableau est de petite taille (moins de la taille de la page), donc il doit être copié en L1, L2, L3. - Je accéder à la valeur à partir de la même matrice qui doit maintenant être en L1. J'ai ensuite accéder à toutes les valeurs d'un tableau de la même taille que le cache L1 d'invalider les données que je veux d'accès (donc, maintenant, il faut juste être dans L2/3). Puis-je répéter ce processus pour les L2 et L3. Les temps d'accès sont clairement si, ce qui signifie que je suis en train de faire quelque chose de mal...

Je pense qu'il pourrait y avoir des problèmes avec le temps qu'il faut pour l'horloge (le démarrage et l'arrêt va prendre un certain temps en ns et il va changer quand ils sont mis en cache/unchached)

Quelqu'un peut-il me donner quelques conseils sur ce que je fais de mal?

UPDATE1: Donc je l'ai amorti le coût de la minuterie en faisant beaucoup de accède, je fixe la taille de mes caches et j'ai aussi suivi les conseils à la rendre de plus en plus complexes schéma d'indexation pour éviter fixe progrès. Malheureusement, les temps sont toujours éteint. Ils semblent tous être à venir pour la L1. Je pense que le problème pourrait être avec l'invalider, au lieu d'y accéder. Serait aléatoire vs LRU régime d'affecter les données étant invalidé?

UPDATE2: Fixe le memset (Ajouté L3 memset pour invalider les données L3 ainsi donc d'abord d'accès commence à la mémoire principale) et schéma d'indexation, toujours pas de chance.

UPDATE3: je ne pouvais pas obtenir que cette méthode fonctionne, mais il y avait quelques bonnes suggestions de réponses, et j'ai posté un couple de solutions de mon propre.

J'ai aussi couru Cachegrind pour afficher hit/miss

 ==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\n", 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\n", 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\n", 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\n", L3Access);
.    .    .       .     .     .      .    .    .  
6    0    0       1     0     0      1    0    0      printf("Read Value: %d", readValue);
.    .    .       .     .     .      .    .    .  
3    0    0       3     0     0      0    0    0  }

Utilisation rdtsc au lieu de clock_gettime voir: [Est clock_gettime() adéquat pour submicrosecond calendrier?][1] [1]: stackoverflow.com/questions/7935518/...
ne devriez pas faire une grande différence dans le grand schéma des choses depuis que je suis à la propagation de la surcharge par de gros d'accès.
L1 peut être une réponse à partir de l'Intel des développeurs manuel. Je suis assez sûr qu'il dit là que la performance de la L1 accès est exactement le même que l'accès de registre. Ce que le hardware prefetcher obtient vs ce qu'il parvient à désespérément muck up ne cesse jamais de me surprendre.
Quelle architecture de processeur que vous utilisez?
architecture x86 🙂
PandaRaid, le Cachegrind n'est pas vrai, c'est le seul simulateur de caches, et ses caches ne sont pas exactement correspondre à la réelle caches du CPU et de leurs moyens/miss régimes). Utilisation perf stat pour obtenir le total réel des comtes de hits/accidents et perf record pour obtenir des informations sur les consignes de faire manque.

InformationsquelleAutor |

Je serais plutôt d'essayer d'utiliser le matériel de l'horloge comme une mesure. Le rdtsc instruction va vous dire que le cycle actuel de compter depuis la CPU a été mis sous tension. Aussi il est préférable d'utiliser asm à assurez-vous toujours les mêmes instructions sont utilisés à la fois mesurée et au sec. En utilisant que quelques ingénieuses statistiques que j'ai fait il y a longtemps:

#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:\n"
"- Level: %d\n"
"- Type: %s\n"
"- Sets: %d\n"
"- System Coherency Line Size: %d bytes\n"
"- Physical Line partitions: %d\n"
"- Ways of associativity: %d\n"
"- Total Size: %zu bytes (%zu kb)\n"
"- Is fully associative: %s\n"
"- Is Self Initializing: %s\n"
"\n"
, 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\n\t"        //memory fence
"rdtsc\n\t"         //get cpu cycle count
"mov %%edx, %2\n\t"
"mov %%eax, %3\n\t"
"mfence\n\t"        //memory fence
"mov %4, %%al\n\t"  //load data
"mfence\n\t"
"rdtsc\n\t"
"sub %2, %%edx\n\t" //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\n", 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\n\t"        //memory fence
"rdtsc\n\t"         //get cpu cycle count
"mov %%edx, %2\n\t"
"mov %%eax, %3\n\t"
"mfence\n\t"        //memory fence
"mfence\n\t"
"rdtsc\n\t"
"sub %2, %%edx\n\t" //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\n", 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\n", i, j - empty_cycles);
break;
}
}
}
return 0;
}

De sortie sur mon 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

Pouvez vous s'il vous plaît écrivez comment vous a compilé? Je reçois error: 'asm' operand has impossible constraints
Sur Core2 latence doit être comme 3 cycles pour la L1, 15 cycles de L2; pour Nehalem - L1 est de 4 cycles, L2 est de 11 et L3 est de 39 - anandtech.com/show/2542/5 - d'après CPU-Z test - là est binaire windows de l'outil cpuid.com/medias/files/softwares/misc/latency.zip Et pour AMD typique de latence est de 12 à 20 cycles pour les L2 -anandtech.com/show/2139/3 Et test similaire le lat_mem_rd est inclus pour lmbench stackoverflow.com/q/19899087/196561
J'étais en vacances, donc désolé pour la réponse tardive. Quel compilateur utilisez-vous et quelle est votre cible de système? Je peux le compiler avec clang 5.0, gcc 4.8 et icc 14.0.1 pour x86_64 générique cible sans erreurs. Essayez de mettre à jour votre compilateur.
gcc 4.8.0 donne: error: 'asm' operand has impossible constraints. icc 13.1.3 (n'ont pas 14) donne: catastrophic error: can't allocate registers for asm instruction
faut-il dire quelle ligne? Êtes-vous en utilisant toutes les autres options du compilateur?
gcc se sont plaints de la asm( ligne dans test_cache. Je n'ai pas utilisé tous les indicateurs.
J'ai nettoyé le code pour permettre au compilateur de choisir registres autant que possible. Il doit compiler sur x64 sans problèmes maintenant. Il y a un bug connu avec gcc qui va provoquer une erreur si vous essayez de compiler pour ia32 (-m32), il suffit de compiler pour 64-bit.
C'est segfaulting pour moi. J'ai trouver j'ai besoin de remplacer "=a", "d=", "=r" dans l'asm blocs avec "=&a", "=&d", "=&r" pour obtenir compilation correcte. L'esperluette demander à gcc de ne pas supposer qu'il peut réutiliser les registres de sortie en tant qu'entrées; ils peuvent être modifiés avant que toutes les entrées sont lues.

InformationsquelleAutor Sergey L.

8

Ok, plusieurs problèmes avec votre code:
1. Comme vous l'avez mentionné, les mesures prennent beaucoup de temps. En fait, ils sont très susceptibles de prendre beaucoup plus de temps que le simple accès lui-même, de sorte qu'ils ne sont pas mesurer quelque chose d'utile. Pour atténuer la situation, l'accès à plusieurs éléments, et de les amortir (diviser le temps total par le nombre d'accès. Notez que pour mesurer la latence, vous voulez que ces accède à être sérialisés, sinon, ils peuvent être réalisées en parallèle et vous aurez seulement à mesurer le débit d'indépendants accède. À atteindre que vous pouvez simplement ajouter une fausse dépendance entre les accès.
  
  Pour, par exemple, d'initialiser la matrice de zéros, et à faire:
```
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
```
  .. et bien sûr n'oubliez pas de diviser le temps par NUM_ACCESSES.
  
  Maintenant, j'ai fait l'indice intentionnellement compliqué pour vous éviter un fixe foulée qui pourrait déclencher une prefetcher (un peu de trop, vous n'êtes pas susceptibles de remarquer un impact, mais pour les besoins de la démonstration...). Vous pourriez probablement se contenter d'un simple index += 32, ce qui vous permettrait des progrès de 128k (deux lignes de cache), et éviter les "avantages" de plus simple adjacentes ligne/simple flux prefetchers. J'ai aussi remplacé le % 1000 avec & 1023 depuis & est plus rapide, mais elle doit être une puissance de 2 à fonctionner de la même manière qu'augmenter ACCESS_SIZE à 1024 et cela devrait fonctionner.
2. Invalider la L1 par le chargement de quelque chose d'autre est bonne, mais les tailles de l'air bizarre. Vous n'avez pas de spécifier votre système, mais 256000 semble assez grand pour la L1. Une L2 est généralement 256k sur de nombreuses communes moderne les Processeurs x86 pour, par exemple, notez Également que 256k est pas 256000, mais plutôt 256*1024=262144. En va de même pour la deuxième taille: 1M n'est pas 1024000, c'est 1024*1024=1048576. En supposant que c'est bien votre L2 taille (plus probablement d'une L3, mais sans doute trop petit pour ça).
3. Votre invalider les tableaux sont de type int, de sorte que chaque élément est plus long qu'un seul octet (le plus probable est de 4 octets, selon le système). Vous êtes en fait invalider L1_CACHE_SIZE*sizeof(int) vaut la peine d'octets (et il en va de même pour la L2 invalidation de la boucle)
Mise à jour:
1. memset reçoit la taille en octets, vos tailles sont divisés par sizeof(int)
2. Invalidation de votre lit ne sont jamais utilisés, et peut être optimisé à. Essayer d'accumuler le lit de la valeur et de l'imprimer à la fin, pour éviter cette possibilité.
3. Le memset au début est de l'accès aux données ainsi, à cet effet, votre première boucle de l'accès aux données à partir de la L3 (depuis les 2 autres memsets étaient toujours en vigueur à expulser de L1+L2, bien que partiellement en raison de la taille de l'erreur.
4. Le progrès est peut-être trop petit, de sorte que vous obtenez deux accès à la même cacheline (L1 hit). Assurez-vous qu'ils sont assez répandus par l'ajout de 32 éléments (x4 octets) - c'est 2 cacheline, donc vous n'aurez pas adjacent cacheline prefetch avantages.
5. Depuis NUM_ACCESSES est plus grande que ACCESS_SIZE, vous êtes essentiellement de répéter les mêmes éléments et serait probablement obtenir L1 hits pour eux (donc le avg temps changements en faveur de la L1 à la latence d'accès). Au lieu d'essayer à l'aide de la L1 de taille de sorte que vous avez accès à l'ensemble de la L1 (sauf pour les sauts) exactement une fois. Par exemple, ce
```
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 
}
```
n'oubliez pas d'augmenter arrayAccess de L1 taille.

Maintenant, avec les modifications ci-dessus (plus ou moins), j'obtiens quelque chose comme ceci:
```
L1 Cache Access 7.812500
L2 Cache Acces 15.625000
L3 Cache Access 23.437500
```
Qui semble encore un peu long, mais peut-être parce qu'il inclut un supplément de dépendance sur des opérations arithmétiques
- Très impressionnant idées, je vais certainement prendre un coup d'oeil à certains des points que vous avez mentionnés. Comme pour mes caches tailles, oui ma L1 est de 256 ko (non unifiée) L2 est 1024k unifiée et L3 est 6433k unifiée.
- le système qui est-ce?
- Extreme i7, je peux me tromper car je n'ai pas lu réelle spécifications de intels de vue, mais ce sont les chiffres que j'ai reçu de "dmidecode -t cache de la commande"
- Étrange, je ne pense pas qu'un i7 peut venir dans une telle saveur différente que la L1/L2 sont différents de la majorité, je m'attends à que seule la L3 peut être modifié pour obtenir de haut/bas de gamme biaise. - Je le prendre vous avez linux - qu'est - /proc/cpuinfo dire?
- La taille du cache dans cpuinfo ne semble pas être le reporting L3 taille qui vous correspond avec la sortie de dmidecode. Je suis d'accord que la L1/L2 semblent plutôt grand (surtout L1, depuis sa 512k entre les données et le cache d'instructions).
- Hmm. Et ce n' /sys/devices/system/cpu/cpu0/cache/index1/size dire?
- Eh bien, c'est plutôt étrange. Cela m'a donné une 32k qui est ce que j'attends d'un non-unifiée cache L1... je me demande pourquoi c'est incompatible avec la dmidecode??
- Peut-être qu'il procure une vue d'ensemble de tous les caches L1, le nombre de noyaux avez-vous?
- J'ai 4, et qui aurait du sens pour le cache L1, mais le cache L2 doit être commune et non privé, ou, au moins, c'est que je ne le pensez.
- Non, L2 est également privé par core i3/5/7, il est seulement commun de retour dans le début des "core/core 2" de la famille quand il n'y a pas encore de L3
- Oups, correction d'une faute de frappe - &-ing doit être avec le 1023, bien sûr..
- Votre exemple utilise un += pour la foulée et je suis un peu confus à ce sujet parce que je vais obtenir un seg fault à l'aide de ce régime.. Est censé être un pied d'égalité?
- oui, et j'ai été aussi manque une parenthèse. De toute façon - édité, pour être plus simple - chaque foulée est i, et depuis i changements il n'y a pas fixé la foulée, pas besoin de la multiplication.
- J'ai fait le changement et, malheureusement, il semble encore comme si ils sont tous les L1 temps d'accès :/
- veuillez voir ma mise à jour
- Je suis toujours avoir des problèmes 🙁 j'apprécie toute l'aide btw!
InformationsquelleAutor Leeor
6

Largement utilisés test classique pour le cache de latence est de parcourir la liste chaînée. Il fonctionne sur moderne superscalar/superpipelined CPU et même en Dehors de l'ordre des cœurs comme le BRAS Cortex-A9+ et Intel Core 2/ix. Cette méthode est utilisée par open-source lmbench - dans le test lat_mem_rd (page de man) et dans CPU-Z latence outil de mesure: http://cpuid.com/medias/files/softwares/misc/latency.zip (natif de Windows binaire)

Il existe des sources de lat_mem_rd test de lmbench: https://github.com/foss-for-synopsys-dwc-arc-processors/lmbench/blob/master/src/lat_mem_rd.c

Et le principal test est
```
#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;
}
```
Donc, après le déchiffrage de la macro, nous faisons beaucoup de linéaire des opérations comme:
```
 p = (char**) *p;  //(in intel syntax) == mov eax, [eax]
p = (char**) *p;
p = (char**) *p;
....   //100 times total
p = (char**) *p;
```
sur la mémoire, rempli avec des pointeurs, chaque pointage stride éléments de l'avant.

Comme le dit la page de man http://www.bitmover.com/lmbench/lat_mem_rd.8.html

Le test s'exécute en tant que deux boucles imbriquées. La boucle externe est la foulée de la taille. La boucle interne est la taille de la matrice. Pour chaque taille de la matrice, l'indice de référence crée un anneau de pointeurs qui pointent vers l'avant d'une foulée. Parcourant le tableau est fait par
```
 p = (char **)*p;
```
dans une boucle for (au-dessus de la tête de la boucle for n'est pas significative; la boucle est déroulé boucle de 1000 charges de long). La boucle s'arrête après avoir fait un million de charges.
La taille de la matrice varie de 512 octets (généralement) huit méga-octets. Pour les petites tailles, le cache va avoir un effet, et la charge sera beaucoup plus rapide. Cela devient d'autant plus évident lorsque les données sont tracées.

Description plus détaillée avec des exemples sur les Pouvoirs est disponible à partir d'IBM wiki: Démêler l'accès à la mémoire de mesures - lat_mem_rd par Jenifer Trémie 2013

La lat_mem_rd test (http://www.bitmover.com/lmbench/lat_mem_rd.8.html) prend deux arguments, un tableau de la taille en MO et une foulée à la taille. Le benchmark utilise deux boucles à parcourir dans le tableau en utilisant la foulée, comme l'incrément de créer un anneau de pointeurs qui pointent vers l'avant d'une foulée. Les mesures de contrôle de lecture de la mémoire de la latence en nanosecondes pour la gamme de tailles de mémoire. La sortie se compose de deux colonnes: la première est la matrice de taille en MO (la valeur à virgule flottante) et le second est à la charge de la latence sur tous les points de la matrice. Lorsque les résultats sont notés, vous pouvez clairement voir la relative latences de l'ensemble de la hiérarchie mémoire, y compris la plus rapide temps de réponse de chaque niveau de cache et la mémoire principale de latence.

PS: Il y a du papier à partir d'Intel (grâce à Eldar Abusalimov) avec des exemples de l'exécution de lat_mem_rd: ftp://download.intel.com/design/intarch/PAPERS/321074.pdf - désolé droite de l'url est http://www.intel.com/content/dam/www/public/us/en/documents/white-papers/ia-cache-latency-bandwidth-paper.pdf
La "mesure de la Cache et la Latence de la Mémoire et du PROCESSEUR à la Mémoire de la bande Passante Pour une utilisation avec une Architecture Intel" par Joshua Ruggiero à partir de décembre 2008:
- Nouveau lien pour la dernière pdf element14.com/community/servlet/JiveServlet/previewBody/... - "Mesure de la Cache et la Latence de la Mémoire et du PROCESSEUR de bande Passante de la Mémoire" - "Pour une utilisation avec l'Architecture Intel®" - 2008
InformationsquelleAutor osgx
1

Pas vraiment une réponse, mais lire de toute façon quelque chose qui a déjà été mentionné dans d'autres réponses et commentaires ici

bien juste l'autre jour, je réponds à cette question:
- Cache de l'estimation de la taille de votre système?
c'est au sujet de la mesure de L1/L2/.../L?/MEMORY taux de transfert de prendre un coup d'oeil pour le meilleur point de départ de votre problème

[Notes]
1. Je recommande fortement d'utiliser l'instruction RDTSC pour la mesure du temps de
  
  surtout pour L1 que tout le reste est trop lent. Ne pas oublier de mettre le processus affinité simple CPU parce que tous les cœurs ont leur propre compteur et leur nombre diffère beaucoup, même sur la même entrée d'Horloge !!!
  
  Ajuster la CPU horloge Maximale pour la variable de l'horloge des ordinateurs et n'oubliez pas de compte pour RDTSC dépassement de capacité si vous utilisez seulement 32 bits de la partie moderne (PROCESSEUR 32 bits de dépassement de compteur dans une seconde). Pour le calcul du temps d'utilisation du PROCESSEUR de l'horloge (le mesurer ou de l'utilisation de la valeur de registre)
```
t0 <- RDTSC
Sleep(250);
t1 <- RDTSC
CPU f=(t1-t0)<<2 [Hz]
```
2. ensemble du processus d'affinité CPU seul
  
  tous CPU cœurs ont généralement leur propre L1,L2 caches donc sur multi-tâche OS vous pouvez mesurer des choses confuses si vous ne le faites pas
3. faire de la sortie graphique (diagramme)
  
  puis vous verrez bien ce qui se passe réellement dans le lien ci-dessus, j'ai posté tout à fait une quelques parcelles
4. utilisation la plus haute priorité du processus disponible en OS
- Êtes-vous sûr que le compteur de cycles diffère entre les cœurs? Maintenant, à l'ère des Processeurs avec une dynamique de changement de fréquence, tsc n'est pas plus une horloge de PROCESSEUR (consultez stackoverflow.com/a/19942784/196561), mais uniforme, cohérente temps de l'horloge, qui compte de certains à haute fréquence et le signal stable près de la typique de la fréquence du PROCESSEUR. Lorsque nous utiliserons RDTSC avec le plus réel possible de l'horloge du processeur, nous allons obtenir des résultats incorrects pour le cache de latence, si son horloge est variable aussi.
- Le dernier que j'ai vu sur AMD phenon x3 avec la fréquence stable. ma conclusion a été que sa causée par des températures différentes (si tous les noyaux ont leur propre PLL) ou les cœurs n'ont pas été mis en place dans le même temps. Nai pas tester sur des Processeurs récents (toujours utiliser l'affinité 1 pour la mesure du temps de thread)
InformationsquelleAutor Spektre

Bien pour ceux qui sont intéressés, je ne pouvais pas obtenir mon premier jeu de codes de travail donc j'ai essayé quelques solutions de rechange qui produit des résultats décents.

Le premier listes liées avec des nœuds affectés foulée octets à part, dans une mémoire contiguë de l'espace. Le déréférencement des nœuds atténue l'efficacité de la pré-récupérateur et dans le cas de plusieurs lignes de cache sont tirés dans j'ai fait le progrès important pour éviter les accès au cache. Comme la taille de la liste alloué augmente, il accède à la mémoire cache ou de la structure de la mémoire qui va contenir montrant clairement les divisions de latence.

#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\t%Lf\n", accessTime, size);  //print results to file
fclose(fp);  //close file
}

Ce produit le plus de résultats cohérents, et en utilisant une variété de la taille des matrices et de tracer le respectifs des latences a donné une distinction très claire des différentes tailles de cache présents.

La méthode suivante comme le précédent alloué augmentation de la taille des tableaux. Mais au lieu d'utiliser une liste chaînée pour l'accès à la mémoire, je remplis chaque indice avec son numéro et mélangées au hasard le tableau. J'ai ensuite utilisé ces indices de sauter autour de aléatoirement dans la matrice des accès, de l'atténuation des effets de la pré-récupérateur. Cependant, il avait un très fort écart de temps d'accès lors de plusieurs lignes de cache adjacentes sont tiré dans et arriver à être frappé.

#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\n", accessTime, size);
}

Moyenne à travers de nombreux essais, cette méthode produit relativement à l'exactitude des résultats aussi bien. Le premier choix est certainement le meilleur des deux, mais c'est une autre approche qui fonctionne très bien.

InformationsquelleAutor PandaRaid

Vous devez vous connecter pour publier un commentaire.

Mise à jour: