Custos de memória entre núcleos

​

Resumo

​

Introdução

• Modified (Modificado)
  • Este processador tem a única cópia válida da linha de cache e fez alterações.
  • A linha de cache não corresponde à memória.
• Owned (Proprietário)
  • Este processador tem a única cópia válida e fez alterações.
  • Outros processadores podem ter uma cópia somente leitura.
• Exclusive (Exclusivo)
  • O processador tem a única cópia da linha de cache.
  • O conteúdo da linha de cache corresponde à memória.
• Shared (Compartilhado)
  • Este processador tem uma de várias cópias da linha de cache.
  • Outro processador pode tê-la no estado Owned se alterações tiverem sido feitas
• Invalid (Inválido)
  • Esta linha de cache não é válida e precisa ser buscada antes do acesso.

​

Dados compartilhados

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

​

Os custos do compartilhamento de dados

​

Perfil de teste

• As instruções testadas foram uma leitura bruta, uma gravação bruta, um carregamento atômico, um armazenamento atômico e uma operação atômica de comparação e armazenamento (CAS). O código usado para cada conjunto de instruções é fornecido no Apêndice: código.
• Os testes foram realizados com um local de memória de 8 bytes compartilhado por todos os threads (linha de cache compartilhada) ou com cada thread tendo um local de memória exclusivo de 8 bytes (linha de cache exclusiva).
• Quarenta mil operações foram executadas em um loop compacto.
• O otimizador foi configurado para minimizar o tamanho, a fim de desabilitar o desenrolamento de loop.
• Foi realizado um total de 100 execuções; a mediana de todas as execuções é mostrada nas tabelas a seguir.

​

Teste em um único núcleo

​

Teste em vários núcleos

• Dois threads em núcleos físicos separados, mas no mesmo cluster.
• Dois threads em núcleos físicos separados e em clusters separados.
• Onde o SMT estava habilitado, dois threads em execução nos dois núcleos lógicos de um único processador físico.

​

Leitura bruta/Carregamento atômico

​

Gravação bruta

​

Armazenamento atômico

​

Comparação e armazenamento atômicos (CAS)

​

Recomendações

• Estrutura de dados: mude de uma matriz de estruturas (AoS) para uma estrutura de matrizes (SoA), em que cada thread opera em uma estrutura exclusiva.
• Separe os dados somente leitura dos dados de leitura/gravação.
• Preenchimento: você pode preencher uma estrutura com um múltiplo do tamanho de uma linha de cache (64 bytes). Isso eliminará o compartilhamento falso se cada thread operar em uma estrutura.
• Contagem de referências (shared_ptr, weak_ptr e assim por diante): ambos têm uma única variável de contagem de referências que é compartilhada entre todas as instâncias do objeto.
• Seja muito claro quanto à propriedade dos dados. Quando os dados são passados para outro thread para processamento, esse thread passa a ser o proprietário dos dados. Evite fazer qualquer coisa com os dados até que esse thread termine de usá-los.
• Fila de trabalhos compartilhada: tente evitar o uso de uma única fila de trabalhos compartilhada por vários threads, especialmente se os trabalhos forem pequenos. Em vez disso, considere ter uma fila de trabalhos exclusiva para cada thread. Você pode usar o algoritmo de roubo de trabalho (work stealing) para ajudar a equilibrar a carga entre os threads.

​

Apêndice: código

​

Leitura bruta

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)  

​

Carregamento atômico

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)  

​

Gravação bruta

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)  

​

Armazenamento 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)