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.
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:
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:
- IF (Instruction Fetch): o
é lido, essa posição é enviada à memória de instruções e a instrução é lida. Normalmente calcula‑se também para a próxima instrução. - ID (Instruction Decode / Register Fetch): a instrução é decodificada; os campos
, , , , e o imediato são extraídos; o arquivo de registradores (register file) é lido nas portas de leitura (os valores de e saem); a unidade de controle gera sinais de controle (RegDst, ALUSrc, MemtoReg, RegWrite, MemRead, MemWrite, Branch, ALUOp, etc.). - 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+
para a operação exata. - 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.
- WB (Write Back): resultado (vindo da ALU ou da memória) é escrito de volta ao arquivo de registradores se
.
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):
-
(Program Counter): contém o endereço da instrução atual. Em IF lê‑se a instrução e actualiza‑se para . - Memória de instruções: dada a
, 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
e ; em WB escreve‑se no registrador destino quando . - Unidade de controle (Control Unit): a partir do campo
gera sinais como , , , , , , . - Unidade ALU + ALUControl: realiza a operação aritmética/ lógica necessária; ALUControl traduz
e, para R‑type, o campo , 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
e 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:
Descrição passo a passo dentro de UM ciclo (IF → ID → EX → MEM → WB):
IF:
- Lê‑se
e acessa a memória de instruções para retornar a instrução binária correspondente a . - Calcula‑se
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:
-
(R‑type), -
, -
, -
, -
(código que indica ADD).
ID:
- A unidade de controle, a partir de
, gera sinais para R‑type: , (ALU usa o segundo operando vindo do registrador, não o imediato), , , , , , código que indica “R‑type” (por exemplo em muitos diagramas). - O arquivo de registradores fornece dois valores:
e . Esses valores saem nas portas de leitura e ficam disponíveis para a ALU na etapa EX.
EX:
- O ALUControl combina
com o campo (que é ) e seleciona a operação soma. - A ALU calcula
. O resultado é o somatório dos conteúdos de e . - Sinais auxiliares como
não são relevantes aqui (úteis para branches).
MEM:
- Para ADD,
e , 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
e , o valor escrito no arquivo de registradores vem do resultado da ALU. -
(resultado da ALU = ). - 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):
- Lê
e , ALU soma, escreve o resultado em . Sinais:
Passo 5
Instrução 2:
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
. - Atualização
.
ID:
- Decodifica‑se a instrução. Campos relevantes:
, (campo ), , . - Arquivo de registradores é lido:
. - O imediato (aqui
) é sign‑extendido para 32 bits (resultado continua 0). - Unidade de controle gera sinais apropriados para LW:
(porque destino é ), (ALU usa imediato como segundo operando), (o valor a escrever vem da memória), , , , código para soma de endereço (normalmente que indica operação de soma).
EX:
- A ALU recebe como operandos
e o imediato sign‑extendido (0). Como , usa o imediato. - A ALU faz a soma
. - Resultado é o endereço efetivo de memória (em bytes). Observação: MIPS usa endereçamento por byte; o imediato é em bytes.
MEM:
- Como
, a memória de dados é acessada na posição calculada ( ) 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
e , o valor escrito de volta no arquivo de registradores é o dado vindo da memória. - O registrador destino é
(porque seleciona campo ). - Assim
.
Resumo prático para a prova (LW):
- Lê base em
, soma imediato para formar endereço, lê memória em esse endereço, escreve o dado em . Sinais típicos:
Passo 6
Instrução 3:
Passos IF → ID → EX → MEM → WB (WB não faz escrita em registrador para SW).
IF:
- Busca da instrução usando
. -
.
ID:
- Campos:
, (rs), contém o dado a ser armazenado, . - Arquivo de registradores é lido:
(base) e (dados a escrever). - Imediato sign‑extendido para 32 bits (resultado = 4).
- Unidade de controle gera sinais para SW:
, , , (usa imediato para calcular endereço), don’t care, don’t care, soma (por exemplo ).
EX:
- ALU calcula
porque . - Resultado é o endereço efetivo para a escrita.
MEM:
- Como
, a memória de dados realiza uma escrita: grava no endereço calculado o conteúdo que veio de . -
, não há leitura.
WB:
- Para SW,
: não há fase de escrita no arquivo de registradores. O ciclo termina sem alteração de registradores (exceto o que já foi atualizado em IF).
Resumo prático para a prova (SW):
- Lê
(base) e (dado), ALU soma base+4 para formar endereço, memória grava o conteúdo de nesse endereço. Sinais:
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 (
), ou a escrita na memória ( ), e qual caminho de dados fornece o valor escrito ( seleciona memória ou ALU). - Para R‑type (ADD): destino vem de campo
(por isso ) e o valor vem da ALU ( ). - Para LW: destino é
( ) e o valor vem da memória ( ). - Para SW: não há escrita em registrador (
), apenas escrita em memória ( ).
Resposta
ADD
: IF busca a instrução; ID lê
e
, control gera
; EX ALU soma os dois valores; MEM sem acesso; WB escreve o resultado da ALU em
.
LW
: IF busca a instrução; ID lê
e sign‑extend do imediato
, control gera
; EX ALU calcula
; MEM lê a palavra em memória nesse endereço; WB escreve o dado lido em
.
SW
: IF busca a instrução; ID lê
(base) e
(dados), sign‑extend do imediato
, control gera
; EX ALU calcula
; MEM escreve o conteúdo de
na memória no endereço calculado; sem WB.