Abstrações e desempenho de computadores

Uma abstração mostra o que um componente faz enquanto oculta os detalhes de seu funcionamento. Um navegador pode pedir ao sistema operacional que leia um arquivo sem controlar os circuitos do dispositivo de armazenamento. Interfaces definidas permitem projetar, testar e substituir partes de um sistema sem reconstruir todas as camadas de uma vez.

As camadas e suas funções

Uma ordem comum, da tarefa do usuário aos dispositivos físicos, é:

1. O software aplicativo realiza tarefas como editar uma planilha ou navegar na web.
2. O software de sistema fornece serviços compartilhados e traduz programas. Inclui sistemas operacionais, compiladores, montadores, ligadores e bibliotecas.
3. A arquitetura do conjunto de instruções (ISA) define as instruções de máquina e outros comportamentos visíveis ao software de baixo nível.
4. A microarquitetura, ou organização, implementa essa ISA com um caminho de dados, uma unidade de controle, pipelines e caches.
5. A lógica digital constrói operações e armazenamento a partir de portas, somadores, multiplexadores e registradores.
6. Os circuitos conectam componentes eletrônicos para realizar essa lógica.
7. Os dispositivos, principalmente transistores, fornecem o comportamento físico de comutação.

Esses limites são visões úteis de uma mesma máquina. Diagramas diferentes podem agrupar camadas vizinhas. Um sistema operacional é software: a CPU executa suas instruções, inclusive instruções privilegiadas que o ajudam a gerenciar recursos com segurança.

Acompanhe uma adição

Considere o comando C total = price + tax;. Um compilador escolhe onde os valores ficam e quais instruções realizam a adição. Ele pode escolher uma instrução de adição sem projetar um somador. Quem projeta a microarquitetura associa essa instrução ao hardware de execução. Quem projeta a lógica constrói o somador a partir de portas; quem projeta os circuitos lida com os detalhes elétricos por trás dessas portas. Cada pessoa usa uma interface mais simples para o nível inferior.

O computador físico tem cinco componentes clássicos: entrada, saída, memória, caminho de dados e unidade de controle. O caminho de dados opera sobre dados. A unidade de controle dirige as operações e coordena a memória e a entrada e saída. Juntos, o caminho de dados e a unidade de controle formam o processador, ou CPU.

Um transistor funciona como uma chave controlada eletricamente. Um circuito integrado, ou chip, reúne muitos transistores em uma única peça de silício. Essas chaves sustentam a lógica; a lógica sustenta as instruções; as instruções sustentam o software.

Mais transistores e velocidades diferentes

A lei de Moore começou com a observação de Gordon Moore em 1965 e foi revisada em 1975 para uma tendência de duplicação da contagem de transistores aproximadamente a cada dois anos. Dez dessas duplicações multiplicam uma contagem por $2^{10}=1024$, ao longo de cerca de 20 anos. Essa é uma tendência de fabricação, não uma garantia física; seu ritmo diminuiu.

Cumprir uma interface preserva o comportamento prometido por ela. Isso não determina desempenho, consumo de energia ou custo. Dois processadores podem implementar corretamente a mesma instrução de adição usando circuitos, caches e frequências de clock diferentes. O aplicativo obtém o mesmo resultado calculado, mas espera por tempos diferentes.

Um processador executa linguagem de máquina, instruções codificadas em bits. O código de alto nível descreve um cálculo com variáveis, expressões, laços e funções. A tradução conecta essas duas visões, frequentemente expandindo um comando curto em várias instruções.

O caminho de um programa compilado

Para um programa em C, as etapas principais são:

Um arquivo objeto pode conter código de máquina sem ainda ser um programa executável completo. Por exemplo, uma chamada a uma função definida em outro arquivo precisa que o ligador resolva essa referência. O carregador faz parte do suporte à execução do sistema operacional, não é outro tradutor de código-fonte.

Acompanhe um comando C

Suponha que price esteja no registrador x6, tax esteja em x7 e o compilador coloque total em x5. Então:

total = price + tax;

pode se tornar esta instrução RISC-V:

add x5, x6, x7

O destino aparece primeiro no texto da linguagem de montagem. A instrução soma os valores em x6 e x7 e escreve o resultado em x5. Sua codificação no formato R de 32 bits coloca os campos em uma ordem diferente:

A união dos campos resulta em 0000000 00111 00110 000 00101 0110011, ou 0x007302B3. Os espaços tornam os campos legíveis; eles não são armazenados como parte da instrução.

Um comando do código-fonte não significa necessariamente uma instrução. Mesmo com todos os operandos em registradores, f = (g + h) - (i + j); precisa de duas adições e uma subtração. Carregar operandos da memória acrescenta instruções. Portanto, a contagem de instruções executadas depende da tradução e da ISA, não apenas do número de linhas do código-fonte.

Outros caminhos para o código de máquina

Um programa de alto nível frequentemente pode ser recompilado para outra ISA. Seu executável existente está vinculado à sua ISA e às convenções do sistema operacional. Um executável x86-64 precisa de recompilação, emulação ou tradução binária para ser executado em uma máquina Arm ou RISC-V que não possa executá-lo nativamente.

Bytecode é um formato intermediário de instruções para um ambiente de execução de linguagem. O CPython compila o código-fonte Python para bytecode e o interpreta com um programa interpretador. Máquinas virtuais Java costumam usar compilação em tempo de execução (JIT) para transformar bytecode usado com frequência em código de máquina enquanto o programa é executado. Em ambos os casos, a CPU física acaba executando instruções de máquina.

A linguagem de montagem continua sendo texto, mesmo quando uma linha se parece muito com uma instrução real. Uma pseudoinstrução é uma facilidade aceita pelo montador: em RISC-V, mv x5, x6 torna-se addi x5, x6, 0. O controle exato das instruções pode ser útil em código de sistema operacional e em laços críticos, mas abre mão de parte da portabilidade e da liberdade do compilador proporcionadas pelo código de alto nível.

A arquitetura do conjunto de instruções (ISA) é o contrato entre o hardware e o software de nível mais baixo. Ela informa a quem programa em linguagem de máquina quais operações existem e o que elas significam. O projeto interno de um processador pode mudar enquanto esse contrato permanece estável.

O que o contrato especifica

Uma ISA define instruções e suas codificações binárias, registradores visíveis a quem programa, comportamento de endereçamento, tipos de dados suportados e mecanismos arquiteturais usados para acessar a entrada e saída. Um compilador tem essas características como alvo quando transforma um cálculo em instruções.

Uma implementação é um projeto físico que obedece à ISA. Sua microarquitetura descreve escolhas internas como unidades de execução, estágios de pipeline, tamanhos de cache e predição de desvios. Essas escolhas afetam fortemente o tempo de execução.

A distinção diz respeito ao comportamento prometido. Um programa deve receber o resultado de multiplicação especificado. Geralmente, não precisa saber como o multiplicador foi construído para obter esse resultado.

Por que uma ISA sozinha não basta para a compatibilidade binária

A interface binária de aplicação (ABI) acrescenta à ISA de nível de usuário a interface do sistema operacional e as convenções binárias. Ela especifica convenções de chamada, como os registradores de argumentos, além da organização dos dados e das convenções de chamadas de sistema. Duas máquinas podem executar as mesmas codificações de instruções, mas discordar sobre como uma função recebe um argumento.

A compatibilidade binária exige suporte aos recursos de ISA e à ABI do programa. Mesmo na família x86, que começou com o 8086 da Intel em 1978, o suporte do sistema operacional e os modos de execução são importantes. A compatibilidade retroativa preservou muitos programas antigos enquanto as implementações dos processadores mudaram, mas compartilhar um nome de família não garante que todo executável histórico seja executado em todos os ambientes.

Uma arquitetura, muitas implementações

Intel e AMD implementam x86-64 com projetos internos diferentes. Arm e RISC-V também permitem implementações com orçamentos de potência e desempenho muito diferentes. RISC-V surgiu na Universidade da Califórnia em Berkeley, em 2010, e é uma ISA aberta e livre de royalties. Seus conjuntos básicos para inteiros incluem RV32I e RV64I; as extensões padronizadas incluem M para multiplicação e divisão de inteiros e F e D para operações de ponto flutuante.

Um programa que usa uma extensão opcional precisa de uma implementação que a suporte. A existência de uma base compartilhada não torna toda extensão universal. O exemplo de adição em RISC-V ilustra a mesma fronteira entre hardware e software encontrada em Arm e x86, embora suas instruções e codificações sejam diferentes.

Riqueza de instruções e tempo de execução

Uma ISA pode expressar mais trabalho em uma instrução, reduzindo a contagem de instruções. Essa instrução também pode levar mais ciclos ou exigir um ciclo mais longo. O cálculo relevante é o produto completo:

Um conjunto de instruções mais rico não basta para determinar qual máquina é mais rápida. Uma ISA compartilhada também não estabelece velocidades iguais: processadores compatíveis podem usar clocks, caches e unidades de execução diferentes para produzir os mesmos resultados exigidos.

Uma pessoa que espera a conversão de um arquivo quer um tempo de resposta curto. Um serviço que processa muitas conversões também precisa de alta vazão. Essas medidas respondem a perguntas diferentes, mesmo quando ambas descrevem o mesmo computador.

Escolha a grandeza adequada à tarefa

O tempo de resposta, também chamado de tempo de execução ou latência, vai do início da tarefa até sua conclusão. Inclui processamento, acessos à memória e ao armazenamento, entrada e saída e atividade relevante do sistema operacional. Se a tarefa espera em uma fila após ser enviada, essa espera contribui para o tempo de resposta percebido pelo usuário.

Vazão é o trabalho concluído por unidade de tempo. Suas unidades podem ser requisições por segundo ou tarefas por hora. Uma máquina pode concluir muitas tarefas por hora enquanto cada tarefa individual ainda leva muito tempo.

Adicionar processadores pode aumentar a vazão ao executar tarefas independentes simultaneamente. Isso não precisa reduzir o processamento da própria tarefa, embora possa reduzir o tempo gasto esperando por um processador livre. Um processador mais rápido frequentemente ajuda ambas as medidas.

Compare o desempenho no sentido correto

Para a mesma tarefa, defina:

Se A leva 10 s e B leva 15 s, o desempenho de A em relação ao de B é:

A é 1,5 vez mais rápido. O desempenho de B é dois terços do de A. Coloque o maior tempo de execução sobre o menor ao informar quantas vezes a máquina mais rápida é mais veloz.

Para uma melhoria, aceleração é o tempo antigo dividido pelo novo. Uma compilação que cai de 60 s para 48 s tem aceleração:

Sua redução de tempo é:

O desempenho aumentou 25%, enquanto o tempo caiu 20%. Essas porcentagens usam denominadores diferentes. Dizer “20% mais rápido” pode obscurecer qual grandeza mudou; a razão e os tempos medidos tornam a afirmação clara.

A mesma vazão pode ocultar esperas diferentes

Um serviço que conclui 1.200 requisições por minuto entrega 20 requisições por segundo. Essa taxa pode resultar do processamento de uma requisição a cada 50 ms, com cada requisição levando 50 ms. Também pode resultar do processamento de dez requisições em paralelo, cada uma levando 500 ms: dez conclusões a cada meio segundo novamente resultam em 20 por segundo.

A segunda organização tem a mesma vazão, mas dez vezes o tempo de processamento por requisição. Um resultado de vazão, por si só, não determina a latência experimentada por um usuário. Compare o mesmo trabalho concluído, informe o intervalo de tempo e mantenha as unidades ao converter entre minutos e segundos.

Um cronômetro mede tudo entre o início e o fim. A equação de desempenho da CPU mede o trabalho do processador. Manter essas visões separadas evita atribuir a uma atualização do processador a redução de um tempo de espera que ela não pode eliminar.

Tempo decorrido e tempo de processador

O tempo decorrido, ou tempo de relógio de parede, inclui processamento, espera por arquivos ou pela rede e intervalos em que outros processos são executados. O tempo de CPU registra o tempo do processador atribuído à tarefa. O tempo de CPU do usuário executa o código do programa; o tempo de CPU do sistema executa código do sistema operacional em nome dele.

Suponha que o comando time do Unix informe “real 2,50 s, user 1,80 s, sys 0,20 s”. O programa usou:

de tempo de CPU. Para este exemplo de medição com uma única thread, os 0,50 s restantes representam tempo não atribuído à execução na CPU, como espera ou tempo fora de execução por decisão do escalonador. Se uma melhoria no processador reduzir pela metade a parte da CPU enquanto essa espera permanece fixa, o tempo decorrido se torna:

Reduzir pela metade os 2,50 s completos aceleraria incorretamente também a espera. O desempenho da CPU frequentemente se concentra no tempo do usuário; o desempenho do sistema é avaliado pelo tempo decorrido sob carga controlada do sistema.

Para um programa paralelo, o tempo de CPU é somado em suas threads e núcleos. Quatro núcleos trabalhando durante a maior parte de um segundo podem produzir 3,6 s de tempo de usuário durante 1,0 s de tempo decorrido. Nesse caso, subtrair o tempo de CPU somado do tempo decorrido não mede a espera.

A frequência de clock é o inverso do período

Um clock fornece um ritmo de sincronização ao hardware síncrono. O período de clock é dado em segundos por ciclo; a frequência de clock é dada em ciclos por segundo:

A 4 GHz, a frequência é de quatro bilhões de ciclos por segundo. Um ciclo dura:

A 2,5 GHz, o período é 400 ps. No sentido oposto, 312,5 ps por ciclo resultam em:

Os prefixos de tempo e frequência usam potências decimais. Os prefixos binários de memória usam potências de dois. Rótulos como “GB” às vezes são usados de modo impreciso para quantidades binárias, portanto verifique o significado antes de converter um tamanho.

Interprete uma medição como uma execução

A frequência anunciada de um processador não registra cada momento da execução. Aumentos temporários de frequência, gerenciamento de energia e redução de desempenho por limitação térmica alteram a frequência. O conteúdo da cache e a atividade em segundo plano também alteram o tempo medido. Repetir uma medição e informar um valor típico, como a mediana, ajuda a distinguir um resultado estável de uma execução excepcionalmente favorável. Use medições de tempo e frequência do mesmo intervalo de execução ao relacioná-las às contagens de ciclos.

Um ciclo de clock é uma unidade de tempo do processador, não uma instrução. Algumas instruções precisam de muitos ciclos, e a execução sobreposta pode concluir várias instruções por ciclo. Comece pelo total de ciclos necessários para o programa inteiro.

Divida ciclos por ciclos por segundo

Se um programa precisa de um número conhecido de ciclos, seu tempo de CPU é:

Para seis bilhões de ciclos a 3 GHz:

As unidades explicam a divisão: ciclos divididos por ciclos por segundo resultam em segundos. Multiplicar ciclos pela frequência produziria ciclos ao quadrado por segundo, não uma duração. Multiplicar pelo período funciona porque sua unidade é segundos por ciclo.

A mesma equação pode determinar outra incógnita. Multiplique o tempo pela frequência para obter os ciclos; divida os ciclos pelo tempo desejado para encontrar a frequência necessária. Mantenha a frequência em Hz quando o tempo estiver em segundos ou cancele explicitamente os fatores correspondentes da ordem de bilhões.

Quando um clock mais rápido exige mais ciclos

O processador A executa um programa em 10 s a 3 GHz. Seu orçamento de ciclos é:

Uma proposta de projeto B aumenta essa contagem de ciclos em 20%. Portanto, B deve executar:

Para terminar em 9 s, B precisa de:

A razão entre as frequências de clock é quatro terços, aproximadamente 1,33. A aceleração real é apenas dez nonos, aproximadamente 1,11, pois B precisa de mais pulsos para concluir o trabalho. Tratar a contagem antiga de ciclos como inalterada levaria à previsão de uma frequência de clock baixa demais para atingir a meta.

Compare um compromisso sem escolher um tamanho de programa

Suponha que um projeto multiplique a contagem antiga de ciclos por um fator $a$ e a frequência antiga de clock por um fator $b$. Então:

O projeto é mais rápido quando o fator de crescimento da contagem de ciclos é menor que o fator de crescimento da frequência. Se ambos crescerem pelo mesmo fator, o tempo de CPU permanece inalterado. Essa razão é útil quando uma proposta de projeto informa mudanças percentuais, mas não fornece uma contagem absoluta de ciclos.

Por que o período tem um limite físico

Entre registradores, sinais percorrem a lógica combinacional e precisam se estabilizar antes que seus resultados sejam capturados. O caminho necessário mais lento é o caminho crítico. A tecnologia dos circuitos e a quantidade de trabalho atribuída a um estágio limitam quão curto pode ser um período de clock seguro.

Uma pessoa projetista pode dividir o trabalho em estágios de pipeline mais curtos para permitir um clock mais rápido, mas a reorganização também pode alterar a contagem de ciclos. Portanto, mais GHz é uma afirmação sobre a frequência dos pulsos. Para estabelecer uma melhoria de desempenho, combine essa informação com os ciclos de que o programa realmente precisa nesse projeto.

Ciclos por instrução (CPI) é o total de ciclos de CPU de um programa dividido pela contagem de instruções executadas. É uma média de uma execução, portanto pode ser fracionária e depende de quais instruções são executadas e de como interagem com a máquina.

Some os ciclos antes de calcular a média

Para classes de instruções com contagens $C_i$ e CPIs por classe $c_i$:

De forma equivalente, multiplique o CPI de cada classe por sua fração da contagem de instruções e some as contribuições. As frações devem descrever instruções executadas, não linhas de código-fonte nem o número de tipos de instrução.

Suponha que instruções da ULA levem 1 ciclo, cargas e armazenamentos levem 4 e desvios levem 2. Uma distribuição de 50%, 30% e 20% resulta em:

Para cinco bilhões de instruções a 3 GHz, o total é de 10,5 bilhões de ciclos e o tempo de CPU é 3,5 s. A média não ponderada dos custos das três classes, cerca de 2,33, está errada: as classes não aparecem com a mesma frequência.

Mais instruções ainda podem significar menos ciclos

Duas versões de um compilador usam os mesmos custos por classe:

A versão 1 executa 800 milhões de instruções. Suas contribuições em ciclos são 400, 1.200 e 200 milhões, totalizando 1.800 milhões. Seu CPI é:

A versão 2 executa 850 milhões de instruções. Suas contribuições são 600, 600 e 200 milhões, totalizando 1.400 milhões. Seu CPI é:

A 3 GHz, os tempos são 0,60 s e cerca de 0,467 s. A versão 2 é cerca de 1,29 vez mais rápida, apesar de executar 50 milhões de instruções a mais. Substituir muitas instruções de memória custosas por mais instruções de ULA baratas pode fazer esse compromisso valer a pena.

O CPI pertence a uma carga de trabalho em uma máquina

Paradas de memória, faltas na cache, comportamento dos desvios e escolhas do compilador alteram o CPI efetivo. Um único “CPI do processador” não pode descrever todos os programas. Contadores de desempenho de hardware ou um simulador podem medir os totais de instruções e ciclos da carga de trabalho analisada.

Instruções por ciclo (IPC) usa os mesmos totais na ordem inversa:

Um IPC de 2,5 resulta em CPI 0,4. Várias instruções podem se sobrepor em um processador que emite e conclui várias instruções por ciclo. Uma média abaixo de um não significa que todo o percurso de uma instrução individual termine em uma fração de um pulso de clock.

A equação de desempenho da CPU reúne os três fatores de tempo:

Aqui $I$ conta as instruções executadas e $f$ é a frequência de clock em vigor durante a execução. Instruções multiplicadas por ciclos por instrução resultam em ciclos. Dividir por ciclos por segundo resulta em segundos.

Calcule um tempo e encontre uma incógnita

Um programa executa dois bilhões de instruções com CPI 1,5 em um processador de 2,5 GHz. Primeiro encontre o total de ciclos e depois converta-o em tempo:

Para inferir o CPI a partir do tempo medido, rearranje a mesma equação:

Para 1,6 bilhão de instruções em 0,8 s a 3,2 GHz, há 2,56 bilhões de ciclos. Dividir por 1,6 bilhão de instruções resulta em CPI 1,6.

Compare produtos completos

Dois processadores executam o mesmo programa compilado com a mesma contagem de instruções. A tem 4 GHz e CPI 1,8; B tem 2,5 GHz e CPI 1,0. Seus tempos por instrução são:

B é 1,125 vez mais rápido. Seu CPI menor compensa mais do que suficientemente seu clock mais lento. A contagem de instruções é cancelada aqui porque é igual; ela não seria cancelada se os dois programas seguissem sequências de instruções diferentes.

Da mesma forma, uma opção do compilador que reduz a contagem de instruções em 10%, mas aumenta o CPI em 15%, na mesma frequência, altera o tempo por um fator de:

O tempo aumenta 3,5%. A redução das instruções, isoladamente, aponta na direção errada.

Relacione escolhas de projeto aos fatores

Essas relações são úteis para análise, não são controles independentes que sempre possam ser ajustados sem consequências. Uma cache reduz os ciclos de espera pela memória, diminuindo o CPI efetivo. A segmentação em pipeline sobrepõe instruções sucessivas e pode reduzir o CPI efetivo ou permitir um período de clock mais curto. Essas mudanças podem introduzir outros custos que aparecem nos totais medidos.

Mantenha o intervalo de medição consistente

Meça tempo de CPU, contagem de instruções, ciclos e frequência para o mesmo trabalho. Contadores ou simulação fornecem as contagens de instruções e ciclos. Os GHz nominais de um produto não são o registro da frequência de uma execução que aumenta ou reduz sua frequência. Quando a frequência varia, a média correspondente é o total de ciclos contados dividido pelo tempo de CPU nesse intervalo.

A equação prevê o tempo de execução da CPU. A espera por armazenamento ou rede faz parte do tempo decorrido e deve ser incluída separadamente quando esse é o resultado de que o usuário precisa.

Uma afirmação útil sobre desempenho diz respeito ao trabalho que importa para o usuário. Um teste de desempenho executa uma carga de trabalho escolhida para medir o desempenho. Um conjunto de testes de desempenho amostra várias cargas quando um aplicativo não consegue representar toda a necessidade.

Identifique o tipo de resultado SPEC

O SPEC CPU 2026, lançado em maio de 2026, sucede o SPEC CPU 2017. Seus conjuntos exercitam processadores, sistemas de memória e compiladores. O SPECspeed mede o tempo de conclusão de uma cópia de um programa; essa cópia pode usar várias threads. O SPECrate mede a vazão usando várias cópias. Os conjuntos para inteiros e para ponto flutuante atendem a diferentes tipos de carga de trabalho, e o produto também oferece métricas de energia.

Uma razão de velocidade para um programa compara o tempo de referência com o tempo medido:

Um tempo de referência de 3.000 s e um tempo medido de 250 s resultam em 12. Quanto maior, melhor. Uma razão de vazão inclui o número de cópias concluídas no intervalo medido. Compare métricas equivalentes e a mesma versão do conjunto; uma pontuação de velocidade e uma pontuação de vazão respondem a perguntas diferentes.

Resuma razões com uma média geométrica

Para razões positivas, o conjunto usa:

As razões 2, 8 e 4 resultam em um produto de 64 e uma raiz cúbica de 4. Sua média aritmética é cerca de 4,67, um resultado diferente.

A comparação por médias geométricas não depende de qual máquina de referência determina as razões. Suponha que X leve 10 s e 40 s em dois programas, enquanto Y leva 20 s e 25 s. Tempos de referência de 100 s para ambos resultam nas razões 10 e 2,5 para X e 5 e 4 para Y. As médias geométricas são 5 e cerca de 4,47, portanto X lidera por cerca de 1,12.

Altere os tempos de referência para 50 s e 200 s: X obtém as razões 5 e 5, e Y obtém 2,5 e 8. Suas médias geométricas permanecem 5 e cerca de 4,47. Já as médias aritméticas mudam de 6,25 contra 4,5 para 5 contra 5,25, invertendo a classificação. A normalização pela referência não deve decidir qual máquina parece mais rápida.

Por que MIPS pode favorecer código mais lento

MIPS, milhões de instruções por segundo, é:

As instruções realizam quantidades diferentes de trabalho útil entre ISAs. Mesmo em uma única máquina, MIPS muda conforme o programa, e uma taxa maior de instruções pode acompanhar um tempo de execução mais longo.

A 3 GHz, suponha que instruções de ULA, carga e armazenamento e desvio custem 1, 4 e 2 ciclos. O código Q executa 400, 300 e 100 milhões delas: 800 milhões de instruções, 1.800 milhões de ciclos, 0,60 s, cerca de 1.333 MIPS. O código P executa 1.500, 100 e 100 milhões: 1.700 milhões de instruções, 2.100 milhões de ciclos, 0,70 s, cerca de 2.429 MIPS. P conclui instruções mais rapidamente, mas termina a tarefa mais tarde.

Taxas de pico descrevem a capacidade ideal do hardware. Cargas de trabalho reais podem alcançar muito menos por causa de dependências, esperas pela memória e outros limites. Use o tempo real da tarefa para avaliar seu desempenho; frequência, MIPS e taxas de pico explicam apenas partes selecionadas dele.

A lei de Amdahl começa dividindo o tempo de execução original em uma parte afetada e uma parte não afetada. Acelere apenas o tempo afetado e depois some novamente as partes. Isso evita aplicar uma melhoria local a um trabalho que ela não pode alterar.

Construa o novo tempo a partir dos tempos antigos

Se a parte afetada se tornar $s$ vezes mais rápida:

Seja $f$ a fração afetada do tempo de execução original. Dividir pelo tempo original fornece a forma de aceleração:

Um programa de 120 s passa 90 s em trabalho de ponto flutuante e 30 s em outras atividades. Assim, a fração afetada é 0,75. Tornar o ponto flutuante três vezes mais rápido reduz seu tempo para 30 s:

O trabalho de ponto flutuante ganha um fator de três; o programa completo ganha um fator de dois. Os 30 s inalterados explicam a diferença.

Calcule de trás para frente a partir de uma meta

Para concluir a mesma tarefa em 40 s, o trabalho inalterado ainda precisa de 30 s. Restam apenas 10 s para a parte de ponto flutuante que levava originalmente 90 s. Portanto:

Uma meta de 30 s deixaria tempo zero para esse trabalho. Nenhuma aceleração finita faz uma quantidade positiva de trabalho afetado levar exatamente zero tempo. À medida que a aceleração local cresce sem limite, a aceleração global se aproxima de:

Aqui o limite é 4, do qual a aceleração se aproxima por baixo. Com uma fração não afetada de um meio, o limite é 2. Quando todo o trabalho é afetado, não há tempo positivo inalterado para impor esse teto finito.

Otimize onde o tempo é gasto

O princípio torne o caso comum rápido significa identificar onde o tempo de execução é realmente gasto. A análise de perfil de execução mede essa distribuição. Dobrar a velocidade de uma parte responsável por 60% do tempo resulta em:

Uma melhoria de dez vezes em uma parte de 10% resulta em apenas:

Um grande fator local pode perder para uma melhoria modesta aplicada a uma parte maior da tarefa.

A fração afetada deve ser uma fração de tempo. Se cargas e armazenamentos representam 30% das instruções, mas consomem 60% dos ciclos, sua fração de tempo em uma frequência de clock fixa é 0,60. Contar as instruções igualmente deixaria de considerar seu custo maior.

Aplique a mesma divisão à espera

Para uma tarefa com 2,00 s de trabalho de CPU e 0,50 s de espera fixa por arquivos, dobrar a velocidade da CPU resulta em 1,50 s no total. Sua aceleração é cerca de 1,67. O mesmo orçamento de tempo funciona para melhorias em hardware, software e entrada e saída: identifique exatamente qual tempo original muda antes de aplicar o fator.

Mais núcleos só reduzem a duração de uma tarefa quando o trabalho pode ser executado simultaneamente. Divida o tempo original de uma tarefa fixa em um único núcleo em uma parte sequencial e uma parte paralela e considere o que os núcleos adicionais podem alterar.

Lei de Amdahl para uma tarefa de tamanho fixo

Seja $p$ a fração paralelizável do tempo original em um único núcleo. Com divisão perfeita entre $N$ núcleos e sem sobrecarga:

Para uma fração paralelizável de 0,95, a fração sequencial é 0,05. Oito núcleos resultam em:

Com 100 núcleos, a aceleração é cerca de 16,8; com 1.000 núcleos, é cerca de 19,6. Os 5% sequenciais mantêm a aceleração de tamanho fixo abaixo de 20, independentemente de quantos núcleos sejam adicionados.

A eficiência paralela é a aceleração dividida pelo número de núcleos. A eficiência com oito núcleos é cerca de 0,74, ou 74%. Com 100 núcleos, é cerca de 17%. Uma aceleração maior pode vir com eficiência menor porque cada núcleo adicional contribui menos para a tarefa fixa.

Por que os ganhos medidos podem ser menores

O modelo ideal divide o trabalho paralelo em partes iguais e não atribui custo à coordenação. Programas reais se comunicam e se sincronizam, e alguns núcleos recebem mais trabalho que outros.

Para 100 unidades iguais de trabalho independente em quatro núcleos idênticos, uma distribuição equilibrada dá 25 unidades a cada um. Se um receber 40 unidades enquanto os demais terminam antes, a conclusão espera pelo núcleo mais ocupado. A aceleração é 100 dividido por 40, ou 2,5, mesmo antes de acrescentar os custos de comunicação. Somar os tempos em que os outros núcleos terminaram mais cedo não forneceria o tempo de conclusão: o último resultado necessário o determina.

Um programa com uma única thread não tem fração paralelizável para distribuir. Mais núcleos ainda podem executar outros programas e melhorar a vazão do sistema, mas não dividem automaticamente o fluxo de instruções desse programa.

Trabalho fixo e trabalho crescente levantam perguntas diferentes

A escalabilidade forte mantém o tamanho total do problema fixo e pergunta quanto mais rápido mais processadores podem concluí-lo. A escalabilidade fraca aumenta o trabalho total proporcionalmente ao número de processadores, de modo que o trabalho por processador permaneça aproximadamente constante. Uma simulação maior pode usar uma malha mais fina mantendo aproximadamente a mesma carga de trabalho por processador.

A lei de Gustafson descreve o trabalho escalado quando o tempo sequencial permanece fixo enquanto o trabalho paralelo cresce. Sua fração sequencial $s$ é medida na execução paralela, diferentemente da fração original de Amdahl em um único núcleo:

Para uma fração sequencial medida de 0,05 em 100 núcleos, a aceleração escalada é 95,05. Isso não contradiz o limite de Amdahl de 20 para uma tarefa fixa cuja fração sequencial original era 5%. O tamanho da tarefa e a base de medição da fração são diferentes.

O software paralelo deve expor trabalho independente, equilibrá-lo e coordenar os resultados. Mais hardware fornece capacidade; a estrutura do programa determina quanto dessa capacidade reduz seu tempo de conclusão.

Processadores CMOS consomem energia quando os sinais comutam e também por fuga enquanto estão alimentados. A energia dinâmica está associada à comutação; a potência estática é consumida mesmo sem comutação útil. Suas parcelas relativas dependem do chip e de sua carga de trabalho.

A tensão tem efeito quadrático

A energia associada a uma transição varia com a capacitância e o quadrado da tensão de alimentação. Uma expressão comum usa metade da capacitância multiplicada pela tensão ao quadrado; um pulso completo de carga e descarga varia com a capacitância multiplicada pela tensão ao quadrado. Para a potência dinâmica média, use:

Aqui $C$ é a carga capacitiva, $V$ é a tensão de alimentação, $f$ é a frequência de clock e $\alpha$ descreve a atividade de comutação segundo a convenção de contagem escolhida. Algumas convenções incorporam um fator de um meio ao fator de atividade. Os cálculos de razões funcionam diretamente quando a convenção de atividade é mantida consistente.

Para capacitância e atividade inalteradas, reduzir a tensão e a frequência em 20% resulta em:

A nova potência dinâmica é 51,2% da original. Reduzir apenas a tensão em 10% resulta em um fator de 0,81, uma redução de 19% na potência dinâmica e na energia por transição.

Uma tensão menor também torna a comutação dos transistores mais lenta. O ajuste dinâmico de tensão e frequência (DVFS) ajusta tensão e frequência em conjunto para que o circuito ainda possa operar na velocidade escolhida.

Potência e energia respondem a perguntas diferentes

Potência é uma taxa, medida em watts; um watt é um joule por segundo. A energia de uma tarefa é a potência média multiplicada pela duração:

B consome mais potência durante a execução, mas usa menos energia para concluir a tarefa. O resfriamento deve lidar com a taxa de produção de calor; o uso da bateria e o consumo de eletricidade acumulam energia ao longo do tempo.

Para um trabalho fixo com a mesma contagem de transições, tensão e atividade, reduzir apenas a frequência distribui essas transições por mais tempo. A potência dinâmica cai, mas a energia dinâmica da tarefa permanece inalterada. Reduzir a tensão também reduz a energia de cada transição. Se a potência estática persistir durante toda a execução mais longa, diminuir a velocidade pode até aumentar essa parte da energia da tarefa.

Fuga e hardware ocioso

Transistores nominalmente desligados ainda deixam passar corrente de fuga. Dispositivos menores e tensões de limiar mais baixas tornam a fuga uma questão importante de projeto. O desligamento seletivo da alimentação desconecta a alimentação de uma região ociosa para reduzir seu consumo estático.

Um servidor com pouca carga ainda pode consumir uma fração considerável de sua potência de pico. Fazer o consumo acompanhar o trabalho útil, chamado de proporcionalidade energética, é uma meta de projeto. Concluir uma tarefa rapidamente e entrar em um estado de baixo consumo pode economizar energia ao reduzir o intervalo durante o qual há consumo por fuga e outras fontes de potência em segundo plano. Portanto, desempenho e eficiência energética podem melhorar juntos.

Durante décadas, transistores menores trouxeram mais dispositivos e comutação mais rápida dentro de um orçamento de calor controlável. A barreira de potência surgiu quando a tensão já não podia continuar caindo o suficiente para sustentar esse padrão. Ela mudou a maneira como projetistas transformavam novos transistores em desempenho útil.

A relação ideal do escalonamento de Dennard

No modelo ideal de escalonamento desenvolvido por Robert Dennard e colegas em 1974, seja um fator $k>1$ que descreve a redução. Dimensões, capacitância, tensão e atraso são divididos por esse fator. A frequência pode ser multiplicada pelo fator. Portanto, a potência dinâmica por transistor muda por:

A área por transistor também cai pelo quadrado do fator de redução. A mesma área pode conter essa quantidade a mais de transistores, compensando a potência menor por dispositivo. A densidade de potência, em watts por unidade de área, permanece aproximadamente constante nesse modelo ideal.

Para um fator de 1,4, a capacitância e a tensão caem para cerca de 0,71 de seus valores originais e a frequência aumenta por um fator de 1,4. A potência por transistor cai para cerca de 0,51. Cabem cerca de 1,96 vez mais transistores, de modo que a potência total na mesma área permanece aproximadamente inalterada.

Por que a tensão deixou de acompanhar o tamanho

Os transistores precisam de um limiar de comutação utilizável. Reduzir demais a tensão de limiar aumenta acentuadamente a fuga. Em meados dos anos 2000, a tensão de alimentação já não podia diminuir no mesmo ritmo das dimensões dos transistores. Com tensão quase fixa, uma frequência maior aumenta a potência dinâmica, e colocar mais transistores ativos em uma área aumenta o calor que deve ser removido.

Os números históricos mostram a escala da mudança anterior: os clocks de computadores de mesa aumentaram de cerca de 10 MHz no início dos anos 1980 para 3,8 GHz em 2004, enquanto as tensões de alimentação caíram de aproximadamente 5 V para perto de 1 V. Esses são valores históricos gerais, não especificações universais. Cerca de 100 W já era um orçamento de resfriamento difícil para muitos projetos comuns daquele período.

O cancelamento pela Intel, em 2004, do planejado Pentium 4 de 4 GHz e do projeto Tejas marcou essa mudança para projetos atentos à potência e núcleos duplos. As frequências de clock permaneceram posteriormente na escala de alguns gigahertz, em vez de seguir a rápida ascensão anterior. A microarquitetura continuou melhorando o desempenho de um único núcleo, mas os aumentos de frequência forneceram uma parcela muito menor do ganho.

Gerencie o orçamento térmico

A potência de projeto térmico (TDP) é uma meta de projeto térmico usada para dimensionar uma solução de resfriamento sob condições de operação especificadas. Ela não é uma medição instantânea de potência nem um máximo universal. Quando os limites térmicos são atingidos, a redução de desempenho por limitação térmica diminui a velocidade de operação para reduzir o calor.

Se um chip contém mais hardware do que seu orçamento de potência pode executar simultaneamente em velocidade máxima, algumas regiões precisam ser desaceleradas ou desligadas. Silício escuro é o nome dado a essa diferença entre os transistores disponíveis e o hardware ativo utilizável simultaneamente.

A lei de Moore e o escalonamento de Dennard descrevem tendências diferentes: contagens de transistores e comportamento de escalonamento considerando a potência. O fim do segundo não significou que as contagens de transistores deixaram de crescer. O obstáculo ao aumento indefinido da frequência é principalmente a potência e o calor, não uma incapacidade repentina de os transistores comutarem mais rapidamente.

Um processador de múltiplos núcleos coloca vários núcleos em um único chip. Cada núcleo executa um fluxo de instruções, enquanto os núcleos compartilham a memória principal e frequentemente algumas caches. Projetos comuns de computadores de mesa e notebooks passaram a usar dois núcleos por volta de 2005–2006, à medida que aumentar o clock de um único núcleo se tornava cada vez mais custoso em potência.

Compare dois núcleos mais lentos com um núcleo mais rápido

Considere um núcleo a 4 GHz e 1,2 V contra dois núcleos a 3 GHz e 1,0 V. Mantenha iguais a capacitância por núcleo e a atividade de comutação nessa comparação. A potência dinâmica relativa é:

Com trabalho igual por ciclo e trabalho independente suficiente para ambos os núcleos, a vazão ideal muda por um fator de:

O par oferece cerca de 50% mais vazão com cerca de 4% mais potência dinâmica. O efeito quadrático da redução de tensão torna o núcleo adicional viável nesse modelo. Potência estática, limites da memória compartilhada e custos de coordenação ainda são importantes ao avaliar um chip completo.

Para um programa sequencial que usa apenas um núcleo novo, o desempenho cai para três quartos do original, com trabalho igual por ciclo. Ele leva quatro terços do tempo. Combinar as duas frequências de 3 GHz em “6 GHz” ocultaria esse resultado: nenhum dos núcleos opera a 6 GHz.

O software deve expor o trabalho

Antes da barreira de potência, frequências maiores e a sobreposição em hardware frequentemente aceleravam o código existente sem grandes mudanças. Núcleos adicionais precisam de fluxos independentes de instruções. Um programa se beneficia deles ao dividir seu trabalho em tarefas concorrentes, equilibrar as atribuições e coordenar os resultados. Bibliotecas paralelas podem fornecer essa estrutura, mas o trabalho ainda deve ter uma forma paralela útil.

O paralelismo em nível de instrução sobrepõe instruções em um fluxo, usando técnicas de hardware e de compilador como segmentação em pipeline e emissão múltipla. O paralelismo em nível de thread executa threads diferentes em vários núcleos. Essas são fontes diferentes de concorrência: a primeira não garante que um programa possa ocupar todos os núcleos.

Requisições independentes a servidores naturalmente fornecem muitos fluxos, portanto múltiplos núcleos podem melhorar a vazão mesmo quando cada requisição permanece sequencial. Reduzir o processamento de uma requisição exige paralelismo dentro dela. Sua fração sequencial então impõe o limite de Amdahl.

Use transistores em tipos eficientes de trabalho

Mais transistores podem sustentar caches maiores, vários núcleos de propósito geral ou hardware especializado. GPUs e aceleradores de domínio específico são voltados a cargas como processamento gráfico, aprendizado de máquina e codificação de vídeo. Chips também podem combinar núcleos rápidos e de alta potência com núcleos menores e mais eficientes, como nos projetos Arm big.LITTLE.

Sob um orçamento fixo de potência, o desempenho por watt compara o desempenho útil com o consumo de potência. O SPEC CPU 2026 também oferece medições de energia junto com métricas de desempenho. Uma boa decisão de projeto considera o tempo de conclusão da carga de trabalho, seu custo energético e a potência que o sistema pode sustentar.