A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

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

Apresentações semelhantes


Apresentação em tema: "Y86: Encadeamento de Instruções (PIPE-) Arquitectura de Computadores Lic. em Engenharia Informática Luís Paulo Santos."— Transcrição da apresentação:

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) AC – Y86: PIPE-2 Conteúdos 9 – Organização do Processador 9.2 – Datapath encadeado (pipeline) 9.3 – Dependências de Dados e Controlo Resultados de Aprendizagem R9.2 – Analisar e descrever organizações encadeadas de processadores elementares R9.3 – Caracterizar limitações inerentes a organizações encadeadas (dependências) e conceber potenciais soluções

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

4 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 SequencialParalelo Encadeado (Pipeline)

5 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 RegReg Clock Comb. logic A RegReg Comb. logic B RegReg Comb. logic C 100 ps20 ps100 ps20 ps100 ps20 ps Latência = 360 ps Ciclo = 120 ps Débito = 8.33 GOPS Clock RegReg RegReg RegReg

6 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 ABC ABC ABC OP1 OP2 OP3

7 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 RegReg Clock RegReg Comb. logic B RegReg Comb. logic C 50 ps20 ps150 ps20 ps100 ps20 ps Comb. logic A Time OP1 OP2 OP3 ABC ABC ABC Latência = 510 ps Ciclo = 170 ps Débito = 5.88 GOPS

8 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= = 420 ps, Ciclo=70 ps, Throughput = GOPS Clock RegReg Comb. logic 50 ps20 ps RegReg Comb. logic 50 ps20 ps RegReg Comb. logic 50 ps20 ps RegReg Comb. logic 50 ps20 ps RegReg Comb. logic 50 ps20 ps RegReg Comb. logic 50 ps20 ps

9 Y86: PIPE- AC – Y86: PIPE-9

10 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

11 I1 I2 I3 I4 I5 I6 Y86 PIPE- : Execução AC – Y86: PIPE-11 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 I2 I1 I2 I3 I1 I2 I3 I4 I1 I2 I3 I4 I5 I2 I3 I4 I5 I6

12 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)

13 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 Instruction memory Instruction memory PC increment PC increment Register file Register file ALU Data memory Data memory Select PC rB dstEdstM Select A ALU A B Mem. control Addr srcAsrcB read write ALU fun. Fetch Decode Execute Memory Write back icode data out data in AB M E M_valA W_valM W_valE M_valA W_valM d_rvalA f_PC Predict PC valEvalMdstEdstM BchicodevalEvalAdstEdstM icodeifunvalCvalAvalBdstEdstMsrcAsrcB valCvalPicodeifunrA predPC CC d_srcBd_srcA e_Bch M_Bch

14 Y86: Dependências de Controlo - jXX AC – Y86: PIPE-14 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 I2 I1 I2 I5 ? I1 I2 I5 Prevê salto condicional como tomado

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 AC – Y86: PIPE-15

16 AC – Y86: PIPE Y86: Dependências de Controlo - jXX 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 F F D F D E I1 I2 I1 I2 I5 I1 I2 I5 F D E M I6 I1 I2 I5 I6 I1 I2 nop icode=00 dstE=dstM=8 nop I3 F M W E D I4 F D W M E I2 I3 nop I4 I5 I6

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 AC – Y86: PIPE-17

18 I1 I3 I6 I4 I5 I1 I3 I5 I4 AC – Y86: PIPE-18AC – Y86: PIPE 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 F F D F D E I1 I3 I1 I3 I4 I1 I3 I4 I5 I6 I7 I2 F E M D I7 I2 W F M D E W F D E M I3 I4 I5 I6 I7 D W M E F I4 I5 I6 I7 nop E D W M F D M E W F I5 I6 I7 nop I6 I2 nop

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: –Stack específica para endereços de retorno ( call / ret ) AC – Y86: PIPE-19

20 AC – Y86: PIPE-20 Y86: Dependências de dados I1: irmovl $10, %eax I2: addl %ebx, %eax I3: irmovl $20, %ebx I4: irmovl $20, %edx F F D F D E I1 I2 I1 I2 I3 I1 I2 B1 B2 B3 F D W M E I3 I1 I2 nop I3 F D M E I1 I2 I3 nop F D W M E I2 nop I3 nop I4 I3 nop I4 nop I2 F D W M E

21 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 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 Dependência no %esp

22 Y86 PIPE- : fetch AC – Y86: PIPE-22 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 )

23 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


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

Apresentações semelhantes


Anúncios Google