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

Apresentação em tema: "Y86: Encadeamento de Instruções (PIPE-)"— 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)
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 AC – Y86: PIPE-

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

4 Encadeamento na Vida Real
Sequencial Paralelo Encadeado (Pipeline) 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 AC – Y86: PIPE-

5 Encadeamento: Exemplo
R e g Clock Comb. logic A B C 100 ps 20 ps Latência = 360 ps Ciclo = 120 ps Débito = 8.33 GOPS R e g R e g R e g Clock 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 AC – Y86: PIPE-

6 Encadeamento: Diagramas
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 OP1 OP2 OP3 AC – Y86: PIPE-

7 Limitações: Latências não uniformes
g Clock Comb. logic B C 50 ps 20 ps 150 ps 100 ps A Latência = 510 ps Ciclo = 170 ps Débito = 5.88 GOPS Time OP1 OP2 OP3 A B C 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 AC – Y86: PIPE-

8 Limitações: custo do registo
Latência= = 420 ps, Ciclo=70 ps, Throughput = GOPS Clock R e g Comb. logic 50 ps 20 ps 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: % (060 em 360 ps) 6-stage pipeline: % (120 em 420 ps) AC – Y86: PIPE-

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

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

12 Y86 PIPE- Forward (Upward) Paths
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) AC – Y86: PIPE-

13 Y86 PIPE-: feedback Predict PC Saltos condicionais Endereço de retorno
Write back W icode valE valM dstE dstM data out read Mem . Data Data control memory memory write Memory data in 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 Addr CC d_ srcB srcA e_Bch M_Bch M_ valA M icode Bch valE valA dstE dstM ALU ALU ALU fun. ALU ALU Execute A B E icode ifun valC valA valB dstE dstM srcA srcB Select d_ rvalA dstE dstM srcA srcB A Decode A B W_ valM Register Register M file file W_ valE E D icode ifun rA rB valC valP Predict PC Instruction Instruction PC PC memory memory increment increment Fetch f_PC M_ valA Select PC W_ valM F predPC AC – Y86: PIPE-

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

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-

16 Y86: Dependências de Controlo - jXX
nop I4 I1 Y86: Dependências de Controlo - jXX PC increment CC ALU Data memory Fetch Decode Execute Memory Write back Register file A B M E valP d_ srcA , srcB valA valB aluA aluB Bch valE Addr , Data rA W F D f_PC Instruction 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 I1 I2 I5 I6 nop icode=00 dstE=dstM=8 I1 I2 I5 1 2 3 4 5 6 nop I1 I2 I5 F F D F D E F D E M F M W E D I1 I2 F D W M E I5 I1 I3 I6 I6 I3 I4 AC – Y86: PIPE-

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-

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

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-

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

21 Y86 – Dependências de dados
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 AC – Y86: PIPE-

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

23 Y86 PIPE- : Sumário Conceito Limitações
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 AC – Y86: PIPE-