Descreva detalhadamente as etapas da execução de uma instrução do tipo LOAD (LW) no MIPS multiciclo, indicando os estados e as transições.

Passo 1

O enunciado pede que eu descreva, passo a passo, as etapas (estados) e as transições que ocorrem quando uma instrução do tipo LOAD (especificamente \text{LW} em MIPS) é executada no datapath multiciclo.
Informações relevantes fornecidas implicitamente (e que vou usar na explicação):
  • A instrução é \text{LW}\,\text{\$rt},\,\text{offset}(\$rs). Um exemplo concreto que usarei para ilustrar: \text{LW}\,\text{\$t1},\,8(\$t0).
  • O datapath multiciclo típico tem registradores internos de estado: \text{PC}, \text{IR}, \text{MDR}, \text{A}, \text{B}, \text{ALUOut}.
  • Existem sinais de controle que podem ser ativados em cada ciclo, por exemplo: \text{MemRead}, \text{MemWrite}, \text{IorD}, \text{IRWrite}, \text{ALUSrcA}, \text{ALUSrcB}, \text{ALUOp}, \text{RegWrite}, \text{MemToReg}, \text{RegDst}, \text{PCWrite}, \text{PCSource}.
  • A ideia do multiciclo é dividir a execução em vários ciclos de clock, reutilizando unidades funcionais (ALU, memória, registradores) em ciclos distintos.

Passo 2

Estado 1 — Instruction Fetch (IF). Objetivo: buscar a instrução da memória e incrementar \text{PC}.
O que acontece (detalhado):
  • Endereço de memória fornecido: \text{addr} = \text{PC}. Isso é feito configurando \text{IorD}=0 (seleciona \text{PC} como fonte de endereço para a memória).
  • Memória (unidade de dados/instruções) é lida com \text{MemRead}=1. Saída da memória vai para \text{MDR}.
  • Habilita-se \text{IRWrite}=1 para que a palavra lida (a instrução) seja carregada em \text{IR}.
  • Paralelamente, a ALU calcula \text{PC}+4 para preparar o próximo PC. Para isso:
    • \text{ALUSrcA}=\text{PC} (lado A da ALU lê \text{PC}),
    • \text{ALUSrcB}=4 (lado B recebe constante 4),
    • \text{ALUOp}=\text{add}.
  • Resultado da soma \text{PC}+4 é colocado em \text{ALUOut}.
  • Escreve-se \text{PC} \leftarrow \text{ALUOut} ativando \text{PCWrite}=1 e ajustando \text{PCSource} para escolher \text{ALUOut}.
Por que cada peça é necessária (didático):
  • \text{IR} guarda a instrução para que, nos ciclos seguintes, decodifiquemos opcode, campos \text{rs}, \text{rt}, \text{immediate}.
  • \text{MDR} é buffer para dados vindos/indo para memória; na busca da instrução usamos \text{MDR} temporariamente antes de mover para \text{IR}.
  • Incrementar \text{PC} já neste ciclo evita precisar recomputar no próximo, e o mesmo ALU é usado para isso (economia de hardware).

Passo 3

Estado 2 — Instruction Decode / Register Fetch (ID). Objetivo: decodificar a instrução e ler os registradores-fonte.
O que acontece (detalhado):
  • A instrução está em \text{IR}. Daí extrai-se os campos: \text{opcode}, \text{rs}, \text{rt}, \text{immediate}. (Ex.: para \text{LW}\,\text{\$t1},8(\$t0), \text{rs}=\text{\$t0}, \text{rt}=\text{\$t1}, \text{immediate}=8.)
  • O arquivo de registradores é lido: \text{A} \leftarrow \text{Reg}[\text{rs}] e \text{B} \leftarrow \text{Reg}[\text{rt}]. \text{A} e \text{B} são registradores internos temporários que guardam os conteúdos lidos.
  • O imediato de 16 bits é sinal-estendido para 32 bits: \text{SignImm} \leftarrow \text{SignExtend}(\text{immediate}). (Sign-extend: se o bit mais significativo do imediato for 1, preenche os bits altos com 1; senão, com 0.)
  • Opcionalmente (no datapath de P&H), a ALU calcula \text{PC} + (\text{SignImm} \ll 2) para preparar cálculo de desvio, mas isso é irrelevante para \text{LW}. O importante aqui é que já temos \text{A}, \text{B} e \text{SignImm} prontos para o próximo passo.
  • Nenhum registro de destino é escrito neste estado; somente leitura.
Didática sobre sign-extension e por que é necessário: endereços de deslocamento (offset) são 16 bits na instrução; para somar corretamente ao conteúdo do registrador (32 bits) precisamos estender para 32 bits respeitando o sinal (caso o offset seja negativo).

Passo 4

Estado 3 — Execution / Effective Address calculation (EX). Objetivo: calcular o endereço efetivo da carga (base + offset).
O que acontece (detalhado):
  • A ALU recebe \text{ALUSrcA} = \text{A} (conteúdo de \text{Reg}[\text{rs}]) e \text{ALUSrcB} = \text{SignImm} (o imediato sinal-estendido). Define-se \text{ALUOp} = \text{add}.
  • A ALU realiza a operação: \text{ALUOut} \leftarrow \text{A} + \text{SignImm}.(Este é o endereço efetivo em byte para a leitura de memória.)
  • \text{ALUOut} é um registrador intermediário que guarda esse resultado para o próximo ciclo (acesso à memória).
Exemplo numérico (didático): se \text{Reg}[\text{\$t0}]=1000 e \text{SignImm}=8, então
\text{ALUOut} = 1000 + 8 = 1008.
Isso indica que vamos ler a palavra armazenada no endereço \,1008.

Passo 5

Estado 4 — Memory Access (MEM). Objetivo: acessar a memória usando o endereço calculado.
O que acontece (detalhado):
  • Configura-se \text{IorD}=1 para que a memória use como endereço a saída \text{ALUOut} (e não \text{PC}).
  • Para um \text{LW}: \text{MemRead}=1 e \text{MemWrite}=0.
  • A memória lê \text{Mem}[\text{ALUOut}] e coloca o valor lido em \text{MDR}: \text{MDR} \leftarrow \text{Mem}[\text{ALUOut}].
  • \text{MDR} segura os dados lidos para que, no ciclo seguinte, possamos escrevê-los no registrador destino.
Observação didática: usamos \text{MDR} porque a leitura de memória produz dados que chegam um pouco depois; o \text{MDR} é buffer para cruzar o limite de ciclo clock.

Passo 6

Estado 5 — Write Back (WB). Objetivo: escrever o dado carregado no registrador destino ( \text{rt}).
O que acontece (detalhado):
  • Seleciona-se a fonte de escrita do registrador como \text{MemToReg}=1 (portanto escreve-se o conteúdo de \text{MDR} no arquivo de registradores).
  • O registrador destino é \text{Reg}[\text{rt}]. Define-se \text{RegDst}=\text{rt} (para instruções tipo carga o destino é \text{rt}).
  • Habilita-se \text{RegWrite}=1. Então: \text{Reg}[\text{rt}] \leftarrow \text{MDR}.
  • Fim da execução da instrução \text{LW}.
Exemplo numérico: se \text{MDR}=42 e \text{rt}=\text{\$t1}, então \text{Reg}[\text{\$t1}] \leftarrow 42.

Passo 7

Resumo dos sinais importantes por estado (para memorizar no exame). Vou listar apenas os sinais mais usados e o que devem valer em cada estado para \text{LW}:
  • IF:
    • \text{IorD}=0, \text{MemRead}=1, \text{IRWrite}=1, \text{ALUSrcA}=\text{PC}, \text{ALUSrcB}=4, \text{ALUOp}=\text{add}, \text{PCWrite}=1.
  • ID:
    • Ler registradores: (nenhum sinal de memória); sinal-extender do imediato; \text{A}\leftarrow\text{Reg}[\text{rs}], \text{B}\leftarrow\text{Reg}[\text{rt}].
  • EX (effective address):
    • \text{ALUSrcA}=\text{A}, \text{ALUSrcB}=\text{SignImm}, \text{ALUOp}=\text{add}. Resultado em \text{ALUOut}.
  • MEM:
    • \text{IorD}=1, \text{MemRead}=1. \text{MDR}\leftarrow\text{Mem}[\text{ALUOut}].
  • WB:
    • \text{RegDst}=\text{rt}, \text{MemToReg}=1, \text{RegWrite}=1. \text{Reg}[\text{rt}]\leftarrow\text{MDR}.
Comentário prático: em provas costumam pedir exatamente esta tabela de sinais ou pedir que você descreva o que cada registrador interno guarda em cada ciclo — decore o papel de \text{IR}, \text{MDR}, \text{A}, \text{B}, \text{ALUOut}.

Passo 8

Por que o multiciclo divide em tantos estados? Explicação didática e intuitiva:
  • Em multiciclo cada instrução ocupa vários ciclos de clock, e cada ciclo realiza uma operação simples (ex.: leitura de memória, operação ALU). Isso permite que:
    • O mesmo hardware (ALU, memória, registrador de propósito geral) seja reutilizado em diferentes ciclos, reduzindo a área do chip (menos hardware duplicado).
    • Cada ciclo seja curto (tempo menor por ciclo do que em um design single-cycle), aumentando a frequência possível.
  • O custo é que a instrução demora vários ciclos, e o controle precisa sequenciar estados corretamente.
  • Para \text{LW} usamos 5 estados porque: busca, decodifica/ler regs, calcula endereço, acessa memória, escreve no registrador.

Passo 9

Exemplo completo com números (para fixar; tudo em LaTeX):
  • Instrução: \text{LW}\,\text{\$t1},\,8(\$t0).
  • Valores iniciais: \text{Reg}[\text{\$t0}] = 1000. Memória tem \text{Mem}[1008] = 42.
    Passo a passo numérico:
  • IF: \text{PC}=200 (exemplo) → lê memória em \text{addr}=200 \text{IR}\leftarrow instrução \text{LW}\,\text{\$t1},8(\$t0). ALU faz \text{PC}+4=204 \text{PC}\leftarrow204.
  • ID: \text{A}\leftarrow\text{Reg}[\text{\$t0}]=1000. \text{SignImm}=8.
  • EX: ALU calcula \text{ALUOut}=1000+8=1008.
  • MEM: lê \text{Mem}[1008] \text{MDR}\leftarrow42.
  • WB: \text{Reg}[\text{\$t1}]\leftarrow42. Instrução concluída; \text{PC}=204 pronto para próxima instrução.

Passo 10

Dicas de prova (quem está nervoso vai gostar):
  • Sempre escreva explicitamente o que cada registrador interno (IR, MDR, A, B, ALUOut) contém ao final de cada ciclo — isso costuma marcar pontos.
  • Lembre-se: para \text{LW} são tipicamente 5 ciclos (IF, ID, EX, MEM, WB). Se a questão pede sinais, liste-os por ciclo como eu fiz.
  • Se pedirem diferenças entre \text{LW} e \text{SW}: \text{SW} usa os mesmos 4 primeiros ciclos, mas no ciclo MEM ativa \text{MemWrite}=1 e usa \text{B} (conteúdo de \text{rt}) como dados; não há ciclo WB.
  • Se a questão pedir transições de estado desenhe uma seta linear: IF → ID → EX → MEM → WB e anote o que é carregado em cada registrador interno em cada seta.

Resposta

IF → ID → EX → MEM → WB (com os detalhes e sinais descritos nos passos anteriores).

Exercícios relacionados