chip - cpu cache levels

Estimación del tamaño de la caché en su sistema

Question

Obtuve este programa desde este enlace ( https://gist.github.com/jiewmeng/3787223). He estado buscando en la web con la idea de obtener una mejor comprensión de los cachés de procesador (L1 y L2). Quiero ser capaz de escribir un programa que me permita adivinar el tamaño de la caché L1 y L2 en mi nueva computadora portátil. (Solo para fines de aprendizaje. Sé que podría verificar las especificaciones).

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define KB 1024
#define MB 1024 * 1024
int main() {
unsigned int steps = 256 * 1024 * 1024;
static int arr[4 * 1024 * 1024];
int lengthMod;
unsigned int i;
double timeTaken;
clock_t start;
int sizes[] = {
1 * KB, 4 * KB, 8 * KB, 16 * KB, 32 * KB, 64 * KB, 128 * KB, 256 * KB,
512 * KB, 1 * MB, 1.5 * MB, 2 * MB, 2.5 * MB, 3 * MB, 3.5 * MB, 4 * MB
};
int results[sizeof(sizes)/sizeof(int)];
int s;
/*for each size to test for ... */
for (s = 0; s < sizeof(sizes)/sizeof(int); s++)
{
lengthMod = sizes[s] - 1;
start = clock();
for (i = 0; i < steps; i++)
{
arr[(i * 16) & lengthMod] *= 10;
arr[(i * 16) & lengthMod] /= 10;
}
timeTaken = (double)(clock() - start)/CLOCKS_PER_SEC;
printf("%d, %.8f /n", sizes[s] / 1024, timeTaken);
}
return 0;
}

El resultado del programa en mi máquina es el siguiente. ¿Cómo interpreto los números? ¿Qué me dice este programa?

1, 1.07000000
4, 1.04000000
8, 1.06000000
16, 1.13000000
32, 1.14000000
64, 1.17000000
128, 1.20000000
256, 1.21000000
512, 1.19000000
1024, 1.23000000
1536, 1.23000000
2048, 1.46000000
2560, 1.21000000
3072, 1.45000000
3584, 1.47000000
4096, 1.94000000 

Answer 1

1. necesitas acceso directo a la memoria

   No estoy hablando de transferencia de DMA por esto. La memoria debe ser accedida por la CPU por supuesto (de lo contrario no está midiendo CACHE ) pero tan directamente como puede ser ... entonces las mediciones probablemente no serán muy precisas en Windows / Linux porque los servicios y otros procesos pueden interferir con las cachés durante el tiempo de ejecución . Mida muchas veces y promedie para obtener mejores resultados (o use el tiempo más rápido o fíltrelo). Para una mejor precisión, use DOS y ASM, por ejemplo

   rep + movsb,movsw,movsd
   rep + stosb,stosw,stosd

   ¡así que mides la transferencia de memoria y no otra cosa como en tu código!

2. medir los tiempos de transferencia sin procesar y trazar un gráfico

   • x eje x es el tamaño del bloque de transferencia
   • y eje es la velocidad de transferencia

   las zonas con la misma velocidad de transferencia son consistentes con la capa CACHE apropiada

[Edit1] no pudo encontrar mi antiguo código fuente para esto, así que busqué algo ahora mismo en C ++ para Windows :

Medida de tiempo:

//---------------------------------------------------------------------------
double performance_Tms=-1.0, // perioda citaca [ms]
performance_tms= 0.0; // zmerany cas [ms]
//---------------------------------------------------------------------------
void tbeg()
{
LARGE_INTEGER i;
if (performance_Tms<=0.0) { QueryPerformanceFrequency(&i); performance_Tms=1000.0/double(i.QuadPart); }
QueryPerformanceCounter(&i); performance_tms=double(i.QuadPart);
}
//---------------------------------------------------------------------------
double tend()
{
LARGE_INTEGER i;
QueryPerformanceCounter(&i); performance_tms=double(i.QuadPart)-performance_tms; performance_tms*=performance_Tms;
return performance_tms;
}
//---------------------------------------------------------------------------

Benchmark (aplicación de 32 bits):

//---------------------------------------------------------------------------
DWORD sizes[]= // used transfer block sizes
{
1<<10, 2<<10, 3<<10, 4<<10, 5<<10, 6<<10, 7<<10, 8<<10, 9<<10,
10<<10, 11<<10, 12<<10, 13<<10, 14<<10, 15<<10, 16<<10, 17<<10, 18<<10,
19<<10, 20<<10, 21<<10, 22<<10, 23<<10, 24<<10, 25<<10, 26<<10, 27<<10,
28<<10, 29<<10, 30<<10, 31<<10, 32<<10, 48<<10, 64<<10, 80<<10, 96<<10,
112<<10,128<<10,192<<10,256<<10,320<<10,384<<10,448<<10,512<<10, 1<<20,
2<<20, 3<<20, 4<<20, 5<<20, 6<<20, 7<<20, 8<<20, 9<<20, 10<<20,
11<<20, 12<<20, 13<<20, 14<<20, 15<<20, 16<<20, 17<<20, 18<<20, 19<<20,
20<<20, 21<<20, 22<<20, 23<<20, 24<<20, 25<<20, 26<<20, 27<<20, 28<<20,
29<<20, 30<<20, 31<<20, 32<<20,
};
const int N=sizeof(sizes)>>2; // number of used sizes
double pmovsd[N]; // measured transfer rate rep MOVSD [MB/sec]
double pstosd[N]; // measured transfer rate rep STOSD [MB/sec]
//---------------------------------------------------------------------------
void measure()
{
int i;
BYTE *dat; // pointer to used memory
DWORD adr,siz,num; // local variables for asm
double t,t0;
HANDLE hnd; // process handle
// enable priority change (huge difference)
#define measure_priority
// enable critical sections (no difference)
// #define measure_lock
for (i=0;i<N;i++) pmovsd[i]=0.0;
for (i=0;i<N;i++) pstosd[i]=0.0;
dat=new BYTE[sizes[N-1]+4]; // last DWORD +4 Bytes (should be 3 but i like 4 more)
if (dat==NULL) return;
#ifdef measure_priority
hnd=GetCurrentProcess(); if (hnd!=NULL) { SetPriorityClass(hnd,REALTIME_PRIORITY_CLASS); CloseHandle(hnd); }
Sleep(200); // wait to change take effect
#endif
#ifdef measure_lock
CRITICAL_SECTION lock; // lock handle
InitializeCriticalSectionAndSpinCount(&lock,0x00000400);
EnterCriticalSection(&lock);
#endif
adr=(DWORD)(dat);
for (i=0;i<N;i++)
{
siz=sizes[i]; // siz = actual block size
num=(8<<20)/siz; // compute n (times to repeat the measurement)
if (num<4) num=4;
siz>>=2; // size / 4 because of 32bit transfer
// measure overhead
tbeg(); // start time meassurement
asm {
push esi
push edi
push ecx
push ebx
push eax
mov ebx,num
mov al,0
loop0: mov esi,adr
mov edi,adr
mov ecx,siz
// rep movsd // es,ds already set by C++
// rep stosd // es already set by C++
dec ebx
jnz loop0
pop eax
pop ebx
pop ecx
pop edi
pop esi
}
t0=tend(); // stop time meassurement
// measurement 1
tbeg(); // start time meassurement
asm {
push esi
push edi
push ecx
push ebx
push eax
mov ebx,num
mov al,0
loop1: mov esi,adr
mov edi,adr
mov ecx,siz
rep movsd // es,ds already set by C++
// rep stosd // es already set by C++
dec ebx
jnz loop1
pop eax
pop ebx
pop ecx
pop edi
pop esi
}
t=tend(); // stop time meassurement
t-=t0; if (t<1e-6) t=1e-6; // remove overhead and avoid division by zero
t=double(siz<<2)*double(num)/t; // Byte/ms
pmovsd[i]=t/(1.024*1024.0); // MByte/s
// measurement 2
tbeg(); // start time meassurement
asm {
push esi
push edi
push ecx
push ebx
push eax
mov ebx,num
mov al,0
loop2: mov esi,adr
mov edi,adr
mov ecx,siz
// rep movsd // es,ds already set by C++
rep stosd // es already set by C++
dec ebx
jnz loop2
pop eax
pop ebx
pop ecx
pop edi
pop esi
}
t=tend(); // stop time meassurement
t-=t0; if (t<1e-6) t=1e-6; // remove overhead and avoid division by zero
t=double(siz<<2)*double(num)/t; // Byte/ms
pstosd[i]=t/(1.024*1024.0); // MByte/s
}
#ifdef measure_lock
LeaveCriticalSection(&lock);
DeleteCriticalSection(&lock);
#endif
#ifdef measure_priority
hnd=GetCurrentProcess(); if (hnd!=NULL) { SetPriorityClass(hnd,NORMAL_PRIORITY_CLASS); CloseHandle(hnd); }
#endif
delete dat;
}
//---------------------------------------------------------------------------

Donde las matrices pmovsd[] y pstosd[] contienen las tasas de transferencia de 32bit medidas [MByte/sec] . Puede configurar el código con use / rem two define al inicio de la función de medida.

Salida gráfica:

Para maximizar la precisión, puede cambiar la clase de prioridad del proceso al máximo. Así que cree thread de medida con máxima prioridad (lo intento pero en realidad hace un lío) y le agrego una sección crítica para que el sistema operativo no interrumpa la prueba con la frecuencia (no hay diferencia visible con y sin subprocesos). Si desea utilizar transferencias de Byte , tenga en cuenta que solo utiliza registros de 16bit por lo que debe agregar repeticiones de bucles y direcciones.

PD.

Si prueba esto en el portátil, debe sobrecalentar la CPU para asegurarse de medir en la CPU / velocidad máxima. Entonces no hay Sleep s. Algunos bucles estúpidos antes de la medición lo harán, pero deberían ejecutarse durante al menos unos pocos segundos. También puede sincronizar esto mediante la medición de frecuencia de la CPU y el bucle mientras aumenta. Parar después de que se satura ...

La instrucción asm RDTSC es la mejor para esto (pero ten en cuenta que su significado ha cambiado ligeramente con las nuevas arquitecturas).

Si no está en Windows , cambie las funciones tbeg,tend con sus equivalentes OS

[edit2] más mejoras de precisión

Después de resolver finalmente el problema con VCL que afecta la precisión de la medición que descubrí gracias a esta pregunta y más al respecto aquí , para mejorar la precisión, puede hacer esto antes del benchmark:

1. establecer clase de prioridad de proceso en realtime

2. establecer la afinidad del proceso a una sola CPU

   así que mides solo una CPU en multi-core

3. enjuague DATOS e Instrucción CACHEs

Por ejemplo:

 // before mem benchmark
DWORD process_affinity_mask=0;
DWORD system_affinity_mask =0;
HANDLE hnd=GetCurrentProcess();
if (hnd!=NULL)
{
// priority
SetPriorityClass(hnd,REALTIME_PRIORITY_CLASS);
// affinity
GetProcessAffinityMask(hnd,&process_affinity_mask,&system_affinity_mask);
process_affinity_mask=1;
SetProcessAffinityMask(hnd,process_affinity_mask);
GetProcessAffinityMask(hnd,&process_affinity_mask,&system_affinity_mask);
}
// flush CACHEs
for (DWORD i=0;i<sizes[N-1];i+=7)
{
dat[i]+=i;
dat[i]*=i;
dat[i]&=i;
}
// after mem benchmark
if (hnd!=NULL)
{
SetPriorityClass(hnd,NORMAL_PRIORITY_CLASS);
SetProcessAffinityMask(hnd,system_affinity_mask);
}

Entonces la medida más precisa se ve así:

Answer 2

Su variable lengthMod no hace lo que cree que hace. Desea que limite el tamaño de su conjunto de datos, pero tiene 2 problemas allí:

• Hacer un Y a nivel de bit con una potencia de 2 enmascararía todos los bits, excepto el que está activado. Si, por ejemplo, lengthMod es 1k (0x400), entonces todos los índices inferiores a 0x400 (es decir, i = 1 a 63) simplemente se asignarían al índice 0, por lo que siempre se presionará la caché. Esa es probablemente la razón por la cual los resultados son tan rápidos. En su lugar, use lengthMod - 1 para crear una máscara correcta (0x400 -> 0x3ff, que enmascararía solo los bits superiores y dejaría intactos los inferiores).
• Algunos de los valores de lengthMod no son una potencia de 2, por lo que hacer la lengthMod-1 no va a funcionar allí ya que algunos de los bits de la máscara aún serían ceros. Elimínelos de la lista o use una operación de módulo en lugar de lengthMod-1 conjunto. Ver también mi respuesta aquí para un caso similar.

Otro problema es que los saltos de 16B probablemente no sean suficientes para omitir una línea de caché, ya que la mayoría de las CPU comunes funcionan con caché de 64 bytes, por lo que solo se obtiene una falla por cada 4 repeticiones. Use (i*64) lugar.