Organização interna e arquiteturas de conjunto de instruções
A CPU (Unidade Central de Processamento), ou processador, é o componente que executa as instruções dos programas. É o "cérebro" do computador.
Ela faz três coisas continuamente: busca instruções na memória, decodifica o que cada uma significa e as executa, manipulando dados. Tudo no ritmo do clock.
| Componente | Função |
|---|---|
| Unidade de Controle (UC) | Comanda e sincroniza tudo: gera os sinais que dizem a cada parte o que fazer e quando. |
| Unidade Lógica e Aritmética (ULA) | Executa operações aritméticas (+, −, ×) e lógicas (AND, OR, NOT, comparações). |
| Registradores | Memórias minúsculas e ultrarrápidas que guardam os dados em uso imediato. |
| Barramentos internos | Conectam UC, ULA e registradores entre si. |
| Clock | Sinal periódico que dá o ritmo de todas as operações. |
| Registrador | Papel |
|---|---|
| PC (Program Counter / Contador de Programa) | Guarda o endereço da próxima instrução. |
| IR (Instruction Register) | Armazena a instrução que está sendo decodificada. |
| MAR (Memory Address Register) | Guarda o endereço de memória a ser acessado. |
| MBR/MDR (Memory Buffer/Data Register) | Guarda o dado lido ou a ser escrito na memória. |
| ACC / registradores de uso geral | Guardam operandos e resultados da ULA. |
| PSW / FLAGS | Indica condições do último resultado (zero, sinal, carry, overflow). |
1. Busca: a instrução em MEM[PC] é trazida para o IR; PC avança. 2. Decodificação: a UC interpreta o opcode. 3. Execução: a ULA opera sobre os registradores. 4. Gravação: o resultado é armazenado. Depois, o ciclo recomeça.
O clock é um sinal que pulsa milhões/bilhões de vezes por segundo. Cada pulso é um ciclo. 3 GHz = 3 bilhões de ciclos por segundo.
O tempo de execução de um programa depende de:
Clock alto não é tudo: uma CPU com instruções mais eficientes ou mais núcleos pode superar outra de clock maior. Por isso comparar só "GHz" entre arquiteturas diferentes engana.
Em vez de esperar uma instrução terminar todas as etapas para começar a próxima, o pipeline sobrepõe as etapas — como uma linha de montagem.
| Ciclo | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| Instr. A | Busca | Decod. | Exec. | Mem. | Grava |
| Instr. B | Busca | Decod. | Exec. | Mem. | |
| Instr. C | Busca | Decod. | Exec. |
Idealmente, uma instrução termina a cada ciclo. Hazards (dependência de dados, desvios) podem forçar paradas; CPUs modernas usam previsão de desvio e execução fora de ordem para minimizá-los.
A ISA (Instruction Set Architecture) é o conjunto de todas as instruções que a CPU entende — a "linguagem nativa" do processador.
É a fronteira entre hardware e software: o compilador traduz o programa para instruções da ISA, e a CPU as executa. Cada instrução tem um opcode (operação) e operandos (dados/endereços).
Complex Instruction Set Computer
Reduced Instruction Set Computer
Hoje a fronteira é difusa: processadores x86 modernos traduzem internamente instruções CISC em micro-operações no estilo RISC. ARM domina dispositivos móveis pela eficiência energética.
Como aumentar o clock esbarrou em limites de calor e energia, a indústria passou a colocar mais núcleos em vez de clocks mais altos.
Cada instrução de máquina é uma palavra binária dividida em campos: o opcode (operação) e um ou mais operandos. Os modos de endereçamento definem como localizar cada operando:
| Modo | O operando é... | Exemplo |
|---|---|---|
| Imediato | o próprio valor, embutido na instrução | ADD R1, #5 |
| Registrador | o conteúdo de um registrador | ADD R1, R2 |
| Direto | o conteúdo do endereço dado | LOAD R1, [100] |
| Indireto | o endereço está em um registrador/memória | LOAD R1, [R2] |
| Base + deslocamento | registrador-base + constante | LOAD R1, 8[R2] |
| Relativo ao PC | PC + deslocamento (usado em desvios) | BEQ +12 |
Mais modos dão flexibilidade ao programador (filosofia CISC), mas complicam a decodificação. RISC limita os modos para manter instruções de tamanho fixo e fáceis de paralelizar no pipeline.
Historicamente, as ISAs diferem em onde os operandos ficam ao serem processados:
| Classe | Como opera | Exemplo |
|---|---|---|
| Pilha | Operandos no topo de uma pilha implícita | JVM, x87 |
| Acumulador | Um registrador fixo guarda um operando e o resultado | Primeiros micros |
| Registrador-memória | Instruções podem operar direto sobre a memória | x86 |
| Registrador-registrador (load/store) | ULA só opera entre registradores; memória só via load/store | ARM, RISC-V, MIPS |
A tendência moderna é load/store: separar acesso à memória do cálculo simplifica o pipeline e aproveita melhor o banco de registradores — chave do desempenho RISC.
O pipeline ideal entrega uma instrução por ciclo, mas hazards (conflitos) podem forçar bolhas (paradas). São de três tipos:
| Hazard | Causa | Solução |
|---|---|---|
| Estrutural | Dois estágios disputam o mesmo recurso | Duplicar recursos (caches I/D separadas) |
| De dados | Instrução precisa de um resultado ainda não gravado | Forwarding (adiantamento) e, se necessário, stall |
| De controle | Desvio muda o fluxo; o pipeline já buscou instruções erradas | Previsão de desvio e delayed branch |
A previsão de desvio (branch prediction) é crucial: o preditor adivinha se o salto será tomado e busca antecipadamente. Um acerto mantém o pipeline cheio; um erro exige descartar (flush) os estágios especulados — penalidade de vários ciclos.
CPUs de alto desempenho não executam só uma instrução por vez. Elas exploram o ILP — instruções independentes executadas em paralelo:
A especulação, levada ao extremo, abriu brechas de segurança famosas (Spectre e Meltdown, 2018): dados especulados deixavam rastros na cache. Mostra como microarquitetura e segurança hoje se entrelaçam.
Flynn (1966) classifica arquiteturas pelo número de fluxos de instruções e de dados processados simultaneamente:
| Classe | Significado | Exemplo |
|---|---|---|
| SISD | 1 instrução, 1 dado | CPU sequencial clássica |
| SIMD | 1 instrução, vários dados | Extensões vetoriais (SSE, AVX), GPUs |
| MISD | várias instruções, 1 dado | Raro (sistemas tolerantes a falha) |
| MIMD | várias instruções, vários dados | Multinúcleo, clusters |
SIMD é a base do desempenho em multimídia e IA: a mesma operação aplicada a milhares de dados de uma vez. A GPU é um processador massivamente SIMD/paralelo, com milhares de núcleos simples — ideal para gráficos e treino de redes neurais.
O tempo de execução é governado pela equação fundamental:
Pipeline e superescalaridade reduzem o CPI; tecnologia reduz o Tclock; compilador e ISA reduzem o IC.
Mas elevar o clock custa energia. A potência dinâmica de um chip CMOS segue:
Com o fim do escalonamento de Dennard, não dá mais para baixar V ao subir f. Resultado: a indústria trocou clock maior por mais núcleos — e o paralelismo virou obrigatório (Lei de Amdahl).
| ULA | Faz operações aritméticas e lógicas. |
| UC | Coordena e gera sinais de controle. |
| ISA | Conjunto de instruções que a CPU entende. |
| Pipeline | Sobreposição de etapas de instruções. |
| RISC/CISC | Instruções reduzidas/simples vs. complexas. |
| Core | Unidade de processamento independente. |
| Hazard | Conflito que para o pipeline (estrutural, de dados, de controle). |
| Superescalar / OoO | Despacha várias instruções por ciclo e as reordena. |
| SIMD | Uma instrução opera sobre vários dados (vetorial, GPU). |
| Modo de endereçamento | Forma de localizar um operando (imediato, direto, indexado...). |
1. Em um pipeline de 5 estágios, quantos ciclos são necessários (idealmente) para executar 1000 instruções? Compare com a execução sem pipeline.
2. Uma CPU tem a mistura: 50% instruções ULA (1 ciclo), 30% loads (2 ciclos) e 20% desvios (3 ciclos). Qual o CPI médio?
3. Classifique x86 e ARM em RISC ou CISC e justifique.
4. Por que a indústria parou de simplesmente aumentar o clock e passou a adicionar núcleos?
A CPU combina UC, ULA e registradores para executar o ciclo busca-decodificação-execução no ritmo do clock. O pipeline e os múltiplos núcleos aumentam o desempenho, enquanto a ISA (RISC ou CISC) define a linguagem que liga o software ao hardware.