Coûts de mémoire inter-cœurs

​

Résumé

​

Introduction

• Modified (modifié)
  • Ce processeur possède la seule copie valide de la ligne de cache et y a apporté des modifications.
  • La ligne de cache ne correspond pas à la mémoire.
• Owned (possédé)
  • Ce processeur possède la seule copie valide et y a apporté des modifications.
  • D’autres processeurs peuvent avoir une copie en lecture seule.
• Exclusive (exclusif)
  • Le processeur possède la seule copie de la ligne de cache.
  • Le contenu de la ligne de cache correspond à la mémoire.
• Shared (partagé)
  • Ce processeur possède l’une des nombreuses copies de la ligne de cache.
  • Un autre processeur peut l’avoir à l’état Owned si des modifications ont été apportées
• Invalid (non valide)
  • Cette ligne de cache n’est pas valide et doit être récupérée avant d’y accéder.

​

Données partagées

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];
};

​

Les coûts du partage de données

​

Profil de test

• Les instructions testées étaient une lecture brute, une écriture brute, un chargement atomique, un stockage atomique et une opération atomique de comparaison et stockage (CAS). Le code utilisé pour chaque ensemble d’instructions est fourni dans l’Annexe : Code.
• Les tests ont été effectués avec un emplacement mémoire de 8 octets partagé par tous les threads (ligne de cache partagée) ou avec un emplacement mémoire unique de 8 octets pour chaque thread (ligne de cache unique).
• Quarante mille opérations ont été exécutées dans une boucle serrée.
• L’optimiseur a été configuré pour réduire la taille au minimum afin de désactiver le déroulement des boucles.
• Au total, 100 exécutions ont été effectuées; la médiane de toutes les exécutions est présentée dans les tableaux qui suivent.

​

Tests sur un seul cœur

​

Tests sur plusieurs cœurs

• Deux threads sur des cœurs physiques distincts, mais dans la même grappe.
• Deux threads sur des cœurs physiques distincts et dans des grappes distinctes.
• Lorsque le SMT était activé, deux threads s’exécutant sur les deux cœurs logiques d’un même processeur physique.

​

Lecture brute/chargement atomique

​

Écriture brute

​

Stockage atomique

​

Comparaison et stockage atomique (CAS)

​

Recommandations

• Structure de données : passez d’un tableau de structures (AoS) à une structure de tableaux (SoA) où chaque thread opère sur une structure unique.
• Séparez les données en lecture seule des données en lecture/écriture.
• Remplissage : vous pouvez remplir une structure selon un multiple de la taille d’une ligne de cache (64 octets). Cela éliminera le faux partage si chaque thread opère sur une structure.
• Comptage de références (shared_ptr, weak_ptr, etc.) : ils ont tous deux une seule variable de compteur de références qui est partagée entre toutes les instances de l’objet.
• Soyez très clair quant à la propriété des données. Lorsque des données sont transmises à un autre thread pour traitement, ce thread est désormais propriétaire des données. Évitez d’effectuer quoi que ce soit sur les données tant que ce thread n’en a pas terminé.
• File de tâches partagée : essayez d’éviter d’utiliser une seule file de tâches partagée par plusieurs threads, surtout si les tâches sont petites. Envisagez plutôt d’avoir une file de tâches unique pour chaque thread. Vous pouvez utiliser l’algorithme de vol de travail (work stealing) pour aider à équilibrer la charge entre les threads.

​

Annexe : Code

​

Lecture brute

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)  

​

Chargement atomique

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)  

​

Écriture brute

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)  

​

Stockage atomique

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 atomique

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)