You are on page 1of 64

Organização de Computadores B 1

Universidade Federal do Rio Grande do Sul
Instituto de Informática

Organização de Computadores

Aulas 11 e 12

Dependências

Organização de Computadores B 2

Pipeline no MIPS
• O que faz isto ser difícil?
• Dependências estruturais – Instruções diferentes, em estágios
diferentes do pipeline, querem utilizar o mesmo recurso de hardware
• Dependências de controle – A próxima instrução que irá ao pipeline
depende da saída de uma instrução de desvio, que já está no pipeline
• Dependências de dado – Uma instrução que entrou no pipeline precisa
de um dado que está sendo computado por uma instrução que entrara
no pipeline.

Organização de Computadores B 3

Sumário
• Dependências Estruturais
• Dependências de Controle
• Dependências de Dados
• Exercícios

Organização de Computadores B 4 Sumário • Dependências Estruturais • Dependências de Controle • Dependências de Dados • Exercícios .

400($0) Reg ALU Reg 2 ns fetch access 2 ns 2 ns 2 ns 2 ns 2 ns . Organização de Computadores B 5 Dependências Estruturais • Não há recursos de hardware suficientes para suportar todas as instruções no pipeline ao mesmo tempo • e.: Suponha uma memória pra instruções e dados no pipeline com uma porta de leitura • Há uma dependência estrutural entre o primeiro e quarto lw Program execution 2 4 6 8 10 12 14 Time order (in instructions) Instruction Data lw $1. 200($0) 2 ns Reg ALU Reg fetch access Dependência estrutural Instruction Data lw $3. 300($0) 2 ns Reg ALU Reg fetch access Instruction Data lw $4.g. 100($0) Reg ALU Reg fetch access Pipeline Instruction Data lw $2.

Organização de Computadores B 6 Sumário • Dependências Estruturais • Dependências de Controle • Dependências de Dados • Exercícios .

Organização de Computadores B 7 Dependências de Controle • Uma decisão precisa ser feita baseada em uma instrução que ainda está sendo executada no pipeline • No MIPS. não sabemos qual é a decisão do desvio condicional até o 4º estágio • O que fazer com as instruções seguintes? .

Organização de Computadores B 8

Dependências de Controle
• Solução 1 – Pare o pipeline (Stall)

Program
execution 2 4 6 8 10 12 14 16
order Time
(in instructions)
Instruction Data
add $4, $5, $6 fetch
Reg ALU
access
Reg Note que o branch é computado
no segundo estágio (mais tarde…)
Instruction Data
beq $1, $2, 40 Reg ALU Reg
2ns fetch access

Instruction Data
lw $3, 300($0) bubble Reg ALU Reg
fetch access

4 ns 2ns

Pipeline stall

Organização de Computadores B 9

Dependências de Controle
• Solução 1 – Pare o pipeline (Stall)

Program
execution 2 4 6 8 10 12 14 16
order • Deve-se procurar antecipar a decisão sobre o desvio
Time
(in instructions)
para Instruction
o estágio mais cedo
Data possível
Note que o branch é computado
add $4, $5, $6 Reg ALU Reg
fetch access
no segundo estágio (mais tarde…)
Instruction Data
beq $1, $2, 40 Reg ALU Reg
2ns fetch access

Instruction Data
lw $3, 300($0) bubble Reg ALU Reg
fetch access

4 ns 2ns

Pipeline stall

Organização de Computadores B 10

Dependências de Controle (2)
• Solução 2 – Delayed Branch
• Sempre execute sequencialmente a próxima instrução
• Como?
• Achando uma instrução que seria executada de certeza antes do desvio
• Colocando esta instrução após o desvio no programa
• Trabalho do Compilador

• Exemplo:
• Máquina com um delayed branch de apenas um ciclo:
• Antes de aplicar a técnica (código original):
ADD R1, R2, R3
if R2 = 0 then
Delay slot

• Após aplicar a técnica:

if R2 = 0 then
ADD R1, R2, R3

300($0) fetch Reg ALU access Reg 2ns 2ns O beq é seguido por um add que é independente . $6 fetch Reg ALU access Reg (delayed branch slot) 2ns Instruction Data lw $3. 40 Reg ALU Reg fetch access Instruction Data add $4. Organização de Computadores B 11 Dependências de Controle (2) • Solução 2 – Delayed Branch • Sempre execute sequencialmente a próxima instrução • Como? • Achando uma instrução que seria executada de certeza antes do desvio • Colocando esta instrução após o desvio no programa • Trabalho do Compilador Program execution 2 4 6 8 10 12 14 order Time (in instructions) Instruction Data beq $1. $5. $2.

Organização de Computadores B 12 Dependências de Controle (3) • Solução 3 – Prever o resultado do desvio • e. $8. 40 Reg ALU Reg 2 ns fetch access Instruction Data lw $3. $2.: prever o desvio como not-taken. $5 . $2. 40 Reg ALU Reg fetch access 2 ns bubble bubble bubble bubble bubble Instruction Data or $7. $5. Program execution 2 4 6 8 10 12 14 order Time (in instructions) Instruction Data add $4.g. $9 Reg ALU Reg fetch access 4 ns Falha: Desfazer (=flush) lw .$6 Reg ALU Reg fetch access Instruction Data beq $1. 300($0) Reg ALU Reg 2 ns fetch access Sucesso! Program execution 2 4 6 8 10 12 14 order Time (in instructions) Instruction Data add $4. $6 fetch Reg ALU access Reg Instruction Data beq $1.

40 Reg ALU Reg fetch access 2 ns bubble bubble bubble bubble bubble Instruction Data or $7. Program execution 2 4 6 8 10 12 14 order Time (in instructions) Instruction Data add $4. $2. $2. $5. porque escrita de valores é Time (in instructions) sempre feita add $4. $8. $6 fetch Reg ALU access Reg Instruction Data beq $1.$6 nos Instruction Reg últimosALU estágios Data Reg do pipeline fetch access Instruction Data beq $1. $9 Reg ALU Reg fetch access 4 ns Falha: Desfazer (=flush) lw . 40 Reg ALU Reg 2 ns fetch access Instruction Data lw $3.: prever o desvio como not-taken. Organização de Computadores B 13 Dependências de Controle (3) • Solução 3 – Prever o resultado do desvio • e. 300($0) Reg ALU Reg 2 ns fetch access • Instruções abandonadas Sucesso! não podem ter afetado conteúdo de registradores Program e memórias 14 execution 2 4 6 8 10 12 •order Isto é usualmente automático. $5 .g.

Custo da Predição errada • Depende de onde o Branch é resolvido! Program Time (in clock cycles) execution CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 CC 8 CC 9 order (in instructions) 40 beq $1. 7 IM Reg DM Reg 44 and $12. $6. $5 IM Reg DM Reg 48 or $13. $2 IM Reg DM Reg 52 add $14. 50($7) IM Reg DM Reg . $2 IM Reg DM Reg 72 lw $4. $3. $2. $2.

15 Predição Estática • Supor sempre mesma direção para o desvio – desvio sempre ocorre – desvio nunca ocorre • Compilador define direção mais provável – instrução de desvio contém bit de predição. ligado / desligado pelo compilador – início de laço (ou desvio para frente): desvio improvável – final de laço (ou desvio para trás): desvio provável • Até 85% de acerto é possível .

16 Predição Dinâmica tabela look-up associativa endereço endereço bit de validade instrução desvio carga do endereço de desvio PC endereço fetch instrução .

Organização de Computadores B 17 Predição Dinâmica (2) • tabela look-up associativa armazena triplas • endereços das instruções de desvio condicional mais recentemente executadas • endereços de destino destes desvios • bit de validade. à procura do endereço desta instrução • se endereço é encontrado e bit de validade está ligado. o endereço de desvio armazenado na tabela é usado • ao final da execução da instrução. endereço efetivo de destino do desvio e bit de validade são atualizados na tabela • tabela pode utilizar diversos mapeamentos e algoritmos de substituição . indicando se desvio foi tomado na última execução • quando instrução de desvio condicional é buscada na memória • é feita comparação associativa na tabela.

Predição de 1 bit • É uma previsão baseada em história (utiliza as informações sobre os desvios anteriores) • Previsão de 1 bit de história • T – taken. N – not taken N T T N N T .

19 Predição de 2 bits N T TT TN T T N N NT NN N T .

Organização de Computadores B 20 Predição de 2 bits – Contador Saturado N T TT TN T T N T N NN NT N .

• contador é incrementado se desvio ocorre • contador é decrementado se desvio não ocorre – valor do contador é utilizado para a predição ... 21 Predição Dinâmica (3) • variação: branch history table – contador associado a cada posição da tabela – a cada vez que uma instrução de desvio contida na tabela é executada .

e decide a partir disto • Correlating Branches • Baseado na idéia que o comportamento do branch atual é relacionado com os dos branches anteriores (pense em um IF- ELSE) • Há bits de predição “locais” e “globais” • Tournament Prediction • Há dois históricos separados: um global e um local. .. Usa um seletor para decidir qual usar • Redes Neurais.. Organização de Computadores B 22 Técnicas mais Avançadas • Two-level adaptive predictor • Guarda uma “sequência” de takens e not-takens para um branch.

Preditores de desvio de 2 bits (Quantitative Approach) .

Pentium 4 – Dados Reais .

executar os dois caminhos possíveis! buffer para instruções seqüenciais fetch restante do pipeline MEM branch buffer para instruções não-seqüenciais . Organização de Computadores B 25 • Ou ainda.

Organização de Computadores B 26 Sumário • Dependências Estruturais • Dependências de Controle • Dependências de Dados • Exercícios .

Dependência de Dados • problema: instruções consecutivas podem fazer acesso aos mesmos operandos • execução da instrução seguinte pode depender de operando calculado pela instrução anterior • caso particular: instrução precisa de resultado anterior (p. registrador) para cálculo de endereço efetivo de operando • tipos de dependências de dados • dependência verdadeira • antidependência • dependência de saída .ex.

$1. Dependência de dados e diagrama de ciclos • Dependências de dados viajam para “trás” no tempo Time (in clock cycles) $2 = 10 antes do sub. $5 or $13. 100($2) IM Reg DM Reg . $2. $2 add $14. $2. $2 IM Reg DM Reg sw $15. 100($2) sw $15. $6. $6. $2 IM Reg DM Reg and $12. $5 IM Reg DM Reg sub $2. $3 or $13. $2. $2. $3 IM Reg DM Reg and $12. $2 add $14. $1. Value of CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 CC 8 CC 9 $2 = -20 depois do sub register $2: 10 10 10 10 10/– 20 – 20 – 20 – 20 – 20 Program execution order (in instructions) sub $2.

Dependências Verdadeiras • exemplo 1. 1 . R1 . R2. R3 = R2 + R1 2. R4 = R3 – 1 • instrução 2 depende de valor de R3 calculado pela instrução 1 • instrução 1 precisa atualizar valor de R3 antes que instrução 2 busque os seus operandos • read-after-write hazard • pipeline precisa ser parado durante certo número de ciclos . ADD R3. SUB R4. R3.

1 .Dependências Falsas Antidependência • exemplo 1. R1 . R3 = R2 + R1 2. SUB R2. ADD R3. R2. R4. R2 = R4 – 1 • instrução 1 utiliza operando em R2 que é escrito pela instrução 2 • instrução 2 não pode salvar resultado em R2 antes que instrução 1 tenha lido seus operandos • write-after-read hazard • não é um problema em pipelines onde a ordem de execução das instruções é mantida • escrita do resultado é sempre o último estágio • problema em processadores super-escalares .

ADD R3. R1 .Dependências Falsas (2) Dependência de saída • exemplo 1. 1 . R2. R3. R2. R5 . R3 = R2 + R1 2. R2 = R3 – 1 3. R3 = R2 + R5 • instruções 1 e 3 escrevem no mesmo R3 • instrução 1 tem que escrever seu resultado em R3 antes do que a instrução 3. ADD R3. SUB R2. senão valor final de R3 ficará errado • write-after-write hazard • também só é problema em processadores super- escalares .

Organização de Computadores B 32 Soluções para dependências verdadeiras • Para falsas. neste mesmo semestre. . veremos mais tarde.

= 1 indica valor válido • se instrução que é buscada e decodificada escreve num registrador.Solução 1: Pipeline Interlock • método para manter seqüência correta de leituras e escritas em registradores • tag de 1 bit é associado a cada registrador tag = 0 indica valor não válido. o tag do mesmo é zerado • tag é ligado quando instrução escreve o valor no registrador • outras instruções que sejam executadas enquanto tag está zerado devem esperar tag = 1 para ler valor deste registrador .

Solução 1: Pipeline Interlock (2) ADD R3. 8 banco de registradores R3 ligar tag de R3 desligar tag de R3 ler tag de R3 esperar. se tag = 0 ADD IF OF EX OS ler operando. R4. R3. se tag = 1 SUB IF OF OF OF EX OS . 4 tag SUB R5.

R2. calculado pela instrução ADD • valor é escrito em R3 por ADD no último estágio WB (write-back) • valor é necessário em SUB no terceiro estágio • instrução SUB ficará presa por 2 ciclos no 2º estágio do pipeline IF OF EX MEM WB IF stall stall OF EX supõe-se escrita no banco de registradores na primeira metade do ciclo e leitura na segunda metade . 8 • instrução SUB precisa do valor de R3. R0 SUB R4.Solução 2: Forwarding • exemplo ADD R3. R3.

Forwarding (2) • caminho interno dentro do pipeline entre a saída da ALU e a entrada da ALU • evita stall do pipeline IF OF EX MEM WB forwarding IF OF EX MEM WB IF OF EX MEM WB .

R3 • forwarding: caminho interno dentro do pipeline entre a saída da memória de dados e a entrada da ALU IF OF EX MEM WB forwarding IF OF EX MEM WB IF OF stall EX MEM . 100 (R0) ADD R1.Forwarding (3) • exemplo 2 LOAD R3. R2.

mas também de registradores de pipeline posteriores • Usar multiplexadores e mais sinais de controle para escolher o valor correto Time (in clock cycles) CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 CC 8 CC 9 Value of register $2 : 10 10 10 10 10/– 20 – 20 – 20 – 20 – 20 Value of EX/MEM : X X X – 20 X X X X X Value of MEM/WB : X X X X – 20 X X X X Program execution order (in instructions) sub $2. Forwarding (4) • Como é feito: • As entradas da ALU não vem apenas do ID/EX. $5 and $12. $2 add $14. $2. $2. $2 IM Reg DM Reg sw $15. $5 IM Reg DM Reg or $13. $3 and $12. $1. $6. 100($2) IM Reg DM Reg . $3 IM Reg DM Reg sub $2. $1. $2. $6. $2. $2 IM Reg DM Reg sw $15. $2 or $13. 100($2) add $14.

$t3 IF ID EX MEM WB 2 4 6 8 10 12 14 Program Time execution order (in instructions) lw $s0.. $s0.g. 20($t1) IF ID EX MEM WB Uma bolha é suficiente bubble bubble bubble bubble bubble sub $t2. $t3 IF ID EX MEM WB . $s0. uma instrução tipo R que precisa do resultado de um load que começou a ser executado no ciclo anterior – load-use data hazard 2 4 6 8 10 12 14 Program Time execution order (in instructions) lw $s0. Forwarding (5) • Forwarding pode não ser suficiente • e. 20($t1) IF ID EX MEM WB Sem stall é impossível entregar o dado a tempo sub $t2.

0($t1) lw $t2. 4($t1) sw $t0.Solução 3 – Software • Exemplo: lw $t0. 0($t1) sw $t0. 4($t1) • Código Reordenado: lw $t0. 0($t1) . 4($t1) Dependência de Dados sw $t2. 0($t1) lw $t2. 4($t1) Trocado sw $t2.

Software (2) • Solução mais radical: o compilador garante que nunca haverá dependência de dados! • Reordenando as instruções • Ou simplesmente colocando bolhas (nops) • Que atrasa a execução do programa .

Organização de Computadores B 42 Sumário • Dependências Estruturais • Dependências de Controle • Dependências de Dados • Projeto para detecção em Hardware • Exercícios .

Bloco Operativo com controle PCSrc ID/EX 0 M u WB x EX/MEM 1 Control M WB MEM/WB EX M WB IF/ID Add Add 4 Add result RegWrite Branch Shift left 2 MemWrite ALUSrc Read MemtoReg Instruction PC Address register 1 Read data 1 Read register 2 Zero Instruction Registers Read ALU ALU memory Write 0 Read data 2 result Address 1 register M data u Data M Write x memory u data x 1 0 Write data Precisamos de Instruction 16 [15– 0] Sign 32 6 ALU MemRead extend control hardware para Instruction DETECTAR e [20– 16] 0 ALUOp M FAZER Instruction [15– 11] u x 1 Forwarding! RegDst .

já que • EX/MEM. não há a necessidade de forward.RegistradorRd = ID/EX. MEM/WB. EX/MEM.RegistradorRt • Eg. não há necessidade de forward de $0.RegistradorRs 1b. Detecção • Condições: 1a..RegistradorRd = ID/EX. no exemplo anterior. EX/MEM.RegistradorRd = ID/EX. $1.RegistradorRt 2a. a primeira dependência entre sub $2. MEM/WB. $5 é detectada quando o and está no estágio EX stage e o sub no estágio MEM. $3 e and $12.RegistradorRd = ID/EX. RegistradorRs = $2 (1a) • Há também as seguintes condições: • Se a instrução posterior vai gravar em um registrador –se não. que sempre tem valor zero por convenção . mesmo que algumas das condições acima seja verdadeira • Se o registrador de destino da instrução posterior não for $0 – neste caso.RegistradorRd = ID/EX.RegistradorRs 2b. $2.

RegisterRd unit b. ID/EX EX/MEM MEM/WB Projeto do Registers ALU Forwarding Data memory M u x a.RegisterRd Rd x Forwarding MEM/WB. With forwarding Com forward . No forwarding Sem forward ID/EX EX/MEM MEM/WB M u x Registers ForwardA ALU M Data u memory x M u x Rs ForwardB Rt Rt M u EX/MEM.

Controle do Multiplexador Mux control Source Explanation ForwardA = 00 ID/EX The first ALU operand comes from the register file ForwardA = 10 EX/MEM The first ALU operand is forwarded from prior ALU result ForwardA = 01 MEM/WB The first ALU operand is forwarded from data memory or an earlier ALU result ForwardB = 00 ID/EX The second ALU operand comes from the register file ForwardB = 10 EX/MEM The second ALU operand is forwarded from prior ALU result ForwardB = 01 MEM/WB The second ALU operand is forwarded from data memory or an earlier ALU result .

EX hazard if ( EX/MEM.RegisterRt ) ) // which matches.RegisterRs ) ) // which matches. then… ForwardB = 10 .RegisterRd  0 ) // to a non-$0 register… and ( EX/MEM.Lógica para detecção de forward 1.RegisterRd  0 ) // to a non-$0 register… and ( EX/MEM.RegisterRd = ID/EX.RegisterRd = ID/EX.RegWrite // if there is a write… and ( EX/MEM.RegWrite // if there is a write… and ( EX/MEM. then… ForwardA = 10 if ( EX/MEM.

RegisterRt ) // and not already a register match // with earlier pipeline register… and ( MEM/WB. $2.RegisterRd  0 ) // to a non-$0 register… and ( EX/MEM.RegisterRs ) ) // but match with later pipeline register.RegisterRd = ID/EX. then… ForwardA = 01 if ( MEM/WB. onde um estágio à esquerda do pipeline (anterior) (EX/MEM) tem um dado mais recente .RegisterRs ) // and not already a register match // with earlier pipeline register… and ( MEM/WB. $1. add $1. $4. then… ForwardB = 01 É necessário para sequências como add $1. add $1.RegisterRd  ID/EX.RegisterRt ) ) // but match with later pipeline register. MEM hazard if ( MEM/WB. Lógica para detecção de forward (2) 2.RegWrite // if there is a write… and ( MEM/WB.RegWrite // if there is a write… and ( MEM/WB. $3. $1.RegisterRd  ID/EX.RegisterRd  0 ) // to a non-$0 register… and ( EX/MEM. $1.RegisterRd = ID/EX.

RegisterRt Rt IF/ID.RegisterRs Rs IF/ID. Controle do PC) .RegisterRd unit Alguns detalhes foram omitidos para facilitar a visualização (ex.RegisterRd IF/ID. Forwarding Hardware with Control ID/EX WB EX/MEM Control M WB MEM/WB IF/ID EX M WB M Instruction u x Registers Instruction Data PC ALU memory memory M u M x u x IF/ID.RegisterRd Rd u x Forwarding MEM/WB.RegisterRt Rt M EX/MEM.

$2 and $4. $2 M Instruction 6 u x Registers Instruction Data PC ALU memory memory M $2 $5 u M x u x 2 2 6 5 M 2 4 4 u x Forwarding Ciclo 4 unit Clock 4 . $2. $4. $1. $2. $2. $1. . $3 EX/MEM 10 Control M WB MEM/WB and $4. $5 sub $2. . $2 4 $4 $2 add $9. $4. $2 and $4. $5 EX M WB IF/ID or $4. $4. $4. . before<1> ID/EX 10 10 WB sub $2. $2 or $4. $3 before<1> before<2> ID/EX 10 10 WB EX/MEM Forwarding IF/ID Control M EX WB M MEM/WB WB 2 $2 $1 M Instruction 5 u x Registers Instruction Data PC ALU memory memory M $5 $3 u M x u x 2 1 5 3 M 4 2 u x Forwarding Ciclo 3 unit • Exemplo: Clock 3 add $9. or $4. $5 sub $2. $4.

$2. . . and $4. $4. $2 M Instruction u x Registers Instruction 4 Data PC ALU memory memory M $2 u M x u x 4 2 M 4 4 9 u x Forwarding Ciclo 6 unit Clock 6 . $2 $4 add $9. . ID/EX 10 WB sub $2. . . $4. $4. . ID/EX 10 10 WB EX/MEM Forwarding 10 Control M WB MEM/WB 1 IF/ID EX M WB 4 $4 $4 M Instruction 2 u x Registers Instruction 2 Data PC ALU memory memory M $2 $2 u M x u x 4 4 2 2 M 4 2 9 4 u x • Exemplo: Forwarding Ciclo 5 unit Clock 5 after<2> after<1> add $9. $4. $2 or $4. $2 and $4. after<1> add $9. $2 or $4. sub $2. . $4. $1. . . . . . $3 EX/MEM 10 Control M WB MEM/WB and $4. $5 EX M WB 1 IF/ID or $4.

20($1) IM Reg DM Reg add $9. 20($1) Time (in clock cycles) Program CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 CC 8 CC 9 and $4. $5 execution order or $8. $4. Dependência de dados e Paradas • Instrução Load ainda pode causar uma dependência não resolvida: • Uma instrução tenta ler um registrador. $6. $2 IM Reg DM Reg slt $1. $2 Slt $1. $6. $4. $7 IM Reg DM Reg • A unidade de detecção de dependência tem de parar (Stall) o pipeline depois da instrução de load . $2. $7 and $4. $5 IM Reg DM Reg Neste caso. cujo o lw anterior vai escrever lw $2. or $8. $6 (in instructions) lw $2. $2. $2. $6 IM Reg DM Reg forwarding não irá resolver add $9. $2.

then… stall the pipeline .RegisterRt = IF/ID.RegisterRt ) ) ) // matches either source register // of the instruction in the ID stage.Lógica para parar • Lógica de detecção da parada (stall) if ( ID/EX.RegisterRt = IF/ID.RegisterRs ) // and the destination register or ( ID/EX.MemRead // if the instruction in the EX stage is a load… and ( ( ID/EX.

a unidade de forwarding consegue resolver a dependência. o pipeline precisa parar por apenas 1 ciclo. uma bolha é inserida. . precisa sofrer a parada também – O PC não pode mudar (desabilita seu sinal de write) • Mudar temporariamente os bits de controle EX. Depois disto. no estágio IF. MEM e WB dos campos de controle no registrador de pipeline ID/EX para zero – nada irá acontecer. • O que é necessário para parar por 1 ciclo: • O registrador IF/ID não muda (desabilita seu sinal de write) – A instrução no estágio ID irá se repetir • A instrução que vem logo após.Mecanismos para parada • Se a parada (stall) precisa acontecer.

RegisterRs IF/ID.RegisterRt Rs Forwarding MEM/WB.RegisterRd Rd u x ID/EX.RegisterRt IF/ID.MemRead detection unit ID/EX WB IF/IDWrite EX/MEM M Control u M WB x MEM/WB 0 IF/ID EX M WB PCWrite M Instruction u x Registers Instruction Data PC ALU memory memory M u M x u x IF/ID.RegisterRd IF/ID.RegisterRd Rt unit . Pipeline com lógica de forwarding e stall Hazard ID/EX.RegisterRt Rt M EX/MEM.

$2 and $4. $5 lw $2. $4. $2. $4. 20($1) before<1> before<2> before<3> Hazard ID/EX. $2 00 WB 11 IF/IDWrite EX/MEM M add $9. $5 lw $2.RegisterRt Forwarding unit Ciclo 3 Clock 3 . 20($1) before<1> before<2> Hazard and $4. $5 2 detection unit ID/EX. and $4.MemRead ID/EX 5 or $4. $2.MemRead detection 1 unit ID/EX X 11 WB IF/IDWrite EX/MEM Stalling IF/ID Control 0 M u x M EX WB M MEM/WB WB PCWrite 1 $1 M Instruction X u x Registers Instruction Data PC ALU memory memory M $X u M x u x • Exemplo: 1 X 2 M u x ID/EX. $4. 20($1) or $4. $2 Control u x M WB MEM/WB 0 IF/ID EX M WB $2 $1 PCWrite 2 M Instruction 5 u x Registers Instruction Data PC ALU memory memory M $5 $X u M x u x 2 1 5 X 2 M 4 u x ID/EX. $2.RegisterRt Forwarding unit CicloClock 2 2 lw $2.

.RegisterRt Forwarding unit Ciclo 5 Clock 5 . $4. $2. . $4. . $2 IF/ID 0 EX M WB 11 add $9. $2 PCWrite 4 $4 $2 M Instruction 2 u x Registers Instruction 2 Data PC ALU memory memory M $2 $5 u M x u x 4 2 2 5 M 2 4 4 u x ID/EX. $2 or $4. 20($1) 2 unit 10 ID/EX 10 IF/IDWrite WB EX/MEM and $4. $5 Control M u M WB 0 x MEM/WB or $4. $2.MemRead detection 4 lw $2.MemRead detection 2 unit ID/EX 5 10 00 IF/IDWrite WB EX/MEM Stalling M 11 Control u M WB x MEM/WB 0 IF/ID EX M WB PCWrite 2 $2 $2 M Instruction 5 u x Registers Instruction Data PC ALU memory memory M $5 $5 u M x u x 2 2 • Exemplo: 5 5 M 2 4 4 u x ID/EX. $5 bubble lw $2. before<1> Hazard ID/EX. Hazard ID/EX. or $4. $2 and $4. . $4.RegisterRt Forwarding unit Ciclo 4 Clock 4 add $9. $4. . $4. $2 and $4. . $2. $5 bubble lw $2.

RegisterRt Forwarding unit Ciclo 7 Clock 7 . after<1> add $9. Hazard detection ID/EX. $4. and $4.MemRead lw $2. . . 20($1) unit ID/EX 10 10 IF/IDWrite WB and $4. . . $2 or $4. $2 0 x MEM/WB 1 IF/ID EX M WB add $9. $2. . bubble Hazard ID/EX. $2 $4 PCWrite M Instruction u x Registers Instruction 4 Data PC ALU memory memory M $2 u M x u x 4 2 M 4 4 9 u x ID/EX. .RegisterRt Forwarding unit Ciclo 6 Clock 6 after<2> after<1> add $9. $2 and $4. $4. $4. $4. $2 or $4. .MemRead detection 4 unit ID/EX 2 10 10 WB IF/IDWrite EX/MEM Stalling M 10 Control u M WB x MEM/WB 0 0 IF/ID EX M WB PCWrite 4 $4 $4 M Instruction 2 u x Registers Instruction Data PC ALU memory memory M $2 $2 u M x u x 4 4 • Exemplo: 2 2 M 4 9 4 u x ID/EX. $5 M EX/MEM 10 Control u M WB or $4. $4. . .

• Na predição errada. mais. • Desta maneira. Otimizando o pipeline para diminuir o delay do Branch • Mover a decisão do branch do estágio MEM para o ID • É preciso mover o somador para o ID para calcular o endereço alvo • É preciso ter um comparador para comparar os valores para tomar a decisão. todos os bits de controle da instrução são transformados para zero • As instruções seguintes ao branch se tornam NOPs na prática • Como nosso pipeline modificado. já que a ALU não vai ser utilizada para este fim. apenas o IF precisa sofrer com o flushing . é possível adicionar recursos sem efetivamente aumentar o caminho crítico • O controle de forward e stall precisam ser mudados para prever a instrução de branch no início.

Flush zera a instrução no registrador de pipeline IF/ID .Flush Hazard detection unit M ID/EX u x WB EX/MEM M Control u M WB x MEM/WB 0 IF/ID EX M WB 4 Shift left 2 M u x Registers = Instruction Data PC ALU memory memory M u M x u x Sign extend M u x Forwarding unit Controle IF.Caminho de dados otimizado para branch IF.

40 beq $1. $4. $6 M u unit ID/EX 76 x WB 52 add $14. $5 Hazard detection 48 or $13 $2. $3.Flush Pipelined Hazard detection unit 72 ID/EX M u 48 x WB EX/MEM M Control u M WB MEM/WB Branch 28 x 0 IF/ID EX M WB 48 44 72 4 $1 Shift M $4 left 2 u x = Registers Instruction Data PC ALU memory memory M 72 44 $3 u M $8 x 7 u x • Exemplo: Sign extend 10 Forwarding unit Ciclo 3 36 sub $10. 50($7) bubble (nop) beq $1. 7 sub $10. $3. . $7 76 IF/ID 72 0 EX M WB … 4 Shift M $1 left 2 u 72 lw $4. $4. $3. 7 before<1> IF. $2. $2 Control M u M EX/MEM WB MEM/WB x 56 slt $15. . 50($7) PC Instruction Registers = x ALU Data memory memory M 76 72 u M $3 x u x Sign extend 10 Forwarding unit Ciclo 4 Clock 4 . . and $12. 7 sub $10. $8 before<1> before<2> IF. $6. $4.Flush 44 and $12 $2. $5 beq $1. $8 Clock 3 lw $4.

Organização de Computadores B 62 Sumário • Dependências Estruturais • Dependências de Controle • Dependências de Dados • Exercícios .

assumindo blocos indivisíveis? (M1) Compare o desempenho com M0 • Qual a MELHOR partição para o pipeline de 5 estágios. assumindo blocos indivisíveis? (M2) Compare o desempenho com M0 • Qual a MELHOR partição. DM=3ns.3 se a taxa de branches é de 30%.Exercícios • Dados os seguintes tempos e assuma M0 single cycle: • IM=4ns. assumindo blocos divisíveis? (M3) • Qual o desempenho de M0.. RegW=1ns • Qual o tempo para executar 1B de instruções? • Qual a MELHOR partição para o pipeline de 3 estágios. sem preditor? • Qual o desempenho de M0. Reg=1ns. com preditor que acerta 90%? t0 t1 t2 t3 t4 ALU IM Reg DM RegW . ALU=3ns.3 se a taxa de branches é de 30%..

onde a decisão sobre saltos acontece no 5o estágio. Qual a penalidade paga. 64 Execícios • O pipe de 5 estágios (MIPS) disponibiliza o endereço de salto no quarto estágio. Qual o CPI? • Melhorou-se o processador com uma política de predição de saltos com 85% de acertos. . A política usada é esvaziar o pipe. Qual a melhoria em desempenho? Qual CPI se tem? • Repita o problema para um pipe de 7 estágios. se 30% das instruções forem branches? Assuma todos errados.