Y86: Encadeamento de Instruções (PIPE)

Y86:Encadeamento de Instruções (PIPE)

Arquitectura de ComputadoresLic. em Engenharia Informática

Luís Paulo Santos

Y86: Encadeamento de instruções (pipeline)

AC – Y86: PIPE 2

Conteúdos9 – Organização do Processador9.2 – Datapath encadeado (pipeline) C1

9.3 – Dependências de Dados e Controlo C1

Resultados de Aprendizagem

R9.2 – Analisar e descrever organizações encadeadas de processadores elementares C1

R9.3 – Caracterizar limitações inerentes a organizações encadeadas (dependências) e conceber potenciais soluções

C1

Y86 PIPE-: Limitações

• Dependências de Dados– Uma leitura de um registo precedida de uma escrita no mesmo registo

constitui uma dependência de dados– Se a leitura ocorre antes da conclusão da escrita ocorre uma anomalia– Na versão PIPE- estas anomalias são corrigidas empatando o pipeline

através da injecção de “bolhas” (nops)• Dependências de controlo

– O desfecho dos saltos condicionais só é conhecido depois da fase de execução. O Y86 prevê que o salto é tomado, executando as instruções no alvo de forma especulativa. Previsões erradas são corrigidas inserindo “bolhas”.

– O destino de um ret só é conhecido depois da fase de leitura de memória. O Y86 resolve esta anomalia inserindo “bolhas” até que o endereço da próxima instrução seja conhecido.

AC – Y86: PIPE 3

Y86 PIPE: Motivação

• As dependências de dados são demasiado comuns • Resolvê-las recorrendo à injecção de “bolhas” resulta no

desperdício de um elevado número de ciclos, comprometendo o desempenho do pipeline

• A versão PIPE do Y86 propõe-se resolver estas dependências de dados, diminuindo o número de bolhas injectadas (logo o número de ciclos desperdiçados)

• As dependências de controlo não sofrem qualquer alteração relativamente a PIPE-

AC – Y86: PIPE 4

PIPE-: Condições para stall

AC – Y86: PIPE 5

• Registo a ler– d_srcA e d_srcB

(instrução no estágio de decode)

• Registos destino – dstE e dstM nos estágios E,

M e W• Dependência Dados

– d_srcA ou d_srcB == E_dst? ou M_dst? Ou W_dst? (? = E ou M)

• Ignorar se RegID==8

E

M

W

F

D

Instructionmemory

Instructionmemory

PCincrement

PCincrement

Registerfile

Registerfile

ALUALU

DatamemoryData

memory

SelectPC

rB

dstE dstMSelectA

ALUA

ALUB

Mem.control

Addr

srcA srcB

read

write

ALUfun.

Fetch

Decode

Execute

Memory

Write back

icode

data out

data in

A BM

E

M_valA

W_valM

W_valE

M_valA

W_valM

d_rvalA

f_PC

PredictPC

valE valM dstE dstM

Bchicode valE valA dstE dstM

icode ifun valC valA valB dstE dstM srcA srcB

valC valPicode ifun rA

predPC

CCCC

d_srcBd_srcA

e_Bch

M_Bch

PIPE- : Implementação do stalling

AC – Y86: PIPE 6

E

M

W

F

D rB

srcAsrcB

icode valE valM dstE dstM


icode ifun valC valA valB dstE dstM srcA srcB


predPC

d_srcB

d_srcA

D_icode

E_dstE

E_dstMPipe

controllogic

D_stall

E_bubble

M_dstE

M_dstM

W_dstE

W_dstM

F_stall

Se (d_srcA in {E_dstE, E_dstM, M_dstE, M_dstM, W_dstE, W_dstM} || d_srcB in {E_dstE, E_dstM, M_dstE, M_dstM, W_dstE, W_dstM} )Então E_bubble = D_stall = F_stall =1;

E_bubble“Injecção” de um nop no estágio E (icode=0, E_dstE=E_dstM=8)

D_stallEscrita no registo D inibida

F_stallEscrita no registo F inibida

Data Forwarding

• Problema– Um registo é lido na fase de DECODE– A escrita só ocorre na fase de WRITEBACK

• Observação– O valor a escrever no registo é gerado na fase de execução

ou memória

• Resolução do problema– Passar o valor necessário directamente do estágio onde está

disponível (E, M ou W) para o estágio de DECODE

AC – Y86: PIPE 7

1 2 3 4 5 6

I1

I2

I3

I4

I5

I6

Y86 PIPE: Exemplo de Forwarding (1)

AC – Y86: PIPE 8

PCincrement

PCincrement

CCCCALUALU

Datamemory

Datamemory

Fetch

Decode

Execute

Memory

Write back

Registerfile

Registerfile

A BM

E

Registerfile

Registerfile

A BM

E

valP

d_srcA, d_srcB

valA

,

valB

aluA, aluB

Bch valE

Addr, Data

rA,

E

M

W

F

D

valP

f_PC

Instructionmemory

Instructionmemory

I1: irmovl $10, %eaxI2: mrmovl 30(%ebx), %ecxI3: addl %esi, %ediI4: addl %esi, %eaxI5: jmp MAIN

FFD

F

DE

FD

EM

FDE

MW

FDEM

W

I1

I2

I3

I4

I5

I2

I3

I4

I5

I6

Forward

valE

W_valE

valB = W_valE

1 2 3 4 5 6

I1

I2

I3

I4

I5

I6


AC – Y86: PIPE 9

PCincrement

PCincrement

CCCCALUALU

Datamemory

Datamemory

Fetch

Decode

Execute

Memory

Write back

Registerfile

Registerfile

A BM

E

Registerfile

Registerfile

A BM

E

valP

d_srcA, d_srcB

valA

,

valB

aluA, aluB

Bch valE

Addr, Data

rA,

E

M

W

F

D

valP

f_PC

Instructionmemory

Instructionmemory

I1: irmovl $10, %eaxI2: mrmovl 30(%ebx), %ecxI3: addl %esi, %eaxI4: …

FFD

F

DE

FD

EM

FDE

MW

FDEM

W

I1

I2

I3

I4

I1

I2

I3

I4

I5

Forward

valE

M_valE

valB = M_valE

1 2 3 4 5 6

I1

I2

I3

I4

I5

I6


AC – Y86: PIPE 10

PCincrement

PCincrement

CCCCALUALU

Datamemory

Datamemory

Fetch

Decode

Execute

Memory

Write back

Registerfile

Registerfile

A BM

E

Registerfile

Registerfile

A BM

E

valP

d_srcA, d_srcB

valA

,

valB

aluA, aluB

Bch valE

Addr, Data

rA,

E

M

W

F

D

valP

f_PC

Instructionmemory

Instructionmemory

I1: irmovl $10, %eaxI2: addl %esi, %eaxI3: …

FFD

F

DE

FD

EM

FDE

MW

FDEM

W

I1

I2

I3

Forward

e_valE

valB = e_valE

1 2 3 4 5 6

I1

I2

I3

I4

I5

I6


AC – Y86: PIPE 11

PCincrement

PCincrement

CCCCALUALU

Datamemory

Datamemory

Fetch

Decode

Execute

Memory

Write back

Registerfile

Registerfile

A BM

E

Registerfile

Registerfile

A BM

E

valP

d_srcA, d_srcB

valA

,

valB

aluA, aluB

Bch valE

Addr, Data

rA,

E

M

W

F

D

valP

f_PC

Instructionmemory

Instructionmemory

I1: mrmovl 30(%ebx), %ecxI3: addl %esi, %ebxI3: addl %esi, %ediI4: addl %ecx, %eaxI5: jmp MAIN

FFD

F

DE

FD

EM

FDE

MW

FDEM

W

I1

I2

I3

I4

I5

I2

I3

I4

I5

I6

Forward

valM

W_valM

valA = W_valM

1 2 3 4 5 6

I1

I2

I3

I4

I5

I6


AC – Y86: PIPE 12

PCincrement

PCincrement

CCCCALUALU

Datamemory

Datamemory

Fetch

Decode

Execute

Memory

Write back

Registerfile

Registerfile

A BM

E

Registerfile

Registerfile

A BM

E

valP

d_srcA, d_srcB

valA

,

valB

aluA, aluB

Bch valE

Addr, Data

rA,

E

M

W

F

D

valP

f_PC

Instructionmemory

Instructionmemory

I1: mrmovl 30(%ebx), %ecxI2: addl %esi, %ediI3: addl %ecx, %eaxI4: …

FFD

F

DE

FD

EM

FDE

MW

FDEM

W

I1

I2

I3

I4

I1

I2

I3

I4

I5

Forward

m_valM

valA = m_valM

I2

I3

I1

nop

I1: mrmovl 30(%ebx), %ecxI2: addl %ecx, %eaxI3: …

1 2 3 4 5 6

I1

I2

I3

I4

I5


AC – Y86: PIPE 13

PCincrement

PCincrement

CCCCALUALU

Datamemory

Datamemory

Fetch

Decode

Execute

Memory

Write back

Registerfile

Registerfile

A BM

E

Registerfile

Registerfile

A BM

E

valP

d_srcA, d_srcB

valA

,

valB

aluA, aluB

Bch valE

Addr, Data

rA,

E

M

W

F

D

valP

f_PC

Instructionmemory

Instructionmemory

F

F

D

F

D

E

FDE

MW

FDEM

W

I1

I2

I3

Forward

m_valM

valA = m_valM

FD

ME M W

Load /Use

• Uma situação de load/use ocorre quando uma leitura de memória para registo é seguida de uma leitura do mesmo registo

• Como I1 ainda está no estágio de Execute quando I2 pede o valor do registo, este valor ainda não foi lido e não pode ser encaminhado (forwarded) para o Decode

• A resolução da anomalia passa por injectar uma “bolha”, dando assim tempo para que a memória seja lida

AC – Y86: PIPE 14

I1: mrmovl 30(%ebx), %ecxI2: addl %ecx, %eax

Detecção de load/use

AC – Y86: PIPE 15

M

F

D

Instructionmemory

Instructionmemory

PCincrement

PCincrement

Registerfile

Registerfile

CCCC ALUALU

Datamemory

Datamemory

SelectPC

rB

dstE dstM

ALUA

ALUB

Mem.control

Addr

srcA srcB

read

write

ALUfun.

Fetch

Decode

Execute

Memory

Write back

data out

data in

A BM

E

M_valA

W_valE

W_valM

W_valE

M_valA

W_valM

f_PC

PredictPC


E icode ifun valC valA valB dstE dstM srcA srcB


predPC

d_srcBd_srcA

e_Bch

M_Bch

Sel+FwdA

FwdB

W icode valE valM dstE dstM

m_valM

W_valM

M_valE

e_valE

M

F

D

Instructionmemory

Instructionmemory

PCincrement

PCincrement

Registerfile

Registerfile

CCCC ALUALU

Datamemory

Datamemory

SelectPC

rB

dstE dstM

ALUA

ALUB

Mem.control

Addr

srcA srcB

read

write

ALUfun.

Fetch

Decode

Execute

Memory

Write back

data out

data in

A BM

E

M_valA

W_valE

W_valM

W_valE

M_valA

W_valM

f_PC

PredictPC




predPC

d_srcBd_srcA

e_Bch

M_Bch

Sel+FwdA

FwdB


m_valM

W_valM

M_valE

e_valE

m_valM

W_valM

M_valE

e_valE

AnomaliaAnomalia CondiçãoCondição

Load/UseLoad/Use E_icode in { IMRMOVL, IPOPL } && E_icode in { IMRMOVL, IPOPL } && E_dstM in { d_srcA, d_srcB }E_dstM in { d_srcA, d_srcB }

1 2 3 4 5 6

I1

I2

I3

I4

I5

I6

Y86 PIPE: Atalho a usar

AC – Y86: PIPE 16

PCincrement

PCincrement

CCCCALUALU

Datamemory

Datamemory

Fetch

Decode

Execute

Memory

Write back

Registerfile

Registerfile

A BM

E

Registerfile

Registerfile

A BM

E

valP

d_srcA, d_srcB

valA

,

valB

aluA, aluB

Bch valE

Addr, Data

rA,

E

M

W

F

D

valP

f_PC

Instructionmemory

Instructionmemory

I1: irmovl $10, %eaxI2: irmovl $30, %eaxI3: addl %eax, %eax

FFD

F

DE

FD

EM

I1

I2

I3

I4

Forward

valE

e_valE

valA = valB = e_valE

AC – Y86: PIPE 17

Y86 PIPE: implementação de

forwarding

– Adicionar 5 atalhos dos registos de pipeline E, M, e W para o estágio DECODE

– Adicionar 2 multiplexers para seleccionar valA e valB no DECODE

M

F

D

Instructionmemory

Instructionmemory

PCincrement

PCincrement

Registerfile

Registerfile

CCCC ALUALU

Datamemory

Datamemory

SelectPC

rB

dstE dstM

ALUA

ALUB

Mem.control

Addr

srcA srcB

read

write

ALUfun.

Fetch

Decode

Execute

Memory

Write back

data out

data in

A BM

E

M_valA

W_valE

W_valM

W_valE

M_valA

W_valM

f_PC

PredictPC




predPC

d_srcBd_srcA

e_Bch

M_Bch

Sel+FwdA

FwdB


m_valM

W_valM

M_valE

e_valE

Y86 PIPE: implementação de forwarding

AC – Y86: PIPE 18

M

F

D

Instructionmemory

Instructionmemory

PCincrement

PCincrement

Registerfile

Registerfile

CCCC ALUALU

Datamemory

Datamemory

SelectPC

rB

dstE dstM

ALUA

ALUB

Mem.control

Addr

srcA srcB

read

write

ALUfun.

Fetch

Decode

Execute

Memory

Write back

data out

data in

A BM

E

M_valA

W_valE

W_valM

W_valE

M_valA

W_valM

f_PC

PredictPC




predPC

d_srcBd_srcA

e_Bch

M_Bch

Sel+FwdA

FwdB


m_valM

W_valM

M_valE

e_valE

## Qual o atalho a utilizar?## NOTA: X representa A ou B conforme## se trate de valA ou valB

int new_E_valX = [ # Use incremented PC

D_icode in { ICALL, IJXX } : D_valP; # Forward valE from execute

d_srcX == E_dstE : e_valE; # Forward valM from memory

d_srcX == M_dstM : m_valM; # Forward valE from memory

d_srcX == M_dstE : M_valE; # Forward valM from write back d_srcX == W_dstM : W_valM; # Forward valE from write back

d_srcX == W_dstE : W_valE; # Use value read from register file 1 : d_rvalX;];

Y86 PIPE: Resumo

• Dependências de Dados– Tratadas maioritariamente com forwarding

• Não há penalização no desempenho– Load/use exige que se empate o pipeline durante 1 ciclo

• Dependências de Controlo (não há alterações relativamente a PIPE-)

– Salto condicional mal previsto: cancelar instruções em F e D• 2 ciclos do relógio desperdiçados

– ret: Empatar o estágio F (injectando bolhas em E) até o endereço de retorno ser lido

• 3 ciclos do relógio desperdiçados

AC – Y86: PIPE 19

Y86: Encadeamento de Instruções (PIPE)

Documents

Transcript of Y86: Encadeamento de Instruções (PIPE)