Como a CPU executa instruções: de portas lógicas ao ciclo de clock

Como a CPU executa instruções: de portas lógicas ao ciclo de clock

Uma CPU não sabe somar. Ela sabe fazer pouquíssimas coisas, e cada uma é tão simples que cabe numa tabela de três linhas. A soma que você vê na tela de uma calculadora nasce da combinação dessas coisas simples, repetida muitas vezes e na ordem certa. Esta nota desce até esse nível. Começamos pelas portas lógicas, passamos pelo somador e pela ULA, e terminamos no ciclo que a CPU repete a cada tique do clock.

Se você nunca estudou eletrônica digital, não precisa de nada além de saber que um fio pode estar em dois estados, ligado ou desligado, e que os chamamos de 1 e 0. Todo o restante é uma questão de combinar esses dois estados com regras fixas. Essas regras se chamam álgebra booleana, e cada regra corresponde a um pequeno circuito chamado porta lógica.

1. Portas lógicas: o alfabeto da CPU

Uma porta lógica é um circuito com uma ou mais entradas e uma saída, cuja saída depende das entradas segundo uma regra fixa. A mais simples é a porta NÃO, que inverte o sinal: entra 1, sai 0, e entra 0, sai 1. A porta E só devolve 1 quando todas as entradas valem 1. A porta OU devolve 1 quando pelo menos uma entrada vale 1. Duas variações úteis são a XOR, que devolve 1 quando as entradas são diferentes, e a NAND, que é a negação de E.

Por que tantas portas? Porque cada uma responde a uma pergunta diferente. A E pergunta se as duas coisas são verdadeiras ao mesmo tempo. A OU pergunta se pelo menos uma é. A XOR pergunta se elas são diferentes, o que, em aritmética binária, dá o bit da soma sem o vai-um. Com essas três respostas e a NÃO, você consegue construir qualquer função lógica, e isso é o que torna a CPU possível. Um detalhe que vale guardar: a NAND sozinha basta para construir todas as outras, e por isso é muito usada na fabricação de chips.

Portas ficam sobre transistores. Um transistor, no uso digital, funciona como uma chave controlada por tensão. Combinando transistores, você monta uma porta, e combinando portas, monta um somador. Não existe mágica acima disso, só camadas de chaves.

2. Um somador de verdade

Vamos somar dois números de 4 bits, 6 (0110) e 3 (0011), para ver como as portas se combinam. Para somar em binário, você soma bit a bit da direita para a esquerda, e quando o resultado de uma coluna passa de 1, leva o excedente para a coluna seguinte. Esse excedente se chama vai-um, ou carry. Cada coluna recebe três entradas: o bit de A, o bit de B e o vai-um que veio da coluna anterior. O circuito que faz isso se chama somador completo.

Começando pela coluna da direita, com A0 = 0, B0 = 1 e vai-um inicial 0, a soma é 1 e não há vai-um. Na segunda coluna, A1 = 1, B1 = 1 e vai-um 0 dão 2, que em binário é 10. O bit da soma é 0 e o vai-um é 1. Na terceira, A2 = 1, B2 = 0 e vai-um 1 somam 2, de novo 10: bit 0 e vai-um 1. Na última, A3 = 0, B3 = 0 e vai-um 1 dão 1: bit 1 e vai-um 0. O resultado é 1001, que é 9 em decimal, e 6 + 3 = 9. Conferimos.

Um somador completo de um bit sai de cinco portas: duas XOR para o bit da soma, duas E e uma OU para o vai-um. A figura abaixo desenha esse circuito com a entrada 1 + 1 + 0, que dá soma 0 e vai-um 1.

Siga a figura pelo fio. Os dois bits de entrada alimentam a primeira XOR e a primeira E. A saída da XOR, que é o bit parcial, entra na segunda XOR junto com o vai-um de entrada, e o resultado sai como bit da soma. Ao mesmo tempo, a primeira E e a segunda E calculam os dois casos em que pode haver vai-um, e a OU junta os dois. Por isso a saída de vai-um é de fato um OU: ela vale 1 quando um dos dois casos acontece. Com 1 e 1 na entrada, a primeira E já vale 1, e o vai-um sai 1 independentemente do vai-um de entrada.

Para somar números de 64 bits, a CPU encadeia 64 somadores completos, com o vai-um de cada um alimentando o seguinte. Em projetos reais existem somadores mais rápidos que esse encadeamento simples, que tentam calcular o vai-um de forma antecipada, mas a ideia básica é esta.

3. A ULA: a unidade que faz as contas

A ULA (unidade lógica e aritmética, em inglês ALU) reúne numa única peça as operações que a CPU precisa: somar, subtrair, fazer E, OU e XOR bit a bit, deslocar bits para a esquerda ou para a direita e comparar valores. Um sinal de controle diz à ULA qual operação fazer, e ela devolve o resultado na saída, junto com algumas flags, que são bits que indicam propriedades do resultado. A mais conhecida é a flag de zero, que vale 1 quando o resultado é zero. Essa flag é o que permite a uma instrução de comparação alimentar um desvio condicional, como “se for igual, pule para tal endereço”.

Subtrair, na prática, é somar o complemento. Em aritmética de complemento de dois, que é a usada pela maioria das CPUs, inverter todos os bits de um número e somar 1 dá o seu negativo. Assim, a ULA não precisa de um circuito de subtração separado: ela inverte um dos operandos e aproveita o somador. Esse tipo de economia de circuito é o que mantém a ULA pequena, e a pequenez é o que permite colocar várias ULAs num mesmo núcleo.

Muitos núcleos modernos têm mais de uma ULA. Isso permite executar duas operações simples no mesmo ciclo, desde que elas não dependam uma da outra. Essa capacidade é a base da execução superescalar, explicada na nota de pipeline.

4. Registradores e barramentos: a bancada

Se a ULA é o fogão, os registradores são a bancada ao alcance da mão. Um registrador é um conjunto de flip-flops, circuitos que guardam um bit até que alguém o troque, e costuma ter a largura de palavra da CPU, como 32 ou 64 bits. Um núcleo tem dezenas de registradores de uso geral, mais alguns especiais, como o contador de programa, que guarda o endereço da próxima instrução, e o ponteiro de pilha, que aponta para o topo da pilha de chamadas de função.

Por que tantos registradores? Porque acessar um registrador leva um passo, enquanto acessar a RAM leva centenas de vezes mais. Um compilador que consegue manter as variáveis mais usadas nos registradores produz código bem mais rápido. Essa é a razão pela qual a história das CPUs dá tanta atenção ao número de registradores e ao tamanho deles, e por que a arquitetura de cada família define um conjunto fixo que o programa pode usar.

Os dados viajam entre registradores, ULA e memória por barramentos. Um barramento é um conjunto de fios paralelos, um por bit. Um barramento de 64 bits transporta uma palavra inteira por vez, e a CPU usa barramentos internos separados para endereços, dados e controle. Pense no barramento como a esteira que leva ingredientes da despensa até a bancada: ela é tão larga quanto o número de bits que pode transportar de uma vez, e sua velocidade define quantos ingredientes passam por segundo.

A figura abaixo mostra o caminho de dados de um núcleo simples. A memória alimenta os registradores, que entregam os operandos à ULA. O resultado volta para os registradores, e a unidade de controle, em laranja, decide quais operações e quais registradores entram em cada etapa.

A linha verde é o fluxo de dados, e a linha tracejada laranja é o fluxo de controle. Essa distinção ajuda a ler qualquer diagrama de CPU: o que carrega valores é uma coisa, e o que decide o que fazer com eles é outra.

5. A unidade de controle e a microprogramação

A unidade de controle é a parte que transforma uma instrução em sinais elétricos. Ela recebe o código da instrução, decodifica os campos (qual operação, quais registradores, se há um endereço de memória) e liga as chaves certas. Em CPUs simples, a decodificação é uma lógica fixa, desenhada à mão em portas. Em CPUs mais complexas, muitas vezes ela usa microprogramação, em que cada instrução é executada por uma pequena sequência de micro-operações guardada numa memória interna, chamada microcódigo.

A microprogramação foi uma ideia importante nos anos 1960 e 1970, porque permitia criar uma família de máquinas compatíveis com o mesmo conjunto de instruções, trocando só o microcódigo. Ela também facilitou a correção de erros, já que um defeito no microcódigo podia ser consertado com uma atualização, e não com uma nova placa. Muitas CPUs x86 de hoje ainda usam microcódigo para instruções complexas, e a nota de gerações explica por que essa camada existe e o que ela custa.

6. O clock e o ciclo busca, decodifica, executa

O clock é um sinal que alterna entre alto e baixo milhões ou bilhões de vezes por segundo. A cada transição, os registradores podem capturar novos valores, e o circuito avança um passo. A frequência do clock diz quantos desses passos acontecem por segundo, e um clock de 3 GHz tem 3 bilhões de transições por segundo. A velocidade do chip é limitada pelo tempo mais longo que um sinal leva para atravessar um caminho entre dois registradores, porque o próximo tique só pode vir depois que todo o caminho estabilizou.

Sobre esse ritmo, a CPU repete um ciclo que, em sua forma clássica, tem três etapas: busca, decodificação e execução. Na busca, a CPU lê na memória a instrução apontada pelo contador de programa, e incrementa esse contador para apontar para a seguinte. Na decodificação, a unidade de controle identifica a operação e os operandos. Na execução, a ULA, a memória ou algum outro bloco faz o trabalho, e o resultado é gravado num registrador. Depois o ciclo recomeça.

A figura abaixo desenha esse ciclo. O contador de programa é o ponto de partida, e a seta laranja de volta representa o avanço do PC ou o novo endereço de um desvio.

Repare que o ciclo fecha um laço. A última etapa alimenta de volta o contador, e é isso que faz a CPU avançar pelo programa, ou saltar para outro ponto quando há um desvio. Essa é a essência do modelo de programa armazenado: a mesma máquina, com o mesmo ciclo, segue qualquer lista de instruções que você colocar na memória.

O mesmo ciclo num núcleo moderno

O ciclo clássico de três etapas é o modelo para entender a ordem lógica, mas um núcleo moderno desdobra a etapa de busca e a de execução em muitas peças. A figura mostra o caminho de uma instrução de soma por essas peças. O contador de programa aponta o endereço, o previsor de desvios escolhe o próximo, e os bytes seguem para o decodificador, que os traduz em micro-operações. Elas passam pela renomeação, que dá nomes físicos aos registradores, entram no escalonador e chegam às ULAs quando seus operandos estão prontos. O buffer de reordenação confirma o resultado na ordem do programa.

Na figura, as cores separam o papel de cada peça: laranja para o que decide o caminho, azul e verde para o que executa e confirma. Os pacotes que correm nas setas mostram só o sentido do fluxo. O que importa é a ordem: o front-end descobre e traduz, o back-end executa e confirma. As peças de renomeação, escalonamento e reordenação são explicadas com números na nota de pipeline, nas seções sobre execução fora de ordem.

7. Desempenho em números

A forma mais útil de pensar em desempenho é uma equação com três fatores: instruções, ciclos por instrução e período do clock. O tempo de execução de um programa é

tempo = número de instruções × CPI × período do clock

O CPI (ciclos por instrução) é a média de ciclos que cada instrução gasta. O período é o inverso da frequência: 1 / 3 GHz ≈ 0,333 ns. Cada fator tem uma origem diferente. O número de instruções depende do algoritmo e do compilador, o CPI depende da microarquitetura e da hierarquia de memória, e o período depende do processo de fabricação e da energia disponível.

Veja um exemplo. Um programa executa 2 bilhões de instruções num núcleo de 3 GHz com CPI de 1,2. O tempo é 2 × 10^9 × 1,2 × 0,333 × 10^-9 = 0,8 s. Se um compilador melhor reduzir as instruções para 1,6 bilhão, o tempo cai para 0,64 s, sem mudar o chip. Se o mesmo programa cair numa cache pior e o CPI subir para 2,0, o tempo sobe para 1,33 s, sem mudar o código.

O CPI nem sempre é constante. Suponha um núcleo ideal com CPI de 1,0 que, em média, erra na cache em 1% das instruções, e cada erro custa 200 ciclos de espera pela RAM. O CPI efetivo vira 1,0 + 0,01 × 200 = 3,0. O núcleo é o mesmo, mas a espera pela memória triplica o custo de cada instrução. É o tipo de conta que explica por que a hierarquia de memória, descrita na nota de pipeline, pesa tanto.

Essa equação também mostra por que um clock maior não garante um programa mais rápido. Um chip de 4 GHz com CPI de 2,0 é mais lento que um de 3 GHz com CPI de 1,2 para o mesmo programa: 2,0 × 0,25 = 0,50 contra 1,2 × 0,333 = 0,40 ns por instrução.

9. Erros comuns

Um erro frequente é olhar só o período na equação de tempo e esquecer o número de instruções e o CPI, o que leva a comparar chips só pelo clock.

8. Um exemplo completo, em câmera lenta

Imagine que o programa diz “some 6 e 3, e guarde o resultado”. Em uma CPU simplificada, a sequência fica assim. No ciclo 1, o contador aponta para a instrução ADD. A busca lê o código, a decodificação identifica soma e os registradores de origem, e a execução entrega 6 e 3 à ULA, que devolve 9. No ciclo 2, o resultado é gravado no registrador de destino e o contador avança para a instrução seguinte.

Esse exemplo esconde detalhes reais, como o acesso à memória que pode demorar, e o fato de que uma CPU moderna não espera um ciclo terminar antes de iniciar o próximo. Mas ele mostra a ordem lógica, que é a parte que você precisa carregar para ler qualquer análise de desempenho. A nota de pipeline mostra o que acontece quando várias instruções ocupam o chip ao mesmo tempo.

O primeiro erro é imaginar que a CPU executa o programa inteiro de uma vez. Ela executa uma sequência de passos pequenos, e a velocidade vem da repetição muito rápida desses passos, não de um passo grande.

O segundo erro é confundir registrador com memória. O registrador é pequeno e interno ao núcleo, e acessá-lo é quase imediato. A memória é grande e distante, e acessá-la custa muito mais. Compiladores e programadores que ignoram essa diferença produzem código lento sem perceber a causa.

O terceiro erro é achar que a ULA sempre faz uma operação por vez. Em núcleos modernos, há várias unidades desse tipo, e o ganho real depende de quantas operações independentes o programa deixa disponíveis. Um programa cheio de dependências entre cálculos não aproveita essas unidades, por mais que existam.

Exercícios

1. Some em binário 0101 (5) com 0111 (7). Escreva a tabela de cada coluna, com o bit da soma e o vai-um, e confira o resultado em decimal.
2. Desenhe a tabela-verdade da XOR e da E, e explique, com as suas palavras, por que a XOR é a parte da soma que não leva vai-um.
3. Descreva o ciclo busca, decodifica, executa para a instrução “subtraia 2 do registrador R1”, e diga em que etapa o contador de programa muda.

Respostas dos exercícios

1. Em binário, 0101 + 0111 dá 1100 (12). Coluna 1: 1 + 1 = 10, bit 0 e vai-um 1. Coluna 2: 0 + 1 + 1 = 10, bit 0 e vai-um 1. Coluna 3: 1 + 1 + 1 = 11, bit 1 e vai-um 1. Coluna 4: 0 + 0 + 1 = 1, bit 1. O resultado 1100 é 12, que confere com 5 + 7.
2. A XOR é 1 quando as entradas são diferentes, e a E é 1 só quando as duas são 1. Somando dois bits sem vai-um, os casos 0 + 0, 0 + 1 e 1 + 0 têm bit de soma 0, 1 e 1, o que coincide com a XOR. O caso 1 + 1 dá bit de soma 0, e a XOR também dá 0 nele. O vai-um aparece só nesse último caso, que é o da E. Por isso a XOR faz a soma e a E faz o vai-um.
3. Para “subtraia 2 do registrador R1”, a busca lê a instrução e o contador avança para a seguinte. A decodificação identifica a subtração, o operando 2 e o registrador R1. A execução entrega R1 e 2 à ULA, e a gravação devolve o resultado a R1. O contador muda na busca, quando avança para a instrução seguinte, e de novo se a instrução for um desvio, quando ele recebe o endereço do alvo.

Fontes

Consultadas em 1 de novembro de 2026. Esta nota trata de conceitos de eletrônica digital e de arquitetura de computadores estáveis há décadas, e a maior parte do conteúdo vem de conhecimento consolidado, sem números de produto. Os dados de cada CPU citada estão na nota de história.

• Descrições de portas lógicas, somadores e complemento de dois seguem os conceitos padrão de arquitetura de computadores. Não há citação de página específica para cada definição nesta versão da aula.
• O modelo de programa armazenado e o ciclo busca, decodifica, executa são descritos de forma geral nas referências clássicas de arquitetura, como o livro de Patterson e Hennessy, sem abrir a edição específica neste levantamento.

Relacionados

• CPU
• História das CPUs
• Pipeline, cache e paralelismo
• Gerações e arquiteturas
• Carga da CPU no Mac