Explique as principais características do caminho de dados monociclo em uma arquitetura MIPS simplificada. Quais são os principais componentes?

Passo 1

O que o enunciado pede: explicar as principais características do caminho de dados monociclo em uma arquitetura MIPS simplificada e listar os principais componentes.
Informações disponíveis: nenhuma figura específica foi enviada — vou usar o caminho de dados monociclo MIPS clássico (o que normalmente aparece em livros/ aulas). Vou responder com uma explicação passo a passo e exemplos de fluxo de dados para as instruções mais comuns. Não vou pedir nada a você; segue a explicação completa.

Passo 2

Visão geral do que é “monociclo” (explicação didática e calma).
Um caminho de dados monociclo significa que cada instrução (por exemplo, uma operação aritmética, um load, um store, um branch ou um jump) é completada em exatamente um ciclo de clock. Isso tem duas implicações importantes:
  • Simplicidade de controle: não há estágio de pipeline a sincronizar, logo a lógica de controle é mais direta.
  • Relógio lento: o período do clock precisa ser longo o suficiente para atravessar o caminho crítico de delay de hardware da instrução mais lenta (normalmente um load), então o desempenho por ciclo é ruim. Pense assim: é como fazer todo o trabalho de uma receita inteira antes de poder começar a próxima — simples, mas demorado.

Passo 3

Lista rápida (resumo) dos componentes que vamos detalhar depois — para você já saber o mapa mental:
Instruction\\ Memory, PC e PC\\ Adder, Register\\ File, Sign\text{-}Extend, ALU e ALU\\ Control, Data\\ Memory, multiplexadores (MUXes), Control\\ Unit, shift-left-2 para branch, lógica de branch/jump. Vou explicar um a um.

Passo 4

Instruction\\ Memory (memória de instruções) — função e conexões.
Função: armazena instruções em formato binário. Entrada: endereço (vindo do PC). Saída: uma palavra de instrução de 32 bits. Esse bloco não executa, só fornece bits da instrução que serão decodificados pelos outros blocos.

Passo 5

PC (Program Counter) e o adder de PC+4.
  • PC contém o endereço da próxima instrução a ser buscada.
  • Normalmente após buscar a instrução calculamos PC + 4 (pois em MIPS cada instrução tem 4 bytes) usando um somador dedicado. O resultado PC+4 vai para a seleção do próximo PC (pode ser PC+4, endereço de branch ou endereço de jump).
    Importante: no monociclo o novo valor do PC é escrito no flanco ativo do clock depois de todo o trabalho da instrução — por isso tudo precisa caber no mesmo ciclo.

Passo 6

Register\\ File (arquivo de registradores) — entrada/saída e operação.
  • Entradas para leitura: os campos rs e rt da instrução indicam quais registradores ler; o arquivo entrega duas saídas: ReadData1 e ReadData2.
  • Escrita: existe um porto de escrita com sinais WriteReg (número do registrador destino), WriteData (dados a gravar) e RegWrite (habilita escrita). A escrita ocorre no final do ciclo (exatamente no flanco do clock).
    Dica prática: memorize que leitura é combinacional (disponível imediatamente), escrita é síncrona (no clock).

Passo 7

Sign-extend e shift-left-2 (para immediatos e branches).
  • Sign\text{-}Extend: toma o imediado de 16 bits da instrução e o estende para 32 bits preservando o sinal (se o bit 15 for 1, os bits altos em 32 ficam 1). Isso é usado para instruções tipo load/store e para calcular o offset do branch.
  • Shift\text{-}left\text{-}2: para calcular o endereço-alvo do branch, o imediato estendido é deslocado 2 bits à esquerda (equivalente a multiplicar por 4), porque os endereços são múltiplos de 4. Depois somamos esse valor a PC+4 para obter o destino do branch.

Passo 8

ALU e ALU\\ Control.
  • ALU: realiza operações aritméticas e lógicas (soma, subtração, AND, OR, etc.). Recebe dois operandos: tipicamente ReadData1 e ou ReadData2 ou o imediato estendido (dependendo do tipo de instrução). Produz ALUResult e sinal Zero (indica se o resultado é zero — usado por beq).
  • MUX ALU\_Src: escolhe o segundo operando do ALU entre ReadData2 (para instruções R-type) ou SignExtend(immediate) (para lw/ sw/immediate). O controle desse MUX é o sinal ALUSrc.
  • ALU\\ Control: traduz sinais do opcode e do campo funct (em instruções R-type) para um código de operação interno do ALU. Normalmente a Control\\ Unit emite um campo ALUOp e o ALU\\ Control combina ALUOp com bits funct para gerar as linhas de controle do ALU.

Passo 9

Data\\ Memory (memória de dados) — para lw e sw.
  • Entradas: endereço (vindo de ALUResult), WriteData (vindo do Register\\ File — normalmente ReadData2), sinais MemRead e MemWrite.
  • Saída: ReadData (dados carregados do endereço para serem escritos no registrador se for lw).
    No monociclo tanto o acesso à memória de instrução quanto à memória de dados acontecem no mesmo ciclo (pelo menos conceitualmente em modelos simplificados).

Passo 10

Mux de Write-back e RegDst.
  • MemtoReg: MUX que escolhe o dado a ser escrito no registrador destino entre ALUResult (resultado de operações aritméticas) e ReadData (dados vindos da memória em um lw). Controlado por MemtoReg.
  • RegDst: em instruções R-type o registrador destino vem do campo rd; em instruções I-type (por exemplo addi ou lw) o destino vem do campo rt. O sinal RegDst escolhe entre rd e rt para formar WriteReg.

Passo 11

Control\\ Unit (unidade de controle) — o cérebro de alto nível.
  • Entrada: opcode (bits mais altos da instrução).
  • Saídas (exemplos clássicos): RegDst, ALUSrc, MemtoReg, RegWrite, MemRead, MemWrite, Branch, Jump, e ALUOp.
  • Propósito: gerar os sinais de controle que configuram os MUXes, a escrita no registrador, memória, e informar o ALU\\ Control que operação realizar. Na prova, você normalmente precisa saber que cada tipo de instrução tem um conjunto de sinais fixos (por exemplo, para lw: MemRead=1, MemtoReg=1, ALUSrc=1, RegWrite=1, etc.).

Passo 12

Lógica de branch e jump (como escolhemos o próximo PC).
  • Cálculo do endereço de branch: BranchTarget = (PC+4) + (SignExtend(immediate) \ll 2). O sinal Zero vindo do ALU e o sinal Branch da Control\\ Unit são combinados (normalmente via AND) para decidir se tomamos o branch.
  • MUX de seleção do PC: existem tipicamente duas etapas: um MUX escolhe entre PC+4 e BranchTarget (quando o branch é tomado), e um outro MUX pode escolher um endereço de jump (formado por concatenar bits altos de PC+4 com o campo de 26 bits da instrução deslocado 2 bits) para suportar instruções jump. O resultado final vai para o PC.

Passo 13

Fluxos concretos (passo a passo) para instruções comuns — isso ajuda a memorizar na hora da prova.
Exemplo A — instrução R-type (por exemplo add com rd destino):
  1. PC fornece endereço para Instruction\\ Memory → buscamos instrução.
  2. Campos rs, rt, rd são usados; Register\\ File ReadData1 e ReadData2.
  3. ALUSrc = 0 (mux escolhe ReadData2). ALU\\ Control usa funct para configurar a operação (soma, sub, etc.).
  4. ALU produz ALUResult. MemRead=0, MemWrite=0.
  5. MemtoReg=0, RegDst=1, RegWrite=1: no write-back o MUX seleciona ALUResult e escreve em rd.
  6. PC é atualizado para PC+4.
Exemplo B — lw (carregar palavra):
  1. Buscar instrução. Ler rs e rt.
  2. ALUSrc=1 → ALU recebe ReadData1 e SignExtend(immediate) → calcula endereço efetivo.
  3. MemRead=1, MemWrite=0 → acessar Data\\ Memory em ALUResult.
  4. MemtoReg=1, RegWrite=1, RegDst=0 → escrever ReadData (vindo da memória) em rt.
  5. PC \leftarrow PC + 4.
Exemplo C — sw (armazenar palavra):
  1. Buscar instrução. Ler rs e rt.
  2. ALU calcula endereço com ALUSrc=1.
  3. MemWrite=1 escreve ReadData2 na memória no endereço ALUResult. Não há escrita no registrador ( RegWrite=0).
  4. PC \leftarrow PC+4.
Exemplo D — beq (branch if equal):
  1. Buscar instrução. Ler rs e rt.
  2. ALU faz ReadData1 - ReadData2 com ALUSrc=0. Se Zero=1 e Branch=1, seleciona-se BranchTarget como novo PC; caso contrário PC+4. Não há escrita em registrador nem acesso a memória de dados.
Exemplo E — jump:
  1. Buscar instrução. O campo de 26 bits é deslocado e concatenado com bits altos de PC+4 para formar o destino de 32 bits. PC recebe esse destino. Geralmente RegWrite=0, sem acesso a memória.

Passo 14

Tempo, caminho crítico e vantagens/desvantagens — fique com isso para a prova.
  • Caminho crítico: em monociclo é a soma dos atrasos de todos os blocos que uma instrução poderia atravessar (Instruction Memory → Register File → ALU → Data Memory → Write-back MUX, etc.). O clock precisa ser maior que esse atraso.
  • Vantagens: simplicidade arquitetural e de controle; fácil de entender e de implementar em aula; sem problemas de hazards de pipeline porque não há pipeline.
  • Desvantagens: baixa eficiência (o clock é ditado pela instrução mais lenta), desperdício de tempo para instruções simples (por exemplo, um add não necessita de memória, mas espera o tempo do ciclo longo), escala ruim para alta performance. Em hardware real costuma-se usar pipeline para contornar isso.

Passo 15

Dicas práticas para a prova (como estudar/ desenhar e checar).
  • Desenhe sempre o diagrama clássico do datapath monociclo: PC Instruction\\ Memory → decodificador/ Register\\ File → ALU (+ MUX ALUSrc) → Data\\ Memory → MUX MemtoReg → Register\\ File write; paralelo: cálculo PC+4, shift-left-2 + adder para branch, concat para jump.
  • Liste os sinais de controle essenciais: RegDst, ALUSrc, MemtoReg, RegWrite, MemRead, MemWrite, Branch, Jump e ALUOp. Para cada tipo de instrução escreva um vetor desses sinais — treino rápido para prova.
  • Na hora de responder questões, siga o fluxo: buscar instrução → ler registradores → calcular ALU → acessar memória (se preciso) → escrever resultado → atualizar PC. Se pedirem o caminho de dados para uma instrução específica, descreva quais blocos são usados e quais sinais de controle assumem 1 ou 0.
  • Força! Você consegue decorar o diagrama e praticar 4–5 instruções (R-type, lw, sw, beq, jump) e estará muito bem preparado.

Resposta

Principais características: cada instrução é completada em um único ciclo de clock, simplicidade de controle (sem pipeline), período de clock grande definido pelo caminho crítico (baixa eficiência/baixo throughput), e uso de multiplexadores e sinais de controle para selecionar diferentes caminhos de dados conforme o tipo de instrução.
Principais componentes: Instruction\\ Memory, PC e PC\\ Adder ( PC+4), Register\\ File, Sign\text{-}Extend, Shift\text{-}left\text{-}2, ALU, ALU\\ Control, Data\\ Memory, multiplexadores (ex.: ALU\_Src, MemtoReg, RegDst, seleção de PC), e Control\\ Unit (geradora de RegDst, ALUSrc, MemtoReg, RegWrite, MemRead, MemWrite, Branch, Jump, ALUOp).

Exercícios relacionados