Arquitetura de um Processador Simples

Modulo 2 · Aula 1 ~22 min de leitura Nivel: Intermediario

Video da aula estara disponivel em breve

Componentes do Datapath

O datapath e o caminho que os dados percorrem dentro do processador durante a execucao de instrucoes. Um processador simples de 32 bits (estilo MIPS ou RISC-V) contem os seguintes componentes fundamentais:

PC (Program Counter): registrador que armazena o endereco da proxima instrucao a ser buscada na memoria. Incrementado por 4 (em arquiteturas de 32 bits com instrucoes de tamanho fixo) a cada ciclo, ou alterado por instrucoes de desvio.
Memoria de Instrucoes: armazena o programa. Recebe o endereco do PC e retorna a instrucao correspondente.
IR (Instruction Register): armazena a instrucao atual, decodificada pela unidade de controle.
Register File: banco de registradores (tipicamente 32 registradores de 32 bits em MIPS/RISC-V). Tem duas portas de leitura e uma de escrita para suportar instrucoes tipo R (dois operandos lidos, um resultado escrito).
ALU (Arithmetic Logic Unit): executa operacoes aritmeticas (ADD, SUB, MUL) e logicas (AND, OR, XOR, SLT). Produz um resultado e flags (zero, overflow, carry).
Memoria de Dados: acessada por instrucoes LOAD e STORE. Separada da memoria de instrucoes na arquitetura Harvard; compartilhada na von Neumann.

Diagrama — Datapath Simplificado (MIPS)

                    +4
                     |
  ┌──────┐     ┌────┴────┐
  │  PC  │────>│  Instr  │
  │      │     │  Memory │
  └──┬───┘     └────┬────┘
     │              │ instrucao (32 bits)
     │         ┌────┴────┐
     │         │  IR /   │
     │         │ Decoder │
     │         └──┬──┬───┘
     │            │  │
     │      rs ───┘  └─── rt/rd
     │         ┌─────────────┐
     │         │  Register   │
     │         │    File     │
     │         │  (32 regs)  │
     │         └──┬──────┬───┘
     │         Read1   Read2
     │            │      │
     │      ┌─────┴──────┴─────┐
     │      │    MUX (ALUSrc)  │  ← imediato ou registrador
     │      └────────┬─────────┘
     │          ┌────┴────┐
     │          │   ALU   │
     │          │ (+ - &  │
     │          │  | ^ <) │
     │          └──┬──┬───┘
     │          result│zero
     │             │
     │       ┌─────┴─────┐
     │       │   Data    │
     │       │  Memory   │
     │       └─────┬─────┘
     │             │
     │       ┌─────┴─────┐
     │       │MUX(MemToR)│ ← resultado da ALU ou da memoria
     │       └─────┬─────┘
     │             │
     └─────────────┘ Write Back ao Register File

Ciclo de Instrucao: Fetch-Decode-Execute

Toda instrucao passa pelo ciclo classico de três (ou mais) fases:

Fetch (Busca): a instrucao e lida da memoria no endereco apontado pelo PC. O PC e incrementado para apontar para a proxima instrucao.
Decode (Decodificacao): a instrucao e interpretada — o opcode identifica a operacao, os campos de registradores sao lidos, e os sinais de controle sao gerados.
Execute (Execucao): a ALU realiza a operacao. Para instrucoes aritmeticas, o resultado e escrito no registrador de destino. Para LOAD/STORE, o endereco de memoria e calculado.
Memory Access: para LOAD, o dado e lido da memoria; para STORE, o dado e escrito na memoria.
Write Back: o resultado (da ALU ou da memoria) e escrito no register file.

Exemplo — Instrucao ADD em MIPS

  Instrucao: ADD $t0, $t1, $t2    (t0 = t1 + t2)
  Binario:   000000 01001 01010 01000 00000 100000
             opcode  rs    rt    rd   shamt  funct

  1. FETCH:   PC → Instr Memory → IR = 0x012A4020
              PC = PC + 4

  2. DECODE:  opcode = 000000 (tipo R)
              rs = $t1 (reg 9),  rt = $t2 (reg 10),  rd = $t0 (reg 8)
              Register File le: A = Reg[9], B = Reg[10]

  3. EXECUTE: ALU calcula A + B
              Resultado = Reg[9] + Reg[10]

  4. MEMORY:  (nao usado para instrucoes tipo R)

  5. WRITE BACK: Reg[8] = Resultado da ALU

Unidade de Controle

A unidade de controle gera os sinais que dirigem o datapath — selecionando entradas de multiplexadores, habilitando escritas em registradores, e definindo a operacao da ALU. Ha duas implementacoes classicas:

Controle Hardwired (Cabecado)

A logica de controle e implementada como um circuito combinacional fixo. O opcode e os campos da instrucao sao as entradas; os sinais de controle sao as saidas.

Vantagem: rapido — os sinais sao gerados em um unico nivel de logica combinacional
Desvantagem: inflexivel — modificar o conjunto de instrucoes exige redesenhar o circuito
Uso: processadores RISC (MIPS, ARM, RISC-V)

Tabela — Sinais de Controle por Tipo de Instrucao

  Instrucao  RegDst  ALUSrc  MemToReg  RegWrite  MemRead  MemWrite  Branch  ALUOp
  ─────────────────────────────────────────────────────────────────────────────────
  R-type      1       0       0         1         0        0         0       10
  LW          0       1       1         1         1        0         0       00
  SW          X       1       X         0         0        1         0       00
  BEQ         X       0       X         0         0        0         1       01

Controle Microprogramado

Os sinais de controle sao armazenados em uma memoria de controle (microcode ROM). Cada instrucao e executada como uma sequência de microinstrucoes.

Vantagem: flexivel — adicionar ou modificar instrucoes requer apenas atualizar a microcode ROM
Desvantagem: mais lento — cada microinstrucao requer um acesso a memoria de controle
Uso: processadores CISC (x86 desde o 8086, ate hoje — instrucoes x86 complexas sao decodificadas em micro-ops internamente)

RISC vs. CISC na pratica moderna Processadores x86 modernos (Intel, AMD) sao externamente CISC mas internamente RISC: instrucoes x86 complexas sao decodificadas em sequências de micro-operacoes (uops) simples que executam em um pipeline superescalar. A fronteira RISC/CISC e hoje mais uma questao de ISA (interface) do que de implementacao.

Single-Cycle vs. Multi-Cycle

Em um processador single-cycle, cada instrucao e executada em exatamente um ciclo de clock. O periodo do clock deve ser longo o suficiente para acomodar a instrucao mais lenta (tipicamente LOAD, que precisa de fetch + decode + ALU + memory + write back).

Em um processador multi-cycle, cada instrucao e dividida em varios ciclos mais curtos. Instrucoes simples (como ADD) usam menos ciclos que instrucoes complexas (como LOAD), melhorando o throughput medio.

Comparacao — Single vs. Multi-Cycle

  Single-Cycle:
  ┌──────────────────────────────────────┐
  │  FETCH │ DECODE │ EXECUTE │ MEM │ WB │  Instrucao 1
  └──────────────────────────────────────┘
  ┌──────────────────────────────────────┐
  │  FETCH │ DECODE │ EXECUTE │ MEM │ WB │  Instrucao 2
  └──────────────────────────────────────┘
  Periodo do clock = tempo da instrucao mais lenta

  Multi-Cycle:
  ┌──────┬──────┬──────┬──────┬──────┐
  │FETCH │DECODE│  EX  │ MEM  │  WB  │  LW (5 ciclos)
  └──────┴──────┴──────┴──────┴──────┘
  ┌──────┬──────┬──────┬──────┐
  │FETCH │DECODE│  EX  │  WB  │         ADD (4 ciclos)
  └──────┴──────┴──────┴──────┘
  Periodo do clock = tempo de 1 fase (mais curto)

  Pipeline (evolucao):
  ┌───┬───┬───┬───┬───┐
  │ F │ D │ E │ M │ W │  Instrucao 1
  └───┼───┼───┼───┼───┘
      │ F │ D │ E │ M │ W │  Instrucao 2 (comeca 1 ciclo depois)
      └───┼───┼───┼───┼───┘
          │ F │ D │ E │ M │ W │  Instrucao 3
          └───┴───┴───┴───┴───┘
  Throughput: ~1 instrucao por ciclo (ideal)

Formato de Instrucoes

Em uma ISA RISC tipica (MIPS), as instrucoes sao codificadas em 32 bits com formatos fixos:

Formatos MIPS

  Tipo R (aritmeticas):
  ┌────────┬─────┬─────┬─────┬───────┬────────┐
  │ opcode │  rs │  rt │  rd │ shamt │ funct  │
  │ 6 bits │5 b  │5 b  │5 b  │ 5 b   │ 6 bits │
  └────────┴─────┴─────┴─────┴───────┴────────┘
  Exemplo: ADD $t0, $t1, $t2

  Tipo I (imediato / load / store / branch):
  ┌────────┬─────┬─────┬──────────────────────┐
  │ opcode │  rs │  rt │     imediato         │
  │ 6 bits │5 b  │5 b  │     16 bits          │
  └────────┴─────┴─────┴──────────────────────┘
  Exemplo: ADDI $t0, $t1, 42
           LW   $t0, 8($sp)

  Tipo J (jump):
  ┌────────┬──────────────────────────────────┐
  │ opcode │         endereco                 │
  │ 6 bits │         26 bits                  │
  └────────┴──────────────────────────────────┘
  Exemplo: J 0x00400020

No harness.os

A arquitetura de um processador simples tem analogias diretas com a arquitetura do harness.os:

Fetch-Decode-Execute = Session Lifecycle: cada sessao do harness.os segue um ciclo analogo: buscar contexto (start_session/handoff), decodificar a tarefa (analisar regras e estado), executar o trabalho, e salvar resultado (end_session).
Unidade de Controle = Regras e Workflows: as regras do harness.os funcionam como a tabela de sinais de controle — dado um tipo de tarefa (opcode), determinam quais acoes executar (sinais de controle).
Register File = Contexto de sessao: os registradores sao o estado "quente" acessado a cada instrucao. No harness.os, o contexto da sessao (variaveis, decisoes recentes) funciona como o register file — acesso instantâneo mas capacidade limitada.
Hardwired vs. Microprogramado = CLAUDE.md vs. Knowledge base: regras em CLAUDE.md sao "hardwired" (fixas, rapidas). Conhecimento no banco e "microprogramado" (flexivel, requer lookup).
Pipeline = Agentes paralelos: assim como pipeline sobrepoem fases de instrucoes diferentes, o harness.os pode sobrepor fases de tarefas diferentes usando agentes paralelos.

Exercicios

Trace o caminho dos dados no datapath para a instrucao LW $t0, 12($sp). Liste cada componente ativado e os sinais de controle necessarios.
Um processador single-cycle tem: Fetch=200ps, Decode=100ps, ALU=200ps, Memory=200ps, WriteBack=100ps. Qual e a frequência maxima de clock? Qual instrucao determina esse limite?
O mesmo processador implementado como multi-cycle pode ter clock de quanto? Compare o tempo total para executar a sequência: ADD, ADD, LW, SW, BEQ.
Projete a tabela de sinais de controle para as instrucoes AND, OR e SLT (Set Less Than) em um processador MIPS simplificado.
Explique por que processadores CISC modernos decodificam instrucoes em micro-ops. Qual a vantagem dessa abordagem hibrida?

Resumo

O datapath contem PC, memoria de instrucoes, register file, ALU e memoria de dados
O ciclo de instrucao classico: Fetch → Decode → Execute → Memory Access → Write Back
Controle hardwired e rapido mas inflexivel; microprogramado e flexivel mas mais lento
Single-cycle executa uma instrucao por ciclo (clock lento); multi-cycle divide em fases (clock rapido)
Pipeline sobrepoem fases de instrucoes diferentes, alcancando ~1 instrucao por ciclo
Instrucoes RISC usam formatos fixos (R, I, J em MIPS) facilitando a decodificacao

Verifique seu entendimento

Em um processador single-cycle, o que determina o periodo minimo do clock?

A instrucao mais rapida, para maximizar o throughput
A instrucao mais lenta, pois todas devem completar em um unico ciclo
A media do tempo de todas as instrucoes
O tempo de acesso a memoria de instrucoes apenas

Aula anterior 1.3 Interfaces de Memoria Proxima aula 2.2 Microcontroladores