Pipelining: Visão Geral e Comparação com Monociclo e Multiciclo

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Aula 4: Pipelining (parte 1 – Visão Geral)
Professor: Leandro Marzulo
Arquiteturas Avançadas de Computadores
Analogia com uma lavanderia 
2
Tempo
7
6
 
P
M
8
9
1
0
1
1
1
2
1
2
 
A
M
A
B
C
D
Ordem das
Tarefas
7
6
 
P
M
8
9
1
0
1
1
1
2
1
2
 
A
M
A
B
C
D
Tempo
Ordem das
Tarefas
 4 Operações  lavar, secar, passar e dobrar
 Tempo gasto em 1 operação  30 min
Sem pipeline:
 Tempo para completar 1 carga de roupa  2h
 Tempo para completar 4 cargas  4*2 = 8h
Com pipeline:
 Tempo para completar 1 carga de roupa  2h
 Tempo para completar 4 cargas  2h + 3*0,5h = 3,5h (tempo de 1 carga + 30 minutos para terminar cada carga subsequente)0
O paradoxo do pipeline
Paradoxo
1 carga leva o mesmo tempo pra terminar com ou sem pipeline.
As 4 cargas terminam mais rápido.
Motivo
A vazão do sistema (throughput) é maior.
Após o término da primeira carga, temos uma carga pronta a cada 30 minutos!
Para muitas cargas, o tempo para encher o pipe (terminar a primeira carga) e para esvaziar (quando não entram mais cargas) podem ser desconsiderados e, se o tempo das etapas for balanceado, o ganho (speedup) será proporcional ao número de etapas (4 etapas = 4 vezes mais rápido).
Se uma carga não necessita ser passada, nada será feito nesta etapa, gerando 30 minutos de ociosidade, pois é preciso aguardar que a carga anterior seja dobrada para que possamos dobrar esta carga (todas as cargas passam por todos os estágios). 
3
Pipeline Clássico do MIPS
5 etapas:
Buscar instrução na memória.
Ler registradores enquanto a instrução é decodificada.
Executar a operação ou calcular um endereço.
Acessar a memória de dados.
Escrever o resultado em um registrador
4
Comparação Monociclo x Multiciclo x Pipeline
Tabela com tempos gastos nas principais unidades funcionais:
Monociclo  tempo do ciclo = tempo total da instrução mais longa (800 ps)
Multicliclo  tempo do ciclo = tempo da etapa mais longa (200 ps). Instruções executam somente etapas necessárias (número de ciclos variável entre 5 e 3)
Pipeline  tempo do ciclo = tempo da etapa mais longa (200 ps). Instruções executam todas as etapas, até mesmo as desnecessárias (número de ciclos fixo = 5)
Pergunta: 200ps é um tempo de ciclo compatível com o que vemos nos processadores atuais? 
Dica 1: Frequência = 1 / Tempo do ciclo
Dica 2: A frequência de operação dos processadores atuais está em torno de 3GHz
5
Classe de Instrução
Busca
Leitura noBR
ALU
Mem
Escrita no BR
Total
LoadWord (lw)
200ps
100ps
200ps
200ps
100ps
800ps
StoreWord(sw)
200ps
100ps
200ps
200ps
700ps
Formato R (add, sub)
200ps
100ps
200ps
100ps
600ps
Branch(beq)
200ps
100ps
200ps
500ps
6
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
800 ps
 
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
800 ps
 
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
 
800 ps
 
T
i
m
e
lw $s1, 100($s0)
lw $s2, 200($s0)
lw $s3, 300($s0)
200
400
600
800
1000
1200
1400
1600
1800
.
.
.
P
r
o
g
r
a
m
e
x
e
c
u
t
i
o
n
o
r
d
e
r
(
i
n
 
i
n
s
t
r
u
c
t
i
o
n
s
)
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
T
i
m
e
200 ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200 ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200 ps
200 ps
200 ps
200 ps
200 ps
P
r
o
g
r
a
m
e
x
e
c
u
t
i
o
n
o
r
d
e
r
(
i
n
 
i
n
s
t
r
u
c
t
i
o
n
s
)
Monociclo
Pipelined
200
400
600
800
1000
1200
1400
1000 ps
 
T
i
m
e
200
400
600
800
1000
1200
1400
1600
1800
.
.
.
P
r
o
g
r
a
m
e
x
e
c
u
t
i
o
n
o
r
d
e
r
(
i
n
 
i
n
s
t
r
u
c
t
i
o
n
s
)
Multiciclo
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
2000
2200
1000 ps
 
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
 
1000 ps
 
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
Tempo total (monociclo)  2400ps
Tempo total (multiciclo)  3000ps
Tempo total (pipelined  1400ps
lw $s1, 100($s0)
lw $s2, 200($s0)
lw $s3, 300($s0)
lw $s1, 100($s0)
lw $s2, 200($s0)
lw $s3, 300($s0)
7
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
800 ps
 
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
800 ps
 
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
 
800 ps
 
T
i
m
e
sub $s4, $s6, $s5 
add $s1, $s2, $s3 
beq $s6, $s5 label
200
400
600
800
1000
1200
1400
1600
1800
.
.
.
P
r
o
g
r
a
m
e
x
e
c
u
t
i
o
n
o
r
d
e
r
(
i
n
 
i
n
s
t
r
u
c
t
i
o
n
s
)
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
T
i
m
e
200 ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200 ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200 ps
200 ps
200 ps
200 ps
200 ps
P
r
o
g
r
a
m
e
x
e
c
u
t
i
o
n
o
r
d
e
r
(
i
n
 
i
n
s
t
r
u
c
t
i
o
n
s
)
Monociclo
Pipelined
200
400
600
800
1000
1200
1400
T
i
m
e
200
400
600
800
1000
1200
1400
1600
1800
P
r
o
g
r
a
m
e
x
e
c
u
t
i
o
n
o
r
d
e
r
(
i
n
 
i
n
s
t
r
u
c
t
i
o
n
s
)
Multiciclo
2000
2200
800 ps
 
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
 
600 ps
 
Tempo total (monociclo)  2400ps
Tempo total (multiciclo)  2200ps
Tempo total (pipelined  1400ps
sub $s4, $s6, $s5 
add $s1, $s2, $s3 
beq $s6, $s5 label
sub $s4, $s6, $s5 
add $s1, $s2, $s3 
beq $s6, $s5 label
R
e
g
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
800 ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
R
e
g
Comparação Monociclo x Multiciclo x Pipeline
1 milhão de instruções
Pior caso – Somente Loads
Tempo Monociclo = 1000000 * 800 ps = 800000000 ps = 8 * 108ps = 8 * 108 * 10-12s = 8 * 10-4s = 0,8ms
Tempo Multiciclo= 1000000 * 1000 ps = 1000000000 ps = 109ps = 109 * 10-12s = 10-3s = 1ms
Tempo Pipeline= 800ps + 1000000 * 200 ps = 200000800 ps ≈ 2 *108ps ≈ 2 * 108 * 10-12s ≈ 2 * 10-4s ≈ 0,2ms
Melhor caso – Somente Branches
Tempo Monociclo = 1000000 * 800 ps = 800000000 ps = 8 * 108ps = 8 * 108 * 10-12s = 8 * 10-4s = 0,8ms
Tempo Multiciclo= 1000000 * 600 ps = 600000000 ps = 6* 108ps = 6 * 108 * 10-12s = 6 * 10-4s = 0,6ms
Tempo Pipeline= 800ps + 1000000 * 200 ps = 200000800 ps ≈ 2 *108ps ≈ 2 * 108 * 10-12s ≈ 2 * 10-4s ≈ 0,2ms  Não é verdade, pois temos dependências!
8
O que torna a implementação do pipeline mais fácil no MIPS
Todas as instruções possuem o mesmo tamanho
Os estágios de busca e decodificação são similares para todas as instruções
Poucos formatos de instrução
Simplifica a decodificação de instruções e possibilita que isto seja feito em apenas 1 estágio
Operandos de memória aparecem apenas em operações de load/store (arquitetura registrador-registrador)
No máximo 1 acesso à memória de dados é feito em 1 instrução e isso é feito em 1 estágio localizado mais ao final do pipe.
Operandos alinhados em memória
Uma instrução de transferência de dados requer apenas um estágio de acesso à memória
OBS: O pipeline de maquinas CISC precisa muitas vezes de múltiplas leituras na memória de instruções, pois as instruções possuem tamanho variável e são, muitas vezes longas (são carregadas e decodificadas em partes).
9
Hazards (Perigos)
Situações onde a próxima instrução não pode executar alguma de suas etapas no ciclo seguinte.
Existem 3 tipos:
Hazards estruturais
Hazards de dados
Hazards de controle
Quando existe um hazard não resolvido, é inserida uma bolha no pipe (sinônimo: stall no pipe). Um stall significa que não será admitida mais uma instrução no ciclo seguinte e que todas as instruções anteriores ao ponto do hazard terão que permanecer no estágio corrente até que a unidade funcional causadora do hazard seja liberada.
10
Hazards estruturais
O hardware não pode admitir a combinação de instruções que queremos executar. Exemplo: Lavadora/Secadora em uma só máquina).
Solução: replicar unidades funcionais para eliminar o conflito e permitir execução simultânea.
Como decidir se vale a pena replicar ou não? 
Quanto custa replicar?
Mais unidades funcionais tornam o projeto mais caro.
Mais unidades funcionais podem alterar o caminho crítico do projeto e, portanto, o tempo do ciclo.
Qual a frequência da ocorrência dos hazards estruturais daquele tipo?
O processo de avaliação é o mesmo para resolver outros tipos de hazards
11
Hazards estruturais - Exemplo
LW – Memória com apenas 1 porta de leitura
Não posso carregar uma instrução enquanto uma instrução de load faz a leitura da memória
200
400
600
800
1
000
1
200
1
400
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
T
i
m
e
lw $s1, 100(($t0)
lw $s2, 200($t0)
lw $s3, 300($t0)
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
P
r
o
g
r
a
m
e
x
e
c
u
t
i
o
n
o
r
d
e
r
(
i
n
 
i
n
s
t
r
u
c
t
i
o
n
s
)
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
lw $s4, 400($t0)
1
600
1
800
200ps
lw $s5, 500($t0)
200ps
 
200ps
200ps
 
200ps
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
2
000
12
Hazards estruturais - Exemplo
LW – Memória com apenas 1 porta de leitura
Inserimos uma bolha mas passamos a ter problema com o load seguinte.
200
400
600
800
1
000
1
200
1
400
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
T
i
m
e
lw $s1, 100($t0)
lw $s2, 200($t0)
lw $s3, 300($t0)
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
P
r
o
g
r
a
m
e
x
e
c
u
t
i
o
n
o
r
d
e
r
(
i
n
 
i
n
s
t
r
u
c
t
i
o
n
s
)
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
lw $s4, 400($t0)
1
600
1
800
bolha
200ps
200ps
 
lw $s5, 500($t0)
200ps
 
200ps
200ps
 
200ps
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
2
000
bolha
bolha
bolha
bolha
13
Hazards estruturais - Exemplo
LW – Memória com apenas 1 porta de leitura
Precisamos de 3 bolhas
200
400
600
800
1
000
1
200
1
400
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
T
i
m
e
lw $s1, 100($t0)
lw $s2, 200($t0)
lw $s3, 300($t0)
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
P
r
o
g
r
a
m
e
x
e
c
u
t
i
o
n
o
r
d
e
r
(
i
n
 
i
n
s
t
r
u
c
t
i
o
n
s
)
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
lw $s4, 400($t0)
1
600
1
800
bolha
200ps
200ps
 
lw $s5, 500($t0)
200ps
 
200ps
200ps
 
200ps
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
2
000
bolha
bolha
bolha
bolha
14
bolha
200ps
bolha
bolha
bolha
bolha
bolha
200ps
bolha
bolha
bolha
bolha
Hazards estruturais - Exemplo
LW – Memória com apenas 1 porta de leitura
Se fossem outras instruções precisamos de menos bolhas
200
400
600
800
1
000
1
200
1
400
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
T
i
m
e
lw $s1, 100($t0)
lw $s2, 200($t0)
add $t1, $t2, $t3
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
P
r
o
g
r
a
m
e
x
e
c
u
t
i
o
n
o
r
d
e
r
(
i
n
 
i
n
s
t
r
u
c
t
i
o
n
s
)
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
sub $t4, $t5, $t6
1
600
1
800
bolha
200ps
200ps
 
lw $s5, 500($t0)
200ps
 
200ps
200ps
 
200ps
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
2
000
bolha
bolha
bolha
bolha
15
Hazards estruturais - Exemplo
LW – Memória com apenas 1 porta de leitura
Solução: Duas portas de leitura na memória, 1 para instruções e outra para dados, exatamente como no projeto monociclo.
16
200
400
600
800
1
000
1
200
1
400
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
T
i
m
e
lw $s1 100(0)
lw $s2 200(0)
lw $s3 300(0)
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
P
r
o
g
r
a
m
e
x
e
c
u
t
i
o
n
o
r
d
e
r
(
i
n
 
i
n
s
t
r
u
c
t
i
o
n
s
)
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
lw $s4 400(0)
1
600
200ps
 
200ps
200ps
 
200ps
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
lw $s5 500(0)
Não temos problemas pois a etapa 5 escreve e a etapa 2 lê. Porque fazemos leitura na primeira metade do ciclo e escrita na segunda metade?
1
800
Hazards de dados
A instrução precisa de dados provenientes de uma instrução anterior, ainda em execução.
Uma meia é encontrada, sem o outro pé, na hora de dobrar, e é preciso dobrar as duas juntas – A outra meia está sendo lavada – É preciso que ela passe pelas etapas de secar e passar antes de ter acesso.
Solução 1: Encaminhar o dado, se possível (forwarding)
17
a
d
d
 
$
s
0
,
 
$
t
0
,
 
$
t
1
s
u
b
 
$
t
2
,
 
$
s
0
,
 
$
t
3
Program
execution
order
(in instruction)
I
F
I
D
W
B
E
X
I
F
I
D
M
E
M
E
X
Time
200
400
600
800
1000
M
E
M
W
B
M
E
M
Hazards de dados
Foward não resolve todas a situações
Para pensar em casa: Quais são as combinações de instruções resolvidas pelo forward e quais precisam de bolha? Considere instruções do tipo R, lw, sw, beq, j, addi e subi. Considere que 5 instruções podem estar no pipe simultaneamente e portanto podemos ter hazards entre quaisquer 5 instruções no pipe. E se temos uma bolha, como fica o forward para as demais instruções?
18
lw $s0, 20($t1)
sub $t2, $s0, $t3
Program
execution
order
(in instruction)
I
F
I
D
W
B
E
X
I
F
I
D
M
E
M
E
X
Time
200
400
600
800
1000
M
E
M
W
B
M
E
M
bolha
bolha
bolha
bolha
bolha
Hazards de dados
Solução 2: Reordenar o código para evitar bolhas
Solução de Software
Feito pelo Compilador
Exemplo:
lw $t0, 0($t1)
lw $t2, 4($t1)
sw $t2, 0($t1)
sw $t0, 4($t1)
Código Reordenado:
lw $t0, 0($t1)
lw $t2, 4($t1)
sw $t0, 4($t1)
sw $t2, 0($t1)
19
Hazard de dados
Instruções trocadas
Hazards de dados
Exemplo 2
A = B+E;
C = B+F;
lw $t1, 0($t0)
lw $t2, 4($t0)
add $t3, $t1, $t2
sw $t3, 12($t0)
lw $t4, 8($t0)
add $t5, $t1, $t4
sw $t5, 16($t0)
20
Hazards de dados
Exemplo 2
A = B+E;
C = B+F;
lw $t1, 0($t0)
lw $t2, 4($t0)
add $t3, $t1, $t2
sw $t3, 12($t0)
lw $t4, 8($t0)
add $t5, $t1, $t4
sw $t5, 16($t0)
21
Hazard de dados
Hazard de dados
Hazards de dados
Código reordenado
lw $t1, 0($t0)
lw $t2, 4($t0)
lw $t4, 8($t0)
add $t3, $t1, $t2
sw $t3, 12($t0)
add $t5, $t1, $t4
sw $t5, 16($t0)
22
Instruções trocadas
Hazards de Controle
Necessidade de tomar uma decisão com base nos resultados de uma instrução, enquanto outras estão sendo executadas (branches e jumps)
Vamos limpar o uniforme de um time de futebol, mas como a roupa está muito suja, precisamos determinar o tipo de detergente e temperatura da água ideais. Depois da primeira carga seca, podemos avaliar o resultado, mudar as configurações e lavar novamente, começando com configurações que limpam menos e agridem menos a roupa. (Stall)
Podemos também tentar prever a configuração ideal baseado em algum critério (previsão de desvio).
Uma terceira solução é colocar cargas que não sejam de futebol até que a decisão seja tomada (delayed branch)
23
Hazards de Controle
Instruções de desvio passam a ser executadas no segundo estágio – Adicionamos HW no projeto – Mesmo assim o problema permanece (bolha de 1 estágio)
Solução 1: Stall
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
T
i
m
e
beq $s1, $s2, x
add $s4, $s5, $s6
lw $s3 300($s0)
400ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
200
400
600
800
1
000
1
200
1
400
1
600
P
r
o
g
r
a
m
e
x
e
c
u
t
i
o
n
o
r
d
e
r
(
i
n
 
i
n
s
t
r
u
c
t
i
o
n
s
)
Pipeline stall
b
u
b
b
l
e
24
b
u
b
b
l
e
b
u
b
b
l
e
b
u
b
b
l
e
b
u
b
b
l
e
Hazards de Controle
Solução 2: Pevisão de desvio – Ex: supor que o desvio nunca será tomado.
Prediction success
Prediction failure: undo (=flush) lw
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
T
i
m
e
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
 
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
 
P
r
o
g
r
a
m
e
x
e
c
u
t
i
o
n
o
r
d
e
r
(
i
n
 
i
n
s
t
r
u
c
t
i
o
n
s
)
I
In
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
T
i
m
e
or $s7, $t1, $t2
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200
400
600
800
1
000
1
200
1
400
200
400
600
800
1
000
1
200
1
400
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
 
400ps
 
b
u
b
b
l
e
b
u
b
b
l
e
b
u
b
b
l
e
b
u
b
b
l
e
b
u
b
b
l
e
P
r
o
g
r
a
m
e
x
e
c
u
t
i
o
n
o
r
d
e
r
(
i
n
 
i
n
s
t
r
u
c
t
i
o
n
s
)
beq $s1, $s2, x
add $s4, $s5, $s6
lw $s3 300($s0)
beq $s1, $s2, x
add $s4, $s5, $s6
Hazards de Controle
Solução 3: Delayed branch: colocar uma instrução (independente) anterior ao branch para executar logo depois do branch, preenchendo a bolha (delay slot) – Feito pelo compilador
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
T
i
m
e
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
 
I
n
s
t
r
u
c
t
i
o
n
f
e
t
c
h
R
e
g
A
L
U
D
a
t
a
a
c
c
e
s
s
R
e
g
200ps
200
400
600
800
1
000
1
200
1
400
200ps
 
(
d
e
l
a
y
e
d
 
b
r
a
n
c
h
 
s
l
o
t
)
P
r
o
g
r
a
m
e
x
e
c
u
t
i
o
n
o
r
d
e
r
(
i
n
 
i
n
s
t
r
u
c
t
i
o
n
s
)
Delayed branch beq é seguido pela instrução add que é independente do resultado do branch
beq $s1, $s2, x
add $s4, $s5, $s6
lw $s3 300($s0)
Contatos
27
leandro@ime.uerj.br
lmarzulo@cos.ufrj.br
leandro.marzulo@gmail.com