Coûts de la 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 copies de la ligne de cache.
  • Un autre processeur peut la détenir à 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 tout accès.

​

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 de 8 octets propre à 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 afin de désactiver le déroulage des boucles.
• Au total, 100 exécutions ont été effectuées ; la médiane de toutes les exécutions est indiquée dans les tableaux qui suivent.

​

Test sur un seul cœur

​

Test sur plusieurs cœurs

• Deux threads sur des cœurs physiques distincts, mais dans le même cluster.
• Deux threads sur des cœurs physiques distincts et dans des clusters distincts.
• 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 atomiques (CAS)

​

Recommandations

• Structure des données : passez d’un tableau de structures (AoS) à une structure de tableaux (SoA) dans laquelle 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 compléter une structure par un multiple de la taille d’une ligne de cache (64 octets). Cela élimine le faux partage si chaque thread opère sur une structure.
• Comptage de références (shared_ptr, weak_ptr, etc.) : ils disposent tous deux d’une seule variable de compteur de références, partagée entre toutes les instances de l’objet.
• Définissez très clairement la propriété des données. Lorsque des données sont transmises à un autre thread pour traitement, ce thread en devient propriétaire. Évitez toute opération sur ces données tant que ce thread n’en a pas terminé.
• File d’attente de tâches partagée : essayez d’éviter d’utiliser une seule file d’attente de tâches partagée par plusieurs threads, en particulier si les tâches sont petites. Envisagez plutôt une file d’attente de tâches propre à chaque thread. Vous pouvez utiliser l’algorithme de vol de travail (work stealing) pour é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)