# Percurso de dados e controlo

Do ciclo único à máquina multiciclo e aos registos de pipeline.

Página: https://resumos.rgo.pt/cadeiras/ac/percurso-dados/

Em `lw t0,12(a0)`, a instrução fornece uma base e um deslocamento. O processador precisa de somá-los, ler a memória e escrever o valor obtido em `t0`. O **percurso de dados** reúne os componentes que fazem estas operações; a **unidade de controlo** seleciona as entradas e autoriza cada escrita. Um multiplexador escolhe uma origem para um sinal.

## Ciclo único

Modelo reduzido: `add/sub/and/or`, `lw`, `sw`, `beq`; memórias de instruções e dados separadas, banco de registos com duas leituras e uma escrita, ALU e gerador de imediatos. A ALU, unidade aritmética e lógica, calcula operações inteiras e endereços.

![Percurso de dados reduzido: PC e instrução comandam controlo, registos e imediato alimentam ALU; memória ou ALU alimenta escrita; a comparação escolhe próximo PC.](https://resumos.rgo.pt/cadeiras/ac/percurso-dados/figura-1.svg)

Em `lw t0,12(a0)`: obtém a instrução; lê `a0`; estende o imediato; a ALU calcula `a0+12`; lê quatro bytes; seleciona o dado da memória para escrever em `t0`. Se `a0=200`, o endereço é 212. O imediato não é o dado carregado.

## Sinais de controlo

Segue três instruções com valores antes de decorar a tabela. Supõe `a0 = 0x1000`, palavra em `0x100C` com valor 9, `t1 = 4`.

Em `lw t0, 12(a0)`, a ALU soma `0x1000 + 12 = 0x100C`. A memória lê 9. O multiplexador de escrita escolhe a memória e o banco escreve 9 em `t0`. Sinais: `ALUSrc = 1`, `MemRead = 1`, `RegWrite = 1`, origem do dado escrito igual a memória.

Em `sw t1, 12(a0)`, a ALU calcula o mesmo endereço. O dado de `t1` segue para a memória. Sinais: `ALUSrc = 1`, `MemWrite = 1`, sem escrita no banco.

Em `beq t0, t1, L`, a ALU subtrai para testar igualdade e o imediato forma o destino. Se a comparação for verdadeira, o PC seguinte é o destino. Com os valores dados, `t0=9` e `t1=4`, a comparação é falsa e o PC avança 4 bytes.

`RegWrite` autoriza escrita no banco; `ALUSrc` escolhe registo ou imediato como segundo operando da ALU. `MemRead/MemWrite` controlam a memória de dados. `MemtoReg` escolhe a memória em vez da ALU para retorno ao banco. `Branch` autoriza a seleção do destino se a condição for verdadeira.

| Classe | ALUSrc | MemtoReg | RegWrite | MemRead | MemWrite | Branch | ALUOp |
| --- | --- | --- | --- | --- | --- | --- | --- |
| R | 0 | 0 | 1 | 0 | 0 | 0 | 10 |
| `lw` | 1 | 1 | 1 | 1 | 0 | 0 | 00 |
| `sw` | 1 | X | 0 | 0 | 1 | 0 | 00 |
| `beq` | 0 | X | 0 | 0 | 0 | 1 | 01 |

X significa indiferente **nesse uso**: como `sw` não escreve registo, MemtoReg não afeta um estado visível. Não significa que todos os sinais sejam dispensáveis.

Neste modelo, ALUOp 00 pede soma de endereço e 01 pede subtração para igualdade; 10 pede descodificação de `funct3/funct7`. A saída Zero de `rs1−rs2` vale 1 quando são iguais.

O PC seguinte é o alvo se `Branch AND Zero`; caso contrário, `PC+4`. O alvo usa o PC da instrução e o deslocamento B reconstruído, não `PC+4`.

## Período de ciclo único

O período tem de acomodar a instrução mais lenta. Se obtenção leva 200 ps, leitura de registos 100 ps, ALU 150 ps, memória de dados 250 ps e escrita 100 ps, um load precisa de 800 ps no modelo de soma desses atrasos. Uma instrução ALU mais curta também ocupa esse ciclo de 800 ps.

Não somes dois componentes que funcionam em paralelo. Primeiro segue o caminho combinacional mais longo entre elementos de estado.

## Uma máquina multiciclo

Uma máquina multiciclo reparte a instrução por estados de controlo, cada um com um ciclo. No modelo seguinte, obtenção e descodificação são separadas do cálculo do endereço. Por isso `lw` usa cinco ciclos, enquanto `add` usa quatro e `beq` usa três.

O período passa a ser determinado pelo estado mais lento. Isso permite um relógio mais rápido, mas cada instrução paga vários períodos. Para comparar organizações, calcula CPI vezes período.

A máquina multiciclo reutiliza memória e ALU em ciclos distintos, porque cada passo usa só uma parte do hardware. Registos temporários guardam a instrução (IR), dado carregado (MDR), operandos (A/B) e resultado (ALUOut). Assim, a instrução não se perde quando a memória recebe outro endereço.

| Passo | Ações principais |
| --- | --- |
| Obter | `IR←Mem[PC]`; guardar PC original e avançar PC |
| Descodificar | Ler A/B; preparar alvo de branch |
| Executar | ALU faz operação ou endereço, ou decide branch |
| Memória | Ler para MDR ou escrever dado B |
| Retorno | Escrever resultado ALU ou MDR no destino |

O branch usa o PC original da instrução. Se o passo de obtenção já avançou o PC, recupera-o do registo guardado ou compensa esse avanço antes de formar o alvo.

R usa 4 ciclos, load 5, store 4 e branch 3, nesta organização. A unidade de controlo é uma máquina de estados: os dois primeiros estados são comuns, depois o opcode escolhe a sequência. O passo de retorno de um store não é necessário.

Se as frações são 40% R, 30% load, 20% store e 10% branch, o CPI é $0,4\times4+0,3\times5+0,2\times4+0,1\times3=4,2$. Com ciclo 250 ps, o tempo por instrução é 1050 ps. Apesar do relógio mais rápido, este exemplo é mais lento do que ciclo único 800 ps, por isso calcula sempre o produto CPI×período.

## O que atravessa uma pipeline

Na pipeline, os registos IF/ID, ID/EX, EX/MEM e MEM/WB separam instruções distintas. Cada instrução leva consigo os dados e sinais de que ainda precisa.

| Registo | Conteúdo necessário no modelo básico |
| --- | --- |
| IF/ID | Instrução e PC |
| ID/EX | PC, operandos, imediato, rs1/rs2/rd e controlos EX/M/WB |
| EX/MEM | Resultado ALU, dado a guardar, rd e controlos M/WB; dados do branch |
| MEM/WB | Dado lido, resultado ALU, rd e controlos WB |

O destino de um load deve atravessar **todos** esses registos até WB. Usar o `rd` da instrução atualmente em ID escreveria no destino de outra instrução. O mesmo vale para `RegWrite` e para a seleção memória/ALU.

Uma bolha desativa os sinais que alteram estado, como RegWrite e MemWrite. Os bits de dados antigos podem continuar nos registos; deixam de causar efeitos porque os sinais de controlo estão inativos.

## Exercícios

Escolher controlos de store

Indica os sinais principais para sw t1, 20(a0) e explica origem do endereço/dado.

Pista

O imediato serve para calcular endereço.

Solução

ALUSrc 1, ALUOp 00, MemWrite 1, MemRead 0, RegWrite 0, Branch 0; MemtoReg indiferente, porque o endereço é a0+20 e a palavra guardada vem de t1.

Confere a tua resposta:

*   Ativei MemWrite e ALUSrc.
*   Desativei RegWrite e MemRead.
*   Usei o segundo registo como dado, não como endereço.

Erros frequentes

Ativar RegWrite ou usar t1 como base do endereço.

[Voltar à explicação](https://resumos.rgo.pt/cadeiras/ac/percurso-dados/#sinais-de-controlo)

Diagnosticar uma escrita no destino errado

Um `lw x7,0(x10)` chega a WB com dado 9. Nesse ciclo, ID descodifica `add x8,x11,x12`. O circuito usa o rd de ID para escrever o dado de WB. Que registo altera indevidamente? Que informação tem de atravessar os registos da pipeline para corrigir o circuito?

Solução

Escreve 9 em x8, embora o load devesse escrever em x7. O destino x7 pertence ao load e deve passar por ID/EX, EX/MEM e MEM/WB. RegWrite e a seleção do dado de memória acompanham-no; usar os controlos de ID também aplicaria os efeitos de uma instrução diferente.

Confere a tua resposta:

*   Identifiquei x7 como destino do load.
*   Mostrei por que usar x8 da instrução em ID corrompe o estado.
*   Transportei rd, RegWrite e a seleção do dado até WB.

[Voltar à explicação](https://resumos.rgo.pt/cadeiras/ac/percurso-dados/#o-que-atravessa-uma-pipeline)

Comparar organizações

Máquina multiciclo: R 4, load 5, store 4, branch 3 ciclos; mistura 40%, 30%, 20%, 10%; período 250 ps. Calcula tempo médio por instrução.

Pista

Pondera ciclos e multiplica pelo período.

Solução

CPI=0,4×4+0,3×5+0,2×4+0,1×3=4,2. Cada ciclo custa 250 ps, logo o tempo médio é 4,2×250=1050 ps. Uma organização de ciclo único com 800 ps por instrução seria mais rápida para esta mistura.

Erros frequentes

Concluir que relógio mais rápido implica menor tempo de execução.

[Voltar à explicação](https://resumos.rgo.pt/cadeiras/ac/percurso-dados/#uma-m%C3%A1quina-multiciclo)