Organização e Arquitetura de computadores

(1)

Organiza

ç

ão e Arquitetura

de computadores

Prof. Dr. Luciano José Senger

Solucionando Hazards no pipeline

Revisão do caminho de dados com

Revisão do caminho de dados com pipelining

pipelining

Read Address Instruction Memory Add P C 4 Write Data Read Addr 1 Read Addr 2 Write Addr Register File Read Data 1 Read Data 2 16 32 ALU Shift left 2 Add Data Memory Address Write Data Read Data IF/ID Sign Extend ID/EX EX/MEM MEM/WB Control ALU cntrl RegWrite MemWrite MemRead MemtoReg RegDst ALUOp ALUSrc Branch PCSrc

Forma mais simples de resolver

hazard

de dados

stall

I n s t r. O r d e r

add

$1

,

AL U IM Reg DM Reg

sub $4,

$1

,$5

and $6,$7,

$1

A L U IM Reg DM Reg A L U IM Reg DM Reg Resolve o hazard através da espera, mas tem impacto negativo no CPI

Solu

Soluç

ção com encaminhamento (

ão com encaminhamento ( forwarding

forwarding

)

add

$1

,

sub $4,

$1

,$5

and $6,$7,

$1

A L U IM Reg DM Reg A L U IM Reg DM Reg Resolve o hazard através do encaminhamento do resultado tão logo este esteja disponível

sw

$4,4(

$1

)

or $8,

$1

,

$1

A L U IM Reg DM Reg A L U IM Reg DM Reg

Implementa

Implementaç

ção de encaminhamento

ão de encaminhamento

• Encaminhamento (forwarding)

– A implementação do forwarding necessita de uma forma de identificar o hazard

– Deve-se coletar o resultado dos registradores de pipeline e realizar o encaminhamento para a ALU que necessita dos dados

• Para a ALU, as entradas vem de quaisquer registradores de pipeline ao invés do registrador ID/EX

• Multiplexadores são adicionados nas entradas da ALU para selecionados os dados corretos

• Adiciona-se um controle de hardware apropriado para controlar os novos multiplexadores

• Outras unidades funcionais, como DM, necessitam de uma lógica similar

– Com forwarding, é possível atingir um CPI igual a 1 mesmo quando existirem dependências de dados

Implementa

Implementaç

ção do encaminhamento

ão do encaminhamento

(2)

Condi

Condiç

ções

ões

para

detecç

detec

ção

ão

de hazard

de

hazard de dados

de dados

1. EX/MEM hazard:

if (EX/MEM.RegWrite

and (EX/MEM.RegisterRd != 0)

and (EX/MEM.RegisterRd = ID/EX.RegisterRs)) ForwardA = 10

if (EX/MEM.RegWrite

and (EX/MEM.RegisterRd != 0)

and (EX/MEM.RegisterRd = ID/EX.RegisterRt)) ForwardB = 10 Encaminha o resultado da instrução anterior para a entrada da ALU 2. MEM/WB hazard: if (MEM/WB.RegWrite and (MEM/WB.RegisterRd != 0)

and (MEM/WB.RegisterRd = ID/EX.RegisterRs)) ForwardA = 01

if (MEM/WB.RegWrite

and (MEM/WB.RegisterRd != 0)

and (MEM/WB.RegisterRd = ID/EX.RegisterRt)) ForwardB = 01

Encaminhamento

em

aç

a

ção

ão

add

$1

,

sub $4,

$1

,$5

and $6,$7,

$1

A L U IM Reg DM Reg A L U IM Reg DM Reg A L U IM Reg DM Reg EX/MEM hazard forwarding MEM/WB hazard forwarding

Outra

complicaç

complica

ção

ão

add

$1

,$1,$2

add

$1

,

$1

,$3

add $1,

$1

,$4

• Outro potencial data hazard pode ocorrer quando

existe um conflito entre o resultado do estágio

WB e o estágio MEM – qual resultado deve ser

encaminhado?

add

$1

,$1,$2

add

$1

,

$1

,$3

add $1,

$1

,$4

Outra

complica

complicaç

ção

ão

• Outro potencial data hazard pode ocorrer quando

existe um conflito entre o resultado do estágio

WB e o estágio MEM – qual resultado deve ser

encaminhado?

Controle

de

de encaminhamento

encaminhamento

corrigido

2. MEM/WB hazard:

if (MEM/WB.RegWrite

and (MEM/WB.RegisterRd != 0)

and (EX/MEM.RegisterRd !=

ID/EX.RegisterRs)

and (MEM/WB.RegisterRd =

ID/EX.RegisterRs))

ForwardA = 01

if (MEM/WB.RegWrite

and (MEM/WB.RegisterRd != 0)

and (EX/MEM.RegisterRd !=

ID/EX.RegisterRt)

and (MEM/WB.RegisterRd =

ID/EX.RegisterRt))

ForwardB = 01

Caminho

de dados com encaminhamento

de dados com

encaminhamento

PCSrc Read Address Instruction Memory Add P C 4 Write Data Read Addr 1 Read Addr 2 Write Addr Register File Read Data 1 Read Data 2 16 32 ALU Shift left 2 Add Data Memory Address Write Data Read Data IF/ID Sign Extend ID/EX EX/MEM MEM/WB Control ALU cntrl Branch Forward Unit

(3)

Caminho

de dados com

de dados com encaminhamento

encaminhamento

PCSrc Read Address Instruction Memory Add P C 4 Write Data Read Addr 1 Read Addr 2 Write Addr Register File Read Data 1 Read Data 2 16 32 ALU Shift left 2 Add Data Memory Address Write Data Read Data IF/ID Sign Extend ID/EX EX/MEM MEM/WB Control ALU cntrl Branch Forward Unit ID/EX.RegisterRt ID/EX.RegisterRs EX/MEM.RegisterRd MEM/WB.RegisterRd

Acessos

à

memó

mem

ória

ria

lw

$1

,4($2)

sw

$1

,4($3)

A L U IM Reg DM Reg

• Para loads imediatamente seguidos de stores,

stalls podem ser evitados adicionando hardware

de encaminhamento a partir do registrador

MEM/WB para a entrada da memória de dados

Hazard

de dados e

de dados e stalls

stalls

(Load

(

Load-

-use

use

hazard

hazard)

)

lw

$1

,4($2)

and $6,

$1

,$7

xor $4,

$1

,$5

or $8,

$1

,$9

A L U IM Reg DM Reg A L U IM Reg DM A L U IM Reg DM Reg A L U IM Reg DM Reg A L U IM Reg DM Reg A L U IM Reg DM Reg

sub $4,

$1

,$5

stall

Load

Load-

-use hazard

use hazard

lw

$1

,4($2)

sub $4,

$1

,$5

and $6,

$1

,$7

xor $4,

$1

,$5

or $8,

$1

,$9

A L U IM Reg DM Reg A L U IM Reg DM A L U IM Reg DM Reg A L U IM Reg DM Reg A L U IM Reg DM Reg A L U IM Reg DM Reg

sub $4,

$1

,$5

and $6,

$1

,$7

xor $4,

$1

,$5

or $8,

$1

,$9

Dete

Deteç

ção

ão

de hazard

de

hazard

do

do tipo

tipo

Load

Load-

-use

use

• É necessário um hardware de deteção de hazard no

estágio ID que insere um stall entre a instrução load e o

seu uso

2. Detecção de Hazard ID if (ID/EX.MemRead

and ((ID/EX.RegisterRt = IF/ID.RegisterRs) or (ID/EX.RegisterRt = IF/ID.RegisterRt))) stall the pipeline

• A primeira linha testa se a instrução no estágio de

execução é um lw; as duas linhas seguintes verificam se

o registrador de destino do lw casa com qualquer

registrador fonte da instrução que está no estágio ID

(instrução load-use)

• Após uma bolha de um ciclo, a lógica de

encaminhamento pode corrigir os hazards de dados

restantes

Gera

Geraç

ção

ão

de bolhas

de

bolhas

(stalls)

• A unidade de detecção de hazard controla a

escrita para o PC e para os registradores IF/ID

(PC.write

e IF/ID.write) como uma

forma de impedir que as instruções que estão nos

estágios IF e ID caminhem pelo pipeline

• Insere uma bolha entre a instrução lw e a

instrução no estágio ID (isto é, insere uma

instrução nop )

– Os bits de controle nos registradores EX, MEM, WB

são setados como 0

– A instrução após a instrução lw continua sua execução

no pipeline

(4)

Caminho

de dados com

de dados com dete

deteç

ção

ão

de hazard

de

hazard

Read Address Instruction Memory Add P C 4 Write Data Read Addr 1 Read Addr 2 Write Addr Register File Read Data 1 Read Data 2 16 32 ALU Shift left 2 Add Data Memory Address Write Data Read Data IF/ID Sign Extend ID/EX EX/MEM MEM/WB Control ALU cntrl Branch PCSrc Forward Unit Hazard Unit 0 1

Caminho

de dados com detec

de dados com

detecç

ção

ão

de hazard

de

hazard

Read Address Instruction Memory Add P C 4 Write Data Read Addr 1 Read Addr 2 Write Addr Register File Read Data 1 Read Data 2 16 32 ALU Shift left 2 Add Data Memory Address Write Data Read Data IF/ID Sign Extend ID/EX EX/MEM MEM/WB Control ALU cntrl Branch PCSrc Forward Unit Hazard Unit 0 1 ID/EX.RegisterRt 0 ID/EX.MemRead

Hazards de

Hazards de controle

controle

• Ocorrem quando o fluxo de execução não é

sequencial (i.e., PC = PC + 4):

– Desvios condicionais (beq, bne)

– Desvios incondicionais (j, jal, jr)

– Exceções

• Como resolver?

– bolhas (impacto negativo no CPI)

– Mover o ponto de decisão mais atrás do pipeline,

como uma forma de reduzir stalls

– Decisão atrasada (necessita de suporte provido pelo

compilador para reorganizar o código)

– Predição de desvios

• Hazards de desvio ocorrem com menos

frequência que hazard de dados, mas não existe

nada tão efetivo como encaminhamento de

dados no hazard de dados

Hazards

de controle

• Considere que o desvio não foi tomado

– Fazer um stall até o desvio termine torna a execução lenta – Um melhoria é considerar que o desvio não foi tomado – Instruções já decodificadas precisam ser descartadas

– Descartar instruções significa que precisamos ser capazes de dar flushnas instruções que estão nos estágios IF, ID e EX do pipeline

• Reduzindo o atraso dos desvios

– Os projetistas do MIPS observaram que a maioria dos desvios é simples (igualdade ou sinal), e não necessitam de uma ALU completa, apenas de um conjunto de portas

– Levar a decisão do desvio para cima exige que duas ações ocorram mais cedo:

• Calcular o endereço de destino do desvio • Avaliar a condição do desvio

Decisão

atrasada

(Delayed branch)

• Se o hardware de controle de desvios for movido

para o estágio ID, pode-se então eliminar todos os

stalls causados por desvios com delayed branchs

• Delayed branchs significam que a próxima

instrução, após a instrução de desvio, será sempre

executada

– O compilador MIPS movimenta uma instrução

imediatamente após o desvio que não é afetada pelo

desvio (instrução chamada de instrução segura)

– Com pipelines mais extensos, a decisão adiada querer

mais de um slot de atraso

• Delayed branches perderam sua popularidade comparada com os mais caros, mas mais flexíveis preditores de desvio

• A integração de transistores torna a predição de desvios mais barata

Escalonamento

de slots de atraso

de slots de

atraso

• A é a melhor escolha, preenche o slot e reduz o CPI

• Em B e C, a instrução sub deve ser copiada, aumentando o CPI • Em B e C, deve tomar cuidado na execução: o sub não pode causar

danos (trabalho desperdiçado mas programa correto)

add $1,$2,$3 if $2=0 then

delay slot

A. From before branch B. From branch target C. From fall through

add $1,$2,$3 if $1=0 then delay slot add $1,$2,$3 if $1=0 then delay slot sub $4,$5,$6 sub $4,$5,$6 becomes becomes becomes

if $2=0 then add $1,$2,$3 add $1,$2,$3 if $1=0 then sub $4,$5,$6 add $1,$2,$3 if $1=0 then sub $4,$5,$6

(5)

Predi

Prediç

ção

ão

est

está

ática

tica

de desvios

de

desvios

• Solução mais simples para a predição é assumir

que o desvio não será tomado, e assim,

continuando com a busca das próximas

instruções; apenas quando o desvio é tomado o

pipeline stalls

• Se o desvio deve ser tomado, deve-se descartar

(flush) as instruções após o branch

• Nos estágios IF, ID, e EX se a lógica de desvios está em MEM –3stalls

• Nos estágios IF e ID se a lógica de desvio estiver em EX –2

stalls

• No estágio IF se a lógica de desvio está em ID –1stall • Reinicia-se então o pipeline para o endereço do desvio

Predi

Prediç

ção

ão

está

est

ática

tica

de desvios

de

desvios

• Assumir que o desvio não será tomado funciona bem

para estruturas de desvios que residem no topo de um

laço de repetição

– Mas tais estruturas tem também um desvio incondicional no final do laço (overhead de jump)

• Assumir que o desvio não será tomado não funciona

bem com estruturas de desvio na forma em que a

decisão está ao final do laço de repetição

Loop: beq $1,$2,Out 1nd_{loop instr}

. . .

last loop instr j Loop Out: fall out instr

Loop: 1st_{loop instr} 2nd_{loop instr}

. . .

last loop instr bne $1,$2,Loop fall out instr

Previsão

dinâmica

de desvios

de

desvios

• Um buffer de predição de desvios (tabela de histórico de

desvios (BHT)) no estágio IF e endereçada pelos bits

menos significativos do PC, contém um bit para cada

estágio ID através do registrador de pipeline IF/ID que

informa se o desvio foi tomado da última vez que foi

executado

– O bit pode informar uma predição incorreta (interação diferente ou coincidentemente os mesmos bits de endereço), mas que não afeta a execução correta, e sim o desempenho.

– A decisão de desvio ocorre no estágio ID após determinar que a instrução é um desvio e checar o bit e predição

– Se a predição não é correta, é necessário descartar a instrução (s) do pipeline, reiniciar o pipeline com a instrução correta e inverter o bit de predição

• Uma tabela de predição de tamanho igual a 4096 varia seu desempenho entre 1% a 18% (percentual de erros)

Buffer de

Buffer de alvos

alvos

de desvios

de

desvios

• A BHT realiza um predição sobre

quando

um desvio é

tomado, mas não informa para

onde

deve prosseguir a

execução

– Um buffer de alvos de desvios (branch target buffer (BTB))no estágio IF pode armazenar temporariamente as instruções nos endereços dos desvios

– O bit de predição de desvio do registrador IF/ID seleciona a próxima instrução a ser executada

• Se a predição é correta, stalls podem ser evitados não

importando se o desvio deve ser tomado ou não

Read Address Instruction Memory P C 0 BTB

Desempenho

da

previsão

com 1 bit

• Um preditor de um 1 bit está errado duas vezes se o desvio não for tomado

• Para 10 vezes que as instruções do laço são executadas, tem-se um desempenho de predição igual a 80 % para um desvio que é tomado 90% do tempo (2 previsões incorretas para 8 corretas)

• Penalidade é maior para laços com número menor de repetições (pense em um laço que é frequentemente executado, mas que repete apenas 5 vezes)

• Assumindo que predict_bit = 0 no início (indicando que o desvio não foi tomado) e o controle de repetição ao final do laço

• Na primeira vez que o laço é executado, o preditor erra a predição desde que o desvio deve ser executado para o início do laço de repetição; o bit é então invertido e segue-se a execução

• Na medida que o laço de repetição executa, o bit de predição é correto • Na saída do laço, o preditor novamente erra sua predição, desde que desta vez o

desvio não deve ser tomado; assim, o bit de predição é invertido (predict_bit = 0) Loop: 1st_{loop instr}

2nd_{loop instr}

. . .

Previsão

com

com dois

dois

bits

• Um esquema de previsão com 2 bits pode obter

uma precisão de 90% desde que a previsão

deve estar errada duas vezes antes de alterar o

valor do bit de previsão

Predict Taken Predict Not Taken Predict Taken Predict Not Taken Taken Not taken Not taken Not taken Not taken Taken Taken Taken

Loop: 1stloop instr 2nd_{loop instr}

. . .

(6)

Previsão

com 2 bits

• Um esquema de previsão com 2 bits pode obter uma precisão de 90% desde que a previsão deve estar errada duas vezes antes de alterar o valor do bit de previsão

Predict Taken Predict Not Taken Predict Taken Predict Not Taken Taken Not taken Not taken Not taken Not taken Taken Taken Taken

Loop: 1stloop instr 2nd_{loop instr}

. . .

Errado na saída do loop

0

1

1 Correto 9 vezes

Correto na 1st iteração

0

10 11 01 00

Pipelining

avan

ç

ado: extraindo mais desempenho

• A técnica de pipelining explora o paralelismo em

nível de instrução (ILP)

• Dois métodos para aumentar o desempenho

– Aumentar o número de estágios

– Replicar os componentes internos do computador de

modo que ele possa iniciar várias instruções ao mesmo

tempo: técnica de despacho múltiplo

• Permite que a velocidade de execução da instrução exceda a velocidade de clock, de forma que o CPI seja menor que 1 • Microprocessadores atuais tentam despachar de três a oito

instruções a cada ciclo de clock

– Formas de despacho múltiplo

• Despacho múltiplo estático • Despacho múltiplo dinâmico

Despacho m

Despacho mú

últiplo

ltiplo

• Duas responsabilidades

– Empacotar as instruções em slots de despacho: como o

processador determina quantas instruções e quais

instruções podem ser despachadas em um determinado

ciclo de clock?

• No despacho estático, tratado pelo menos parcialmente pelo compilador

• No despacho dinâmico, isso normalmente é tratado durante a execução pelo processador, embora o compilador já tenha ajudado a melhorar a velocidade do despacho colocando as instruções em um ordem benéfica

– Lidar com hazards de dados e controle

• em processadores de despacho estático, os hazards são tratados estaticamente pelo compilador

• Em processadores com despacho dinâmico, tratados durante a execução

O conceito de especula

O conceito de especulaç

ção

ão

• Técnica que permite que o compilador e/ou processador

adivinhem as propriedades (dependências) das instruções

– Execução adiantada de instruções – Exemplos:

• pode-se especular a respeito de um desvio e executar as instruções após o desvio mais cedo

• Pode-se especular que store que precede um load não se refere ao mesmo endereço e executá-lo mais cedo

– Por software

• Reorganiza o código de forma a melhorar o desempenho, associando rotinas para tratar caso uma especulação seja incorreta

– Por hardware

• Processador armazena os resultados especulados em um buffer, de forma que os resultados são escritos nos registradores apenas se a especulação for correta

Despacho m

Despacho mú

últiplo est

ltiplo está

ático

tico

• Processadores com despacho estático

– Compilador ajuda o empacotamento das instruções

– Conjunto de instruções despachadas em um ciclo de

clock

é chamado de pacote de despacho

– Pode-se considerar que um pacote de despacho como

uma única instrução, que permitem várias operações

– VLIW (Very long instruction word)

• Arquitetura Intel: EPIC (Explicitly Parallel Instruction Computer)

– Processadores Itanium

– Os hazards de dados e controle são controlados pelo

compilador, que pode assumir também as tarefas de

previsão estática de desvios

– Hardware também pode detectar os hazards e gerar

stalls, quando necessário

Despacho m

Despacho mú

últiplo com o ISA do MIPS

ltiplo com o ISA do MIPS

• Fazer com que o despacho funcione envolve:

– Tratamento de hazards pelo compilador e/ou

processador

(7)

Despacho m

Despacho mú

últiplo com o ISA do MIPS

ltiplo com o ISA do MIPS

• Requisitos

– Para emitir uma operação da ALU e um operação de transferência de dados em paralelo, a primeira necessidade para o hardware adicional são portas extras no banco de registradores

– Somador separado para calcular o endereço efetivo em operações de load/store , pois a ALU é utilizada para a instrução aritmética no mesmo ciclo

• Sem tais recursos, o pipeline ficaria preso aos hazards estruturais

Desdobramento de

Desdobramento de loop

loop

lp: lw $t0,0($s1) # $t0=array element lw $t1,-4($s1) # $t1=array element lw $t2,-8($s1) # $t2=array element lw $t3,-12($s1) # $t3=array element addu $t0,$t0,$s2 # add scalar in $s2 addu $t1,$t1,$s2 # add scalar in $s2 addu $t2,$t2,$s2 # add scalar in $s2 addu $t3,$t3,$s2 # add scalar in $s2 sw $t0,0($s1) # store result sw $t1,-4($s1) # store result sw $t2,-8($s1) # store result sw $t3,-12($s1) # store result addi $s1,$s1,-16 # decrement pointer bne $s1,$0,lp # branch if $s1 != 0

Escalonamento do c

Escalonamento do có

ódigo desdobrado

digo desdobrado

8 sw $t3,4($s1) bne $s1,$0,lp 7 sw $t2,8($s1) 6 sw $t1,12($s1) addu $t3,$t3,$s2 5 sw $t0,16($s1) addu $t2,$t2,$s2 4 lw $t3,4($s1) addu $t1,$t1,$s2 3 lw $t2,8($s1) addu $t0,$t0,$s2 2 lw $t1,12($s1) 1 lw $t0,0($s1) addi $s1,$s1,-16 lp: CC Data transfer ALU or branch

Arquitetura Intel IA

-

64

• IA-64

– Conjunto de instruções registrador-registrador, estilo RISC, como a versão de 64 bits da arquitetura MIPS (MIPS-64), com vários recursos exclusivos para dar suporte à exploração explícita do ILP, controlada por compilador

– Técnica chamada de EPIC (Explicity parallel instruction computer)

• IA-64 tem vários registradores, 128 registradores inteiros e 128 registradores em ponto flutuante

• Instruções em formato fixo e designação explícita de dependências

– Idéia de grupos de instruções e parada entre instruções – Pacotes de 128 bits de largura

• Campo de modelo de 5 bits e três instruções, cada uma com 41 bits de largura

• Modelo especifica quais das unidades de execução serão utilizadas (ALU inteiros, ALU não inteiros, memória, PF e unidade de desvio) • Predição para melhorar o desempenho de desvios e loops, com uso de