Costos de memoria entre núcleos

​

Resumen

​

Introducción

• Modified
  • Este procesador tiene la única copia válida de la línea de caché y ha realizado cambios.
  • La línea de caché no coincide con la memoria.
• Owned
  • Este procesador tiene la única copia válida y ha realizado cambios.
  • Otros procesadores pueden tener una copia de solo lectura.
• Exclusive
  • El procesador tiene la única copia de la línea de caché.
  • El contenido de la línea de caché coincide con la memoria.
• Shared
  • Este procesador tiene una de varias copias de la línea de caché.
  • Otro procesador puede tenerla en el estado Owned si se han realizado cambios.
• Invalid
  • Esta línea de caché no es válida y debe capturarse antes de acceder a ella.

​

Datos compartidos

class OuterClassSlow
{
    struct InnerStruct
    {
        uint64_t threadOne;
        uint64_t threadTwo;
        uint64_t threadThree;
        uint64_t threadFour;
    };

    InnerStruct dataArray[1024];
};

class OuterClassFast
{
    uint64_t dataArrayThreadOne[1024];
    uint64_t dataArrayThreadTwo[1024];
    uint64_t dataArrayThreadThree[1024];
    uint64_t dataArrayThreadFour[1024];
};

​

Los costos de compartir datos

​

Perfil de prueba

• Las instrucciones probadas fueron una lectura sin procesar, una escritura sin procesar, una carga atómica, un almacenamiento atómico y una operación atómica de comparación y almacenamiento (CAS). El código usado para cada conjunto de instrucciones se proporciona en el Apéndice: código.
• Las pruebas se realizaron con una ubicación de memoria de 8 bytes compartida por todos los subprocesos (línea de caché compartida) o con cada subproceso teniendo una ubicación de memoria única de 8 bytes (línea de caché única).
• Se ejecutaron cuarenta mil operaciones en un bucle cerrado.
• El optimizador se configuró para minimizar el tamaño con el fin de deshabilitar el desenrollado de bucles.
• Se realizaron un total de 100 ejecuciones; la mediana de todas las ejecuciones se muestra en las tablas siguientes.

​

Pruebas en un solo núcleo

​

Pruebas en varios núcleos

• Dos subprocesos en núcleos físicos separados, pero en el mismo clúster.
• Dos subprocesos en núcleos físicos separados y en clústeres separados.
• Cuando SMT estaba habilitado, dos subprocesos ejecutándose en los dos núcleos lógicos de un único procesador físico.

​

Lectura sin procesar/carga atómica

​

Escritura sin procesar

​

Almacenamiento atómico

​

Comparación y almacenamiento atómicos (CAS)

​

Recomendaciones

• Estructura de datos: cambie de usar una matriz de estructuras (AoS) a una estructura de matrices (SoA) donde cada subproceso opere sobre una estructura única.
• Separe los datos de solo lectura de los datos de lectura/escritura.
• Relleno (padding): puede rellenar una estructura con un múltiplo del tamaño de una línea de caché (64 bytes). Esto eliminará el uso compartido falso si cada subproceso opera sobre una estructura.
• Recuento de referencias (shared_ptr, weak_ptr, etc.): ambos tienen una única variable de recuento de referencias que se comparte entre todas las instancias del objeto.
• Sea muy claro sobre la propiedad de los datos. Cuando los datos se pasan a otro subproceso para su procesamiento, ese subproceso ahora es el propietario de los datos. Evite hacer cualquier cosa con los datos hasta que ese subproceso haya terminado con ellos.
• Cola de trabajos compartida: intente evitar usar una cola de trabajos compartida por varios subprocesos, especialmente si los trabajos son pequeños. En su lugar, considere tener una cola de trabajos única para cada subproceso. Puede usar el algoritmo de robo de trabajo (work stealing) para ayudar a equilibrar la carga entre los subprocesos.

​

Apéndice: código

​

Lectura sin procesar

for (uint64_t j = 0; j < params.iterations; j++)
{
    fred += *buffer + j;
}

mov         rcx,qword ptr [r8]  
add         rcx,rdx  
inc         rdx  
add         rdi,rcx  
cmp         rdx,r9  
jb          PerfRun::WorkerThreadRead+0D4h (07FF756A2E094h)  

​

Carga atómica

for (uint64_t j = 0; j < params.iterations; j++)
{
    fred += buffer->load() + j;
}

mov         rax,qword ptr [rsi]  
add         rax,rcx  
inc         rcx  
add         rdi,rax  
cmp         rcx,rdx  
jb          PerfRun::WorkerThreadAtomicRead+0CFh (07FF756A2E4EFh)  

​

Escritura sin procesar

for (uint64_t j = 0; j < params.iterations; j++)
{
    *buffer = *buffer + 1;
}

mov         rcx,qword ptr [r8]  
inc         rcx  
mov         qword ptr [r8],rcx  
sub         rdx,1  
jne         PerfRun::WorkerThreadWrite+0D2h (07FF756A2E212h)  

​

Almacenamiento atómico

for (uint64_t j = 0; j < params.iterations; j++)
{
    buffer->store(buffer->load() + 1);
}

mov         rcx,qword ptr [rdi]  
inc         rcx  
xchg        rcx,qword ptr [rdi]  
sub         rdx,1  
jne         PerfRun::WorkerThreadAtomicWrite+0CAh (07FF756A2E38Ah)  

​

CAS atómico

for (uint64_t j = 0; j < params.iterations; j++)
{
    uint64_t temp = buffer->load();
    buffer->compare_exchange_strong(temp, temp + 1);
}

mov         rax,qword ptr [rdi]  
lea         rcx,[rax+1]  
lock cmpxchg qword ptr [rdi],rcx  
sub         rdx,1  
jne         PerfRun::WorkerThreadAtomicCAS+0CDh (07FF756A2E68Dh)