No modelo monociclo, todas as instruções são executadas em um único ciclo de clock. Quais são as implicações desse modelo para o tempo de execução de instruções com diferentes níveis de complexidade, como ADD e LW?

Passo 1

O enunciado diz: no modelo monociclo (single-cycle) todas as instruções são executadas em um único ciclo de clock. A pergunta é: quais são as implicações disso para o tempo de execução de instruções com diferentes níveis de complexidade, exemplificadas por \text{ADD} (soma, simples) e \text{LW} (load word, mais complexa por acessar memória)?\n
Informações dadas/no problema: (1) todas as instruções devem terminar dentro de um mesmo ciclo de clock; (2) temos duas instruções representativas: \text{ADD} e \text{LW}. Nada mais foi pedido explicitamente.

Passo 2

O que significa, em prática, “todas as instruções em um único ciclo”? Vou explicar passo a passo os blocos que normalmente compõem uma instrução e quanto tempo cada bloco pode levar. Uma instrução típica passa por estágios (vou nomear e explicar cada um, bem mastigado):
  • IF (Instruction Fetch): busca da instrução na memória. Precisa de tempo para consultar a memória de instruções e trazer os bits da instrução.
  • ID (Instruction Decode + register read): decodificar a instrução e ler registradores.
  • EX (Execute / ALU): executar operação aritmética ou calcular endereço (por exemplo, para \text{LW} calcula-se o endereço base+offset).
  • MEM (Memory access): acessar memória de dados (ler para \text{LW}, escrever para \text{SW}). Nem toda instrução usa essa etapa.
  • WB (Write Back): escrever o resultado de volta no registrador (por exemplo, resultado do \text{ADD} ou dado carregado pela \text{LW}).
Cada estágio tem um atraso/tempo próprio, que vou chamar de t_{IF}, t_{ID}, t_{EX}, t_{MEM}, t_{WB}. Esses tempos são positivos e dependem do hardware (velocidade da memória, atraso da ALU, etc.).

Passo 3

No modelo monociclo a duração do ciclo de clock precisa ser suficientemente longa para que a instrução mais demorada complete todos os estágios dentro de um único ciclo. Portanto o tempo do ciclo de clock (vou chamar de T_{clk}) é a soma dos tempos dos estágios, porque o mesmo ciclo precisa conter todos eles sequencialmente:
T_{clk} = t_{IF} + t_{ID} + t_{EX} + t_{MEM} + t_{WB}.
Observação importante: mesmo que uma instrução não use um estágio (por exemplo, \text{ADD} normalmente não usa \text{MEM}), o ciclo inteiro ainda tem duração T_{clk}. Ou seja, o ciclo é fixado pelo pior caso.

Passo 4

Agora veja como isso afeta especificamente \text{ADD} e \text{LW}.
  • Para \text{ADD} os estágios usados tipicamente são IF, ID, EX e WB. O tempo “real necessário” para completar uma \text{ADD} seria aproximadamente
t_{ADD} = t_{IF} + t_{ID} + t_{EX} + t_{WB}.
  • Para \text{LW} os estágios usados são IF, ID, EX, MEM e WB. O tempo necessário é
t_{LW} = t_{IF} + t_{ID} + t_{EX} + t_{MEM} + t_{WB}.
Logo t_{LW} \ge t_{ADD} porque \text{LW} inclui o acesso à memória ( t_{MEM}) a mais.
No monociclo, todavia, o tempo real por instrução é igual a T_{clk} para todas as instruções (porque cada instrução tem que caber num ciclo). Como já mostrei,
T_{clk} = t_{LW} \quad\text{(ou em geral, o tempo da instrução mais lenta)}.çã
Isso implica que a \text{ADD} também gastará T_{clk}, mesmo que pudesse ser feita mais rápido.

Passo 5

Vamos ilustrar com um número simples (para você ver que não é só discurso):
  • suponha t_{IF}=1, t_{ID}=1, t_{EX}=1, t_{MEM}=3, t_{WB}=1 (unidades: ns, só exemplo).
  • Então
T_{clk} = 1+1+1+3+1 = 7\\ \text{ns}.
  • Uma \text{ADD} “precisaria” de 1+1+1+1 = 4\\ \text{ns} se rodasse exatamente no que precisa, mas no monociclo ela acabará levando 7\\ \text{ns} porque o ciclo é de 7\\ \text{ns}.
  • Uma \text{LW} realmente precisa dos 7\\ \text{ns} por causa do t_{MEM}=3\\ \text{ns}.
Isso mostra a ineficiência: instruções simples perdem tempo esperando o ciclo finalizado pelo caso pior.

Passo 6

Conectando com a fórmula clássica de desempenho de CPU (que é útil na prova):
\text{CPU time} = \text{Instruction Count (IC)} \times \text{CPI} \times T_{clk}.
No monociclo temos \text{CPI}=1 (cada instrução ocupa exatamente um ciclo). Assim
\text{CPU time} = \text{IC} \times 1 \times T_{clk} = \text{IC}\cdot T_{clk}.
Como T_{clk} é grande (determinado pelo caso mais lento, tipicamente instruções que acessam memória como \text{LW}), o tempo total da CPU cresce mesmo que muitas instruções sejam simples. Portanto o throughput/performace fica limitado pelo tempo do ciclo, não pelo gasto real de cada instrução isolada.

Passo 7

Outras implicações práticas (resumidas e didáticas):
  • Ineficiência: instruções simples (ADD) são “forçadas” a gastar tempo extra — desperdício.
  • Frequência de clock baixa: para acomodar a instrução mais lenta, a frequência máxima da CPU fica limitada a 1/T_{clk}, que é pequena.
  • Simplicidade de controle: o monociclo é simples de projetar e entender (controle único que garante que tudo ocorra em um ciclo), então é pedagógico e fácil de implementar, mas paga preço em desempenho.
  • Uso de recursos: os componentes ficam subutilizados em muitas instruções (por exemplo, a memória de dados fica ociosa durante \text{ADD}, mas o ciclo todo é longo).
  • Comparação rápida com alternativas: multicycle e pipeline dividem o trabalho em passos menores e permitem ciclos mais curtos ou sobreposição de estágios, melhorando performance. No monociclo isso não é possível.

Passo 8

Resumo que é útil para a prova e que você pode escrever em uma resposta curta:
  • explique que T_{clk} é fixado pelo tempo da instrução mais lenta (normalmente \text{LW});
  • escreva a relação \text{CPU time} = \text{IC}\cdot T_{clk} (porque \text{CPI}=1);
  • ressalte que isso faz com que \text{ADD} (outras instruções simples) sejam obrigadas a executar no mesmo tempo de \text{LW}, gerando perda de desempenho.

Resposta

O tempo do ciclo de clock T_{clk} é determinado pela instrução mais lenta (por exemplo \text{LW}), isto é T_{clk}=t_{IF}+t_{ID}+t_{EX}+t_{MEM}+t_{WB}.
Como \text{CPI}=1 no modelo monociclo, o tempo total é \text{CPU time}=\text{IC}\cdot T_{clk}, logo instruções simples como \text{ADD} também demoram T_{clk} mesmo que precisem de menos estágios.
Implicações práticas: desperdício de tempo para instruções simples, menor frequência máxima possível (clock lento), simplicidade de implementação (pró) mas baixo desempenho em comparação a projetoss multicycle ou pipeline (contra).

Exercícios relacionados