Y86: Encadeamento de Instruções (PIPE-)

Y86:Encadeamento de Instruções (PIPE-)

Arquitectura de ComputadoresLic. em Engenharia Informática

2008/09Luís Paulo Santos

Y86: Encadeamento de instruções (pipeline)

AC – Y86: PIPE- 2

Conteúdos

9 – Organização do Processador

9.3 – Datapath encadeado (pipeline) C1

9.4 – Dependências de Dados e Controlo C2

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

C2

Clock

Lógica CombinatóriaReg

300 ps 20 ps

Clock

Latência= 320 psCiclo = 320 psDébito = 1 / 320E-12 = 3.12 GOPS

Reg

Exemplo Sequencial

• Toda a computação feita num único ciclo: 300 ps para gerar os resultados + 20 ps para os armazenar

• Ciclo do relógio >= 320 ps

AC – Y86: PIPE- 3

Encadeamento na Vida Real

AC – Y86: PIPE- 4

• Ideia– Dividir processo em estágios

independentes– Objectos movem-se através dos

estágios em sequência– Em cada instante, múliplos objectos são

processados simultaneamente

Sequencial Paralelo

Encadeado (Pipeline)

Encadeamento: Exemplo

AC – Y86: PIPE- 5

– Dividir lógica combinatória em 3 blocos de 100 ps cada– Nova operação começa logo que uma termina o bloco A.

• Ciclo >= 120 ps– Latência aumenta (360 ps) mas débito também

Reg

Clock

Comb.logicA

Reg

Comb.logicB

Reg

Comb.logicC

100 ps 20 ps 100 ps 20 ps 100 ps 20 ps

Latência = 360 psCiclo = 120 psDébito = 8.33 GOPS

Clock

Reg

Reg

Reg

Encadeamento: Diagramas

AC – Y86: PIPE- 6

• Sequencial

– Só começa uma nova operação quando a anterior termina• 3-Way Pipelined

– Até 3 operações simultaneamente

Time

OP1

OP2

OP3

Time

A B C

A B C

A B C

OP1

OP2

OP3

Limitações: Latências não uniformes

AC – Y86: PIPE- 7

– Débito limitado pelo estágio mais lento– Outros estágios ficam inactivos durante parte do tempo– Desafio: decompor um sistema em estágios balanceados

Reg

Clock

Reg

Comb.logic

B

Reg

Comb.logic

C

50 ps 20 ps 150 ps 20 ps 100 ps 20 ps

Comb.logic

A

Time

OP1

OP2

OP3

A B C

A B C

A B C

Latência = 510 psCiclo = 170 psDébito = 5.88 GOPS

Limitações: custo do registo

AC – Y86: PIPE- 8

– Pipelines mais profundos têm maiores custos associados aos registos

– Percentagem de tempo devido aos registos por instrução:• 1-stage pipeline: 6.25% (020 em 320 ps)• 3-stage pipeline: 16.67% (060 em 360 ps)• 6-stage pipeline: 28.57% (120 em 420 ps)

Latência= 300 + 120 = 420 ps, Ciclo=70 ps, Throughput = 14.29 GOPSClock

Reg

Comb.logic

50 ps 20 ps

Reg

Comb.logic

50 ps 20 ps

Reg

Comb.logic

50 ps 20 ps

Reg

Comb.logic

50 ps 20 ps

Reg

Comb.logic

50 ps 20 ps

Reg

Comb.logic

50 ps 20 ps

Y86: PIPE-

AC – Y86: PIPE- 9

Instructionmemory

Instructionmemory

PCincrement

PCincrement

CCCCALUALU

Datamemory

Datamemory

Fetch

Decode

Execute

Memory

Write back

icode, ifunrA, rB

valC

Registerfile

Registerfile

A BM

E

Registerfile

Registerfile

A BM

E

pState

valP

srcA, srcBdstA, dstB

valA, valB

aluA, aluB

Bch

valE

Addr, Data

valM

PC

valE, valM

valM

icode, valCvalP

PCPC

incrementPC

increment

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

valM

PC

W_valE, W_valM, W_dstE, W_dstMW_icode, W_valM

icode, ifun,rA, rB, valC

E

M

W

F

D

valP

f_PC

predPC

Instructionmemory

Instructionmemory

M_icode, M_Bch, M_valA

Y86: Estágios do pipeline

AC – Y86: PIPE- 10

• Fetch– Seleccionar PC– Ler instrução– Calcular próximo PC

• Decode– Ler registos genéricos

• Execute– ALU

• Memory– Ler ou escrever na memória

• Write Back– Escrever nos registos

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

valM

PC

W_valE, W_valM, W_dstE, W_dstMW_icode, W_valM

icode, ifun,rA, rB, valC

E

M

W

F

D

valP

f_PC

predPC

Instructionmemory

Instructionmemory

M_icode, M_Bch, M_valA

1 2 3 4 5 6

I1

I2

I3

I4

I5

I6

Y86 PIPE- : Execução

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: irmovl $10, %eax

I2: mrmovl 30(%ebx), %ecx

I3: addl %esi, %edi

I4: subl %esi, %ebx

I5: addl %eax, %eax

I6: jmp MAIN

F

F

D

F

D

E

F

D

E

M

F

D

E

M

W

F

D

E

M

W

I1

I1

I2

I1

I2

I3

I1

I2

I3

I4

I1

I2

I3

I4

I5

I2

I3

I4

I5

I6

Y86 PIPE-

AC – Y86: PIPE- 12

– Os registos do Pipeline contêm todos os valores intermédios necessários para executar a instrução

• Forward (Upward) Paths– Os valores passam de um

estágio para o próximo– Não podem saltar estágios

• ex., valC passa pelo estágio de Decode (apesar de não ser usado)

E

M

W

F

D

Instructionmemory

Instructionmemory

PCincrement

PCincrement

Registerfile

Registerfile

ALUALU

Datamemory

Datamemory

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

AC – Y86: PIPE- 13

Y86 PIPE-: feedback

• Predict PC– Valor do próximo PC

– valP: instruções genéricas– valC: jmp, call

• Saltos condicionais– tomado/não tomado– Alvo (valC) / Continua (valP)

• Endereço de retorno– Ler da memória

• Actualizar registos

E

M

W

F

D

Instructionmemory

Instructionmemory

PCincrement

PCincrement

Registerfile

Registerfile

ALUALU

Datamemory

Datamemory

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


predPC

CCCC

d_srcBd_srcA

e_Bch

M_Bch

1 2 3 4 5 6

Y86: Dependências de Controlo - jXX

AC – Y86: PIPE- 14

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: subl %eax, %eax

I2: jz I5

I3: addl %esi, %edi

I4: subl %esi, %ebx

I5: addl %ecx, %edx

F

F

D

F

D

E

I1

I1

I2

I1

I2

I5

?

I1

I2

I5

Prevê salto condicional como tomado


• Análises estatísticas mostram que os saltos condicionais são tomados em 60% dos casos

• Prevendo que o salto é tomado a decisão certa é tomada mais do que metade das vezes

• Alternativas:– NT – Not Taken– BTFNT – Backward Taken, Forward Not Taken

AC – Y86: PIPE- 15

AC – Y86: PIPE- 16

1 2 3 4 5 6


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: subl %eax, %eax

I2: jnz I5

I3: addl %esi, %edi

I4: subl %esi, %ebx

I5: addl %ecx, %edx


I7: irmovl $20, %esi

F

F

D

F

D

E

I1

I1

I2

I1

I2

I5

I1

I2

I5

F

D

E

M

I6

I1

I2

I5

I6

I1

I2

nop

icode=00dstE=dstM=8

nop

I3I3 F

M

W

E

D

I4 F

D

W

M

E

I2

I3

nop

nop

I4

I5

I6


• Prevê-se que o salto é sempre tomado• A correcção da previsão é determinada 2 ciclos depois, quando

a instrução de salto termina o estágio de execução• Se a previsão estiver errada as 2 instruções que entretanto

foram lidas para o pipeline são convertidas em nops:– Injecção de “bolhas”

• Isto é possível porque estas instruções ainda não tiveram hipótese de alterar o estado da máquina– Escritas que alteram o estado acontecem apenas nas fases de “EXECUTE”

(CC), “MEMORY” e “WRITEBACK” (Registos)• stall do pipeline (injecção de “bolhas”): resulta num desperdício

de um número de ciclos igual ao número de bolhas injectadas

AC – Y86: PIPE- 17

AC – Y86: PIPE- 18AC – Y86: PIPE- 18

1 2 3 4 5 6

Y86: Dependências de Controlo - ret

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: call I2

I2: halt

I3: ret

I4: addl %eax, %eax

F

F

D

F

D

E

I1

I1

I3

I1

I3

I4

I1

I3

I4

I4

I4 F

M

W

E

D

I2

I1

I3

nop

nop

I4F

E

M

D

I1

I3

I4

nop

I3

nop

nop

nop

F

W

M

E

D

I2

Y86: Dependências de Controlo - ret

• Não é possível prever o destino do salto, pois este endereço encontra-se no topo da pilha

• A memória é lida apenas durante o estágio “MEMORY”• O endereço de retorno estará disponível apenas 4 ciclos

depois do início da execução do ret (W_valM)

• Obriga a injectar 3 “bolhas”

• Alternativas:– Stack específica para endereços de retorno (call / ret)

AC – Y86: PIPE- 19

1 2 3 4 5 6 7

AC – Y86: PIPE- 20

Y86: Dependências de dados

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


I2: addl %ebx, %eax

I3: irmovl $20, %ebx

I4: irmovl $20, %edx

F

F

D

F

D

E

I1

I1

I2

I1

I2

I3

I1

I2

B1

B2

B3

F

D

W

M

E

I3

I1

I2

nop

nop

I3F

D

M

E

I1

I2

I3

nop

F

D

W

M

E

I2

nop

nop

I3

nop

I4

I3

nop

I4

nop

I2

F

D

W

M

E

Y86 – Dependências de dados

• Os registos são escritos apenas no estágio de WRITEBACK• Se uma instrução tenta ler um registo antes da escrita

estar terminada é necessário resolver a dependência• Na versão PIPE- a leitura tem que ser adiada até ao ciclo

imediatamente a seguir à escrita• Isto é conseguido injectando “bolhas” no estágio de

execução

AC – Y86: PIPE- 21


I2: addl %ebx, %eax

I3: irmovl $20, %ebx


I1: popl %eax

I2: addl %ebx, %eax

I3: pushl %ebx


Dependênciano %esp

Y86 PIPE- : fetch

AC – Y86: PIPE- 22

F

D rB

M_icode

PredictPC


Instructionmemory

Instructionmemory

PCincrement

PCincrement

predPC

Needregids

NeedvalC

Instrvalid

AlignAlignSplitSplit

Bytes 1-5Byte 0

SelectPC

M_Bch

M_valA

W_icode

W_valM

• Prever PC

• valP ou valC da instrução anterior• M_valA – jXX baseado em M_icode, M_Bch• W_valM – ret baseado em W_icode

• Ler instrução

• calcular valP

• seleccionar valP ou valC baseado em icode (jmp,call)

Y86 PIPE- : Sumário

AC – Y86: PIPE- 23

• Conceito– Dividir execução das instruções em 5 estágios

• Limitações– Dependências entre instruções resolvidas injectando “bolhas”

Pode resultar num número significativo de ciclos desperdiçados– Dependências de Dados

• Uma instrução escreve um registo, outra lê-o mais tarde• Exigem a injecção de “bolhas”

– Dependências de Controlo• Saltos condicionais: pode ser carregado um valor errado no PC (erro de

previsão)• Return: não pode ser previsto qual o endereço de retorno• Exigem a injecção de “bolhas”

Documents

Y86: Encadeamento de Instruções (PIPE-)