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

1. Y86:Encadeamento de Instruções (PIPE-) Arquitectura de Computadores Lic. em Engenharia Informática Luís Paulo Santos

2. Y86: Encadeamento de instruções (pipeline)

3. 300 ps 20 ps Lógica Combinatória R e g Latência= 320 ps Ciclo = 320 ps Débito = 1 / 320E-12 = 3.12 GOPS Clock 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 R e g Clock

4. Paralelo Sequencial Encadeado (Pipeline) Encadeamento na Vida Real • Ideia • Dividirprocessoemestágiosindependentes • Objectosmovem-se através dos estágiosemsequência • Emcadainstante, múliplosobjectossãoprocessadossimultaneamente

5. 100 ps 20 ps 100 ps 20 ps 100 ps 20 ps Comb. logic A R e g Comb. logic B R e g Comb. logic C R e g Latência = 360 ps Ciclo = 120 ps Débito = 8.33 GOPS Clock Encadeamento: Exemplo R e g R e g R e g Clock • Dividirlógicacombinatóriaem 3 blocos de 100 pscada • Nova operaçãocomeça logo queumatermina o bloco A. • Ciclo >= 120 ps • Latênciaaumenta (360 ps) masdébitotambém

6. OP1 A A A B B B C C C OP2 OP3 OP1 Time OP2 Time OP3 Encadeamento: Diagramas • Sequencial • Sócomeçauma nova operaçãoquando a anterior termina • 3-Way Pipelined • Até 3 operaçõessimultaneamente

7. 50 ps 20 ps 150 ps 20 ps 100 ps 20 ps Comb. logic A R e g Comb. logic B R e g Comb. logic C R e g Clock OP1 A A A B B B C C C OP2 OP3 Time Limitações: Latências não uniformes Latência = 510 ps Ciclo = 170 ps Débito = 5.88 GOPS • Débitolimitadopeloestágiomais lento • Outrosestágiosficaminactivosdurante parte do tempo • Desafio: decompor um sistemaemestágiosbalanceados

8. Latência= 300 + 120 = 420 ps, Ciclo=70 ps, Throughput = 14.29 GOPS 50 ps 20 ps 50 ps 20 ps 50 ps 20 ps 50 ps 20 ps 50 ps 20 ps 50 ps 20 ps Comb. logic R e g Comb. logic R e g Comb. logic R e g Comb. logic R e g Comb. logic R e g Comb. logic R e g Clock Limitações: custo do registo • Pipelines maisprofundostêmmaiorescustosassociadosaosregistos • Percentagem de tempo devidoaosregistosporinstruçã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)

9. Y86: PIPE-

10. Y86: Estágios do pipeline • 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

11. W M E D rA , valP Instruction Instruction memory memory f_PC F I2 I1 Y86 PIPE- : Execução I1: irmovl $10, %eax I2: mrmovl 30(%ebx), %ecx I3: addl %esi, %edi I4: subl %esi, %ebx I5: addl %eax, %eax I6: jmp MAIN Data Data I1 I3 I2 memory memory Memory Addr , Data Bch valE I1 I2 I3 I4 CC CC ALU ALU Execute aluA , aluB I1 I2 I3 I4 I5 valA , valB d_ srcA , F D E M W Decode A A B B d_ srcB M M Register Register Register Register file file file file E E Write back F D E M W valP F D E M I1 I2 I3 I4 I5 I6 F D E PC PC increment increment Fetch F D F

12. Y86 PIPE- • Os registos do Pipeline contêmtodososvaloresintermédiosnecessáriosparaexecutar a instrução • Forward (Upward) Paths • Os valorespassam de um estágiopara o próximo • Nãopodemsaltarestágios • ex., valCpassapeloestágio de Decode (apesar de não ser usado)

13. M_Bch e_Bch CC CC d_ srcA d_ srcB Write back Y86 PIPE-: feedback W icode valE valM dstE dstM data out read Data Data Mem . control memory memory write Memory data in Addr • Predict PC • Valor do próximo PC • valP: instruçõesgenéricas • valC: jmp, call • Saltoscondicionais • tomado/nãotomado • Alvo (valC) / Continua (valP) • Endereço de retorno • Ler da memória • Actualizarregistos M_ valA M icode Bch valE valA dstE dstM ALU ALU ALU fun. ALU ALU A B Execute E icode ifun valC valA valB dstE dstM srcA srcB d_ rvalA Select dstE dstM srcA srcB A W_ valM Decode A B M Register Register file W_ valE file E D icode ifun rA rB valC valP Predict PC Instruction PC Instruction PC memory increment memory increment Fetch f_PC M_ valA Select PC W_ valM F predPC

14. W M E D rA , valP Instruction Instruction memory memory f_PC F Y86: Dependências de Controlo - jXX I1: subl %eax, %eax I2: jz I5 I3: addl %esi, %edi I4: subl %esi, %ebx I5: addl %ecx, %edx Data Data memory memory Memory Addr , Data ? Prevê salto condicional como tomado Bch valE I1 CC CC ALU ALU Execute aluA , aluB I1 I2 valA , valB d_ srcA , F D E Decode A A B B d_ srcB M M Register Register I1 Register Register file file file file E E Write back F D I2 valP I5 F I1 I2 I5 PC PC increment increment Fetch

15. Y86: Dependências de Controlo - jXX • 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

16. W M E D rA , valP Instruction Instruction memory memory f_PC F I1 Y86: Dependências de Controlo - jXX I2 I1: subl %eax, %eax I2: jnz I5 I3: addl %esi, %edi I4: subl %esi, %ebx I5: addl %ecx, %edx I6: irmovl $10, %eax I7: irmovl $20, %esi I2 Data Data memory memory nop icode=00 dstE=dstM=8 Memory Addr , Data Bch valE nop I1 I1 CC CC ALU ALU Execute nop aluA , aluB nop I5 I1 I2 I2 valA , valB d_ srcA , I3 F D E E M M W W Decode A A B B d_ srcB M M Register Register I1 Register Register file file file file E E Write back F D D M I2 valP E E D I5 F F I5 I1 I6 I3 D I2 I5 I6 I6 F F PC PC I4 increment increment Fetch I3 I4

17. Y86: Dependências de Controlo - jXX • 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

18. W M E D rA , valP Instruction Instruction memory memory f_PC F I6 I5 I4 I1 I3 Y86: Dependências de Controlo - ret I1: call I3 I2: halt I3: addl %ebx, %ebx I4: addl %ecx, %ecx I5: addl %ecx, %ecx I6: ret I7:addl %eax, %eax nop I6 I5 I3 I4 Data Data memory memory Memory Addr , Data Bch valE I1 I1 nop nop I6 I4 I5 CC CC ALU ALU Execute aluA , aluB W F I1 W I1 I4 nop nop nop I6 I3 I3 valA , valB I5 I3 d_ srcA , D E E M M Decode A A B B d_ srcB M M Register Register Register Register E D file file file file I4 M W E E Write back F D valP M W I5 E D F F I6 D E M W I2 I1 I7 I7 I2 I6 I7 I3 I4 I5 F PC PC D increment increment E M F I7 Fetch D E F I7 F D I7 AC – Y86: PIPE- 18 I2 F

19. 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: • Stackespecífica para endereços de retorno (call / ret)

20. W M E D rA , valP Instruction Instruction memory memory f_PC F nop nop Y86: Dependências de dados I1 I1:irmovl $10, %eax I2:addl %ebx, %eax I3:irmovl $20, %ebx I4:irmovl $20, %edx Data Data memory memory nop nop nop Memory Addr , Data Bch valE I1 I1 nop CC CC ALU ALU Execute I2 nop nop aluA , aluB F I1 I1 I2 valA , valB B1 d_ srcA , I3 I2 I2 W W D E M W Decode A A B B d_ srcB M M Register Register Register Register file file file file E E B2 Write back M M E M valP B3 E E I2 I2 I1 I2 I3 I3 D E D D D PC PC I4 I3 I3 increment increment Fetch I3 F F F D F F I4 F

21. Y86 – Dependências de dados Dependência no %esp I1:irmovl $10, %eax I2:addl %ebx, %eax I3:irmovl $20, %ebx I4:irmovl $20, %edx I1:popl %eax I2:addl %ebx, %eax I3:pushl %ebx I4:irmovl $20, %edx • 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

22. Y86 PIPE- : fetch • Prever PC • valPou valCda 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)

23. Y86 PIPE- : Sumário • 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”