Nos dois artigos anteriores, montamos a base do sistema de memória: a hierarquia de memória que organiza DRAM, SRAM e armazenamento secundário, e a cache que serve de tampão entre o processador e a memória principal. Agora chegamos ao coração do sistema: a Unidade Central de Processamento (CPU).
A CPU é o componente que de fato computa — que executa operações aritméticas, toma decisões lógicas, busca instruções da memória e coordena todos os demais subsistemas. Processadores modernos são fabricados em um único chip, com bilhões de transistores, e operam em frequências de gigahertz. Mas a essência da CPU permanece a mesma desde os primeiros computadores: buscar uma instrução, decodificá-la e executá-la — repetidamente, até o sistema ser desligado.
Neste artigo você vai entender:
- quais são as duas funções básicas da CPU e o que ela realiza em termos de operações primitivas;
- o que é uma instrução de máquina e como ela é estruturada em bits;
- quais componentes formam a CPU e qual o papel de cada um;
- o que são flags de estado e por que elas existem;
- como o clock sincroniza tudo e por que frequência não é sinônimo de desempenho;
- os microeventos do ciclo de busca em notação LTR;
- as diferenças entre arquiteturas CISC e RISC.
A CPU no mundo real #
A CPU é o componente que de fato executa instruções, processa dados e coordena o funcionamento do sistema. Em computadores atuais, ela costuma vir em um único encapsulamento conectado à placa-mãe, embora internamente possa conter um ou mais blocos de silício, além de caches e unidades funcionais especializadas.
Apesar da enorme evolução física — bilhões de transistores, frequências de gigahertz e múltiplos núcleos — a ideia fundamental permanece a mesma: buscar uma instrução, decodificá-la e executá-la.
O processador no mundo real
Ao analisar a especificação de um processador real, observamos não apenas sua organização lógica, mas também características físicas e de integração: tecnologia de fabricação, número de transistores, tipo de encapsulamento, soquete, quantidade de núcleos, tamanhos de cache e presença de unidades especializadas para diferentes tipos de cálculo, como inteiros, ponto flutuante e vetores.
O que a CPU faz #
A CPU possui duas funções fundamentais:
- Processamento de dados: executar operações aritméticas (somar, subtrair, multiplicar, dividir), lógicas (AND, OR, XOR), movimentação de dados, desvios e operações de entrada/saída.
- Controle: coordenar o funcionamento de todos os componentes do sistema — memória principal, dispositivos de E/S e os demais subsistemas.
Na prática, toda computação complexa é decomposta em operações primitivas:
somar, subtrair, mover dados entre locais de armazenamento, transferir dados para
dispositivos de saída. Um compilador, ao processar uma expressão como
X = A + B*C, gera uma sequência de instruções primitivas que a CPU executa
uma a uma:
T = B * C ; 1ª instrução
X = A + T ; 2ª instruçãoA CPU nunca vê a expressão de alto nível — só as instruções elementares que o compilador produziu a partir dela.
A figura abaixo mostra um esquema simplificado da CPU, destacando seus principais componentes e como eles se conectam à memória principal. Note que a CPU é um sistema complexo, mas podemos entender sua organização básica a partir de seus blocos funcionais e dos fluxos de dados e controle entre eles.
Vamos detalhar esses componentes no decorrer do artigo, mas antes, precisamos entender o que é uma instrução de máquina.
Instruções de máquina #
Uma instrução de máquina é uma sequência de bits que codifica exatamente o que a CPU deve fazer. Ela tem dois campos principais:
- Código de operação (C.Op): especifica qual operação executar
- Operandos: os dados a operar ou os endereços de onde obtê-los
Por exemplo, uma instrução de 12 bits com 4 bits para o C.Op e 8 bits para os operandos poderia ser estruturada assim:
| C.Op (4 bits) | Operando 1 (4 bits) | Operando 2 (4 bits) |
0 1 0 1 0 1 0 0 1 0 0 0A operação acima pode, por exemplo, representar ADD R1, R2 — somar os valores
dos registradores R1 e R2 e armazenar o resultado em um registrador de destino
implícito (como o ACC).
Com \(n\) bits de C.Op, temos \(2^n\) operações possíveis. Com 4 bits, por exemplo, chegamos a \(2^4 = 16\) operações distintas.
O programa vive na memória principal
Um programa executável é uma sequência de instruções de máquina armazenadas em células consecutivas da MP. Para iniciar a execução:
- as instruções devem estar em células sucessivas da MP;
- o endereço da primeira instrução deve estar no CI (Contador de Instrução);
- a CPU executa as instruções na ordem dos endereços, salvo desvios explícitos.
Tamanho da palavra e registradores #
Em arquiteturas clássicas, o tamanho da palavra do processador costuma coincidir com a largura dos registradores de propósito geral e com a quantidade de bits manipulados de uma só vez pela UAL. Isso, porém, não significa que todos os registradores da CPU tenham necessariamente a mesma largura.
Registradores especializados podem ter tamanhos diferentes, de acordo com sua função. Por exemplo:
- o CI / PC e o REM / MAR acompanham o tamanho do endereço;
- o RDM / MBR acompanha a largura da transferência de dados com a memória;
- os registradores de uso geral e o ACC normalmente acompanham a palavra do processador.
O impacto do tamanho da palavra #
O tamanho da palavra influencia diretamente a quantidade de dados que a CPU pode transferir e processar por vez. Em um exemplo simples, se dois valores de 16 bits precisam ser somados:
- em um sistema com palavra de 8 bits, cada valor precisará ser tratado em duas partes;
- em um sistema com palavra de 16 bits, cada valor pode ser tratado de uma só vez.
Isso não significa que um processador com palavra maior será sempre exatamente duas vezes mais rápido, mas ajuda a entender por que arquiteturas com palavras maiores tendem a reduzir o número de acessos e etapas necessárias para certas operações.
Para somar \(A = \text{3A25}_{16}\) e \(B = \text{172C}_{16}\) (valores de 16 bits):
| Sistema | Largura da palavra | Acessos à MP | Tempo relativo |
|---|---|---|---|
| Sistema 1 | 8 bits | 2 acessos (8 bits por vez) | \(T_1\) |
| Sistema 2 | 16 bits | 1 acesso (16 bits de uma vez) | \(T_2 \approx T_1/2\) |
Isso explica a evolução histórica: de processadores de 8 e 16 bits para os de 32 e 64 bits presentes hoje em qualquer computador pessoal ou smartphone.
Componentes da CPU #
Internamente, a CPU é composta por dois grandes blocos funcionais: a Unidade de Controle (UC) e a Unidade Aritmética e Lógica (UAL), conectados por registradores e barramentos internos.
graph TB
subgraph UCP["Unidade Central de Processamento"]
subgraph CTR["Unidade de Controle"]
REL["Relógio (Clock)"]
UC["UC — Unidade de Controle"]
DEC["Decodificador (C.Op → operação)"]
CI["CI / PC — Próxima instrução"]
RI["RI / IR — Instrução atual"]
REM["REM / MAR — Endereço p/ MP"]
RDM["RDM / MBR — Dado da MP"]
end
subgraph PROC["Unidade Aritmética e Lógica"]
UAL["UAL / ALU"]
ACC["ACC — Acumulador"]
REGS["Registradores de propósito geral"]
FLAGS["Registrador de Flags (N, Z, V, C)"]
end
REL --> UC
UC --> DEC
RI --> DEC
DEC --> UAL
CI --> REM
RDM --> RI
UAL <--> ACC
UAL <--> REGS
UAL --> FLAGS
end
MP[("Memória Principal")]
REM -->|"Barramento de Endereços"| MP
RDM <-->|"Barramento de Dados"| MP
UC -.->|"Barramento de Controle"| MP
| Componente | Nome alternativo | Função |
|---|---|---|
| UAL | ALU | Executa operações aritméticas e lógicas |
| Registradores | Registers | Armazenam dados, endereços e instruções temporariamente |
| ACC | Acumulador | Registrador especial; resultado implícito em arquiteturas antigas |
| RI | IR (Instruction Register) | Armazena a instrução que está sendo executada |
| CI | PC (Program Counter) | Armazena o endereço da próxima instrução |
| REM | MAR (Memory Address Register) | Armazena o endereço para acesso à MP |
| RDM | MBR (Memory Buffer Register) | Buffer de dado entre CPU e MP |
| UC | Control Unit | Gera os sinais de controle para todos os componentes |
| Decodificador | Decoder | Identifica a operação a partir dos bits do C.Op |
| Relógio | Clock | Gera pulsos que sincronizam todas as operações |
Tamanho dos registradores e palavra do processador
A capacidade de um registrador é igual ao tamanho da palavra do processador. Um Intel 486 tem palavra de 32 bits → registradores de 32 bits. Registradores de 16 bits podem ser divididos em parte alta (H) e baixa (L): AH, AL, BH, BL.
Flags de estado #
A UAL não apenas calcula resultados — ela também registra propriedades do último
resultado em bits especiais chamados flags (bandeiras). Esses bits são
consultados por instruções de desvio condicional (if, while, etc.) para
decidir se o fluxo do programa deve mudar.
Um exemplo histórico bastante conhecido é o conjunto de flags do Motorola 68000:
| Flag | Significado | Condição de ativação |
|---|---|---|
| N | Negativo (Negative) | Resultado < 0 |
| Z | Zero | Resultado = 0 |
| V | Overflow | Estouro da capacidade do registrador |
| C | Carry (vai-um) | Carry gerado em operação aritmética |
| X | Extend | Extensão do carry |
Esse conjunto não deve ser lido como “o padrão atual universal”, mas como um bom exemplo histórico para entender a função das flags em uma CPU.
Por exemplo, após calcular A - B, a CPU verifica a flag Z para saber se o
resultado foi zero — o que equivale a A == B — e a flag N para saber se foi
negativo — equivalente a A < B. Uma instrução de desvio condicional usa esses
flags para decidir qual instrução executar a seguir.
No entanto, antes de poder calcular qualquer coisa ou checar flags, a CPU precisa responder à pergunta mais básica ao ler a memória: “O que essa sequência de zeros e uns significa?”. É aqui que o decodificador entra em cena.
O decodificador #
O decodificador é um circuito combinacional do tipo \(n\)-para-\(2^n\): cada combinação dos bits do C.Op ativa exatamente uma saída, que corresponde à operação a realizar.
$$n\ \text{bits de C.Op} \implies 2^n\ \text{operações distintas possíveis}$$Com 4 bits, por exemplo, 16 saídas; com 8 bits, 256 saídas. Somente a saída correspondente ao código recebido é ativada; as demais permanecem inativas. Esse circuito é o que transforma os bits do C.Op em sinais elétricos que configuram a UAL para a operação correta.
A UAL — Unidade Aritmética e Lógica #
Uma vez que o decodificador “traduziu” a instrução e preparou os caminhos elétricos do sistema, o palco está pronto para a força bruta do processador agir. A UAL obtém os dados dos registradores e deposita os resultados de volta neles. É ela quem realiza todo o trabalho computacional propriamente dito:
| Categoria | Operações |
|---|---|
| Aritmética inteira | Soma, subtração, multiplicação, divisão |
| Ponto flutuante | Mesmas operações sobre números reais (co-processador, hoje integrado) |
| Lógica bit a bit | AND, OR, XOR, NOT |
| Deslocamento de bits | Shift left (\(\times 2\)), Shift right (\(\div 2\)) |
| Incremento/Decremento | \(+1\), \(-1\) |
A UAL não acessa a memória diretamente — ela só opera sobre valores que já estão nos registradores. Cabe ao ciclo de instrução (seção seguinte) garantir que os dados certos estejam nos registradores certos antes que a UAL opere.
O relógio e os ciclos #
O relógio é um gerador de pulsos que sincroniza todas as operações da CPU. A frequência indica quantos ciclos ocorrem por segundo:
$$f = \frac{1}{T} \qquad \Longleftrightarrow \qquad T = \frac{1}{f}$$| Processador (exemplo) | Frequência | Período de ciclo |
|---|---|---|
| M1 | 25 MHz | \(T = 1/(25 \times 10^6) = 40\ \text{ns}\) |
| M2 | 400 MHz | \(T = 1/(400 \times 10^6) = 2{,}5\ \text{ns}\) |
Frequência ≠ desempenho
Um processador com frequência maior não necessariamente executa mais instruções por segundo. Pipeline, cache, arquitetura e o número de ciclos por instrução (CPI) também determinam o desempenho real. É perfeitamente possível que um processador a 3 GHz execute menos instruções por segundo do que um a 2 GHz com melhor pipeline.
Cada ciclo de relógio pode ser subdividido em subciclos (\(t_0, t_1, t_2, \ldots, t_n\)), que correspondem a microeventos internos do ciclo de instrução.
Para burlar o limite da frequência e aumentar o desempenho, os processadores evoluíram seus modos de execução. Historicamente, as CPUs operavam no modo exclusivamente sequencial (uma instrução só começava após a anterior terminar). Hoje, operamos com execução concorrente (pipeline), onde várias instruções se sobrepõem em estágios diferentes (como uma linha de montagem); execução paralela, com múltiplos núcleos processando instruções simultaneamente; e execução vetorial, onde uma única instrução opera sobre múltiplos dados ao mesmo tempo
O ciclo de instrução #
A CPU opera em um laço perpétuo:
$$\text{Ciclo de instrução} = \text{Ciclo de busca} + \text{Ciclo de execução}$$Na prática, a coreografia desse laço perpétuo divide a CPU em dois papéis distintos. Na primeira etapa, o processador age como um leitor buscando a sua próxima tarefa; na segunda, ele vira o executor:
| Fase | O que acontece |
|---|---|
| Ciclo de busca | Busca a instrução na MP → armazena no RI → decodifica |
| Ciclo de execução | Gera sinais de controle → executa na UAL ou acessa dispositivos |
A figura abaixo mostra um fluxograma simplificado do ciclo de instrução, mostra a busca, a interpretação e a execução de uma instrução.
Controle cabeado e microprogramado #
Para gerar os sinais de controle do ciclo de instrução, há duas abordagens clássicas de projeto da Unidade de Controle:
- controle cabeado (hardwired control): os sinais são produzidos por circuitos lógicos fixos; tende a ser mais rápido, mas também menos flexível;
- controle microprogramado: as microoperações são descritas em uma memória de controle interna; tende a simplificar o projeto da UC, embora normalmente seja mais lento que o controle totalmente cabeado.
Essa distinção é importante porque mostra que a CPU não “entende” instruções magicamente: ela depende de um mecanismo interno que traduza cada instrução em uma sequência organizada de sinais de controle.
Microeventos do ciclo de busca #
O ciclo de busca se desdobra em três microtempos consecutivos, descritos em notação LTR (a mesma que usamos para operações de memória no artigo sobre hierarquia de memória):
| Subciclo | Microevento em LTR | Descrição |
|---|---|---|
| \(t_0\) | \(\text{REM} \leftarrow (CI)\) | O endereço da próxima instrução vai para o REM; é enviado pelo barramento de endereços à MP |
| \(t_1\) | \(CI \leftarrow CI + N\) e \(\text{RDM} \leftarrow M(\text{REM})\) | O CI é incrementado (aponta para a instrução seguinte) enquanto a MP lê a instrução e a deposita no RDM |
| \(t_2\) | \(\text{RI} \leftarrow \text{RDM}\) | A instrução é transferida do RDM para o RI, onde será decodificada pela UC |
Aqui, \(N\) representa a quantidade de células ocupadas pela instrução. Em arquiteturas de instrução fixa, esse incremento costuma ser constante; em arquiteturas mais complexas, depende do tamanho efetivo da instrução buscada.
Note que \(t_1\) tem duas operações simultâneas — o incremento do CI e a leitura da MP podem ocorrer em paralelo porque usam recursos distintos: o CI e a UAL (para o incremento) versus o barramento e a MP (para a leitura).
Formatos de instrução #
Uma instrução pode conter um número variável de operandos, dependendo da arquitetura. Os três formatos principais diferem em quantos valores explícitos a instrução referencia:
| Formato | Semântica | Exemplo em assembly |
|---|---|---|
| 3 operandos | \(\text{Op3} \leftarrow \text{Op1} \oplus \text{Op2}\) | ADD R1, R2, R3 → R3 = R1 + R2 |
| 2 operandos | \(\text{Op1} \leftarrow \text{Op1} \oplus \text{Op2}\) | ADD R1, R2 → R1 = R1 + R2 |
| 1 operando | \(\text{ACC} \leftarrow \text{ACC} \oplus \text{Op}\) | ADD B → ACC = ACC + (B) |
O formato de 1 operando é característico das arquiteturas com acumulador: o ACC é sempre um dos operandos implícitos, o que simplifica o circuito decodificador às custas de menos expressividade por instrução.
O tamanho do C.Op pode ser fixo (implementação mais simples e rápida, mas limita o número de operações) ou variável (mais flexível, decodificação mais complexa). Arquiteturas CISC tendem a usar formatos variáveis; RISC, fixos.
CISC vs. RISC #
Essa exata discussão sobre o design das instruções — se os formatos deveriam ser variáveis e repletos de opções, ou fixos e enxutos — foi o grande divisor de águas na indústria de hardware, criando duas escolas de pensamento que se confrontaram por décadas:
| Característica | CISC | RISC |
|---|---|---|
| Nome completo | Complex Instruction Set Computers | Reduced Instruction Set Computers |
| Filosofia | Muitas instruções, algumas complexas | Poucas instruções, mais simples e uniformes |
| Formato das instruções | Variado (tamanhos diferentes) | Uniforme (tamanho fixo) |
| Modos de endereçamento | Mais numerosos | Mais restritos |
| Foco histórico | Expressividade por instrução | Facilidade de implementação, pipeline e execução rápida |
A intuição do CISC era reduzir o número de instruções necessárias para representar um programa. A do RISC era simplificar as instruções para tornar a execução mais rápida e previsível.
Na prática, processadores modernos misturam ideias das duas escolas: por exemplo, a família x86 mantém uma interface historicamente CISC, mas internamente traduz as instruções em micro-operações mais simples.
O artigo seguinte a este explora em detalhes como um processador hipotético executa instruções concretas, passo a passo.
Exemplos práticos #
Com todos os componentes em mente, podemos dimensionar os registradores e barramentos de uma máquina concreta a partir de suas especificações:
Exemplo — Projeto completo dos registradores
Uma máquina deve endereçar 4 M células de memória principal, com cada célula armazenando 2 bytes. Cada instrução contém: código de operação (máximo 64 operações), um operando de endereço de MP e um operando de registrador (a máquina tem 16 registradores).
Determine: (a) tamanho do REM e do barramento de endereços; (b) tamanho da instrução em bits e em células; (c) tamanho do RDM e do BD para obter a instrução em um único acesso; (d) acessos necessários se 1 célula por vez; (e) tamanhos do RI e do CI.
(a) REM / BE: \(N = 4\text{M} = 2^{22}\) células → \(E = 22\) bits → REM = BE = 22 bits
(b) Tamanho da instrução:
- C.Op: 64 operações \(= 2^6\) → 6 bits
- Operando (endereço): 22 bits
- Operando (registrador): 16 registradores \(= 2^4\) → 4 bits
- Total: \(6 + 22 + 4 = \mathbf{32\ \text{bits}}\) = 2 células (cada célula = 16 bits)
(c) RDM / BD para 1 acesso: Para obter a instrução inteira em 1 acesso → RDM = BD = 32 bits
(d) Acessos se 1 célula por vez: Instrução = 32 bits; célula = 16 bits → 2 acessos
(e) RI e CI:
- RI = 32 bits (armazena a instrução completa)
- CI = 22 bits (endereça toda a MP)
Os dois exemplos a seguir combinam conceitos vistos aqui com conceitos de hierarquia de memória e cache vistos nos artigos anteriores, mostrando como o projeto da CPU e da memória estão interligados.
Exemplo — Da capacidade máxima ao barramento de dados
Uma máquina pode endereçar 16 M células. Cada célula armazena uma palavra, e cada instrução tem o tamanho de uma palavra. O código de operação suporta no máximo 256 operações distintas e o operando é um endereço de MP. São necessários quatro ciclos de busca para obter uma instrução completa.
Determine: tamanho do CI, capacidade total, REM, RI, BE e BD.
\(N = 16\text{ M} = 2^{24}\) células → CI = REM = BE = 24 bits
C.Op: \(256 = 2^8\) → 8 bits. Operando: 24 bits. Instrução = \(8 + 24 = 32\) bits = tamanho de uma célula \((M)\).
RI = 32 bits (armazena a instrução inteira para decodificação).
\(T = 2^{24} \times 32 = \mathbf{512\ \text{Mbits}}\ (= 64\ \text{Mbytes})\)
BD: instrução = 32 bits em 4 ciclos de busca → BD = \(32/4 = 8\) bits
Exemplo — Instrução com dois operandos e ciclo de busca duplo
Uma máquina tem 256 M células, com 512 instruções distintas. Cada instrução contém um código de operação e dois operandos de endereço de MP. O barramento de dados tem largura igual à metade do tamanho de uma instrução.
Determine: REM, RI, RDM, capacidade total e descreva o ciclo de busca.
\(N = 256\text{ M} = 2^{28}\) → REM = 28 bits
C.Op: \(\log_2 512 = 9\) bits. Cada operando: 28 bits. Instrução = \(9 + 28 + 28 = \mathbf{65\ \text{bits}}\) → RI = RDM = 65 bits
\(T = 2^{28} \times 65 = 256 \times 65\ \text{Mbits} = \mathbf{16.640\ \text{Mbits}}\)
BD = \(65/2 \approx 32\) bits → fica faltando 1 bit → 3 ciclos de busca para a instrução completa
Conclusão e próximos artigos #
Entendemos agora o que a CPU é e como ela está organizada. Conhecemos cada componente — UAL, UC, registradores, decodificador, clock — e como o ciclo de busca os mobiliza em sequência para trazer uma instrução da memória até o RI. Mas descrever componentes e o ciclo de busca é apenas metade da história: ainda não vimos o que acontece durante o ciclo de execução — como a CPU realmente processa uma instrução específica, operando sobre dados concretos.
No próximo artigo, vamos explorar um processador hipotético de 12 bits com um conjunto limitado de instruções. Ele servirá como modelo para entender o ciclo de instrução completo, a execução passo a passo de instruções como LDA (load) e ADD (add), e os fundamentos do assembly — a linguagem de baixo nível que se comunica diretamente com o hardware.
Até lá!
