Modulo 7 - Pipeline

Arquitetura do processador
Pipelining
Cap. 4: “The Processor”
3 May, 2021
Desenho do processador
Suporte para o conjunto de instruções
Desenho do processador
Suporte para o ISA do RISC-V
Tipo de instruções Mnemónicas

Aritméticas (INT) add, addi, sub, mul, mulh, mulsu, mulu, div, divu, rem, remu
Aritméticas (FP) fsgnj_, fmin, fmax, fadd, fsub, fmul, fdiv, fsqrt, fmadd, fmsub, fnmadd, fnsub
Convert (INT↔FP) fcvt, fmv
Lógicas and, andi, or, ori, xor, xori
Deslocamento sll, slli, srl, srli, sra, srai
Transferência lui, auipc
Acesso à memória lb, lbu, lh, lhu, lw, sb, sh, sw, flw, fld, fsw, fsd
Comparação slt, slti, sltu, sltiu, feq, flt, fle, fclass
Controlo de fluxo beq, bne, bge, bgeu, blt, bltu, jal, jalr
3
Arquitetura de Ciclo Único 4
Instruction Instruction Execute Memory Access Write Back
Fetch (IF) Decode (ID) (EX) (MEM) (WB)
IMM
JumpPC
PC
+
MUX
MUX
Xa NextPC
Jsel, BRSel Jsel,BRSel JSel BRSel

PCSel
WE
DA
Flags
4 AA Xa Branch Control NextPC
INT INTD
INT INTD
RF
MUX
+ (R0-R31) Xb ALU FPD
BA
Descodificação da instrução
PC NextPC Address
MUX
PC IMM
Xb DATA
MUX
SelB Din
Address Fb MEM
Instrução
MEMD
IntOp
SelM
INST. MEM MW WE Dout
Data MLen WordLen
WBSel WBSel
FPOp
SelA
Xa
MUX
MUX
Fa
FAA FP FP FPD
RF Unit
(F0-F31) Fb, Fc
FBA, FCA
FDA
FWE
IMM
JumpPC
PC
+
MUX
MUX
Xa NextPC

PCSel
WE
DA
Flags
INT INTD
INT INTD
RF
MUX
BA
PC NextPC Address
MUX
PC IMM
Xb DATA
MUX
SelB Din
Address Fb MEM
Instrução
MEMD
IntOp
SelM
Data MLen WordLen
WBSel WBSel
FPOp
SelA
Xa
MUX
MUX
Fa
FAA FP FP FPD
RF Unit
(F0-F31) Fb, Fc
FBA, FCA
Fusão entre a fase
de ID e a fase de OF FDA
FWE
IMM
JumpPC
PC
+
MUX
MUX
Xa NextPC

PCSel
WE
DA
Flags
INT INTD
INT INTD
RF
MUX
BA
PC NextPC Address
MUX
PC IMM
Xb DATA
MUX
SelB Din
Address Fb MEM
Instrução
MEMD
IntOp
SelM
Data MLen WordLen
WBSel WBSel
FPOp
Exercise: SelA
Xa
What is the control MUX
MUX
Fa
word for the FAA FP FP FPD
instructions: RF Unit
(F0-F31) Fb, Fc
FBA, FCA
flw f7,8(x12)
mul x10,x11,x10
FDA
jalr x1,x5,8 FWE
IMM
JumpPC
PC
+
MUX
MUX
Xa NextPC
- Jsel, BRSel NoBranch BRSel
Jsel,BRSel JSel PCSel
0 WE
- DA Flags
12
INT INTD
INT INTD
RF
MUX
- BA
PC NextPC Address
MUX
PC 8 IMM
Xb DATA
MUX
IMM SelB Fb
Din
MEM
Address
Instrução
MEMD
+ IntOp
INST. MEM - SelM
0 MW WE Dout
Data Word MLen WordLen
Memory WBSel WBSel
- FPOp
Exercise: - SelA Xa
What is the control MUX
MUX
Fa
word for the - FAA FP FP FPD
instructions: RF Unit
(F0-F31) Fb, Fc
- FBA, FCA
flw f7,8(x12)
mul x10,x11,x10 7 FDA
jalr x1,x5,8
1 FWE
IMM
JumpPC
PC
+
MUX
MUX
Xa NextPC
- Jsel, BRSel NoBranch BRSel
1 WE
10 DA Flags
Xa Branch Control
4 11 AA NextPC
INT INTD
INT INTD
RF
MUX
10 BA
PC NextPC Address
MUX
PC - IMM
Xb DATA
MUX
Xb SelB Fb
Din
MEM
Address
Instrução
MEMD
x IntOp
INST. MEM - SelM
0 MW WE Dout
Data - MLen WordLen
INTD WBSel WBSel
- FPOp
- SelA Xa
Exercise: MUX
MUX
What is the control word - FAA
Fa
for the instructions: FP FP FPD
RF Unit
(F0-F31) Fb, Fc
flw f7,8(x12) - FBA, FCA
mul x10,x11,x10
jalr x1,x5,8 - FDA
0 FWE
IMM
JumpPC
PC
+
MUX
MUX
Xa NextPC
Xa Jsel, BRSel JumpAlways BRSel
1 WE
1 DA Flags
Xa Branch Control
4 5 AA NextPC
INT INTD
INT INTD
RF
MUX
- BA
PC NextPC Address
MUX
PC 8 IMM
Xb DATA
MUX
- SelB Fb
Din
MEM
Address
Instrução
MEMD
- IntOp
INST. MEM - SelM
0 MW WE Dout
Data - MLen WordLen
NextPC WBSel WBSel
- FPOp
- SelA Xa
Exercise: MUX
MUX
What is the control word - FAA
Fa
for the instructions: FP FP FPD
RF Unit
(F0-F31) Fb, Fc
flw f7,8(x12) - FBA, FCA
Mul x10,x11,x10
jalr x1,x5,8 - FDA
0 FWE
Determinação da palavra de controlo
▪ Observações:
▫ Os sinais que controlam a escrita em registos (incluindo PC) nunca são

opcionais
▫ É mais fácil determinar o valor dos sinais de controlo, percorrendo a

arquitectura do fim (escrita/resultado) para o início (leitura dos
operandos)
10
Desempenho do processador
Análise
▪ O desempenho do processador, d, é uma medida inversamente

proporcional ao tempo de execução (t):
▪ Exemplos de medidas de desempenho:

#Inst./106
▫ 𝑀𝐼𝑃𝑆 (Million Instructions Per Second) =
𝑡
#FPOps
▫ 𝐹𝐿𝑂𝑃𝑆 (Floating Point Operations Per Second) =
𝑡
12
Noção de caminho crítico
▪ O desempenho do processador, d, é uma medida inversamente

proporcional ao tempo de execução (t).
▪ O desempenho do processador depende da frequência de relógio!

▫ Em geral, frequências de relógio superiores ➔ maior desempenho. Contudo,
como se verá em aulas futuras, isto não é sempre necessariamente verdade.
▪ A frequência de relógio (fCLK) é limitada pelo caminho crítico:

▫ O período de relógio (TCLK=1/fCLK) é determinado (limite inferior) pelo tempo
máximo de propagação entre dois elementos síncronos.
13
Determinação da frequência de relógio
▪ Para a determinação do caminho crítico, vamos admitir que:

▫ A memória de instruções corresponde a um elemento assíncrono
▫ A memória de dados permite leituras assíncronas, mas a escrita é síncrona
▫ Os restantes elementos síncronos correspondem aos registos, nomeadamente:
• PC
• Banco de registos para números inteiros: INT RF
• Banco de registos para números em vírgula flutuante: FP RF
Nota: os pressupostos para a memória (considerando processadores comuns encontrados em portáteis ou telemóveis)
são pouco realistas, como se verá em capítulos posteriores. Contudo, estes pressupostos são suficientes para ilustrar
porque razão esta arquitectura simplista é pouco eficiente.
14
Potenciais caminhos críticos 15

IMM
JumpPC
PC
+
MUX
MUX
Xa NextPC

PCSel
WE
DA
Flags
INT INTD
INT INTD
MUX
RF
+ ALU
BA (R0-R31) Xb FPD
NextPC
MUX
PC Address
PC IMM
Ex:
Xb DATA
MUX
SelB Din
Fb MEM
MEMD
Address
Instrução
IntOp
add,
SelM
Data MLen WordLen
WBSel
FPOp
WBSel
sub,
mul,
SelA
Xa
MUX
MUX
Fa
FAA
div,
FP FP FPD
RF Unit
(F0-F31) Fb, Fc
…
FBA, FCA
FDA
FWE

IMM
JumpPC
PC
+
MUX
MUX
Xa NextPC

PCSel
WE
DA
Flags
INT INTD
INT INTD
MUX
RF
+ ALU
BA (R0-R31) Xb FPD
NextPC
MUX
PC Address
PC IMM
Ex:
Xb DATA
MUX
SelB Din
Fb MEM
MEMD
Address
Instrução
IntOp
fadd,
SelM
Data MLen WordLen
WBSel
FPOp
WBSel
fmul,
fdiv,
SelA
Xa
MUX
MUX
Fa
FAA
…
FP FP FPD
RF Unit
(F0-F31) Fb, Fc
FBA, FCA
FDA
FWE

IMM
JumpPC
PC
+
MUX
MUX
Xa NextPC

PCSel
WE
DA
Flags
INT INTD
INT INTD
MUX
RF
+ ALU
BA (R0-R31) Xb FPD
NextPC
MUX
PC Address
PC IMM
Ex:
Xb DATA
MUX
SelB Din
Fb MEM
MEMD
Address
Instrução
IntOp
sw
SelM
Data MLen WordLen
WBSel WBSel
FPOp
SelA
Xa
MUX
MUX
Fa
FAA FP FP FPD
RF Unit
(F0-F31) Fb, Fc
FBA, FCA
FDA
FWE

IMM
JumpPC
PC
+
MUX
MUX
Xa NextPC

PCSel
WE
DA
Flags
INT INTD
INT INTD
MUX
RF
+ ALU
BA (R0-R31) Xb FPD
NextPC
MUX
PC Address
PC IMM
Ex:
Xb DATA
MUX
SelB Din
Fb MEM
MEMD
Address
Instrução
IntOp
lw,
SelM
Data MLen WordLen
WBSel
FPOp
WBSel
flw
…
SelA
Xa
MUX
MUX
Fa
FAA FP FP FPD
RF Unit
(F0-F31) Fb, Fc
FBA, FCA
FDA
FWE
Determinação da frequência de relógio
▪ Para o processador em questão, o caminho crítico deverá passar

pelo acesso (leitura à memória), já que requer:
1. Leitura da instrução da memória de instruções (IF)
2. Descodificação da instrução e leitura dos operandos (ID)
3. Cálculo do endereço efectivo (EX)
4. Leitura dos dados da memória (MEM)
5. Escrita do resultado num dos bancos de registos (WB)
▪ Dá origem a caminhos críticos demasiado longos (frequência de

relógio baixa), o que invalida a utilização deste tipo de arquitectura.
19
Arquitetura Pipeline
Estrutura
Analogia da lavandaria
▪ Consideremos que temos de limpar várias tulhas de roupa suja. Cada

tulha de roupa envolve a realização das seguintes tarefas:
▫ lavagem, secagem, engomagem e arrumação no armário
21
▪ Assumindo que iniciamos a actividade às 18h e que cada uma destas

tarefas demora cerca de 30 minutos, poderemos começar a tratar
da 2ª tulha pelas 20h e teremos tudo pronto às 2h00 (!!!)
22
▪ Assumindo que iniciamos a actividade às 18h e que cada uma destas

tarefas demora cerca de 30 minutos, poderemos começar a tratar
da 2ª tulha pelas 20h e teremos tudo pronto às 2h00 (!!!)
Não conseguimos fazer

melhor do que isto?
23
▪ Porque não fazemos várias actividades em simultâneo?
24
▪ Porque não fazemos várias actividades em simultâneo?

▫ Se iniciarmos a actividade às 18h, terminaremos todas as actividades pelas 9h30.
▫ Ou seja: em vez de demorarmos 8h demoraremos 3h30
▫ Mais do que 2x mais rápido!!!
25
Como aumentar a frequência de relógio
▪ Em geral, a forma de melhorar o desempenho de processadores

passa por explorar algum tipo de paralelismo:
▫ Paralelismo ao nível dos dados, usando instruções SIMD (Single-Instruction
Multiple-Data)
▫ Paralelismo ao nível da instrução…
26
Como aumentar a frequência de relógio
▪ Em geral, a forma de melhorar o desempenho de processadores

passa por explorar algum tipo de paralelismo:
▫ Paralelismo ao nível dos dados, usando instruções SIMD (Single-Instruction
Multiple-Data)
▫ Paralelismo ao nível da instrução…
Já que identificámos 5 fases na execução de uma instrução (IF,ID,EX,MEM,WB), porque

não dividir a execução das instruções em ciclos de relógio diferentes….
Nota: a existência do estágio de MEM prende-se com a necessidade de suportar instruções de LD/ST com endereço indexado, i.e.,
[Rx+IMM]. Se o ISA só definir instruções com endereçamento direto, [IMM], ou só com endereçamento indireto por registo, [Rx], a
27 memória de dados pode ser colocada em paralelo com a ALU, passando a haver apenas 4 estágios: IF, ID, EX/MEM, WB
Principais alterações
1. Introdução de registos de Registos entre estágios do

pipeline entre estágios do processador
processador
▫ VANTAGEM: Redução do
caminho
crítico
→ Período de relógio menor
→ Maior frequência de relógio
28
Arquitetura Pipeline 29
ID_IMM
+ MEM_JumpPC MEM_PCSel
MUX
MEM_JumpPC
MEM_PCSel
ID_Xa
Jsel
BRSel
DA,WE
EX_Flags
IF_NextPC AA ID_Xa Branch
INT Control
4 RF INT
MUX
ALU
EX_INTD
MUX BA (R0-R31) ID_Xb

+
MUX
IF_PC
PC IMM
Address
MEM_MEMD
SelB
IntOp
Address ID_Xb
DATA MEM
IF_Instrução
MUX
Din
INST. ID_Fb
Dout
MEM SelM
MW,MLen WE,WordLen
Data WBSel
FPOp
SelA
ID_Xa
EX_FPD
MUX
MUX
ID_Fa
FAA
FP FP
RF Unit
FBA, FCA (F0-F31) ID_Fb, ID_Fc
FDA,FWE
1. Introdução de registos de pipeline entre estágios do processador

▫ Período de relógio reduzido
2. Os sinais devem atravessar os registos de pipeline
▫ Cada sinal possui agora diversas
designações dependendo dos estágios
em que são produzidos/consumidos
▫ P.ex., os sinais DA e WE, produzidos
pelo descodificador de instruções e
utilizado aquando da escrita no banco
de registos, têm de atravessar os
registos de pipeline, já que só são
consumidos no estágio de WB.
30
ID_IMM
+ MEM_JumpPC MEM_PCSel WB_DA,
MUX
MEM_JumpPC
WB_WE
MEM_PCSel
ID_Xa
Jsel
BRSel
DA,WE
ID_DA, ID_WE EX_DA, EX_WE MEM_DA, MEM_WE

INT Control
4 RF INT
MUX
ALU
EX_INTD

+
MUX
IF_PC
PC IMM
Address
MEM_MEMD
SelB
IntOp
Address ID_Xb
DATA MEM
IF_Instrução
MUX
Din
INST. ID_Fb
Dout
MEM SelM
MW,MLen WE,WordLen
Data WBSel
FPOp
SelA
ID_Xa
EX_FPD
MUX
MUX
ID_Fa
FAA
FP FP
RF Unit
FDA,FWE
ID_IMM
MUX
MEM_JumpPC
MEM_PCSel
ID_NextPC ID_Xa EX_NextPC

Jsel MEM_NextPC WB_NextPC
BRSel
DA,WE
EX_Flags
INT Control
4 RF INT
MUX
ALU
EX_INTD

+
MUX
IF_PC
PC IMM
Address
MEM_MEMD
SelB
IntOp
Address ID_Xb
DATA MEM
IF_Instrução
MUX
Din
INST. ID_Fb
Dout
MEM SelM
MW,MLen WE,WordLen
Data WBSel
FPOp
SelA
ID_Xa
EX_FPD
MUX
MUX
ID_Fa
FAA
FP FP
RF Unit
FDA,FWE


▫ Cada sinal possui agora diversas designações dependendo dos estágios em que são
produzidos/consumidos
▫ P.ex., os sinais DA e WE, produzidos pelo descodificador de instruções, têm de
atravessar os registos de pipeline, já que só são consumidos no estágio de WB.
3. O estágio de IF, por omissão, “incrementa” sempre o PC (soma 4),

registando apenas um salto quando uma instrução de branch
chega ao estágio de MEM, assinalando no sinal MEM_PCSel que o
multiplexer de selecção do próximo PC deve escolher o sinal
MEM_JumpPC
33

▫ Cada sinal possui agora diversas designações dependendo dos estágios em que são
produzidos/consumidos
▫ P.ex., os sinais DA e WE, produzidos pelo descodificador de instruções, têm de atravessar
os registos de pipeline, já que só são consumidos no estágio de WB.
3. O estágio de IF, por omissão, “incrementa” sempre o PC (soma 4),
registando apenas um salto quando uma instrução de branch chega ao
estágio de MEM.
4. Em cada ciclo, há uma instrução diferente em cada estágio do pipeline
▫ Em cada ciclo, as instruções deslocam-se, entrando uma nova instrução para o estágio de IF
e saindo uma instrução (fim de execução) no estágio de WB.
34
Funcionamento
Arquitetura Pipeline (figura repetida dos slides anteriores) 36
ID_IMM
MUX
MEM_JumpPC
MEM_PCSel
ID_Xa
Jsel
BRSel
DA,WE
EX_Flags
INT Control
4 RF INT
MUX
ALU
EX_INTD

+
MUX
IF_PC
PC IMM
Address
MEM_MEMD
SelB
IntOp
Address ID_Xb
DATA MEM
IF_Instrução
MUX
Din
INST. ID_Fb
Dout
MEM SelM
MW,MLen WE,WordLen
Data WBSel
FPOp
SelA
ID_Xa
EX_FPD
MUX
MUX
ID_Fa
FAA
FP FP
RF Unit
FDA,FWE
Execução de código
▪ Para facilitar a leitura, vamos simplificar a figura, e executar um

pequeno troço de código…
PC Instrução
10h: addi x10,x0,vector
14h: ori x11,x0,100
18h: ori x12,x0,1
1Ch: ori x13,x0,8
20h: lw x14,0(x10)
24h: lw x15,8(x10)
37
Ciclo de relógio #1
PC Instrução
(IF) 10h: addi x10,x0,vector addi x10,x0,vector
14h: ori x11,x0,100
18h: ori x12,x0,1
1Ch: ori x13,x0,8
20h: lw x14,0(x10)
24h: lw x15,8(x10)
38
PC Instrução
(ID) 10h: addi x10,x0,vector addi x10,x0,…
(IF) 14h: ori x11,x0,100 ori x11,x0,100
18h: ori x12,x0,1
1Ch: ori x13,x0,8
20h: lw x14,0(x10)
24h: lw x15,8(x10)
39
PC Instrução
(EX) 10h: addi x10,x0,vector addi x10,x0,…
(ID) 14h: ori x11,x0,100 ori x11,x0,100
(IF) 18h: ori x12,x0,1 ori x12,x0,1
1Ch: ori x13,x0,8
20h: lw x14,0(x10)
24h: lw x15,8(x10)
40
PC Instrução
(MEM) 10h: addi x10,x0,vector addi x10,x0,…
(EX) 14h: ori x11,x0,100 ori x11,x0,100
(ID) 18h: ori x12,x0,1 ori x12,x0,1
(IF) 1Ch:ori x13,x0,8 ori x13,x0,8
20h: lw x14,0(x10)
24h: lw x15,8(x10)
41
PC Instrução
(WB) 10h: addi x10,x0,vector addi x10,x0,…
(MEM) 14h: ori x11,x0,100 ori x11,x0,100
(EX) 18h: ori x12,x0,1 ori x12,x0,1
(ID) 1Ch:ori x13,x0,8 ori x13,x0,8
(IF) 20h:lw x14,0(x10) lw x14,0(x10)

24h: lw x15,8(x10)
42
PC Instrução
✓ 10h: addi x10,x0,vector
(WB) 14h: ori x11,x0,100 ori x11,x0,100
(MEM) 18h: ori x12,x0,1 ori x12,x0,1
(EX) 1Ch: ori x13,x0,8 ori x13,x0,8
(ID) 20h: lw x14,0(x10) lw x14,0(x10)
(IF) 24h: lw x15,8(x10) lw x15,8(x10)
43
PC Instrução
✓ 14h: ori x11,x0,100
(WB) 18h: ori x12,x0,1 Ori x12,x0,1
(MEM) 1Ch: ori x13,x0,8 Ori x13,x0,8
(EX) 20h: lw x14,0(x10) lw x14,0(x10)
(ID) 24h: lw x15,8(x10) lw x15,8(x10)
44
PC Instrução
✓ 14h: ori x11,x0,100
✓ 18h: ori x12,x0,1
(WB) 1Ch: ori x13,x0,8 ori x13,x0,8
(MEM) 20h: lw x14,0(x10) lw x14,0(x10)
(EX) 24h: lw x15,8(x10) lw x15,8(x10)
Latência (latency): cada instrução demora 5 ciclos de relógio a executar

Ritmo de execução (throughput performance): executa (até) 1 instrução por ciclo de relógio
45
Execução de código: visão alternativa
PC Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10
10h: addi x10,x0,vector IF ID EX MEM WB
14h: ori x11,x0,100 IF ID EX MEM WB
1Ch: ori x13,x0,8 IF ID EX MEM WB
20h: lw x14,0(x10) IF ID EX MEM WB
46
Pipeline do processador
47
Latência (latency): cada instrução demora 5 ciclos de relógio a executar

Ritmo de execução (throughput performance): executa (até) 1 instrução por ciclo de relógio
48
Desempenho
Arquitetura Pipeline vs Arquitetura de Ciclo Único
Arquitetura de Ciclo Único Arquitetura Pipeline (S=5 estágios)
#Ciclos para executar N instruções: N #Ciclos para executar N instruções: N + (S-1)

Período de relógio (𝐓𝐂𝐋𝐊): limitado pelo maior Período de relógio (𝐓 ෡ CLK): limitado pelo maior
caminho crítico, que deve corresponder a caminho crítico, que se deverá ou ao acesso à memória
uma instrução de load: ou à execução de uma instrução de FP (mais provável):
TCLK=TPC+TINSTR. MEM+TDECODER+TREAD OPERANDS + ෡CLK = TP FFs + TFP UNIT + TSU FFs
T
TINT ALU+TDATA MEM+TWRITE RF 𝑇෠ 𝐶𝐿𝐾 ≳ TCLK / S
Tempo de execução: T = N × TCLK Tempo de execução (para N>>S): T
෡ =N×T
෡CLK
Nota: no cálculo do período de relógio, deve-se somar o tempo de propagação e setup dos flip-flops ao tempo de propagação da lógica
49
(combinatória) do processador
Desempenho
Arquitetura Pipeline vs Arquitetura de Ciclo Único
Arquitetura de Ciclo Único Arquitetura Pipeline (S=5 estágios)

Desempenho do processador melhorado Tempo do processador original T TCLK
Speedup = = = =
Desempenho do processador original Tempo do processador melhorado T ෡ T ෡CLK
Admitindo que o tempo de setup e hold dos flip-flops é desprezável e que a divisão do pipeline em
estágios é feita de forma perfeitamente equitativa,
TCLK
#Ciclos para executar N instruções: N T
෡CLK ≈ #Ciclos para
⇒
Speedup = S executar N instruções: (S-1) + N
𝑆
Periodo de relógio (𝐓𝐂𝐋𝐊): limitado pelo maior Periodo de relógio (𝐓 ෡ CLK): limitado pelo maior
caminho
Assim, crítico, que deve
o desempenho docorresponder
processador,aem condições ideais,caminho crítico,
aumenta que deverá ou ao ao
proporcionalmente acesso
númeroà memória
de
uma instrução de load:
estágios de pipeline. Contudo, na prática: ou à execução de uma instrução de FP (mais provável):
TCLK =TPC+TINSTR +TDECODER+TREAD o tempo de ෡CLK = TP FFs + TFP UNIT + TSU FFs
+ propagação
T
1. Quando o número de estágios aumenta muito,OPERANDS
. MEM e setup dos flip-flops deixa de serTdesprezável
PIPE > TCU / S
TINT ALU+TDATA MEM+TWRITE RF
2. A divisão do processador em estágios nunca é totalmente equilibrada
Tempo de execução:
3. Esta T = as
estimative ignora N dependências
× TCLK entre instruções! Tempo de execução (para N>>S): T
෡ =N×T
෡CLK
Nota: no cálculo do periodo de relógio deve-se somar o tempo de propogação e setup dos flip-flops ao tempo de propogação através da
50
lógica (combinatória) do processador
Novo exemplo de código
i=N-1;
do{
C[i]=A[i]+k;
i--;
} while (i>=0);
; x10=A, x11=k, x12=C, x13=i

ori x13,x0,N
addi x13,x13,-1 ; i=N-1
sll x14,x13,3 ; cada elemento de C[] e A[] ocupa 8 Bytes
add x10,x10,x14 ; X10 aponta para o último elemento de A, i.e., A[i], com i=N-1
add x12,x12,x14 ; X12 aponta para o último elemento de C
lw x15,0(x10) ; X15 = A[i]
add x15,x15,x11 ; X15 = A[i]+k
sw x15,0(x12) ; guarda em C[i]
addi x10,x10,-8 ; atualiza X0 de forma a apontar para A[i-1]
addi x12,x12,-8 ; atualiza X2 de forma a apontar para C[i-1]
addi x13,x13,-1 ; i--
51 bge x13,x0,-9 ; volta ao loop
CLK
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
ori x13,x0,N IF ID EX MEM WB X13
addi x13,x13,-1
sll x14,x13,3
add x10,x10,x14
add x12,x12,x14
lw x15,0(x10)
add x15,x15,x11
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,-9
52
CLK
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
ori x13,x0,N IF ID EX MEM WB x13
addi x13,x13,-1 IF ID EX MEM WB x13
sll x14,x13,3
add x10,x10,x14
add x12,x12,x14
lw x15,0(x10)
add x15,x15,x11
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,-9
Conflito de dados:
Lê o valor do registo x13 (operando),
contudo o valor correto ainda não foi escrito no RF
53
CLK
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
sll x14,x13,3 IF ID EX MEM WB x14
add x10,x10,x14
add x12,x12,x14
lw x15,0(x10)
add x15,x15,x11
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,-9
Conflito de dados:
54
CLK
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
add x10,x10,x14 IF ID EX MEM WB x10
add x12,x12,x14
lw x15,0(x10)
add x15,x15,x11
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,-9
Conflito de dados:
55
CLK
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
lw x15,0(x10)
add x15,x15,x11
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,-9
Conflito de dados:
56
CLK
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
lw x15,0(x10) IF ID EX MEM WB x15
add x15,x15,x11
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,-9
Conflito de dados:
57
CLK
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,-9
Conflito de dados:
58
CLK
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
sw x15,0(x12) IF ID EX MEM -
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,-9
Conflito de dados:
Lê o valor dos registos x12 e x15 (operandos),
59
CLK
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
bge x13,x0,-9
60
CLK
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
bge x13,x0,-9 IF ID EX MEM WB
Conflito de controlo:
→ Qual o valor do PC da próxima instrução?
→ O estágio de IF não sabe que a instrução
61 corresponde a um branch!!!
CLK
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Conflito de dados:
Lê o valor dos registos x13 e x0
(operandos), contudo o valor correto
62 de x13 ainda não foi escrito no RF
CLK
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Conflito de dados: Conflito de controlo:

Lê o valor dos registos (operandos), → Qual o valor do PC da próxima instrução?
contudo o valor correto ainda não foi escrito no RF → O estágio de IF não sabe que a instrução
63 corresponde a um branch!!!
Identificação de conflitos
ID_IMM
MUX
MEM_JumpPC
MEM_PCSel
ID_Xa
Jsel
BRSel
DA,WE
EX_Flags
INT Control
4 RF INT
MUX
ALU
EX_INTD

+
MUX
IF_PC
PC IMM
Address
MEM_MEMD
SelB
IntOp
Address ID_Xb
DATA MEM
IF_Instrução
MUX
Din
INST. ID_Fb
Dout
MEM SelM
MW,MLen WE,WordLen
Data WBSel
FPOp
SelA
ID_Xa
EX_FPD
MUX
MUX
ID_Fa
FAA
FP FP
RF Unit
FDA,FWE
Conflitos
▪ Conflito (Hazard)
▫ Designa-se de conflito (hazard) toda e qualquer situação em que não
seja possível executar uma determinada instrução no instante em que
ela é processada pelo processador.
66
Tipos de conflitos
▪ Conflitos de dados
▫ Os operandos da instrução ainda não estão disponíveis para serem lidos
▪ Conflitos de controlo
▫ Originados por uma instrução de controlo de fluxo (beq, bne, bge, blt, bgeu, bltu, jal, jalr). A
arquitectura não sabe qual a próxima instrução a executar!
▪ Conflitos estruturais
▫ Falta de recursos em hardware para executar uma dada instrução. Considere-se por
exemplo a adição da nova instrução:
swr x5,x4(x2) ➔ M[x4+x2] x5

Requer a leitura de três operandos, mas o RF de inteiros apenas permite a leitura de 2
67 operandos!
Conflitos de dados
Identificação de dependências e de conflitos de dados
▪ As dependências ocorrem sempre que uma instrução consome o resultado de uma

instrução anterior, ex:
mul x15,x13,x12
A existência de um conflito depende do
… número de instruções no meio
add x17,x15,x12
▪ Um conflito ocorre sempre que o funcionamento do pipeline leva a que a

dependência não seja respeitada, i.e., o valor lido de um (ou mais) operandos não
corresponde ao valor correto.
68
Conflitos de dados
Ciclo de relógio: k k+1 k+2 k+3 k+4 k+5 k+6 k+7 k+8 k+9 …
mul x5,x3,x2 IF ID EX MEM WB x5
 +3 ciclos
Como a leitura é realizada no estágio de ID e o valor só está

disponível após o estágio de WB, pelo que são necessárias
3 instruções entre a escrita e a leitura
mul x5,x3,x2 IF ID EX MEM WB x5
Inst #1 … … … … …
Inst #2 … … … … …
Inst #3 … … … … …
add x7,x5,x2 IF ID EX MEM WB X7
☺
69
Conflitos de dados
sw x5,0(x10) IF ID EX MEM WB
lw x3,-8(x4) IF ID EX MEM WB x3
Admitindo que X10=X4-8, ☺
i.e., a instrução de load lê o
valor escrito pela instrução Como a leitura da memória é realizada no estágio de MEM (ciclo
de store. k+4) e a escrita do valor também é realizada no mesmo estágio
(mas no ciclo k+3), esta dependência nunca gera um conflito (com
esta arquitetura)
70
Conflitos de controlo
Identificação de conflitos de controlo
▪ Os conflitos de controlo ocorrem sempre que entra uma instrução de

controlo no pipeline do processador:
▫ Qual é a próxima instrução? O PC deve ser atualizado no estágio de IF, mas nessa altura não
sabemos sequer se a instrução atual é do tipo de controlo!
Ciclo de relógio: k k+1 k+2 k+3 k+4 k+5 …

jal x1,label IF ID EX MEM WB
??? IF ID EX MEM WB
Qual é o próximo PC?
É uma Ciclo de relógio: k k+1 k+2 k+3 k+4 k+5 …

instrução de beq x5,x6,label IF ID EX MEM WB
controlo? ??? IF ID EX MEM WB
Ciclo de relógio: k k+1 k+2 k+3 k+4 k+5 …

jalr x1,x6,0 IF ID EX MEM WB
??? IF ID EX MEM WB
71
Resolução de conflitos por software
Conflitos de dados
▪ A resolução dos conflitos por software consiste em:

▫ Inserir uma ou mais instruções NOP (no-operation) entre instruções dependentes de forma a garantir a
inexistência de conflitos, ou
▫ Re-ordenar as instruções, também de forma a garantir a inexistência de conflitos
▪ Por vezes a resolução de um conflito pode levar à resolução de outros

conflitos, p.ex:
Ciclo de relógio: k k+1 k+2 k+3 k+4 k+5 k+6 k+7 Ciclo de relógio: k k+1 k+2 k+3 k+4 k+5 k+6 k+7
mul x5,x7,x8 IF ID EX MEM WB x5 mul x5,x7,x8 IF ID EX MEM WB x5
mul x6,x2,x3 IF ID EX MEM WB x6 mul x6,x2,x3 IF ID EX MEM WB x6
add x4,x5,x6 IF ID EX MEM WB x4 nop IF ID EX MEM WB
nop IF ID EX MEM WB
nop IF ID EX MEM WB
add x4,x5,x6 IF ID EX MEM
73
“O estágio de IF, por omissão, “incrementa” sempre o PC (soma 4),

PCSel
chega ao estágio de MEM (sinal PCSel).”
▪ Assim, o programa segue em frente até à resolução (i.e.,
execução) do branch.
Wrong Inst1 IF ID EX MEM WB
label: add x4,x2,x1 IF ID EX MEM WB
O PC é atualizado com o resultado
da instrução “jal x0,label”
74

PCSel
▪ A resolução por software passa por assumir que o salto é

retardado: cabe ao programador inserir instruções válidas
nos slots que ainda vão ser executados!
Delay Slot #1 IF ID EX MEM WB
75 label: add x4,x2,x1 IF ID EX MEM WB

PCSel
▪ A resolução por software passa por assumir que o salto é

retardado: cabe ao programador inserir instruções válidas
nos slots que ainda vão ser executados!
▫ Estes Delay Slots podem conter: NOPs, instruções de acesso à
memória, ou de processamento de dados
▫ Os delay slots *não* podem conter outras instruções de controlo de
salto (branch/jump)!
76
Exemplo de resolução de conflitos
ori x13,zero,N
subi x13,x13,1
sll x14,x13,3
add x10,x10,x14
add x12,x12,x14
loop: lw x15,0(x10)
add x15,x15,x11
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,loop
77
ori x13,zero,N
3 NOPs
subi x13,x13,1
sll x14,x13,3
Nota: não há nenhuma instrução em baixo que se possa mover
add x10,x10,x14
para aqui sem quebrar uma dependência de dados
add x12,x12,x14
loop: lw x15,0(x10)
add x15,x15,x11
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,loop
78
ori x13,zero,N NOP

3x nop NOP
subi x13,x13,1 NOP
sll x14,x13,3
add x10,x10,x14
add x12,x12,x14
loop: lw x15,0(x10)
add x15,x15,x11
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,loop
79
ori x13,zero,N
3x nop
subi x13,x13,1
3 NOPs
sll x14,x13,3
add x10,x10,x14 Nota: não há nenhuma instrução em baixo que se possa mover
add x12,x12,x14 para aqui sem quebrar uma dependência de dados
loop: lw x15,0(x10)
add x15,x15,x11
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,loop
80
ori x13,zero,N
3x nop
subi x13,x13,1
3x nop
sll x14,x13,3
3 NOPs
add x10,x10,x14
add x12,x12,x14 Nota: não há nenhuma instrução em baixo que se possa mover
loop: lw x15,0(x10) para aqui sem quebrar uma dependência de dados
add x15,x15,x11
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,loop
81
ori x13,zero,N
3x nop
subi x13,x13,1
3x nop
sll x14,x13,3
3x nop
add x10,x10,x14
add x12,x12,x14 Esta dependência já não gera conflitos
loop: lw x15,0(x10)
add x15,x15,x11
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,loop
82
ori x13,zero,N
3x nop
subi x13,x13,1
3x nop
sll x14,x13,3
3x nop
add x10,x10,x14
add x12,x12,x14
loop: lw x15,0(x10) 2 NOPs
add x15,x15,x11
Nota: há uma instrução no meio que ajuda a resolver o conflito
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,loop
83
ori x13,zero,N
3x nop
subi x13,x13,1
3x nop
sll x14,x13,3
3x nop
add x10,x10,x14
add x12,x12,x14
2x nop
loop: lw x15,0(x10) Podemos mover duas instruções para ajudar na resolução…
add x15,x15,x11 Mas ainda precisamos de 1 NOP
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,loop
84
ori x13,zero,N
3x nop
subi x13,x13,1
3x nop
sll x14,x13,3
3x nop
add x10,x10,x14
add x12,x12,x14
2x nop
loop: lw x15,0(x10)
addi x10,x10,-8
addi x13,x13,-1
nop
add x15,x15,x11
sw x15,0(x12) Podemos adiar o store para os slots do bge
addi x12,x12,-8 Para respeitar a dependência do addi, teremos de o mover também
bge x13,x0,loop
85
ori x13,zero,N
3x nop
subi x13,x13,1
3x nop
sll x14,x13,3
3x nop
add x10,x10,x14
add x12,x12,x14
2x nop
loop: lw x15,0(x10)
addi x10,x10,-8
addi x13,x13,-1
nop
add x15,x15,x11
nop Resta um NOP para garantir a distância entre o add e o sw
bge x13,x0,loop (dependência de x15)
nop
sw x15,0(x12)
86
addi x12,x12,-8
ori x13,zero,N
3x nop
subi x13,x13,1
3x nop
sll x14,x13,3
3x nop
add x10,x10,x14
add x12,x12,x14
2x nop
loop: lw x15,0(x10)
addi x10,x10,-8
addi x13,x13,-1
nop
add x15,x15,x11 Podemos mover o addi, desde que alteremos o offset do sw:
nop para que o endereço escrito pelo sw não se altere (por via da
bge x13,x0,loop antecipação do addi, o endereço deve ser obtido por (R2 + 8), dado que
nop na altura em que o sw é realizado, o R2 já foi subtraído de 8 unidades
sw x15,0(x12) (ver próximo slide).
87
addi x12,x12,-8
ori x13,zero,N
3x nop
subi x13,x13,1
3x nop
sll x14,x13,3
3x nop
add x10,x10,x14
add x12,x12,x14
2x nop
loop: lw x15,0(x10)
addi x10,x10,-8
addi x13,x13,-1
addi x12,x12,-8
add x15,x15,x11
nop Podemos eliminar o nop, desde que o sw mova para baixo
bge x13,x0,loop
nop
sw x15,8(x12)
88
nop
ori x13,zero,N
3x nop
subi x13,x13,1
3x nop
sll x14,x13,3
3x nop
add x10,x10,x14
add x12,x12,x14
2x nop
loop: lw x15,0(x10)
addi x10,x10,-8
addi x13,x13,-1
addi x12,x12,-8
add x15,x15,x11
bge x13,x0,loop
nop
nop
sw x15,8(x12)
89
ori x13,zero,N
3x nop
subi x13,x13,1
3x nop
sll x14,x13,3
3x nop
add x10,x10,x14
add x12,x12,x14
2x nop
loop: lw x15,0(x10)
addi x10,x10,-8
addi x13,x13,-1
addi x12,x12,-8
add x15,x15,x11
bge x13,x0,loop
nop Porque não aproveitamos estes 2 ciclos para antecipar
nop o início da próxima iteração (i.e. a instrução lw) ?
sw x15,8(x12)
90
ori x13,zero,N ori x13,zero,N

3x nop 3x nop
subi x13,x13,1 subi x13,x13,1
3x nop 3x nop
sll x14,x13,3 sll x14,x13,3
3x nop 3x nop
add x10,x10,x14 add x10,x10,x14
add x12,x12,x14 add x12,x12,x14
2x nop 2x nop
loop: lw x15,0(x10) loop: lw x16,0(x10)
addi x10,x10,-8 addi x10,x10,-8
addi x13,x13,-1 addi x13,x13,-1
addi x12,x12,-8 addi x12,x12,-8
add x15,x15,x11 Renomeando o resultado add x15,x16,x11
bge x13,x0,loop do load, do registo x15 bge x13,x0,loop
nop para x16 nop
nop nop
sw x15,8(x12) sw x15,8(x12)
91

3x nop 3x nop
3x nop 3x nop
sll x14,x13,3 sll x14,x13,3
3x nop 3x nop
add x10,x10,x14 add x10,x10,x14
add x12,x12,x14 add x12,x12,x14
2x nop 2x nop
loop: lw x15,0(x10) loop: lw x16,0(x10)
addi x10,x10,-8 addi x10,x10,-8
addi x13,x13,-1 Movendo o inicio da addi x13,x13,-1
addi x12,x12,-8 iteração k+1 para o fim da addi x12,x12,-8
add x15,x15,x11 iteração k add x15,x16,x11
bge x13,x0,loop bge x13,x0,loop
nop nop
nop nop
sw x15,8(x12) sw x15,8(x12)
92

3x nop 3x nop
3x nop 3x nop
sll x14,x13,3 sll x14,x13,3
3x nop 3x nop
add x10,x10,x14 add x10,x10,x14
add x12,x12,x14 add x12,x12,x14
2x nop 2x nop
loop: lw x15,0(x10) lw x16,0(x10)
addi x10,x10,-8 addi x10,x10,-8
addi x13,x13,-1 loop: addi x13,x13,-1
addi x12,x12,-8 addi x12,x12,-8
add x15,x15,x11 add x15,x16,x11
bge x13,x0,loop bge x13,x0,loop
nop lw x16,0(x10)
nop addi x10,x10,-8
sw x15,8(x12) sw x15,8(x12)
93
Exemplo de resolução de conflitos (ignorando os slides informativos, a cinzento)
ori
3x nop
x13,zero,N ▪ Para N iterações, é necessário executar:
subi x13,x13,1 ▫ Preâmbulo: 5 instruções + 11 NOPs
3x nop
▫ Ciclo: (7 instruções + 2 NOPs) x N iterações
sll x14,x13,3
▫ Total: 16 + 9N instruções
3x nop ▫ Latência: (16 + 9N + 4) TCLK PIPE

add x10,x10,x14
add x12,x12,x14
2x nop
▪ Por comparação, na solução original (ciclo único) eram
necessárias:
loop: lw x15,0(x10)
addi x10,x10,-8 ▫ Preâmbulo: 5 instruções
▫ Ciclo: 7 instruções x N iterações
addi
addi
x13,x13,-1
x12,x12,-8
▫ Total: 5 + 7N instruções
add x15,x15,x11 ▫ Latência: (5 + 7N) TCLK ORIGINAL

bge x13,x0,loop
nop
nop
▪ Se TCLK ORIGINAL=5TCLK PIPE (caso óptimo), então:
94
sw x15,8(x12) ▫ Speedup =
5(5+7𝑁)
20+9𝑁
5(5+7𝑁)
lim
𝑁→+∞ 20+9𝑁
=
35
9
= 3.9
4.0 Caso ideal TCLK ORIGINAL=5TCLK PIPE

3.5
TCLK ORIGINAL=4TCLK PIPE
3.0
2.5 TCLK ORIGINAL=3TCLK PIPE

Speedup
2.0
TCLK ORIGINAL=2TCLK PIPE
1.5
1.0
0.5
0.0
0 5 10 15 20 25 30 35 40 45 50
Número de iterações
95
▪ A resolução dos conflitos de controlo é

muito ineficiente.
▪ Será que conseguimos melhor?
96
Arquitetura Pipeline (Resolução das instruções de controlo no estágio de MEM) 97
ID_IMM
MUX
MEM_JumpPC
MEM_PCSel
ID_Xa
Jsel
BRSel
DA,WE
EX_Flags
INT Control
4 RF INT
MUX
ALU
EX_INTD

+
MUX
IF_PC
PC IMM
Address
MEM_MEMD
SelB
IntOp
Address ID_Xb
DATA MEM
IF_Instrução
MUX
Din
INST. ID_Fb
Dout
MEM SelM
MW,MLen WE,WordLen
Data WBSel
FPOp A resolução das
SelA
ID_Xa
instruções de
EX_FPD
controlo no
MUX
MUX
ID_Fa
FAA
FP FP estágio de MEM
RF Unit obriga à
Delay FBA, FCA Delay ID_Fb, ID_Fc
(F0-F31) Delay
slot #1 slot #2 slot #3 existência de 3
FDA,FWE delay slots
SOLUÇÃO: Antecipar a resolução das instruções de controlo 98
ID_IMM
MUX
MEM_JumpPC
MEM_PCSel
ID_Xa
Jsel
BRSel
DA,WE
EX_Flags
INT Control
4 RF INT
MUX
ALU
EX_INTD

+
MUX
IF_PC
PC IMM
Address
MEM_MEMD
SelB
IntOp
Address ID_Xb
DATA MEM
IF_Instrução
MUX
Din
INST. ID_Fb
Dout
MEM SelM
MW,MLen WE,WordLen
Data WBSel
FPOp
SelA
ID_Xa
EX_FPD
MUX
MUX
ID_Fa
FAA
FP FP
RF Unit
FDA,FWE
Arquitetura Pipeline (Resolução das instruções de controlo no estágio de EX) 99
ID_IMM
O impacto no caminho
+ crítico é mínimo já que
MUX
MEM_JumpPC
as flags dizem
MEM_PCSel
ID_Xa
Jsel respeito ao somador e
BRSel Branch Control
DA,WE o caminho crítico é
EX_Flags ditado pelas unidades
ID_Xa
IF_NextPC AA mais complexas
INT
4 RF INT (cálculo em FP ou
MUX
ALU EX_INTD divisão inteira)

+
MUX
IF_PC
PC IMM
Address
MEM_MEMD
SelB
IntOp
Address ID_Xb
DATA MEM
IF_Instrução
MUX
Din
INST. ID_Fb
Dout
MEM SelM
MW,MLen WE,WordLen
Data WBSel
SelA
ID_Xa
instruções de
controlo no
MUX
MUX
ID_Fa
FAA
FP estágio
FP deEX_FPD
EX
RF Unit
obriga à
Delay FBA, FCA Delay ID_Fb, ID_Fc
(F0-F31)
slot #1 slot #2 existência de 2
FDA,FWE delay slots
Arquitetura Pipeline (figura repetida do slide anterior) 100
ID_IMM
+
MUX
MEM_JumpPC
MEM_PCSel
ID_Xa
Jsel
BRSel Branch Control
DA,WE
EX_Flags
AA ID_Xa
IF_NextPC
INT
4 RF INT
MUX
ALU EX_INTD

+
MUX
IF_PC
PC IMM
Address
MEM_MEMD
SelB
IntOp
Address ID_Xb
DATA MEM
IF_Instrução
MUX
Din
INST. ID_Fb
Dout
MEM SelM
MW,MLen WE,WordLen
Data WBSel
FPOp
SelA
ID_Xa
MUX
MUX
ID_Fa
FAA
FP FP EX_FPD
RF Unit
FDA,FWE
SOLUÇÃO: Antecipar a resolução das instruções de controlo 101
ID_IMM
MUX
MEM_JumpPC
MEM_PCSel
ID_Xa
Jsel
BRSel
DA,WE
?
EX_Flags
INT Control
4 RF INT
MUX
ALU
EX_INTD

+
MUX
IF_PC
PC IMM
Address
MEM_MEMD
SelB
IntOp
Address ID_Xb
DATA MEM
IF_Instrução
MUX
Din
INST. ID_Fb
Dout
MEM SelM
MW,MLen WE,WordLen
Data WBSel
FPOp
SelA
ID_Xa
EX_FPD
MUX
MUX
ID_Fa
FAA
FP FP
RF Unit
FDA,FWE
ID_IMM +
MUX
MEM_JumpPC
MEM_PCSel
ID_Xa
Jsel
BRSel Branch CTRL
DA,WE
ID_Flags -
IF_NextPC AA
INT ID_Xa
4 RF INT
MUX
ALU EX_INTD

+
MUX
IF_PC
PC IMM
Address
MEM_MEMD
SelB
IntOp 1. Precisamos de um somador adicional para calcular a
Address DATA MEM
ID_Xb subtração entre os operandos (para o caso de
IF_Instrução
MUX
Din
INST. ID_Fb instruções condicionais)
Dout
MEM SelM
MW,MLen WE,WordLen
Data WBSel 2. O somador para calculo do endereço efetivo de salto
FPOp também tem de passar para o estágio de ID
SelA
ID_Xa
3. Aumenta consideravelmente o caminho crítico do
MUX
MUX
ID_Fa
FAA
FP FP EX_FPD estágio de ID. Pode ou não levar a uma alteração de
RF Unit frequência de relógio dependendo do caminho
crítico dos restantes estágios.
FDA,FWE
ID_IMM +
MUX
MEM_JumpPC
MEM_PCSel
ID_Xa
Jsel
BRSel Branch CTRL
DA,WE
ID_Flags -
IF_NextPC AA
INT ID_Xa
4 RF INT
MUX
ALU EX_INTD

+
MUX
IF_PC
PC IMM
Address
MEM_MEMD
SelB
IntOp
Address ID_Xb
DATA MEM
IF_Instrução
MUX
Din
INST. ID_Fb
Dout
MEM SelM
MW,MLen WE,WordLen
Data WBSel
SelA instruçõesID_Xa
de
controlo no
MUX
MUX
ID_Fa
FAA
FP
estágio de ID FP EX_FPD
obriga RFà existência Unit
Delay FBA, FCA (F0-F31) ID_Fb, ID_Fc
slot #1 de apenas 1 delay
FDA,FWE slot
ID_IMM
+
MUX
MEM_JumpPC
MEM_PCSel
ID_Xa
Jsel
BRSel Branch CTRL
DA,WE
ID_Flags -
IF_NextPC AA
INT ID_Xa
4 RF INT
MUX
ALU EX_INTD

+
MUX
IF_PC
PC IMM
Address
MEM_MEMD
SelB
IntOp
Address ID_Xb
DATA MEM
IF_Instrução
MUX
Din
INST. ID_Fb
Dout
MEM SelM
MW,MLen WE,WordLen
Data WBSel
FPOp
SelA
ID_Xa
MUX
MUX
ID_Fa
FAA
FP FP EX_FPD
RF Unit
FDA,FWE
▪ Embora este esquema funcione, não é muito

intuitivo ou eficiente:
▫ Requer que o programador saiba como funciona a

arquitetura
▫ Obriga à introdução de muitos NOPs, o que reduz o

desempenho do processador
105
Resolução de conflitos por hardware
▪ Conflitos de dados (semelhante à resolução por software):

1. identificação de dependências que geram conflitos
2. Introdução de NOPs (bolhas ou stalls)
ou
Antecipação dos resultados no pipeline
3. Re-ordenação das instruções (apenas em arquiteturas avançadas – fora de contexto desta
UC)
▪ Conflitos de controlo:
1. Identificação dos conflitos de controlo (sempre após a descodificação da instrução)
2. Antecipação da resolução dos conflitos de controlo
3. Previsão do resultado da instrução
107
Identificação dos conflitos de dados
A. Verificar, durante o Operand Fetch (OF), i.e., estágio de ID, se há alguma

instrução no pipeline que escreve em algum dos registos de operando
Instrução i+1 add X13,X11,X12 Instrução i-1 Instrução i-2 Instrução i-3
Exemplo: ADD X3,X1,X2
Instrução i-3
Instrução i-2
Instrução i-1
add x13,x11,x12
Instrução i+1
Operandos:
X11,X12
Escrevem em x11 ou x12? Se sim, existe
108 um conflito
B. Se existir um conflito: (1) deixar as instruções anteriores avançar no pipeline,

(2) emitir uma bolha/NOP para o estágio de EX; (3) parar (stall) o pipeline nos
estágios de IF e ID, de forma repetir as mesmas instruções.
Ciclo k: Instrução i+1 add X13,X11,X12 Instrução i-1 Instrução i-2 Instrução i-3
Ciclo k+1: Instrução i+1 add X13,X11,X12 NOP Instrução i-1 Instrução i-2
Instrução i-3
Instrução i-2
Instrução i-1
add x13,x11,x12
Instrução i+1
109
C. (Próximo ciclo de relógio) Repetir os passos A e B.

Instrução i+1 add X13,X11,X12 NOP Instrução i-1 Instrução i-2
Instrução i-3
Instrução i-2
Instrução i-1
add x13,x11,x12
Instrução i+1
Escrevem em x11 ou x12? Se sim, existe

110 um conflito
Resolução dos conflitos por hardware
Exemplo de código
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
addi x13,x13,-1 IF ID ID ID ID EX MEM WB x13
sll x14,x13,3 IF IF IF IF ID ID ID ID EX MEM WB x14
add x10,x10,x14 IF IF IF IF ID ID ID ID EX MEM
add x12,x12,x14 ID Stalls: IF IF IF IF ID EX
lw x15,0(x10) O valor de x13 ID Stalls: IF ID
add x15,x15,x11 ainda não O valor de x13 ID Stalls: IF
sw x15,0(x12) está no ainda não O valor de x14
addi x10,x10,-8 ainda não ID Stalls:
registo está no
addi x12,x12,-8
está no O valor de x10
addi x13,x13,-1 registo ainda não
bge x13,x0,-9 registo
está no
registo
Resolve o problema para o programador, mas a arquitetura é igualmente ineficiente!
111
Resolução de conflitos de dados por hardware
▪ Solução alternativa…
FORWARDING / BYPASSING
112
ID_IMM
+
MUX
MEM_JumpPC
MEM_PCSel
ID_Xa
Jsel
BRSel Branch CTRL
DA,WE
ID_Flags -
IF_NextPC AA
INT ID_Xa
4 RF INT
MUX
ALU EX_INTD

+
MUX
IF_PC
PC IMM
Address
MEM_MEMD
SelB
IntOp
Address ID_Xb
DATA MEM
IF_Instrução
MUX
Din
INST. ID_Fb
Dout
MEM SelM
MW,MLen WE,WordLen
Data WBSel
FPOp
SelA
ID_Xa
MUX
MUX
ID_Fa
FAA
FP FP EX_FPD
RF Unit
FDA,FWE
ID_IMM
+
MUX
MEM_JumpPC
MEM_PCSel
ID_Xa
Jsel
BRSel Branch CTRL
DA,WE
IF_NextPC AA
VERSÃO SIMPLIFICADA
ID_Flags - (mesmo esquema, mas omitindo a maioria dos sinais de controlo):
INT ID_Xa
INT
4 RF
IF ID EX MEM WB
MUX
ALU EX_INTD

+
MUX
IF_PC
PC IMM
Address
MEM_MEMD
SelB
IntOp
Address ID_Xb
DATA MEM
IF_Instrução
BR CTRL
MUX
Din
ID_Fb ID_Xa WB_NextPC
INST. INT Dout
SelM INT WB_INTD
MEM RF
MW,MLen ALU
WE,WordLen
Address
WB_FPD
Data WBSel
ID_IMM
MEM/WB
EX/MEM
DECODE
DATA
ID/EX
FPOp INST IF/ID ID_Xb
PC
MEM ID_Fb
Data
MEM
SelA
ID_Xa ID_Xa
MUX
MUX
ID_Fa FP FP
FAA
FP FP EX_FPD UNIT WB_FPD
RF ID_Fb
RF Unit
FDA,FWE
Revisão dos passos de execução!
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
ori x13,x0,N IF Leitura da instrução da memória: IM[PC]
addi x13,x13,-1
sll x14,x13,3
add x10,x10,x14
add x12,x12,x14
lw x15,0(x10)
add x15,x15,x11
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,-9
115
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
ori x13,x0,N IF ID Descodificação e leitura dos operandos do RF: x130+N
addi x13,x13,-1 IF Leitura da instrução da memória : IM[PC]
sll x14,x13,3
add x10,x10,x14
add x12,x12,x14
lw x15,0(x10)
add x15,x15,x11
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,-9
116
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
ori x13,x0,N IF ID EX Soma o resultado: x13N
addi x13,x13,-1 IF ID Descodificação e leitura dos operandos do RF : x13x13? - 1
sll x14,x13,3 IF Leitura da instrução da memória : IM[PC]
add x10,x10,x14
add x12,x12,x14
lw x15,0(x10) O valor calculado pela instrução ori ainda
add x15,x15,x11 não foi escrito em x13… contudo:
sw x15,0(x12) - Esse valor já foi determinado (no estágio
addi x10,x10,-8 de EX, pela instrução ori;
addi x12,x12,-8 - O addi só precisa desse valor quando
addi x13,x13,-1 chegar ao estágio de EX de forma a
bge x13,x0,-9 realizar a operação!
Então… vamos deixar a instrução avançar...
117
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
ori x13,x0,N IF ID EX MEM -
addi x13,x13,-1 IF ID EX Subtrai…
sll x14,x13,3 IF ID x14 x13? << 2
add x10,x10,x14 IF IM[PC]
add x12,x12,x14
lw x15,0(x10) O valor de x13 ainda não está no
add x15,x15,x11 RF….
sw x15,0(x12) mas já foi calculado… corresponde
CAMINHOS DE
addi
FORWARDINGx10,x10,-8 ao sinal MEM_DALU
addi x12,x12,-8
addi x13,x13,-1 Nesse caso, porque não lemos esse
bge x13,x0,-9 valor directamente?
Na gíria de arquitetura de
computadores, este processo é
denominado de forwarding ou
bypassing.
118
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
ori x13,x0,N IF ID EX MEM WB
addi x13,x13,-1 IF ID EX MEM
sll x14,x13,3 IF ID x14 x13? << 2
add x12,x12,x14
lw x15,0(x10)
add x15,x15,x11 O mesmo caso que anteriormente…
sw x15,0(x12) vamos deixar a instrução avançar e
addi x10,x10,-8 depois vamos fazer forwarding
addi x12,x12,-8 MEM → EX.
addi x13,x13,-1
bge x13,x0,-9
119
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
ori x13,x0,N IF ID EX MEM WB Write on x13
addi x13,x13,-1 IF ID EX MEM -
sll x14,x13,3 IF ID EX LSL com forwarding de OpA
add x10,x10,x14 IF ID x10  x10 + x14?
lw x15,0(x10)
add x15,x15,x11 O mesmo caso que anteriormente…
sw x15,0(x12) vamos deixar a instrução avançar e
addi x10,x10,-8 depois vamos fazer forwarding
addi x12,x12,-8 MEM → EX.
addi x13,x13,-1
bge x13,x0,-9
120
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
addi x13,x13,-1 IF ID EX MEM WB Write on x13
sll x14,x13,3 IF ID EX MEM -
add x10,x10,x14 IF ID EX ADD com forwarding de OpB
add x12,x12,x14 IF ID x12  x12 + x14?
lw x15,0(x10) IF IM[PC]
add x15,x15,x11
sw x15,0(x12) Neste caso o valor também já foi
addi x10,x10,-8 calculado, vamos novamente deixar
addi x12,x12,-8 a instrução avançar…
addi x13,x13,-1
bge x13,x0,-9
121
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
sll x14,x13,3 IF ID EX MEM WB Write on x14
add x10,x10,x14 IF ID EX MEM -
add x12,x12,x14 IF ID EX ADD com forwarding do OpB (WB→EX)
lw x15,0(x10) IF ID x15  M[x10? + 0]
IFadd ID
x15,x15,x11 EX MEM IF WB
IM[PC]
sw x15,0(x12)
addi x10,x10,-8
addi x12,x12,-8 BR CTRL
addi x13,x13,-1
INT
ID_Xa WB_NextPC
INT MEM_INTD WB_INTD
bge x13,x0,-9
RF ALU WB_FPD
Address
MEM/ WB
EX/ MEM
ID_IMM
DECODE
ID/ EX
DATA
IF/ ID
INST ID_Xb
PC
Data
MEM ID_Fb MEM
ID_Xa
FP FP
MEM_FPD WB_FPD
RF ID_Fb UNIT
122
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
sll x14,x13,3 IF ID EX MEM WB Write on x14
add x12,x12,x14 IF ID EX ADD com forwarding do OpB (WB→EX)
lw x15,0(x10) IF ID x15  M[x10? + 0]
sw x15,0(x12)
addi x10,x10,-8
Neste caso o valor também já foi
addi x12,x12,-8
calculado, vamos novamente deixar
addi x13,x13,-1
a instrução avançar e depois fazer
bge x13,x0,-9
forwarding WB→EX
123
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
add x10,x10,x14 IF ID EX MEM WB Write on x10
lw x15,0(x10) IF ID EX ADD com forwarding do OpA (WB→EX)
add x15,x15,x11 IF ID x15  x15? + x11
sw x15,0(x12) IF IM[PC]
addi x10,x10,-8
addi x12,x12,-8 Não podemos deixar avançar, já que o valor do x15 é lido
addi x13,x13,-1 da memória no estágio de MEM, e portanto só podemos
bge x13,x0,-9 fazer forwarding no estágio de WB, i.e., WB→EX.
Assim, vamos ter de introduzir um stall ao pipeline!
Nota: teoricamente poderíamos aplicar forwarding do final do

MEM para o ID ou EX, contudo isto leva a um caminho crítico
proibitivo, pelo que não se usa.
124
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
add x12,x12,x14 IF ID EX MEM WB
lw x15,0(x10) IF ID EX MEM
add x15,x15,x11 IF ID ID
sw x15,0(x12) IF IF
addi x10,x10,-8
addi x12,x12,-8 Stall
addi x13,x13,-1 Agora já podemos deixar a instrução
bge x13,x0,-9 avançar!
125
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
lw x15,0(x10) IF ID EX MEM WB
add x15,x15,x11 IF ID ID EX
sw x15,0(x12) IF IF ID
addi x10,x10,-8 IF
addi x12,x12,-8
addi x13,x13,-1
bge x13,x0,-9 Conflito em x15: deixamos avançar o
pipeline e fazemos forwarding
(MEM→EX)
126
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
add x15,x15,x11 IF ID ID EX MEM WB x15
sw x15,0(x12) IF IF ID EX MEM WB
addi x10,x10,-8 IF ID EX MEM
addi x12,x12,-8 IF ID EX
addi x13,x13,-1 IF ID
bge x13,x0,-9
127
Resolução dos O valor do operando x13 já está a ser calculado
e está disponível no ciclo seguinte… podemos
conflitos por fazer forwarding MEM→EX
hardware
Dependências para Ciclo n: add mul

a instrução anterior Ciclo n+1: add mul
(k-1)
CAMINHOS DE
mul x13,X11,x12 FORWARDING
add x14,x13,x15
128
Resolução dos Não é possível fazer forwarding porque o valor
conflitos por só vai ser calculado no estágio de MEM ➔ Stall
hardware
Dependências para Ciclo n: add lw

a instrução de load Ciclo n+1: add nop lw
anterior (k-1)
CAMINHOS DE
lw x13,0(x11) FORWARDING
add x14,x13,x15
LOAD: única dependência de

dados que NÃO conseguimos
resolver com forwarding
129
Resolução dos O valor do operando x13 já está calculado e
está disponível no ciclo seguinte… podemos
conflitos por fazer forwarding WB→EX
hardware
Dependências para Ciclo n: add ? lw

a instrução k-2 Ciclo n+1: add ? lw
CAMINHOS DE
Instrução
add x14,x13,x15
130
De forma equivalente é necessário acrescentar caminhos de
forwarding para o store.
Como a entrada de dados da memória pode receber um valor do

Resolução dos datapath de inteiros ou de floating-point, o multiplixer
conflitos por correspondente recebe todos os caminhos.
hardware
Dependências para Ciclo n: sw ? lw

a instrução k-2 Ciclo n+1: sw ? lw
CAMINHOS DE
Instrução
sw x13,0(x2)
131
O valor do operando x13 já está no
processo de escrita, pelo que não é
Resolução dos possível fazer forwarding para o EX.
Alternativa: implementar um banco de
conflitos por registos transparente
hardware
Dependências para Ciclo n: add ? ? lw

a instrução k-3 Ciclo n+1: add ? ?
CAMINHOS DE
Instrução
Instrução
add x14,x13,x15
132
Na prática um banco de registos transparente
aplica um processo de forwarding entre a
Resolução dos entrada e a saída, i.e., fazendo bypass aos
registos.
conflitos por
hardware
Dependências para
a instrução k-3
lw x13,0(x11)
x31 x30 x29 x2 x1
Instrução
Instrução
add x14,x13,x15
133
▪ Alternativa:
▫ Em processadores simples (como este), o caminho crítico do estágio de WB
é mais curto que o dos outros estágios
Resolução dos ▫ Podemos realizar a escrita (WB) em meio-ciclo, i.e., se a escrita nos flip-flops
conflitos por é ativada no flanco ascendente, então a escrita nos bancos de registos é
realizada no flanco descendente.
hardware Nota: Nem sempre o caminho crítico no WB é suficientemente curto para implementar
esta técnica
Dependências para
a instrução k-3 CLK
IF ID EX MEM WB
lw x13,0(x11)
BR CTRL
Instrução ID_Xa WB_NextPC
INT INT MEM_INTD WB_INTD
Instrução RF ALU WB_FPD
Address
add x14,x13,x15 ID_IMM
MEM/WB
EX/MEM
DECODE
DATA
ID/EX
CLK
INST
IF/ID
ID_Xb
PC
MEM ID_Fb
Data
MEM
ID_Xa
FP FP
MEM_FPD
RF ID_Fb UNIT WB_FPD
134
Resolução dos conflitos de dados por hardware
Impacto na frequência de operação
▪ Em geral os caminhos de forwarding encontram-se no caminho crítico

(geralmente corresponde à unidade de execução, já que o acesso à memória é feito através de uma memória cache
de acesso rápido – ver módulo seguinte)
▫ Dá origem a uma ligeira redução da frequência máxima de operação
IF ID EX MEM WB
ID_Xa
BR CTRL WB_NextPC
RF ALU WB_FPD
Address
ID_IMM
MEM/WB
EX/MEM
DECODE
DATA
ID/EX
INST
IF/ID
ID_Xb
PC
MEM ID_Fb
Data
MEM
ID_Xa
FP FP
MEM_FPD
135
▪ Controlo dos multiplexers de forwarding do estágio de
EX (sinais produzidos durante o estágio de ID):
Resolução dos - Sinal 0x (no forwarding) se não existir uma dependência entre o operando e
um dos resultados que se encontra no pipeline
conflitos por - Sinal 10 (forwarding MEM→EX) se existir uma instrução no estágio de EX que
hardware -
gera o valor do operando pretendido
Sinal 11 (forwarding WB→EX) se existir uma instrução no estágio de MEM que
gera o valor do operando pretendido, e a instrução no estádio de EX não
Sinais de controlo escreve no registo pretendido
SelForwA[1] = ID_AA!=0 && (

(ID_AA==EX_DA && EX_WE==1) ||
(ID_AA==MEM_DA && MEM_WE==1)
)
SelForwA[0] = (ID_AA==MEM_DA && MEM_WE==1) &&

!(ID_AA==EX_DA && EX_WE==1)
136
▪ Controlo dos multiplexers de forwarding do estágio de
EX (sinais produzidos durante o estágio de ID):
Resolução dos - Sinal 0x (no forwarding) se não existir uma dependência entre o operando e
um dos resultados que se encontra no pipeline
conflitos por - Sinal 10 (forwarding MEM→EX) se existir uma instrução no estágio de EX que
hardware -
gera o valor do operando pretendido
Sinal 11 (forwarding WB→EX) se existir uma instrução no estágio de MEM que
gera o valor do operando pretendido, e a instrução no estádio de EX não
Sinais de controlo escreve no registo pretendido
SelForwB[1] = ID_BA!=0 && ID_SelB==0 && (

(ID_BA==EX_DA && EX_WE==1) ||
(ID_BA==MEM_DA && MEM_WE==1)
)
SelForwB[0] = (ID_BA==MEM_DA && MEM_WE==1) &&

!(ID_BA==EX_DA && EX_WE==1)
137
LOAD: única dependência de
Resolução dos dados que NÃO conseguimos
conflitos por v f w → STALL
hardware
Dependências para Ciclo n: add lw

a instrução de load Ciclo n+1: add nop lw
anterior (k-1)
CAMINHOS DE
add x14,x13,x15
138
▪ Indicação de STALL por dependência de dados:
Existe uma dependência do operando A ou do operando B por uma
Resolução dos instrução no estágio de EX que corresponde a um load
conflitos por
hardware STALL = (ID_AA!=0 &&
Sinais de controlo (ID_AA==EX_DA && EX_WE==1 && EX_WBSel==MEM) ) ||

(ID_BA!=0 && ID_SelB==0 &&
(ID_BA==EX_DA && EX_WE==1 && EX_WBSel ==MEM) )
ID_Xa
BR CTRL WB_NextPC
RF ALU WB_FPD
Address
ID_IMM
MEM/WB
EX/MEM
DECODE
DATA
ID/EX
INST
IF/ID
ID_Xb
PC
MEM ID_Fb
Data
MEM
ID_Xa
FP FP
MEM_FPD
139
Resolução de conflitos por hardware (resumo)
▪ Conflitos de dados (semelhante à resolução por software):

1. identificação de dependências que geram conflitos
2. Introdução de NOPs (bolhas ou stalls)
ou
Antecipação dos resultados no pipeline (forwarding)
3. Re-ordenação das instruções por hardware (apenas em arquitecturas avançadas – fora do
contexto de ACOMP)
140
Resolução de conflitos de controlo por hardware
▪ Solução alternativa…
EXECUÇÃO ESPECULATIVA
(escolhe uma opção, preferencialmente a correta, e corrige
se necessário)
141
Execução especulativa
Predição de salto
▪ Realização da predição de salto:

▫ É necessário saber se a instrução no IF é um branch, para prever o próximo PC
▫ Mas a descodificação só é realizada no ID!
▫ Sem outra informação, a única hipótese é admitir sempre que a instrução que
entra no IF não é um branch
➔ STATIC BRANCH PREDICTION: PREDICT NOT TAKEN
Os preditores mais avançados, A previsão “Predict Taken”, em geral, só é

tipicamente encontrados na possível com esquemas dinâmicos, já
generalidade dos PCs, tablets ou que requer o conhecimento da existência
telemóveis, usam um esquema dinâmico de uma instrução de salto no estágio de
que tem em conta não só o histórico de IF, como ainda saber qual o destino de
cada instrução de controlo salto
(jump/branch), como também a
142 correlação entre instruções de controlo
Arquitetura Pipeline (versão simplificada)
Implementação
do Branch, no
estágio MEM
IF ID EX MEM WB
ID_Xa
BR CTRL WB_NextPC
RF ALU WB_FPD
Address
ID_IMM
MEM/WB
EX/MEM
DECODE
DATA
ID/EX
INST
IF/ID
ID_Xb
PC
MEM ID_Fb
Data
MEM
ID_Xa
FP FP
MEM_FPD
143
Resolução dos conflitos de controlo por hardware
Aplicação de um preditor de salto estático do tipo Not Taken
Ciclo de relógio: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
lw x15,0(x10) IF ID EX MEM WB x15 IF ID
add x15,x15,x11 IF ID ID EX MEM WB x15 IF
sw x15,0(x12) IF IF ID EX MEM WB x15
Instrução k+1 IF ID EX Eliminada
Instrução k+2 IF ID Eliminada
Instrução k+3 IF Eliminada
Obriga a invalidar 3 instruções a seguir ao branch!

144
Eliminação de instruções inválidas (miss-speculation)
▪ INVALIDATE ➔ transforma a instrução carregada nos registos de pipeline num NOP, colocando
todos os enables de escrita (WE) a 0.
▫ Na prática funciona de forma semelhante a um sinal de reset, mas atuando apenas nos bits de enable de escrita
(inclui a indicação de que a instrução não é um branch).
IF ID EX MEM WB
CORRECT_PC
INVALIDATE
ID_Xa
BR CTRL WB_NextPC
RF ALU WB_FPD
Address
ID_IMM
MEM/WB
EX/MEM
DECODE
DATA
ID/EX
INST
IF/ID
ID_Xb
PC
MEM ID_Fb
Data
MEM
ID_Xa
FP FP
MEM_FPD
145
Eliminação de instruções inválidas (miss-speculation)
▪ INVALIDATE ➔ transforma a instrução carregada no registo de pipeline num NOP, colocando

todos os enables de escrita a 0.
▫ Na prática funciona de forma semelhante a um sinal de reset, mas atuando apenas nos bits de enable de escrita
(inclui a indicação que a instrução não é um branch).
▪ O impacto de uma predição errada é grande: perdemos 3 instruções!

▫ Alternativa: tentar antecipar a unidade de controlo de salto para um estágio anterior (EX ou mesmo ID), mesmo que à
custa de um aumento do caminho crítico do processador
146
Redução do impacto de uma predição de salto errada
Antecipação da unidade de controlo

de salto do estágio de MEM para o
estágio de EX
147
▪ Mover a unidade de controlo de salto para o estágio de EX permite reduzir o

impacto de uma predição errada para 2 ciclos.
IF ID EX MEM WB
CORRECT_PC
INVALIDATE
BR CTRL
ID_Xa WB_NextPC
RF ALU WB_FPD
Address
ID_IMM
MEM/WB
EX/MEM
DECODE
DATA
ID/EX
INST
IF/ID
ID_Xb
PC
MEM ID_Fb
Data
MEM
ID_Xa
FP FP
MEM_FPD
148
Conflitos de dados e caminhos de forwarding adicionais?
▪ As instruções de branch (beq, bne, blt, bge, …) consomem as flags

normalmente…
beq x5,x6,label IF ID EX MEM WB
mas aumentam o caminho crítico: forwarding + ALU + BR CTRL + PC
149
▪ As instruções de branch consomem as flags normalmente…

▫ Será maior que o caminho crítico da FP ALU?
IF ID EX MEM WB
CORRECT_PC
INVALIDATE
BR CTRL
ID_Xa WB_NextPC
RF ALU WB_FPD
Address
ID_IMM
MEM/WB
EX/MEM
DECODE
INST
ID/EX DATA
IF/ID
ID_Xb
PC
MEM ID_Fb
Data
MEM
ID_Xa
FP FP
MEM_FPD
150
▪ As instruções de branch consomem as flags normalmente…

▫ Será maior que o caminho crítico da FP ALU?
IF ID EX MEM WB
CORRECT_PC
INVALIDATE
BR CTRL
ID_Xa WB_NextPC
RF ALU WB_FPD
Address
ID_IMM
MEM/WB
EX/MEM
DECODE
INST
ID/EX DATA
IF/ID
ID_Xb
PC
MEM ID_Fb
Data
MEM
ID_Xa
FP FP
MEM_FPD
151
Antecipação da unidade de controlo

de salto do estágio de MEM para o
estágio de ID
152
▪ Mover a unidade de controlo de salto para o estágio de ID permite reduzir o

impacto de uma predição errada para 1 ciclo.
IF ID EX MEM WB
CORRECT_PC
INVALIDATE
BR
CTRL
ID_Xa WB_NextPC
RF ALU WB_FPD
Address
ID_IMM
MEM/WB
EX/MEM
DECODE
DATA
ID/EX
INST
IF/ID
ID_Xb
PC
MEM ID_Fb
Data
MEM
ID_Xa
FP FP
MEM_FPD
153
▪ As instruções de branch (beq, bne, blt, …) requerem a existência de um

comparador/subtrator no estágio de ID…
154
▪ As instruções de branch (beq, bne, blt, …) requerem a existência de um

comparador no estágio de ID…
IF ID EX MEM WB
CORRECT_PC BR CTRL
INVALIDATE
SUB
WB_NextPC
INT ID_Xa INT MEM_INTD WB_INTD
RF ALU WB_FPD
Address
ID_IMM
MEM/WB
EX/MEM
DECODE
DATA
ID/EX
INST
IF/ID
ID_Xb
PC
MEM ID_Fb
Data
MEM
ID_Xa
FP FP
MEM_FPD
155

▪ E o que acontece se o valor de x5 ou x6 ainda não estiver disponível?
▪ Soluções…
▫ Adicionar ainda mais caminhos de forwarding?
Maior caminho crítico  / Mais prático para o programador ☺
156
▪ Mover a unidade de controlo de salto para o estágio de ID pode aumentar

significativamente o caminho crítico
IF ID EX MEM WB
CORRECT_PC BR CTRL
INVALIDATE
SUB
WB_NextPC
INT ID_Xa INT MEM_INTD WB_INTD
RF ALU WB_FPD
Address
ID_IMM
MEM/WB
EX/MEM
DECODE
DATA
ID/EX
INST
IF/ID
ID_Xb
PC
MEM ID_Fb
Data
MEM
ID_Xa
FP FP
MEM_FPD
157

▪ Soluções…
▫ Indicar que as instruções de branch não podem ser usadas quando os registos dependentes
(x5,x6) forem produzidos por uma instrução recente….
Menor caminho crítico ☺ / Menos hardware ☺ / Obriga o programador a conhecer os detalhes da arquitectura 
158

▪ Soluções…
▫ Indicar que as instruções de branch não podem ser usadas quando os registos dependentes
(x5,x6) forem produzidos por uma instrução recente….
Menor caminho crítico ☺ / Menos hardware ☺ / Obriga o programador a conhecer os detalhes da arquitectura 
▫ Fazer stall quando ocorrer um conflito de dados
Caminho crítico inalterado ☺ / Pouco hardware adicional ☺ / Prático para o programador ☺ / Leva a ocorrência de stalls que
podem ser limitados se o programador (ou o compilador) conhecer a arquitetura.
159
Soluções típicas
Processadores simples/low-power
➔Unidade de controlo de salto no estágio de ID
Processadores de elevado desempenho

(PCs, tablets, telemóveis, servidores, etc.)
➔Unidade de controlo de salto no estágio de EX
➔Utilização de técnicas de predição dinâmica de salto
160
Predição dinâmica de salto
▪ BRANCH PREDICT: tabela com o histórico da resolução dos branches

Para cada branch, guarda a predição do salto (taken/not taken) e o endereço de destino (se taken)
IF ID EX MEM WB
CORRECT_PC
INVALIDATE
BR CTRL
BRANCH
PREDICT ID_Xa WB_NextPC
RF ALU WB_FPD
Address
ID_IMM
MEM/WB
EX/MEM
DECODE
INST
ID/EX DATA
IF/ID
ID_Xb
PC
MEM ID_Fb
Data
MEM
ID_Xa
FP FP
MEM_FPD
161

▪ A forma mais simples de predição de salto é realizado com 1 bit (BPB):

Branch not taken
Branch BPB=1 BPB=0 Branch

taken not taken
(Predict Taken) (Predict Not Taken)
Branch taken
▪ Sempre que o resultado do salto for not taken, colocar a predição em BPB=0
▪ Sempre que o resultado do salto for taken, colocar a predição em BPB=1
162

▪ Mas pode ser realizado com mais bits, p. ex., 2 bits:

Branch not taken
Strong Predict Weak Predict

Taken Taken
PREDICT Branch
Branch taken not taken
TAKEN
PREDICT Branch
NOT TAKEN taken
Branch taken
Branch Strong predict Weak Predict
not taken Not Taken Not Taken
163 Branch not taken

Interrupções e exceções
Atendimento de interrupções e
exceções
164
Atendimento de interrupções e exceções
▪ As exceções podem ser:

▫ Recuperáveis: a existência de uma exceção não impede que o programa
continue a executar (ex: FP overflow)
▫ Não recuperáveis: a existência da exceção obriga a que o programa termine a
execução (ex: invalid/illegal instruction)
▪ As interrupções causadas por eventos externos são, em geral,

sempre recuperáveis
165
▪ Do ponto de vista da arquitetura do processador, uma exceção/interrupção

é vista com outra forma de controlo:
▫ Os mecanismos de resolução são, em geral, bastante semelhantes aos de uma predição
errada de um salto
▪ Contudo…
▫ As exceções podem ocorrer em pontos diferentes do pipeline
▫ Podem ocorrer múltiplas exceções e interrupções ao mesmo tempo ou fora de ordem
Page Illegal FP divide Page

ecall
Fault Instruct. by zero Fault
External
interrupt
166
▪ O atendimento da exceção obriga a anular a execução de todas as

instruções após a exceção.
▪ Passos para o tratamento de uma interrupção/exceção:
1. Guardar o valor do PC que gera a exceção:
SEPC  NextPC
Revisão do
2. Saltar para o inicio da rotina de tratamento de interrupções: capítulo 3
PC  STVEC
SSTATUS[SPIE]  SSTATUS[GIE]
SSTATUS[GIE]  0
SCAUSE  higher priority from SIP
SIP[selected]  0
3. Anular todas as instruções no pipeline entre a instrução que gera a exceção e a instrução de
inicio da rotina de tratamento de interrupções/excepções
167
3. Anular todas as instruções no pipeline entre a instrução que gera a exceção e a

instrução de inicio da rotina de tratamento de interrupções/excepções
Ciclo de relógio: k k+1 k+2 k+3 k+4 k+5 k+6 k+7 k+8 …
lw x7,0(x2) IF ID EX MEM WB
Instrução k+1 IF ID EX Anulada…
Instrução k+2 IF ID Anulada…
Instrução k+3 IF Anulada…
1ª instr. da rotina interrupção/excepção IF ID EX MEM WB
168
Arquiteturas de elevado
desempenho
Arquiteturas de elevado desempenho
Arquiteturas superescalares
▪ As arquiteturas modernas permitem fazer fetch

simultâneo de múltiplas instruções (ex: 2)
▪ A execução das instruções

é escalonada para
diferentes unidades
funcionais (se não houver
conflitos irresolúveis)
ARM CORTEX A7 Pipeline
▪ Dependendo da instrução, podem haver
pipelines mais ou menos profundos
170
Arquiteturas superescalares com execução fora de ordem
▪ As instruções são
lidas da memória
e colocadas em
buffers
(Reservation
stations)
▪ Quando todos os
conflitos
estiverem
resolvidos, são
executadas
171
Arquiteturas superescalares com execução fora de ordem
ARM CORTEX A73 Pipeline
172
Intel pipeline
Arquiteturas de
elevado
desempenho
Arquiteturas
superescalares com
execução fora de
ordem
173

Modulo 7 - Pipeline

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Modulo 7 - Pipeline

Enviado por

Direitos autorais:

Formatos disponíveis

Arquitetura do processador

Cap. 4: “The Processor”

Tipo de instruções Mnemónicas

Jsel, BRSel Jsel,BRSel JSel BRSel

Jsel, BRSel Jsel,BRSel JSel BRSel

Jsel, BRSel Jsel,BRSel JSel BRSel

▫ Os sinais que controlam a escrita em registos (incluindo PC) nunca são

▫ É mais fácil determinar o valor dos sinais de controlo, percorrendo a

▪ O desempenho do processador, d, é uma medida inversamente

▪ Exemplos de medidas de desempenho:

▪ O desempenho do processador, d, é uma medida inversamente

▪ O desempenho do processador depende da frequência de relógio!

▪ A frequência de relógio (fCLK) é limitada pelo caminho crítico:

▪ Para a determinação do caminho crítico, vamos admitir que:

Instruction Instruction Execute Memory Access Write Back

Jsel, BRSel Jsel,BRSel JSel BRSel

Instruction Instruction Execute Memory Access Write Back

Jsel, BRSel Jsel,BRSel JSel BRSel

Instruction Instruction Execute Memory Access Write Back

Jsel, BRSel Jsel,BRSel JSel BRSel

Instruction Instruction Execute Memory Access Write Back

Jsel, BRSel Jsel,BRSel JSel BRSel

▪ Para o processador em questão, o caminho crítico deverá passar

2. Descodificação da instrução e leitura dos operandos (ID)

3. Cálculo do endereço efectivo (EX)

4. Leitura dos dados da memória (MEM)

5. Escrita do resultado num dos bancos de registos (WB)

▪ Dá origem a caminhos críticos demasiado longos (frequência de

▪ Consideremos que temos de limpar várias tulhas de roupa suja. Cada

▪ Assumindo que iniciamos a actividade às 18h e que cada uma destas

▪ Assumindo que iniciamos a actividade às 18h e que cada uma destas

Não conseguimos fazer

▪ Porque não fazemos várias actividades em simultâneo?

▪ Porque não fazemos várias actividades em simultâneo?

▪ Em geral, a forma de melhorar o desempenho de processadores

▫ Paralelismo ao nível da instrução…

▪ Em geral, a forma de melhorar o desempenho de processadores

▫ Paralelismo ao nível da instrução…

Já que identificámos 5 fases na execução de uma instrução (IF,ID,EX,MEM,WB), porque

1. Introdução de registos de Registos entre estágios do

→ Período de relógio menor

→ Maior frequência de relógio

MUX BA (R0-R31) ID_Xb

1. Introdução de registos de pipeline entre estágios do processador

IF_NextPC AA ID_Xa Branch

MUX BA (R0-R31) ID_Xb

ID_NextPC ID_Xa EX_NextPC

MUX BA (R0-R31) ID_Xb

1. Introdução de registos de pipeline entre estágios do processador

2. Os sinais devem atravessar os registos de pipeline

3. O estágio de IF, por omissão, “incrementa” sempre o PC (soma 4),

1. Introdução de registos de pipeline entre estágios do processador

MUX BA (R0-R31) ID_Xb

▪ Para facilitar a leitura, vamos simplificar a figura, e executar um

(ID) 1Ch:ori x13,x0,8 ori x13,x0,8

(IF) 20h:lw x14,0(x10) lw x14,0(x10)

(IF) 24h: lw x15,8(x10) lw x15,8(x10)

(MEM) 20h: lw x14,0(x10) lw x14,0(x10)

(EX) 24h: lw x15,8(x10) lw x15,8(x10)

Latência (latency): cada instrução demora 5 ciclos de relógio a executar

Latência (latency): cada instrução demora 5 ciclos de relógio a executar

Arquitetura de Ciclo Único Arquitetura Pipeline (S=5 estágios)

#Ciclos para executar N instruções: N #Ciclos para executar N instruções: N + (S-1)

Arquitetura de Ciclo Único Arquitetura Pipeline (S=5 estágios)