1 / 23

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

Y86: Encadeamento de Instruções (PIPE-). Arquitectura de Computadores Lic. em Engenharia Informática Luís Paulo Santos. Y86: Encadeamento de instruções (pipeline). 300 ps. 20 ps. Lógica Combinatória. R e g. Latência= 320 ps Ciclo = 320 ps Débito = 1 / 320E-12

newman
Download Presentation

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

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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”

More Related