Explique os 5 estágios do pipeline MIPS.

Passo 1

O que o enunciado pede: explicar os cinco estágios do pipeline MIPS.
Informações relevantes que vou usar e responder:
  • Vou listar e explicar, passo a passo, cada estágio do pipeline MIPS (IF, ID, EX, MEM, WB).
  • Vou mostrar o que cada estágio faz (entradas, saídas, operações principais), quais registradores de pipeline existem entre estágios, e problemas típicos (hazards) e como são tratados.
  • Vou dar exemplos simples (instruções tipo load, store, ALU e branch) para ilustrar o comportamento na prática.

Passo 2

O que é pipelining e por que usamos isto (aulas rápidas e intuitivas).
  • Ideia simples: em vez de executar instruções uma a uma até terminar uma antes de começar a próxima, dividimos a execução de cada instrução em estágios menores e fazemos várias instruções sobrepostas no tempo (como uma linha de montagem).
  • Benefício: maior throughput — idealmente uma instrução completada por ciclo após o pipeline encher. Em termos simples: sem pipeline, se uma instrução demora k etapas sequenciais, demora k ciclos por instrução; com pipeline de k estágios, na melhor situação se completa ~1 instrução por ciclo.
  • Limitação prática: hazards (conflitos de dados, conflito por recursos, desvios) evitam alcançar o ideal; por isso existem mecanismos como forwarding, stalls e predição de desvios.

Passo 3

Estágio 1 — Fetch de instrução (IF). O que acontece aqui, passo a passo.
  • Objetivo: buscar a próxima instrução da memória de instruções usando o contador de programa PC.
  • Operações principais:
    1. Ler a instrução em memória: \text{instr} \leftarrow \text{IMEM}[PC].
    2. Calcular PC+4 para apontar à próxima instrução sequencial (em MIPS de 32 bits a próxima instrução está em PC+4).
    3. Escrever na trava de pipeline entre IF e ID (registro IF/ID) os campos necessários: a instrução ( IR), o PC+4, e possivelmente sinais de controle já decodificados dependendo da implementação.
  • Observações importantes para a prova: anote sempre que o estágio IF produz IR e PC+4 e esses serão usados no estágio seguinte; branches podem modificar o PC, então há decisões a tomar sobre quando atualizar PC e quando descartar instruções já buscadas.

Passo 4

Estágio 2 — Decodificação / Leitura do registrador (ID). O que é feito aqui, com detalhe didático.
  • Objetivo: entender a instrução, ler operandos do banco de registradores e preparar sinais de controle.
  • Operações principais:
    1. Decodificar a instrução: identificar opcode, registradores fonte/destino, imediato, tipo (R/I/J).
    2. Ler o banco de registradores: R[s] e R[t] — onde s,t são os índices extraídos da instrução. (Em MIPS o banco de registradores tem porta de leitura dupla e uma porta de escrita.)
    3. Fazer a extensão de sinal do campo imediato quando necessário (por exemplo para instruções tipo load/store/immediate).
    4. Gerar sinais de controle que dizem o que a ALU fará, se haverá acesso à memória, se vai escrever no registrador, etc.
    5. Escrever tudo no registro de pipeline ID/EX: os valores lidos dos registradores, campos do imediato, PC+4, e sinais de controle.
  • Dica de prova: explique cada sinal de controle (por exemplo: RegWrite, MemRead, MemWrite, ALUSrc, MemToReg, Branch) e que eles são gerados na ID. Se houver dependência de dados imediata aqui (por exemplo instrução seguinte precisa do resultado de uma load anterior), o detectador de hazards pode inserir um stall (bolha) — isso é checado aqui pelo bloco de detecção de hazards.

Passo 5

Estágio 3 — Execução / Cálculo de endereço (EX). O que ocorre e por que é central.
  • Objetivo: executar a operação da ALU (operação aritmética ou lógica) ou calcular o endereço efetivo para loads/stores; também avaliar condição de branch.
  • Operações principais:
    1. Determinar os operandos da ALU: podem ser R[s] e R[t] (para instruções R), ou R[s] e imediato estendido (para instruções I). O multiplexador que escolhe entre esses vem de um sinal ALUSrc.
    2. Executar a operação da ALU conforme ALUOp (soma, subtração, AND, OR, etc.) — por exemplo, para load/store calcula-se o endereço efetivo R[s] + \text{imediato}.
    3. Em branches (ex.: beq), a ALU compara R[s] e R[t] (faz R[s]-R[t]) para decidir se o branch é tomado; se tomado, calcular PC_{target} = PC+4 + (\text{imediato}\ll2).
    4. Escrever no registro EX/MEM: resultado da ALU, R[t] (para possible store), sinais de controle para MEM/WB, etc.
  • Conceito de forwarding (encaminhamento): se uma instrução precisa do resultado de uma instrução anterior que ainda não chegou ao WB, o hardware pode “encaminhar” o resultado diretamente da saída da ALU (EX/MEM) ou da etapa de Write-back para a entrada da ALU, evitando o stall. Sempre explique que o propósito do forwarding é eliminar stalls por dependências verdadeiras quando possível.

Passo 6

Estágio 4 — Acesso à memória (MEM). Detalhes práticos.
  • Objetivo: para instruções de load/store acessar a memória de dados; para outras instruções este estágio geralmente passa os valores adiante.
  • Operações principais:
    1. Se MemRead = 1 (instrução load), ler \text{DMEM}[ALU\_result] e obter os dados da memória.
    2. Se MemWrite = 1 (store), escrever no endereço \text{DMEM}[ALU\_result] \leftarrow R[t] (valor vindo de ID/EX).
    3. Para instruções ALU-only, apenas encaminhar o resultado ALU para o próximo estágio.
    4. Escrever no registro MEM/WB os dados lidos da memória (se houver), o resultado da ALU e o sinal de controle MemToReg que indica qual valor será gravado no registrador no WB.
  • Observação de prova: mencionar alinhamento, tamanhos (byte/word) e que caches reais tornam o tempo de acesso variável — mas no modelo pipeline básico assumimos acesso em um ciclo.

Passo 7

Estágio 5 — Write-back (WB). O final do pipeline explicado.
  • Objetivo: escrever o resultado final da instrução no banco de registradores, quando aplicável.
  • Operações principais:
    1. Selecionar entre a saída de memória e o resultado da ALU com base em MemToReg.
    2. Se RegWrite = 1, escrever no registrador destino R[d] (índice depende do formato da instrução) o valor escolhido.
    3. Este é o ponto onde a instrução fica “completamente” terminada do ponto de vista arquitetônico.
  • Dica prática: o write-back ocorre no final do ciclo; o banco de registradores pode ser lido na fase ID do próximo ciclo e o hardware garante que a leitura consiga ver o valor correto (dependendo da implementação, o write e read podem ser ordenados para evitar inconsistências).

Passo 8

Registros de pipeline e por que eles são necessários.
  • Entre cada estágio existe um registro de pipeline: IF/ID, ID/EX, EX/MEM, MEM/WB.
  • Função: armazenam as informações produzidas por um estágio para serem usadas pelo próximo no ciclo seguinte; garantem isolamento entre estágios e permitem que cada estágio trabalhe com seus próprios dados sem interferir.
  • Em prova, desenhar os quatro registros de pipeline com os principais campos (por exemplo, ID/EX contém: sinais de controle, R[s], R[t], imediato, PC+4, campos de registrador destino) é uma forma padrão de mostrar entendimento.

Passo 9

Principais hazards (problemas) e estratégias para lidar com eles — com exemplos práticos.
  • Structural hazard (recurso): ocorre se dois estágios precisarem do mesmo recurso físico ao mesmo tempo (por exemplo uma única memória para instrução e dados). Solução: replicar recursos (IMEM e DMEM separados em MIPS) ou stalls.
  • Data hazard (dependência de dados): ocorre quando uma instrução depende do resultado de outra anterior que ainda não foi escrito. Exemplos e soluções:
    1. Exemplo: \text{lw } \$t0,0(\$t1) seguido de \text{add } \$t2,\$t0,\$t3. Aqui o add precisa do dado carregado pela lw; forwarding não resolve completamente porque o load obtém o dado só no estágio MEM. Resultado: é necessário um stall (bolha) de um ciclo ou usar um hardware que detecta esse caso e insere o bubble. Este caso é chamado de load-use hazard.
    2. Para instruções ALU-ALU, forwarding normalmente resolve: o resultado produzido na EX do primeiro pode ser encaminhado para a EX do segundo.
  • Control hazard (desvios): quando uma instrução de branch altera o fluxo e instruções já buscadas podem estar na pipeline. Soluções comuns: predição de desvios (não tomado por padrão), executar verificação cedo (avaliar condição no EX), ou usar delay slots (MIPS clássico), ou flushing (descartar instruções incorretas).
  • Em prova: saber identificar cada hazard num pequeno trecho de código e dizer se precisa de forwarding, stall ou flush ganha pontos.

Passo 10

Exemplo passo-a-passo de 3 instruções para ver o pipeline em ação (cronograma simplificado).
Considere as instruções abaixo (bem simples):
  1. \text{I1: lw } \$t0,0(\$t1)
  2. \text{I2: add } \$t2,\$t0,\$t3
  3. \text{I3: sub } \$t4,\$t2,\$t5
Linha temporal por ciclo (resumida, IF/ID/EX/MEM/WB):
  • Ciclo 1: I1 in IF
  • Ciclo 2: I1 in ID; I2 in IF
  • Ciclo 3: I1 in EX; I2 in ID; I3 in IF
  • Ciclo 4: I1 in MEM; I2 in EX (mas precisa do valor de I1 — load-use hazard: I2 ainda não tem o dado); I3 in ID
    • Aqui, I2 precisa do dado que só ficará disponível no fim de MEM de I1; portanto um stall é inserido: I2 fica no estágio EX/ID por um ciclo, I3 pode precisar ficar no IF/ID, etc. Após o stall:
  • Ciclo 5: I1 in WB; I2 in MEM (recebe o valor via forwarding ou já lido); I3 em EX (se o forwarding permitiu que I2 concluísse antes)
  • Ciclo 6: I2 in WB; I3 in MEM
  • Ciclo 7: I3 in WB
Comentário final sobre o exemplo: mostra que loads introduzem stalls, enquanto ALU-ALU pode se beneficiar de forwarding. Em prova, desenhar essa tabela de ciclos e marcar o stall (bolha) é uma boa prática.

Passo 11

Como mostrar isso de forma eficiente na prova (checklist prático).
  • Desenhe o pipeline com os 5 estágios e os registros IF/ID, ID/EX, EX/MEM, MEM/WB.
  • Para cada instrução, liste os sinais relevantes (RegWrite, MemRead, MemWrite, ALUSrc, MemToReg, Branch).
  • Para analisar hazards: compare os destinos/escritas e leituras de registradores entre instruções próximas; aplique regras de forwarding e identifique load-use que exige stalls.
  • Para branches, diga quando o PC é atualizado e se haverá flushes; mencione predição se necessário.
  • Seja claro sobre onde cada dado é produzido (EX, MEM, WB) e de onde pode ser encaminhado.

Passo 12

Resumo rápido e incentivo final (amigável).
  • Em poucas palavras: os cinco estágios são a forma padrão de dividir a execução de instruções em MIPS para sobrepor trabalho e aumentar throughput. Saber o que cada estágio faz, quais sinais controla, e como os hazards aparecem/resolvem é essencial para responder questões de prova.
  • Você está indo bem — desenhe sempre o pipeline, marque os registros de pipeline e destaque onde os dados são produzidos e consumidos; isso evita confusões e impressiona o avaliador.

Resposta

IF — Fetch da instrução: busca \text{instr}=\text{IMEM}[PC], computa PC+4 e grava IF/ID.
ID — Decode / Register read: decodifica opcode, lê registradores R[s],R[t], estende imediato e gera sinais de controle; grava ID/EX.
EX — Execute / Address calc: ALU realiza operação (ou calcula endereço R[s]+\text{imediato} ou compara para branch); grava EX/MEM.
MEM — Memory access: lê/escreve \text{DMEM} para loads/stores ou apenas passa resultado adiante; grava MEM/WB.
WB — Write-back: seleciona entre ALU ou dados de memória e escreve no banco de registradores se RegWrite=1.

Exercícios relacionados