Processadores paralelos e de múltiplos núcleos

Computadores paralelos realizam operações ao mesmo tempo. Eles podem reduzir a latência, o tempo que uma tarefa leva, ou aumentar a vazão, o número de tarefas concluídas por segundo. Esses objetivos levam a formas diferentes de dividir o trabalho.

A barreira de potência

Aumentar a frequência de clock antes tornava cada geração de processadores mais rápida. A potência dinâmica segue aproximadamente $P\approx C{V}^{2}f$: capacitância vezes tensão ao quadrado vezes frequência de chaveamento. A tensão aparece duas vezes nesse produto. Reduzir tanto a tensão quanto a frequência em 15% resulta em ${\mathrm{0,85}}^2\times \mathrm{0,85}=\mathrm{0,614125}$ da potência dinâmica original, cerca de 61%.

A tensão não podia continuar caindo o suficiente para compensar frequências de clock mais altas. A corrente de fuga e o calor tornaram custoso demais continuar aumentando a frequência. Essa barreira de potência levou a indústria aos chips de múltiplos núcleos em meados dos anos 2000. Um chip de múltiplos núcleos coloca vários núcleos de processador em um chip; um sistema multiprocessador tem pelo menos dois processadores. Núcleos mais modestos podem realizar mais trabalho total por joule, desde que haja trabalho suficiente para dividir.

Quatro fontes de trabalho paralelo

O ILP é identificado principalmente pelo hardware e pelos compiladores. A segmentação em pipeline, a emissão múltipla e a execução fora de ordem sobrepõem instruções enquanto preservam os resultados exigidos pelo programa. Dependências e desvios limitam a sobreposição disponível.

O DLP aparece quando muitos elementos precisam do mesmo cálculo. Instruções SIMD, processadores vetoriais e GPUs exploram essa regularidade. O TLP exige que o trabalho seja dividido em threads pelo código, por uma biblioteca ou por um compilador. Uma thread tem seu próprio contador de programa, registradores e pilha; threads de um mesmo processo compartilham seu espaço de endereçamento. Processos distintos têm espaços de endereçamento distintos.

O trabalho em nível de requisição precisa de pouca cooperação entre tarefas. Adicionar servidores pode, portanto, aumentar a capacidade quase proporcionalmente aos recursos acrescentados. Executar vários programas independentes em um notebook também usa núcleos que estariam ociosos, aumentando a vazão geral mesmo quando nenhum desses programas é paralelizado internamente.

Tarefas concorrentes e execução simultânea

Concorrência significa que tarefas progridem durante períodos sobrepostos. Um núcleo pode fazer isso alternando entre elas. Paralelismo significa que operações são executadas no mesmo instante em unidades de hardware distintas. Um sistema de núcleo único pode manter vários programas em andamento sem executar suas instruções simultaneamente.

Um programa com uma thread sequencial não se divide entre oito núcleos simplesmente porque eles existem. Os núcleos extras podem executar outro trabalho, mas reduzir o tempo desse programa exige trabalho paralelo dentro dele. Mesmo depois que o trabalho é dividido, qualquer parte sequencial restante ainda limita o ganho.

Um processador pode conter muitas unidades aritméticas sem seguir muitos fluxos de instruções independentes. A taxonomia de Flynn classifica o hardware por seus fluxos de instruções e de dados, portanto o primeiro passo é escolher o nível da máquina que está sendo descrito.

As quatro classes de hardware

Um processador convencional de núcleo único é SISD mesmo quando seu pipeline sobrepõe várias instruções. A emissão superescalar, por si só, não cria contadores de programa independentes nem transforma o núcleo em hardware MIMD.

Uma instrução SIMD pode somar oito pares de números de ponto flutuante de 32 bits em um registrador de 256 bits. Ela tem oito vias aritméticas, mas elas seguem uma instrução. Extensões SIMD de largura fixa incluem x86 SSE e AVX e Arm Neon; arquiteturas vetoriais também se enquadram na classe SIMD. Cálculos regulares em vetores são adequados porque muitos elementos precisam da mesma operação.

Processadores MIMD escolhem suas instruções independentemente. Chips de múltiplos núcleos, multiprocessadores de memória compartilhada e aglomerados de computadores se enquadram nessa classe. Os núcleos podem executar programas diferentes ou cópias do mesmo programa que chegam a desvios diferentes em momentos diferentes.

MISD completa a classificação dois por dois. Há poucos exemplos práticos claros. Alguns sistemas tolerantes a falhas e pipelines de processamento são descritos dessa forma, mas sua classificação depende de como seus fluxos são definidos.

Um programa ainda pode ter muitos fluxos de instruções

SPMD, programa único e múltiplos dados, é um estilo de programação. Cada unidade de trabalho executa uma cópia do mesmo programa e usa seu identificador para selecionar sua parcela dos dados. As unidades têm estados de execução independentes, portanto SPMD normalmente é executado em hardware MIMD.

Para quatro núcleos somando 4.000 valores, o núcleo de identificador $i$ trata os índices de $1000i$ a $1000i+999$. O núcleo 0 trata de 0 a 999; o núcleo 3 trata de 3000 a 3999. Cada um produz uma soma parcial, e essas quatro somas são combinadas. O texto compartilhado do programa não exige que os quatro núcleos emitam a mesma instrução no mesmo ciclo.

Classifique cada nível separadamente

Considere uma CPU de oito núcleos cujas threads usam instruções AVX. Entre os núcleos, ela é MIMD: os núcleos avançam independentemente. Dentro de uma operação AVX, ela é SIMD: uma instrução controla várias vias. Contar todas as unidades aritméticas juntas ocultaria essa estrutura.

Um aglomerado que executa cópias de um programa científico também é hardware MIMD usando software SPMD. Seus nós se comunicam por mensagens. Uma GPU combina muitos grupos de threads escalonados independentemente com execução semelhante a SIMD dentro de cada grupo; a NVIDIA chama seu estilo de execução baseado em threads de SIMT.

Para classificar uma descrição, pergunte quem escolhe a próxima instrução. Depois, pergunte se essa instrução processa um elemento de dados ou vários. O número de arquivos-fonte, programas instalados ou unidades aritméticas, por si só, não responde a essas duas perguntas.

Uma falta na cache pode deixar um núcleo esperando centenas de ciclos. O multithreading em hardware mantém os estados de execução de várias threads dentro de um núcleo para que instruções úteis de outra thread possam ser executadas durante essa espera.

O que é duplicado e o que é compartilhado

Cada thread de hardware tem seu próprio contador de programa e estado de registradores. As threads compartilham as unidades de execução, as caches e o acesso à largura de banda da memória do núcleo. Manter o estado no hardware torna a troca muito mais rápida do que salvar e restaurar um processo do sistema operacional, o que pode custar milhares de ciclos. O hardware pode fazer a troca em um ciclo ou menos.

O sistema operacional vê cada thread de hardware como um processador lógico. Oito núcleos físicos com duas threads de hardware por núcleo apresentam 16 processadores lógicos. Essa contagem descreve os contextos de thread disponíveis, não 16 núcleos físicos completos.

Três formas de escalonamento

O escalonamento de granularidade fina pode alternar entre threads prontas mesmo quando a thread anterior poderia continuar. O escalonamento de granularidade grossa continua executando essa thread até que uma parada custosa justifique a troca. O SMT usa um núcleo com emissão múltipla e escalonamento dinâmico: instruções de threads diferentes podem ocupar posições livres de emissão diferentes durante um ciclo. A renomeação de registradores mantém seus estados separados. O Hyper-Threading da Intel é uma implementação de SMT; alguns processadores IBM POWER suportam oito threads de hardware por núcleo.

Analise a ocultação de latência

Suponha que uma thread calcule por 20 ciclos e depois espere 200 ciclos pela memória. Seu ciclo tem 220 ciclos de duração. Sozinho, o trabalho útil ocupa $20\mathrm{/}220\approx \mathrm{0,091}$, ou 9,1% do tempo.

Com quatro threads, trabalho escalonado livremente e sem custo de troca ou disputa adicional, o trabalho útil pode ocupar $4\times 20\mathrm{/}220\approx \mathrm{0,364}$, ou 36,4%. O núcleo ainda tem intervalos ociosos porque quatro períodos de 20 ciclos não conseguem cobrir os períodos de espera.

Onze threads fornecem 220 ciclos de períodos de cálculo no total. Enquanto uma espera por 200 ciclos, as outras dez podem calcular por 20 cada uma. Esse escalonamento ideal mantém o núcleo ocupado. O desempenho real também depende de essas threads competirem ou não por recursos de memória e execução.

Vazão e tempo de conclusão de uma thread

O multithreading aumenta principalmente a vazão. Uma thread específica pode levar mais tempo porque outras threads usam ciclos e espaço de cache que ela receberia de outra forma. Duas threads de hardware que compartilham uma unidade aritmética não podem receber, ambas, a capacidade de um segundo núcleo completo.

Se ambas as threads já exigem as mesmas unidades de execução totalmente ocupadas, o SMT tem pouca capacidade livre para preencher. Se uma para enquanto a outra pode executar, o compartilhamento é útil. As GPUs aplicam a ocultação de latência em escala maior, mantendo muitos grupos de threads prontos para seus escalonadores.

Uma máquina paralela é útil quando altera o tempo decorrido. A aceleração compara a melhor execução sequencial com a execução paralela; a eficiência compara esse ganho com o número de processadores usados.

Comece pelo tempo medido

Para $p$ processadores, $S(p)=T_1\mathrm{/}{T}_p$ e $E(p)=S(p)\mathrm{/}p$. Uma tarefa sequencial de 100 s que termina em 16 s em oito núcleos tem aceleração $100\mathrm{/}16=\mathrm{6,25}$. Sua eficiência é $\mathrm{6,25}\mathrm{/}8=\mathrm{0,78125}$, cerca de 78%. Meça o tempo decorrido de relógio para ambas as execuções, usando a mesma tarefa fixa.

Divida o tempo em partes melhorada e inalterada

Na lei de Amdahl, $f$ é a fração do tempo de execução original que uma melhoria acelera. É uma fração de tempo, não uma fração das linhas de código-fonte. Se essa parte se torna $s$ vezes mais rápida, então

A parte inalterada ainda leva todo o seu tempo original. Para uma divisão paralela ideal entre $p$ processadores, faça $s=p$. Esse modelo exclui sobrecargas de comunicação, desequilíbrio e sincronização; esses custos podem aumentar o tempo medido.

Com 90% de tempo paralelizável e dez processadores, o tempo normalizado é $\mathrm{0,1}+\mathrm{0,9}\mathrm{/}10=\mathrm{0,19}$. A aceleração é $1\mathrm{/}\mathrm{0,19}\approx \mathrm{5,26}$, e a eficiência é de cerca de 53%. Com 100 processadores, o tempo é $\mathrm{0,1}+\mathrm{0,009}=\mathrm{0,109}$ e a aceleração é de cerca de 9,17. Aumentar o número de processadores em dez vezes não dobrou a aceleração.

Encontre o limite antes de comprar mais processadores

À medida que o número de processadores cresce, o tempo paralelo se aproxima de zero. A fração sequencial permanece, produzindo o teto $S_{max}=1\mathrm{/}(1-f)$. Uma fração sequencial de 10% limita a aceleração ideal a 10; uma fração de 5% a limita a 20. Quantidades finitas de processadores se aproximam desses tetos por baixo.

A lei de Amdahl também avalia uma classe de instruções mais rápida. Se a multiplicação ocupa 30% de uma execução e se torna quatro vezes mais rápida, o tempo normalizado passa a ser $\mathrm{0,7}+\mathrm{0,3}\mathrm{/}4=\mathrm{0,775}$. O programa inteiro fica apenas $1\mathrm{/}\mathrm{0,775}\approx \mathrm{1,29}$ vezes mais rápido.

Resolva a partir de uma meta

Para obter aceleração 90 em 100 processadores, escreva $1\mathrm{/}90=(1-f)+f\mathrm{/}100=1-\mathrm{0,99}f$. Portanto, $f=(1-1\mathrm{/}90)\mathrm{/}\mathrm{0,99}\approx \mathrm{0,99888}$. Apenas cerca de 0,11% do tempo original pode permanecer sequencial. Uma meta próxima do número de processadores exige uma fração inalterada muito pequena.

Uma aceleração medida pode às vezes superar o número de processadores. Dividir um grande conjunto de trabalho pode fazer cada parte caber na cache, reduzindo o custo por operação. Essa aceleração superlinear altera uma premissa do modelo simples: o trabalho paralelo já não é apenas o trabalho original dividido em parcelas iguais. Verifique o algoritmo, o tamanho dos dados e o comportamento da cache antes de interpretar essa medição.

Adicionar processadores pode reduzir o tempo da mesma tarefa ou permitir que uma máquina trate uma tarefa maior. A escalabilidade forte e a escalabilidade fraca medem esses usos diferentes, e ambas dependem de quanto trabalho útil resta após os custos de coordenação.

Trabalho fixo e trabalho crescente

A escalabilidade forte mantém o tamanho do problema fixo. A escalabilidade fraca aumenta o trabalho proporcionalmente ao número de processadores, mantendo constante o trabalho por processador. A escalabilidade fraca perfeita mantém o tempo decorrido constante enquanto o trabalho total cresce.

Considere dez adições sequenciais seguidas de uma soma elemento a elemento de duas matrizes. Uma matriz de 10 por 10 precisa de 100 adições paralelas. O tempo total é de 110 unidades em um processador, 20 em dez e 12 em cinquenta: acelerações de 5,5 e cerca de 9,2. Uma matriz de 40 por 40 precisa de 1.600 adições paralelas. Os tempos passam a 1.610, 170 e 42 unidades: acelerações de cerca de 9,5 e 38,3. O problema maior dá mais peso ao trabalho paralelo útil em relação às mesmas dez adições sequenciais.

A base diferente de Gustafson

A lei de Gustafson usa a fração do tempo sequencial medida na execução paralela. Chamando essa fração de $s$, a aceleração com tamanho escalonado é $S_G=s+(1-s)p$. Para $s=\mathrm{0,05}$ e 100 processadores, $S_G=\mathrm{0,05}+\mathrm{0,95}(100)=\mathrm{95,05}$.

A lei de Amdahl com 5% de tempo sequencial na execução original em um processador dá apenas cerca de 16,8 em 100 processadores. Essas frações usam denominadores diferentes e respondem a perguntas diferentes. Uma aceleração com tamanho escalonado de 95,05 não significa que a tarefa original de tamanho fixo terminou 95,05 vezes mais rápido.

A unidade mais lenta determina o tempo de conclusão

Se 400 unidades iguais de trabalho forem distribuídas entre oito núcleos, a parcela equilibrada será de 50 para cada um. Suponha que um receba 120 enquanto os outros sete recebem 40 cada. A etapa dura 120 unidades de tempo, portanto a aceleração é $400\mathrm{/}120\approx \mathrm{3,33}$. Dividir pela carga média deixaria de considerar a espera pelo núcleo mais ocupado.

Criação de threads, escalonamento, mensagens, barreiras e disputa pela largura de banda compartilhada também consomem tempo. Granularidade é a quantidade de cálculo entre eventos de comunicação ou sincronização. Partes maiores reduzem o custo de coordenação por operação útil, mas partes em número insuficiente podem deixar algumas unidades de trabalho ociosas.

Mais processadores podem aumentar o tempo

Para uma tarefa totalmente paralela de 100 s com sobrecarga de $\mathrm{0,5}p$ segundos, $T_p=100\mathrm{/}p+\mathrm{0,5}p$. Dez processadores levam 15 s. Quatorze levam cerca de 14,14 s, perto do mínimo de aproximadamente $\sqrt{200}$ processadores. Quarenta levam 22,5 s porque sua sobrecarga de 20 s supera a redução do tempo de cálculo útil.

Ao apresentar um resultado, informe se o trabalho permaneceu fixo ou cresceu e compare com o tempo do melhor programa sequencial. Usar como base uma implementação paralela lenta executada em um processador pode inflar a aceleração apresentada.

A taxa aritmética anunciada de um processador é apenas um dos limites. O modelo Roofline também pergunta se a memória consegue fornecer dados com rapidez suficiente para sustentar essa taxa. Ele fornece um limite superior, que ajuda a identificar uma direção útil para a otimização.

Conte operações por byte da DRAM

A intensidade aritmética é o número de operações de ponto flutuante dividido pelos bytes transferidos entre a DRAM e o processador. O trabalho original sobre o modelo Roofline chama essa medida baseada na DRAM de intensidade operacional. Conte o tráfego nessa fronteira, incluindo leituras e escritas.

DAXPY calcula $y_i=a{x}_i+y_i$ usando números de precisão dupla. Cada elemento exige uma multiplicação e uma adição: dois FLOPs. Ler um valor de 8 bytes de cada vetor e escrever 8 bytes de volta transfere 24 bytes. A intensidade é $I=2\mathrm{/}24\approx \mathrm{0,0833}$ FLOPs por byte. O coeficiente escalar é reutilizado; nesse modelo de tráfego, ele não exige uma nova carga da DRAM para cada elemento.

Aplique os dois limites

Se a capacidade de cálculo de pico é $P$ e a largura de banda de pico da memória é $B$, o teto é $\min (P,BI)$. Largura de banda multiplicada por FLOPs por byte tem como unidade FLOPs por segundo. Em um gráfico log-log, o limite de largura de banda sobe em uma linha inclinada e o limite de cálculo é horizontal.

Para 1.000 GFLOP/s e 100 GB/s, o ponto de transição é $P\mathrm{/}B=1000\mathrm{/}100=10$ FLOPs por byte. Abaixo dessa intensidade, o teto de largura de banda é menor; acima dela, o teto de cálculo é menor. DAXPY é limitado a $100(2\mathrm{/}24)\approx \mathrm{8,33}$ GFLOP/s, menos de 1% da capacidade de cálculo de pico da máquina. Um kernel com intensidade 2 é limitado a 200 GFLOP/s.

Um kernel limitado pela largura de banda da memória ainda pode se beneficiar de núcleos extras ou de SIMD mais largo enquanto tiver poucas requisições em andamento para usar a largura de banda disponível. Quando essa largura de banda está saturada, a capacidade aritmética adicional não eleva seu teto. Aumentar a largura de banda ou realizar mais cálculo útil por byte transferido eleva esse limite.

A reutilização altera a intensidade

Multiplicar duas matrizes de precisão dupla de 1000 por 1000 realiza cerca de $2(1000{)}^3=2\times {10}^9$ FLOPs. Se cada elemento das duas entradas e da saída atravessar a fronteira da DRAM uma vez, o tráfego total será de 24 MB, resultando em cerca de 83 FLOPs por byte. Esse valor está acima do ponto de transição da máquina do exemplo.

Uma implementação ingênua pode reler repetidamente os valores das matrizes da DRAM. A blocagem organiza os laços em torno de submatrizes que cabem na cache, de modo que os valores sirvam a muitas operações antes de serem substituídos. O algoritmo continua sendo a multiplicação de matrizes, mas a implementação transfere menos bytes da DRAM por operação.

Um teto não é um resultado medido

Um kernel pode ser executado abaixo do limite por causa de dependências, sobrecarga de instruções, padrões de acesso inadequados ou trabalho paralelo insuficiente. Tetos de desempenho mais baixos mostram essas restrições: a falta de SIMD pode reduzir o teto de cálculo, enquanto padrões de acesso inadequados reduzem a largura de banda utilizável. Um ponto abaixo de um teto precisa de investigação; o teto, por si só, não prevê sua taxa de execução exata.

Uma extensão SIMD divide um registrador largo em vias. Uma instrução realiza a mesma operação em cada via, tornando os laços regulares sobre elementos independentes uma boa opção.

Conte vias e iterações

O número de vias é igual à largura do registrador dividida pela largura do elemento. Um registrador de 256 bits comporta oito números de ponto flutuante de 32 bits, quatro de precisão dupla de 64 bits ou 32 elementos de um byte. SSE usa registradores XMM de 128 bits; AVX e AVX2 usam registradores YMM de 256 bits. No modo de 64 bits, há 16 registradores YMM. AVX-512 oferece 32 registradores ZMM de 512 bits, cada um comportando 16 números de ponto flutuante. Arm Neon usa registradores de 128 bits.

Para c[i] = a[i] + b[i] sobre 1.000 números de ponto flutuante, instruções de oito vias processam o vetor em 125 iterações vetoriais. Cada iteração carrega dois vetores, soma suas vias e armazena um vetor. Com 1.003 elementos, 125 iterações completas deixam três elementos. Um laço escalar para o restante ou uma operação com máscara trata essa parte curta sem acessar posições além dos vetores.

Oito vias representam capacidade aritmética, não uma garantia de aceleração de oito vezes do programa. A preparação, o tratamento do restante, o trabalho sequencial e a largura de banda da memória ainda consomem tempo.

Escolha uma organização que preencha um registrador

Cargas vetoriais simples funcionam bem com elementos contíguos, de passo unitário. Um vetor de pontos {x, y, z} com campos de 4 bytes coloca campos x consecutivos a 12 bytes de distância. Uma estrutura de vetores coloca os valores de x juntos, depois os valores de y e depois os de z. Processar apenas x agora pode preencher um vetor com uma carga contígua. Instruções de coleta e dispersão aceitam endereços espalhados, mas normalmente com custo de acesso maior.

Mantenha o trabalho condicional dentro das vias

Para c[i] = (a[i] > 0) ? a[i] : 0, uma comparação cria uma máscara por via. Uma seleção escolhe entre resultados candidatos, ou instruções com máscara atualizam apenas as vias selecionadas. As vias inativas mantêm ou recebem valores conforme o comportamento da máscara da instrução.

Se vias diferentes precisarem seguir ramos longos e diferentes, as instruções desses caminhos ainda deverão ser emitidas, com apenas as vias pertinentes ativas. O grupo não pode dar a cada via um fluxo de instruções separado. Uma máscara preserva a correção, mas não faz todas essas instruções de caminho desaparecerem.

Verifique a independência das iterações

Compiladores podem vetorizar laços automaticamente; programadores também podem usar bibliotecas ou funções intrínsecas como _mm256_add_ps. O compilador deve estabelecer que iterações simultâneas preservam o resultado. A recorrência a[i] = a[i-1] + b[i] depende do novo valor da iteração anterior e não pode ser vetorizada diretamente como elementos independentes. A possível sobreposição de ponteiros, chamada aliasing, também pode exigir uma verificação de sobreposição em tempo de execução ou impedir a vetorização.

Uma redução mantém várias somas parciais em um registrador e depois combina as vias. Reordenar adições de ponto flutuante pode alterar os últimos bits porque a adição não é associativa. Somas de inteiros coincidem quando a aritmética escolhida não apresenta estouro ou usa aritmética modular definida.

SIMD e execução em múltiplos núcleos podem ser combinados. Oito núcleos, cada um emitindo uma adição de oito vias por ciclo, podem realizar até 64 adições de ponto flutuante por ciclo. Eles ainda compartilham limites como a largura de banda da memória.

Uma arquitetura vetorial expressa uma operação sobre uma sequência de elementos e armazena o comprimento do vetor ativo em um registrador. O mesmo programa pode ser executado em implementações com capacidades diferentes de registradores vetoriais.

Separe capacidade, comprimento e vias

A extensão vetorial RISC-V, RVV, versão 1.0, foi ratificada em 2021. Ela oferece 32 registradores vetoriais, de v0 a v31. Cada implementação escolhe a largura de seus registradores, VLEN, como uma potência de dois. A largura dos elementos e o agrupamento de registradores determinam quantos elementos cabem.

O comprimento ativo, vl, é o número de elementos tratados pelas próximas instruções vetoriais. vsetvli configura a operação vetorial a partir da quantidade restante de elementos e do formato desejado para eles, retornando o vl selecionado. O código avança pelo valor retornado. Isso importa porque o código portável deve usar o comprimento real selecionado pela implementação.

Vias são os pipelines paralelos que executam a operação vetorial. Uma adição de 32 elementos em quatro vias leva cerca de oito ciclos após o início do pipeline. Um vetor de 32 elementos não exige 32 unidades aritméticas. Vetores mais longos e mais vias são escolhas de projeto distintas.

Particione um laço em blocos

O particionamento do laço em blocos divide um laço longo em partes do tamanho de um vetor. Para 100 elementos e um máximo de 32 por operação, uma sequência válida de comprimentos é 32, 32, 32 e 4. Cada passagem carrega a próxima parte, calcula, armazena e reduz a quantidade restante pelo seu vl.

DAXPY sobre 1.000 números de precisão dupla pode, da mesma forma, usar 31 passagens de 32 seguidas por uma passagem de oito, totalizando 32 passagens. RVV pode escolher outros comprimentos válidos perto do fim, portanto o laço usa o vl retornado em vez de supor uma divisão final específica. Definir o comprimento ativo trata o trecho final curto sem um laço escalar separado para o restante.

O padrão de controle do laço é:

1. Solicite um comprimento para os elementos restantes.
2. Carregue e calcule essa quantidade de elementos.
3. Armazene os resultados.
4. Avance os ponteiros e subtraia o comprimento retornado.

Uma instrução vetorial descreve muitas operações sobre elementos, reduzindo o trabalho de busca e decodificação em comparação com um corpo escalar repetido para cada elemento.

Alimente operações dependentes e dados não contíguos

O encadeamento permite que uma instrução vetorial consumidora comece a usar os primeiros resultados antes que a produtora tenha terminado os elementos posteriores. Em uma multiplicação seguida de uma adição, o primeiro produto pode entrar no pipeline de adição enquanto os produtos posteriores ainda estão sendo formados.

Uma máscara, normalmente no registrador v0 de RVV, seleciona quais elementos são atualizados. Uma carga com passo constante acessa elementos com um espaçamento fixo em bytes. Em uma matriz de precisão dupla de 100 por 100 armazenada por linhas, descer uma coluna avança 100 elementos, ou 800 bytes. Cargas e armazenamentos indexados usam endereços explícitos para dados irregulares.

Arquiteturas vetoriais e extensões de largura fixa são ambas SIMD na taxonomia de Flynn. Extensões de largura fixa codificam larguras específicas; código RVV expressa comprimentos que se adaptam ao hardware disponível. Ambas ainda precisam de uma ordem de execução que respeite as dependências de dados do laço.

Uma CPU concentra recursos em baixa latência para poucas threads. Uma GPU concentra recursos em alta vazão entre muitas threads com paralelismo de dados. Escolher entre elas exige analisar a tarefa inteira, incluindo a movimentação de dados.

Threads são executadas em multiprocessadores de streaming

Uma GPU da NVIDIA contém muitos multiprocessadores de streaming, ou SMs. Um SM tem vias aritméticas, escalonadores de warps, um grande banco de registradores e memória compartilhada rápida no chip. Um “núcleo CUDA” designa uma via aritmética, não um núcleo completo e independente semelhante ao de uma CPU. A AMD chama o grupo de processamento correspondente de unidade de computação.

A NVIDIA agrupa threads em warps de 32. Uma instrução emitida opera sobre as threads ativas do warp, cada uma com seus próprios valores de registradores e dados. Isso é SIMT, instrução única e múltiplas threads. A AMD usa wavefronts, com 32 ou 64 threads, dependendo da arquitetura.

Um SM mantém muitos warps residentes. Quando um espera pela memória, o escalonador seleciona outro warp pronto. Ter mais threads prontas do que vias oculta a latência; isso não reduz a latência de um acesso individual à DRAM.

A divergência deixa vias inativas

Se threads de um warp seguirem ramos diferentes, o warp executará os caminhos necessários com as outras threads desativadas por máscara. Um if-else dividido igualmente, com ramos de mesmo custo, pode levar aproximadamente o dobro do tempo de um caminho porque ambos precisam ser executados. Um desvio pode não causar prejuízo quando sua condição é uniforme dentro de cada warp, mesmo que warps diferentes escolham caminhos diferentes.

Faça os acessos à memória trabalharem em conjunto

Registradores por thread armazenam valores privados. A memória compartilhada por bloco é um armazenamento no chip gerenciado pelo programa. As caches L1 e L2 permitem reutilização automática, enquanto a memória global é a DRAM da GPU, como GDDR ou HBM.

Quando 32 threads leem palavras consecutivas de 4 bytes, seu intervalo de 128 bytes pode ser atendido por um pequeno número de transações largas. Essa coalescência usa a largura de banda com eficiência. Endereços espalhados podem exigir muitas transações para os mesmos dados úteis. A reutilização na memória compartilhada pode reduzir ainda mais o tráfego repetido da memória global.

Inclua o tempo de transferência

Para uma GPU dedicada, entradas e resultados atravessam um enlace como PCIe ou NVLink. Enviar 800 MB e receber 400 MB a uma taxa efetiva de 20 GB/s transfere 1,2 GB em 0,06 s, ou 60 ms. Acrescentar um kernel de 10 ms resulta em 70 ms no total. Uma CPU que termina em 50 ms vence essa comparação apesar do cálculo muito mais rápido da GPU.

Manter dados na GPU ao longo de vários kernels evita transferências repetidas. Tarefas grandes e regulares também podem oferecer trabalho aritmético útil suficiente para compensar os custos de movimentação e lançamento. Tarefas pequenas, sequenciais e com muitos desvios frequentemente favorecem uma CPU.

Especialize ainda mais quando o trabalho permitir

Um sistema heterogêneo usa a CPU para executar o programa e o sistema operacional e um acelerador para as partes adequadas. Aceleradores de domínio específico, como TPUs e NPUs, dedicam hardware a uma tarefa mais restrita, frequentemente multiplicação de matrizes com inteiros de 8 bits ou ponto flutuante de 16 bits. A especialização pode melhorar o desempenho por watt nesse domínio, ao mesmo tempo que reduz a variedade de trabalhos que o hardware trata bem.

Um kernel de GPU é executado uma vez por thread lançada. O hospedeiro lança uma grade de blocos de threads, e cada thread calcula qual parte dos dados lhe cabe. CUDA chama a CPU de hospedeiro e a GPU de dispositivo; OpenCL usa os termos relacionados work-item e work-group.

Calcule um índice único

Para um lançamento unidimensional, o índice do elemento é blockIdx.x * blockDim.x + threadIdx.x. Com 256 threads por bloco, a thread 5 no bloco 2 trata o elemento 517: os dois blocos anteriores correspondem a 512 elementos, e a thread acrescenta um deslocamento de cinco. Os índices de threads e blocos começam em zero.

Um kernel SAXPY aplica uma multiplicação e uma adição a cada número de ponto flutuante:

__global__ void saxpy(int n, float a, float *x, float *y) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n) {
        y[i] = a * x[i] + y[i];
    }
}

A grade substitui o laço comum sobre os elementos. Cada thread ativa atualiza seu próprio y[i]; threads vizinhas usam endereços vizinhos, favorecendo a coalescência.

Arredonde o número de blocos para cima

Para 1.000.000 de elementos e 256 threads por bloco, a grade precisa de $\lceil 1000000\mathrm{/}256\rceil =3907$ blocos. Eles lançam 1.000.192 threads. As últimas 192 têm índices fora do vetor, portanto a condição i < n impede seus acessos à memória. Arredondar para baixo lançaria threads insuficientes e deixaria elementos válidos sem tratamento.

Um bloco de 256 threads forma oito warps. Blocos podem ser atribuídos a qualquer SM e executados em qualquer ordem. A correção do programa não deve depender de o bloco 0 terminar antes do bloco 1.

Organize o trabalho do hospedeiro e do dispositivo

Um hospedeiro típico aloca armazenamento no dispositivo, copia as entradas, lança saxpy<<<3907, 256>>>(n, 2.0f, d_x, d_y) e obtém os resultados. O lançamento é assíncrono: a CPU pode continuar enquanto o kernel é executado. O hospedeiro deve esperar por meio de sincronização ou de uma cópia bloqueante adequada dos resultados antes de usar os dados concluídos.

Coopere dentro de um bloco

Threads de um bloco podem trocar valores pela memória compartilhada e se encontrar em __syncthreads(). Toda thread participante dessa barreira de todo o bloco deve alcançá-la. Colocar a barreira dentro de if (i < n) não é seguro quando apenas algumas threads satisfazem a condição.

Para uma redução de 1.024 valores na memória compartilhada, 512 threads somam pares, depois 256 combinam os resultados, depois 128 e assim por diante. Dez estágios de divisão pela metade deixam uma soma. Uma barreira entre estágios impede que uma thread consuma um resultado parcial antes que sua produtora o escreva.

Um lançamento comum não tem barreira que abranja toda a grade. Blocos separados podem escrever somas parciais e um segundo kernel pode combiná-las, ou operações atômicas adequadas podem atualizar um resultado global. Uma barreira de bloco, por si só, não pode coordenar blocos diferentes. Um laço com passo igual ao tamanho da grade é outro padrão de mapeamento: cada thread trata vários elementos, avançando pelo tamanho total da grade.

Um multiprocessador de memória compartilhada oferece a seus processadores um espaço de endereçamento físico. As threads se comunicam com cargas e armazenamentos em variáveis compartilhadas, enquanto mantêm valores privados, como somas parciais locais.

Endereços compartilhados podem ter custos diferentes

Em UMA, acesso uniforme à memória, o tempo de acesso à memória é aproximadamente o mesmo a partir de qualquer processador. Em NUMA, acesso não uniforme à memória, um soquete acessa sua memória local mais rapidamente do que a memória de outro soquete. O espaço de endereçamento é compartilhado mesmo que a memória física seja distribuída.

Com 70% de acessos locais a 80 ns e 30% de acessos remotos a 140 ns, a média ponderada é $\mathrm{0,7}(80)+\mathrm{0,3}(140)=98$ ns. Mover dados para perto de quem mais os usa reduz a parcela remota. Contar todo acesso como local subestimaria o tempo.

Uma organização comum de caches oferece a cada núcleo caches L1 privadas de instruções e dados, frequentemente uma L2 privada e uma cache compartilhada de último nível. Um anel ou uma malha conecta os núcleos e as caches. Memória compartilhada descreve o endereçamento; ela não exige que todos os núcleos usem uma cache comum.

Divida, calcule e reduza

Para somar 64.000 valores em 64 núcleos, cada núcleo trata 1.000 valores. As 64 somas parciais podem ser combinadas em uma árvore de redução. O número de somadores ativos cai pela metade em cada estágio: 32, 16, 8, 4, 2 e 1. Seis estágios combinam os resultados parciais.

Usar aproximadamente 1.000 etapas de adição local mais seis etapas de combinação resulta em cerca de 1.006 etapas no caminho mais longo, antes da sobrecarga. A árvore evita que cada entrada atualize um contador compartilhado. Cada estágio depende dos valores concluídos do estágio anterior, portanto as unidades de trabalho se encontram em barreiras entre estágios.

OpenMP pode expressar isso com #pragma omp parallel for reduction(+:sum). Ele divide as iterações, dá às threads somas parciais privadas e as combina. Threads POSIX oferecem controle mais explícito sobre o gerenciamento de threads.

Torne uma atualização indivisível

Uma operação de leitura-modificação-escrita atômica torna uma atualização indivisível do ponto de vista dos outros processadores. A troca atômica e a busca e soma atômica são exemplos. Uma carga seguida de um armazenamento comum são duas operações separadas, portanto outra thread pode intervir.

RISC-V oferece lr.w e sc.w. A carga reservada lê uma palavra e estabelece uma reserva. O armazenamento condicional tenta escrever e informa sucesso ou falha. Uma escrita intermediária na posição reservada faz a tentativa falhar; o software tenta novamente. A reserva não bloqueia outros processadores, e a falha também pode ocorrer por outros motivos permitidos. Essas operações primitivas dão suporte a mecanismos de sincronização.

Observe os gargalos compartilhados

Se cada núcleo consegue transferir continuamente 15 GB/s, mas o soquete fornece 60 GB/s, cerca de quatro desses fluxos saturam a largura de banda. Mais núcleos não podem aumentar a taxa de dados do soquete. A comunicação por caches também exige trabalho: quem escreve sem permissão de escrita deve obter a posse e invalidar outras cópias. Quem escreve e já possui um bloco no estado modificado pode continuar localmente; leitores posteriores podem precisar buscar uma nova cópia.

Caches privadas melhoram a latência, mas podem manter várias cópias da mesma posição de memória. A coerência de cache impede que essas cópias apresentem históricos conflitantes das escritas nessa posição.

Por que atualizar a memória não basta

Comece com X = 0 na memória. O núcleo A lê e armazena zero em sua cache; o núcleo B faz o mesmo. A escreve um em sua cache com escrita posterior. Sem um protocolo de coerência, B pode acertar em sua própria cache e continuar lendo zero. Escrever diretamente na memória não corrigiria a cópia já armazenada na cache de B.

A coerência funciona na granularidade de blocos de cache, normalmente de 64 bytes. Um controlador rastreia o estado de cada bloco e segue as regras do protocolo quando processadores leem ou escrevem nele. A migração move dados úteis para a cache de quem os usa no momento. A replicação permite que vários leitores mantenham cópias limpas. A coerência deve preservar ambos os benefícios enquanto controla as escritas.

Três propriedades necessárias

Se uma posição recebe uma escrita de um seguida de uma escrita de dois, os leitores não podem discordar sobre qual escrita veio depois. Observar a escrita posterior e depois a anterior inverteria esse histórico. Uma nova escrita subsequente poderia, é claro, armazenar o valor um novamente; a serialização diz respeito a eventos de escrita, não à possibilidade de um valor numérico se repetir.

Controle a posse e as cópias

Em um protocolo de invalidação na escrita, quem escreve obtém permissão exclusiva de escrita e invalida outras cópias armazenadas em cache. Uma leitura posterior de um bloco invalidado sofre uma falta e busca os dados atuais. Essa é uma falta de coerência, além das faltas compulsórias, de capacidade e de conflito.

Um protocolo de atualização na escrita envia novos valores às cópias existentes. Escritas repetidas podem tornar isso custoso. A monitoração de coerência difunde requisições para que as caches possam reagir. Um diretório rastreia os detentores de cópias e direciona mensagens às caches pertinentes.

Coerência, ordenação e atomicidade

A coerência diz respeito a uma posição. Um modelo de consistência de memória define as ordenações observáveis permitidas e os resultados de leituras e escritas, incluindo operações em posições diferentes. A consistência sequencial exige um resultado que corresponda a um entrelaçamento que preserve a ordem do programa de cada processador. Modelos relaxados permitem mais reordenações; instruções de barreira de memória impõem a ordenação necessária quando preciso.

Nem cópias coerentes nem uma ordenação consistente tornam atômico um incremento de várias instruções. Suponha que duas threads incrementem um contador compartilhado inicialmente igual a cinco. Uma sequência possível é: A lê cinco, B lê cinco, A escreve seis, B escreve seis. Cada leitura e escrita pode ser coerente, mas o contador final é seis em vez de sete. O programa precisa de uma atualização atômica ou de sincronização adequada para preservar ambos os incrementos.

Um controlador de cache que monitora a coerência observa requisições em uma interconexão de difusão. Para acompanhar um protocolo, mantenha um estado para a cópia do bloco de cada núcleo e atualize todas as cópias afetadas após cada acesso.

Leia os estados como permissões

No MSI básico, uma falta de leitura envia uma leitura ao barramento e carrega o bloco em S. Escrever em um bloco em S exige uma promoção para invalidar outras cópias. Escrever a partir de I exige uma requisição de leitura exclusiva para buscar os dados e obter a posse. Quem escreve termina em M. Um acerto em M não exige transação de coerência.

Acompanhe cinco acessos

Comece com X = 0 na memória e A e B no estado inválido.

1. A lê X. Uma leitura no barramento fornece zero. Estados: A = S, B = I.
2. B lê X. Outra leitura no barramento fornece zero. Estados: A = S, B = S.
3. A escreve um. Sua promoção invalida B. Estados: A = M, B = I.
4. B lê X. B sofre uma falta; A fornece um e passa a S. No MSI básico, a memória também é atualizada. Estados: A = S, B = S.
5. B escreve dois. Sua promoção invalida A. Estados: A = I, B = M.

Cada acesso nesse acompanhamento exige uma transação no barramento. O quarto acesso é a verificação importante de posse: a memória ainda tinha o valor antigo antes de A fornecer seus dados modificados.

O que o estado exclusivo economiza

O MESI acrescenta E para uma única cópia limpa em cache. Se A lê um bloco que não está em cache e nenhuma outra cache o possui, A recebe E. Uma escrita posterior muda E para M silenciosamente, pois não há outras cópias a invalidar. O MSI carregaria primeiro em S e depois enviaria uma promoção para essa escrita.

Se outro núcleo lê enquanto A possui E, ambos passam a S. M e E têm um único detentor válido, mas apenas M contém dados mais recentes que a memória.

Escritas repetidas e escala

Quem escreve e obteve M pode atualizar o bloco dez vezes sem dez novas invalidações. Um esquema de atualização na escrita enviaria os valores alterados aos detentores de cópias.

A monitoração por difusão se torna custosa à medida que mais núcleos observam cada requisição. Estruturas de diretório reduzem essa distribuição. Protocolos mais elaborados acrescentam estados úteis: o estado Owned do MOESI permite uma cópia modificada compartilhada, e o MESIF designa um detentor Forward para responder às requisições.

Difundir cada requisição de coerência se torna custoso em máquinas grandes. Um diretório registra quais caches podem possuir cada bloco para que as requisições possam ser enviadas a essas caches. O mesmo rastreamento em nível de bloco também explica um problema comum de desempenho: o falso compartilhamento.

Consulte a origem de um bloco

Cada bloco tem uma entrada no diretório de origem que registra se ele não está em cache, está compartilhado ou modificado e quais caches o possuem. As origens são distribuídas entre nós ou partes do diretório, distribuindo o armazenamento e o tratamento de requisições.

Uma falta de leitura vai para a origem. Se a memória tiver os dados atuais, ela poderá fornecê-los e o diretório registrará o novo detentor de cópia. Se outra cache possuir uma cópia no estado modificado, a origem encaminhará a requisição a essa detentora para que os dados atuais sejam fornecidos. Em um protocolo básico de diretório, isso também atualiza a memória novamente.

Para escrever sem já ter a posse no estado modificado, um núcleo pede permissão à origem. O diretório envia invalidações aos detentores registrados, espera as confirmações e concede a posse exclusiva. Acertos de escrita repetidos em M não precisam de outras mensagens de coerência. A passagem pelo diretório acrescenta latência, mas o tráfego ponto a ponto evita consultar todas as caches sobre cada bloco. Filtros de monitoração no chip atendem a um objetivo relacionado, restringindo as requisições aos possíveis detentores.

Estime o armazenamento do diretório

Um vetor de presença completo tem um bit por núcleo por bloco. Para 64 núcleos, são 64 bits, ou oito bytes. Em relação a um bloco de dados de 64 bytes, apenas os bits de presença custam $8\mathrm{/}64=\mathrm{0,125}$, ou 12,5%. Com 256 núcleos, o vetor de 32 bytes custa 50%. Bits de estado acrescentam mais. Listas limitadas de detentores, vetores de granularidade mais grossa e o rastreamento apenas de blocos em cache reduzem esse custo de armazenamento.

Reconheça o falso compartilhamento

O compartilhamento verdadeiro ocorre quando núcleos trocam dados pela mesma palavra. O falso compartilhamento ocorre quando eles acessam variáveis diferentes dentro de um bloco de cache e pelo menos um escreve. As variáveis são independentes no programa, mas a unidade de coerência é maior que cada uma delas.

Duas threads incrementam contadores separados de 8 bytes em 0x1000 e 0x1008. Com blocos de 64 bytes, seus números de bloco são $\lfloor 4096\mathrm{/}64\rfloor =64$ e $\lfloor 4104\mathrm{/}64\rfloor =64$. Cada mudança de posse transfere a permissão para ambos os contadores em conjunto. Escritas alternadas frequentes podem fazer o bloco passar de uma cache para outra mesmo que nenhuma thread precise do valor da outra.

Mover o segundo contador para 0x1040 o coloca no bloco 65. Preenchimento ou alinhamento pode separar dados de cada thread; agrupar valores por quem os escreve também ajuda. Um acumulador local escrito de volta uma vez reduz o tráfego de posse sem acrescentar preenchimento a cada valor.

Quem escreve e quem lê uma variável vizinha também podem sofrer falso compartilhamento: quem escreve invalida o bloco que, de outra forma, seria útil ao leitor. Dois leitores sozinhos não o causam. O falso compartilhamento acrescenta tráfego e atraso; ele não faz, por si só, que atualizações de variáveis separadas produzam valores incorretos. Meça os padrões de acesso e a posição das linhas de cache antes de alterar uma organização de dados.

Um aglomerado de computadores conecta computadores completos, cada um com sua própria memória e sistema operacional. Os nós cooperam por mensagens explícitas. A localização dos dados e o custo de comunicação, portanto, passam a fazer parte do modelo de desempenho do programa.

Particione dados e combine resultados

MPI, a interface de passagem de mensagens, dá a cada processo um identificador no comunicador e operações como envio, recebimento, difusão e redução. Um programa SPMD pode usar esses identificadores para selecionar os dados de cada processo. Um ponteiro no espaço de endereçamento privado de um nó não é uma referência comum de memória compartilhada aos dados de outro nó.

Se um milhão de valores já estiverem distribuídos por 100 nós, cada nó somará 10.000 localmente. Uma redução em árvore combina as somas parciais em sete rodadas porque $\lceil {\log }_{2}100\rceil =7$. Essas rodadas envolvem mensagens de rede, não apenas adições locais. Manter os dados perto do trabalho que os usa reduz as transferências.

Aglomerados podem crescer com componentes padronizados, e o hardware com falha pode ser substituído. Uma aplicação ainda pode precisar de recuperação ou reinício após a falha de um nó; nós substituíveis, por si só, não preservam o progresso de uma tarefa interrompida.

Meça mais que a velocidade do enlace

Latência é o tempo que uma mensagem leva para chegar. Largura de banda do enlace é a taxa de dados de um enlace. A largura de banda total da rede soma a capacidade dos enlaces e descreve um agregado ideal com todos os enlaces ocupados. A largura de banda de bisseção soma a capacidade que atravessa o corte de menor capacidade que divide os nós em metades iguais.

Para enlaces de mesma capacidade e largura de banda $B$, compare redes de 64 nós usando uma convenção consistente de contagem de enlaces:

A malha tem oito linhas de sete enlaces horizontais e oito colunas de sete enlaces verticais, totalizando 112. Conectar as extremidades das duas dimensões produz os 128 enlaces do toro. Cada nó do hipercubo tem seis vizinhos, resultando em $64(6)\mathrm{/}2=192$ enlaces porque cada enlace é contado em duas extremidades.

Acompanhe o corte e depois considere o custo

Um corte que divide um anel em duas metades atravessa apenas dois enlaces. Muitas mensagens podem, portanto, disputar esse limite apesar dos 64 enlaces do anel no total. Uma rede totalmente conectada tem $32(32)=1024$ enlaces entre suas duas metades, mas precisa de $64(63)\mathrm{/}2=2016$ enlaces no total.

Mais enlaces podem melhorar a largura de banda e reduzir saltos, ao mesmo tempo que aumentam o número de portas de comutadores, cabos e a potência necessária. Barramentos compartilhados têm um único recurso de comunicação compartilhado; malhas e toros distribuem os enlaces pelo espaço. Grandes aglomerados frequentemente usam redes comutadas de múltiplos estágios, como árvores gordas. Sua utilidade depende do padrão de tráfego e da capacidade agregada. Para comunicação entre metades de uma máquina, a bisseção revela um limite que o total oculta.

Um computador em escala de centro de dados combina dezenas de milhares de servidores com alimentação elétrica, refrigeração e uma rede para fornecer serviços de internet. Requisições independentes fornecem trabalho paralelo, enquanto estruturas de processamento em lote, como MapReduce, dividem grandes tarefas de processamento de dados entre máquinas.

Ajuste o projeto ao serviço

Sistemas em escala de centro de dados priorizam custo por requisição, eficiência energética e disponibilidade. O software tenta novamente o trabalho, replica dados e desvia das máquinas com falha. Um supercomputador prioriza mais frequentemente um único programa científico fortemente acoplado e uma interconexão rápida.

Os servidores se conectam a comutadores no topo dos racks, que se conectam por níveis superiores de comutadores. Níveis adicionais aumentam a latência de comunicação. Os enlaces de subida frequentemente são sobressubscritos, ou seja, sua capacidade é inferior à capacidade agregada dos enlaces dos servidores. Algumas redes não bloqueantes no estilo Clos oferecem capacidade suficiente nos níveis superiores para evitar essa restrição.

Quarenta servidores com enlaces de 10 Gbit/s oferecem 400 Gbit/s a um comutador de rack. Quatro enlaces de subida de 25 Gbit/s fornecem 100 Gbit/s, portanto a proporção é 4:1. Se todos os servidores enviarem dados para fora do rack ao mesmo tempo e dividirem a capacidade igualmente, cada um terá uma média de 2,5 Gbit/s. Um servidor com pouca carga pode usar mais quando os outros estão ociosos.

Separe a sobrecarga da instalação do cálculo útil

A efetividade do uso de energia, PUE, é a energia total da instalação dividida pela energia dos equipamentos de TI no mesmo período. Dez MW de carga constante de TI mais 1,5 MW de sobrecarga de refrigeração e distribuição resultam em $PUE=\mathrm{11,5}\mathrm{/}10=\mathrm{1,15}$. O valor ideal é 1,0. O Google informou uma PUE anual de 1,09 para o conjunto de suas instalações em 2025.

A PUE mede a sobrecarga da instalação, não os cálculos úteis por joule. Servidores ociosos ou ineficientes podem desperdiçar energia dentro da parcela de TI mesmo quando a instalação tem uma PUE excelente.

Para 50.000 servidores com média de 300 W, a potência de TI é de 15 MW. Com PUE de 1,2, a potência da instalação é de 18 MW. Mantida por 8.760 horas, ela consome 157.680 MWh; apenas a sobrecarga consome 26.280 MWh. Equipamentos de alimentação elétrica, refrigeração, eletricidade, servidores e edifícios contribuem para o custo de propriedade.

Uma carga baixa ainda pode consumir bastante potência

Proporcionalidade energética significa que a potência deve crescer proporcionalmente à carga. Um servidor com potência ociosa de 150 W e pico de 300 W, com crescimento linear, consome $150+\mathrm{0,3}(150)=195$ W com 30% de carga. Ele usa 65% da potência de pico para 30% do trabalho de pico. Medições históricas em centros de dados de grande escala encontraram muitos servidores operando entre aproximadamente 10% e 50% de utilização, tornando a potência ociosa importante.

Planeje para falhas e respostas lentas

Se 50.000 servidores apresentarem, cada um, uma média de uma falha a cada dez anos, espera-se que o conjunto apresente 5.000 falhas por ano, cerca de 14 por dia. Essa expectativa justifica redundância e novas tentativas; ela não prevê exatamente 14 falhas todos os dias.

Uma requisição que precisa de respostas de muitos servidores espera pela resposta necessária mais lenta. Se cada um de 100 servidores tiver, independentemente, uma chance de 1% de estar lento, a chance de nenhum estar lento é ${\mathrm{0,99}}^{100}$. Assim, pelo menos um está lento com probabilidade $1-{\mathrm{0,99}}^{100}\approx \mathrm{0,634}$. A latência de cauda de um servidor se torna um atraso comum em nível de requisição quando a distribuição entre servidores é grande.