Considere o seguinte programa em linguagem assembly MIPS:
ADD $R1, $R2, $R3
LW $R4, 0($R5)
SW $R6, 4($R7)
Para cada instrução, explique detalhadamente o que ocorre em um único ciclo de clock.

Passo 1

O enunciado dá três instruções MIPS e pede que eu explique, para cada uma, o que ocorre durante um único ciclo de clock. As instruções são:
\text{ADD }\$R1,\\ \$R2,\\ \$R3
\text{LW }\$R4,\\\ 0(\$R5)
\text{SW }\$R6,\\\ 4(\$R7)
Informações relevantes fornecidas pelo enunciado:
  • São instruções MIPS escritas no formato assembly acima.
  • A análise pedida é “em um único ciclo de clock” — ou seja, presumimos o modelo clássico de CPU single‑cycle (todas as etapas da instrução ocorrem dentro do mesmo ciclo).
  • Não há mais dados (valores específicos em registradores ou memória); portanto descreverei o comportamento estrutural e de sinais para cada instrução (quais registradores são lidos/escritos, que operação a ALU faz, se há acesso à memória, quais sinais de controle ficam ativos, etc.).

Passo 2

Antes de entrar em cada instrução, é importantíssimo entender o que significa “um único ciclo” no modelo single‑cycle. Vou explicar, passo a passo, quais fases existem e o que cada uma faz (a explicação é didática para você poder repetir na hora da prova).
As cinco fases lógicas que ocorrem dentro de UM ciclo são:
  1. IF (Instruction Fetch): o \text{PC} é lido, essa posição é enviada à memória de instruções e a instrução é lida. Normalmente calcula‑se também \text{PC} \leftarrow \text{PC}+4 para a próxima instrução.
  2. ID (Instruction Decode / Register Fetch): a instrução é decodificada; os campos \text{opcode}, \text{rs}, \text{rt}, \text{rd}, e o imediato são extraídos; o arquivo de registradores (register file) é lido nas portas de leitura (os valores de \text{rs} e \text{rt} saem); a unidade de controle gera sinais de controle (RegDst, ALUSrc, MemtoReg, RegWrite, MemRead, MemWrite, Branch, ALUOp, etc.).
  3. EX (Execute / Effective Address): a ALU realiza a operação apropriada (ex.: soma para ADD ou para calcular endereço base+offset em LW/SW). MUXes escolhem entre registrador/imediato, e o ALUControl traduz ALUOp+ \text{funct} para a operação exata.
  4. MEM (Memory access): se for LW, lê da memória de dados; se for SW, escreve na memória de dados; se não, nenhuma operação de memória é feita.
  5. WB (Write Back): resultado (vindo da ALU ou da memória) é escrito de volta ao arquivo de registradores se \text{RegWrite}=1.
No modelo single‑cycle essas cinco fases são realizadas sequencialmente (no tempo) dentro de um único pulso de clock — isso implica que o período de clock precisa ser longo o suficiente para acomodar a soma dos atrasos dessas fases (por isso single‑cycle é simples, mas lento).

Passo 3

Componentes principais envolvidos (explicando o papel de cada um, porque isso costuma cair em prova):
  • \text{PC} (Program Counter): contém o endereço da instrução atual. Em IF lê‑se a instrução e actualiza‑se para \text{PC}+4.
  • Memória de instruções: dada a \text{PC}, retorna a instrução de 32 bits.
  • Arquivo de registradores (Register File): tem duas portas de leitura e uma porta de escrita típicas. Em ID lê‑se os registradores \text{rs} e \text{rt}; em WB escreve‑se no registrador destino quando \text{RegWrite}=1.
  • Unidade de controle (Control Unit): a partir do campo \text{opcode} gera sinais como \text{RegDst}, \text{ALUSrc}, \text{MemtoReg}, \text{RegWrite}, \text{MemRead}, \text{MemWrite}, \text{ALUOp}.
  • Unidade ALU + ALUControl: realiza a operação aritmética/ lógica necessária; ALUControl traduz \text{ALUOp} e, para R‑type, o campo \text{funct}, na operação exata (ADD, SUB, AND, OR, etc.).
  • Memória de dados (Data Memory): usada por LW e SW.
  • MUXes: selecionam entre sinais (por exemplo, escolha entre \text{rt} e \text{rd} para o endereço de escrita; escolha entre ALU result e Mem data para escrever no registrador).
Com isso em mente, agora vamos detalhar instrução por instrução, fase por fase, incluindo os sinais de controle e quais registradores/memória são tocados.

Passo 4

Instrução 1: \text{ADD }\$R1,\\ \$R2,\\ \$R3
Descrição passo a passo dentro de UM ciclo (IF → ID → EX → MEM → WB):
IF:
  • Lê‑se \text{PC} e acessa a memória de instruções para retornar a instrução binária correspondente a \text{ADD }\$R1,\\ \$R2,\\ \$R3.
  • Calcula‑se \text{PC} \leftarrow \text{PC} + 4 e guarda para a próxima instrução.
Observação sobre campos (visto da instrução): esta é uma instrução R‑type. Os campos importantes são:
  • \text{opcode} = 0 (R‑type),
  • \text{rs} = \$R2,
  • \text{rt} = \$R3,
  • \text{rd} = \$R1,
  • \text{funct} = \text{funct}_{\text{ADD}} (código que indica ADD).
ID:
  • A unidade de controle, a partir de \text{opcode}=0, gera sinais para R‑type: \text{RegDst}=1, \text{ALUSrc}=0 (ALU usa o segundo operando vindo do registrador, não o imediato), \text{MemtoReg}=0, \text{RegWrite}=1, \text{MemRead}=0, \text{MemWrite}=0, \text{Branch}=0, \text{ALUOp}= código que indica “R‑type” (por exemplo \text{ALUOp}=10 em muitos diagramas).
  • O arquivo de registradores fornece dois valores: A = \text{Reg}[\$R2] e B = \text{Reg}[\$R3]. Esses valores saem nas portas de leitura e ficam disponíveis para a ALU na etapa EX.
EX:
  • O ALUControl combina \text{ALUOp} com o campo \text{funct} (que é \text{funct}_{\text{ADD}}) e seleciona a operação soma.
  • A ALU calcula A + B. O resultado é o somatório dos conteúdos de \$R2 e \$R3.
  • Sinais auxiliares como \text{Zero} não são relevantes aqui (úteis para branches).
MEM:
  • Para ADD, \text{MemRead}=0 e \text{MemWrite}=0, logo não há acesso à memória de dados. Esta etapa é efetivamente “sem efeito” para esta instrução no single‑cycle (mas ainda consome atraso no caminho lógico).
WB:
  • Como \text{RegWrite}=1 e \text{MemtoReg}=0, o valor escrito no arquivo de registradores vem do resultado da ALU.
  • \text{Reg}[\$R1] \leftarrow (resultado da ALU = \text{Reg}[\$R2] + \text{Reg}[\$R3]).
  • A escrita ocorre no fim do ciclo (no edge apropriado), enquanto as leituras ocorreram mais cedo durante o mesmo ciclo. Em single‑cycle o arquivo de registradores precisa suportar leitura e escrita no mesmo ciclo com a ordem temporal correta (leitura primeiro, escrita depois), o que é implementado fisicamente por sincronização dos sinais.
Resumo prático para a prova (o que você deve memorizar para ADD):
  • \$R2 e \$R3, ALU soma, escreve o resultado em \$R1. Sinais: \text{RegDst}=1,\\ \text{ALUSrc}=0,\\ \text{MemRead}=0,\\ \text{MemWrite}=0,\\ \text{MemtoReg}=0,\\ \text{RegWrite}=1.

Passo 5

Instrução 2: \text{LW }\$R4,\\\ 0(\$R5)
Novamente, fases IF → ID → EX → MEM → WB com atenção especial ao cálculo do endereço e ao acesso de memória.
IF:
  • Busca da instrução em memória de instruções usando \text{PC}.
  • Atualização \text{PC} \leftarrow \text{PC}+4.
ID:
  • Decodifica‑se a instrução. Campos relevantes: \text{opcode}=\text{lw}, \text{base} = \$R5 (campo \text{rs}), \text{rt} = \$R4, \text{immediate} = 0.
  • Arquivo de registradores é lido: B_{\text{base}} = \text{Reg}[\$R5].
  • O imediato (aqui \,0) é sign‑extendido para 32 bits (resultado continua 0).
  • Unidade de controle gera sinais apropriados para LW: \text{RegDst}=0 (porque destino é \text{rt}), \text{ALUSrc}=1 (ALU usa imediato como segundo operando), \text{MemtoReg}=1 (o valor a escrever vem da memória), \text{RegWrite}=1, \text{MemRead}=1, \text{MemWrite}=0, \text{ALUOp}= código para soma de endereço (normalmente \text{ALUOp}=00 que indica operação de soma).
EX:
  • A ALU recebe como operandos B_{\text{base}} = \text{Reg}[\$R5] e o imediato sign‑extendido (0). Como \text{ALUSrc}=1, usa o imediato.
  • A ALU faz a soma \text{Endereço} = \text{Reg}[\$R5] + 0ç.
  • Resultado é o endereço efetivo de memória (em bytes). Observação: MIPS usa endereçamento por byte; o imediato é em bytes.
MEM:
  • Como \text{MemRead}=1, a memória de dados é acessada na posição calculada ( \text{Endereço}ç) e lê‑se uma palavra (32 bits).
  • O dado lido da memória é colocado em uma linha de saída do Data Memory.
WB:
  • Como \text{RegWrite}=1 e \text{MemtoReg}=1, o valor escrito de volta no arquivo de registradores é o dado vindo da memória.
  • O registrador destino é \$R4 (porque \text{RegDst}=0 seleciona campo \text{rt}).
  • Assim \text{Reg}[\$R4] \leftarrow \text{Mem}[\text{Reg}[\$R5] + 0].
Resumo prático para a prova (LW):
  • Lê base em \$R5, soma imediato \,0 para formar endereço, lê memória em esse endereço, escreve o dado em \$R4. Sinais típicos: \text{ALUSrc}=1,\\ \text{MemRead}=1,\\ \text{MemtoReg}=1,\\ \text{RegWrite}=1.

Passo 6

Instrução 3: \text{SW }\$R6,\\\ 4(\$R7)
Passos IF → ID → EX → MEM → WB (WB não faz escrita em registrador para SW).
IF:
  • Busca da instrução usando \text{PC}.
  • \text{PC} \leftarrow \text{PC} + 4.
ID:
  • Campos: \text{opcode}=\text{sw}, \text{base}=\$R7 (rs), \text{rt}=\$R6 contém o dado a ser armazenado, \text{immediate}=4.
  • Arquivo de registradores é lido: \text{Reg}[\$R7] (base) e \text{Reg}[\$R6] (dados a escrever).
  • Imediato sign‑extendido para 32 bits (resultado = 4).
  • Unidade de controle gera sinais para SW: \text{RegWrite}=0, \text{MemWrite}=1, \text{MemRead}=0, \text{ALUSrc}=1 (usa imediato para calcular endereço), \text{MemtoReg}= don’t care, \text{RegDst}= don’t care, \text{ALUOp}= soma (por exemplo \text{ALUOp}=00).
EX:
  • ALU calcula \text{Endereço} = \text{Reg}[\$R7] + 4ç porque \text{ALUSrc}=1.
  • Resultado é o endereço efetivo para a escrita.
MEM:
  • Como \text{MemWrite}=1, a memória de dados realiza uma escrita: grava no endereço calculado o conteúdo que veio de \text{Reg}[\$R6].
  • \text{MemRead}=0, não há leitura.
WB:
  • Para SW, \text{RegWrite}=0: não há fase de escrita no arquivo de registradores. O ciclo termina sem alteração de registradores (exceto o \text{PC} que já foi atualizado em IF).
Resumo prático para a prova (SW):
  • \$R7 (base) e \$R6 (dado), ALU soma base+4 para formar endereço, memória grava o conteúdo de \$R6 nesse endereço. Sinais: \text{ALUSrc}=1,\\ \text{MemWrite}=1,\\ \text{RegWrite}=0.

Passo 7

Observações importantes em estilo “dica de prova” — por que essas coisas importam e o que costuma ser cobrado:
  • Em single‑cycle, todas as fases ocorrem dentro do mesmo ciclo, por isso o período do clock precisa ser longo o suficiente para englobar IF+ID+EX+MEM+WB. É por isso que, em implementações reais, usamos pipelining para reduzir o tempo de clock.
  • Em provas, é comum pedirem: quais registradores são lidos, quais são escritos, se há acesso à memória, qual sinal de controle habilita a escrita no registrador ( \text{RegWrite}), ou a escrita na memória ( \text{MemWrite}), e qual caminho de dados fornece o valor escrito ( \text{MemtoReg} seleciona memória ou ALU).
  • Para R‑type (ADD): destino vem de campo \text{rd} (por isso \text{RegDst}=1) e o valor vem da ALU ( \text{MemtoReg}=0).
  • Para LW: destino é \text{rt} ( \text{RegDst}=0) e o valor vem da memória ( \text{MemtoReg}=1).
  • Para SW: não há escrita em registrador ( \text{RegWrite}=0), apenas escrita em memória ( \text{MemWrite}=1).

Resposta

ADD \$R1,\\ \$R2,\\ \$R3: IF busca a instrução; ID lê \text{Reg}[\$R2] e \text{Reg}[\$R3], control gera \text{RegDst}=1,\\ \text{ALUSrc}=0,\\ \text{RegWrite}=1; EX ALU soma os dois valores; MEM sem acesso; WB escreve o resultado da ALU em \text{Reg}[\$R1].
LW \$R4,\\\ 0(\$R5): IF busca a instrução; ID lê \text{Reg}[\$R5] e sign‑extend do imediato 0, control gera \text{ALUSrc}=1,\\ \text{MemRead}=1,\\ \text{MemtoReg}=1,\\ \text{RegWrite}=1; EX ALU calcula \text{Reg}[\$R5]+0; MEM lê a palavra em memória nesse endereço; WB escreve o dado lido em \text{Reg}[\$R4].
SW \$R6,\\\ 4(\$R7): IF busca a instrução; ID lê \text{Reg}[\$R7] (base) e \text{Reg}[\$R6] (dados), sign‑extend do imediato 4, control gera \text{ALUSrc}=1,\\ \text{MemWrite}=1,\\ \text{RegWrite}=0; EX ALU calcula \text{Reg}[\$R7]+4; MEM escreve o conteúdo de \text{Reg}[\$R6] na memória no endereço calculado; sem WB.

Exercícios relacionados