1 / 58

MC542 Organização de Computadores Teoria e Prática

MC542 Organização de Computadores Teoria e Prática. 2007 Prof. Paulo Cesar Centoducatte ducatte@ic.unicamp.br www.ic.unicamp.br/~ducatte. MC542 Arquitetura de Computadores Micro-Arquitetura Pipeline. “DDCA” - (Capítulo 7) “COD” - (Capítulo ). Micro-Arquitetura Pipeline Sumário.

conner
Télécharger la présentation

MC542 Organização de Computadores Teoria e Prática

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. MC542Organização de ComputadoresTeoria e Prática 2007 Prof. Paulo Cesar Centoducatte ducatte@ic.unicamp.br www.ic.unicamp.br/~ducatte

  2. MC542Arquitetura de ComputadoresMicro-Arquitetura Pipeline “DDCA” - (Capítulo 7) “COD” - (Capítulo )

  3. Micro-Arquitetura Pipeline Sumário • Introdução • Execução Pepiline • MIPS Pepilinig • 5 estágios • MIPS Pipelined • Execução de Instruções no MIPS Pipeline • DataPath Single-Cycle e Pipelining • Controle do Pepiline • Limites de Pipelining • Hazards • Estrutura • Dado • Controle • Como Tratar os Hazards de Dados

  4. A B C D Pipelining - Conceito • Exemplo: Lavanderia • 4 trouxas para serem lavadas • Lavar: 30 minutos • Secar: 40 minutos • Passar: 20 minutos

  5. A B C D Lavanderia Seqüencial • Lavanderia seqüencial: 6 horas para lavar 4 trouxas • Se for usado pipelining, quanto tempo? 6 Horas 7 8 9 11 10 Tempo O r d e m T a r e f a s 30 40 20 30 40 20 30 40 20 30 40 20

  6. 30 40 40 40 40 20 A B C D Lavanderia Pipelined • Lavanderia Pipelined: 3.5 horas para 4 trouxas 6 Horas 7 8 9 11 10 Tempo O r d e m T a r e f a s

  7. 30 40 40 40 40 20 A B C D Pipelining • O Pipelining não ajuda na latência de uma tarefa, ajuda no throughput de toda a carga de trabalho • O período do Pipeline é limitado pelo estágio mais lento • Múltiplas tarefas simultâneas • Speedup potencial = Número de estágios • Estágios não balanceados reduzem o speedup • O Tempo de “preenchimento” e de “esvaziamento“ reduzem o speedup 6 7 8 9 Time T a s k O r d e r

  8. CPU Pipeline • Executam bilhões de instruções: throughput • Características desejáveis em um conjunto de instruções (ISA) para pipelining? • Instruções de tamanho variável vs. Todas instruções do mesmo tamanho? • Operandos em memória em qq operação vs. operandos em memória somente para loads e stores? • Formato das instruções irregular vs. formato regular das instruções (ié. Operandos nos mesmos lugares)?

  9. Um RISC Típico • Formato de instruções de 32-bit (3 formatos) • Acesso à memória somente via instruções load/store • 32 GPR de 32-bits (R0 contém zero) • Instruções aritméticas: 3-address, reg-reg, registradores no mesmo lugar • Modo de endereçamento simples para load/store(base + displacement) • Sem indireção • Condições simples para o branch • Delayed branch SPARC, MIPS, HP PA-Risc, DEC Alpha, IBM PowerPC, CDC 6600, CDC 7600, Cray-1, Cray-2, Cray-3

  10. Exemplo: MIPS (Localização dos regs) Register-Register 6 5 11 10 31 26 25 21 20 16 15 0 Op Rs1 Rs2 Rd Opx Register-Immediate 31 26 25 21 20 16 15 0 immediate Op Rs1 Rd Branch 31 26 25 21 20 16 15 0 immediate Op Rs1 Rs2 Jump / Call 31 26 25 0 target Op

  11. Processador MIPS Pipelined • Paralelismo Temporal • Divide o processador single-cycle em 5 estágios: • Fetch • Decode • Execute • Memory • Writeback • Adicinar registradores de pipeline entre os estágios

  12. Single-Cycle 0 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900 Instr Time (ps) Fetch Execute Memory Write Decode 1 Instruction ALU Read / Write Reg Read Reg Fetch Execute Memory Write Decode 2 Instruction ALU Read / Write Reg Read Reg Pipelined Instr Fetch Execute Memory Write Decode 1 Instruction ALU Read/Write Reg Read Reg Fetch Execute Memory Write Decode 2 Instruction ALU Read/Write Reg Read Reg Fetch Execute Memory Write Decode 3 Instruction ALU Read/Write Reg Read Reg Processador MIPS Pipelined

  13. Jump MemtoReg Control MemWrite Unit Branch PCSrc ALUControl 2:0 31:26 Op ALUSrc 5:0 Funct RegDst RegWrite CLK CLK CLK 0 WE3 Zero WE SrcA 25:21 0 A1 RD1 PC' PC Instr 0 Result 1 A RD ALUResult ReadData ALU 1 A RD 1 Instruction 20:16 A2 RD2 0 SrcB Data Memory A3 1 Memory WriteData Register WD3 WD File 20:16 0 PCJump 15:11 1 WriteReg 4:0 PCPlus4 + SignImm <<2 4 15:0 Sign Extend PCBranch + 27:0 31:28 25:0 <<2 Processador MIPS Pipelined MIPS single-cycle

  14. Adder 4 Address Inst ALU Processador MIPS Pipelined Instruction Fetch Instr. Decode Reg. Fetch Execute Addr. Calc Memory Access Write Back Next PC MUX Next SEQ PC Zero? RS1 Reg File MUX RS2 Memory Data Memory L M D RD MUX MUX Sign Extend Imm WB Data

  15. 1 2 3 4 5 6 7 8 9 10 Time (cycles) $0 $s2 lw DM lw $s2, 40($0) IM RF RF + 40 $t1 $s3 add DM add $s3, $t1, $t2 IM RF RF + $t2 $s1 $s4 sub DM sub $s4, $s1, $s5 IM RF RF - $s5 $t5 $s5 and DM and $s5, $t5, $t6 IM RF RF & $t6 $s1 $s6 sw DM sw $s6, 20($s1) IM RF RF + 20 $t3 $s7 or DM or $s7, $t3, $t4 IM RF RF | $t4 Processador MIPS Pipelined • Abstração da execução Pipeline

  16. CLK CLK CLK WE3 Zero WE SrcA 25:21 0 A1 RD1 PC' PC Instr 0 A RD ALUResult ReadData ALU 1 A RD 1 Instruction 20:16 A2 RD2 0 SrcB Data Memory A3 1 Memory WriteData Register WD3 WD File 20:16 0 WriteReg 4:0 15:11 1 PCPlus4 + SignImm 4 <<2 15:0 Sign Extend PCBranch + Result CLK CLK ALUOutW CLK CLK CLK CLK CLK WE3 WE ZeroM SrcAE 25:21 0 A1 RD1 PC' PCF InstrD 0 A RD ReadDataW ALU ALUOutM 1 A RD 1 Instruction 20:16 A2 RD2 0 SrcBE Data Memory A3 1 Memory WriteDataM Register WriteDataE WD3 WD File RtE 20:16 0 WriteRegE 4:0 RdE 15:11 1 + SignImmE 4 <<2 15:0 PCBranchM Sign Extend + PCPlus4F PCPlus4D PCPlus4E ResultW Fetch Decode Execute Memory Writeback Processador MIPS Pipelined • DataPath Single-Cycle e Pipelining

  17. MEM/WB ID/EX EX/MEM IF/ID Adder 4 Address ALU Processador MIPS Pipelined Instruction Fetch Execute Addr. Calc Memory Access Instr. Decode Reg. Fetch Write Back Next PC MUX Next SEQ PC Next SEQ PC Zero? RS1 Reg File MUX Memory RS2 Data Memory MUX MUX Sign Extend WB Data Imm RD RD RD

  18. CLK CLK ALUOutW CLK CLK CLK CLK CLK WE3 WE ZeroM SrcAE 25:21 0 A1 RD1 PC' PCF InstrD 0 A RD ReadDataW ALU ALUOutM 1 A RD 1 Instruction 20:16 A2 RD2 0 SrcBE Data Memory A3 1 Memory WriteDataM Register WriteDataE WD3 WD File RtE 20:16 0 WriteRegE WriteRegM WriteRegW 4:0 4:0 4:0 RdE 15:11 1 + SignImmE <<2 15:0 Sign Extend + PCBranchM 4 PCPlus4F PCPlus4D PCPlus4E ResultW Fetch Decode Execute Memory Writeback Processador MIPS Pipelined

  19. CLK CLK CLK RegWriteE RegWriteM RegWriteW RegWriteD Control MemtoRegE MemtoRegM MemtoRegW MemtoRegD Unit MemWriteE MemWriteM MemWriteD BranchE BranchM BranchD 31:26 PCSrcM Op ALUControlE ALUControlD 2:0 5:0 Funct ALUSrcD ALUSrcE RegDstD RegDstE ALUOutW CLK CLK CLK CLK WE3 WE ZeroM SrcAE 25:21 0 A1 RD1 PC' PCF InstrD 0 A RD ALU ReadDataW ALUOutM 1 A RD 1 Instruction 20:16 A2 RD2 0 SrcBE Data Memory A3 1 Memory Register WriteDataM WriteDataE WD3 WD File RtE 20:16 0 WriteRegE WriteRegM WriteRegW 4:0 4:0 4:0 RdE 15:11 1 + <<2 15:0 Sign Extend SignImmE + PCBranchM 4 PCPlus4F PCPlus4D PCPlus4E ResultW Processador MIPS Pipelined • Controle do Pepiline

  20. Limites de Pipelining • Hazards: impedem que a próxima instrução seja executada no ciclo de clock “previsto” para ela • Structural hazards: O HW não suporta uma dada combinação de instruções • Data hazards: Uma Instrução depende do resultado da instrução anterior que ainda está no pipeline • Control hazards: Causado pelo delay entre o fetching de uma instrução e a decisão sobre a mudança do fluxo de execução (branches e jumps).

  21. Reg Reg Reg Reg Reg Reg Reg Reg Reg Reg Ifetch Ifetch Ifetch Ifetch DMem DMem DMem DMem ALU ALU ALU ALU ALU Memória Única (D/I) - Structural Hazards Time (clock cycles) Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7 I n s t r. O r d e r Load DMem Instr 1 Instr 2 Instr 3 Ifetch Instr 4

  22. Reg Reg Reg Reg Reg Reg Reg Reg Ifetch Ifetch Ifetch Ifetch DMem DMem DMem ALU ALU ALU ALU Bubble Bubble Bubble Bubble Bubble Memória Única (D/I) - Structural Hazards Time (clock cycles) Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7 I n s t r. O r d e r Load DMem Instr 1 Instr 2 Stall Instr 3

  23. Data Hazards • Read After Write (RAW) InstrJ lê o operando antes da InstrI escreve-lo • Causada por uma “Dependência” (nomenclatura de compiladores). I: add r1,r2,r3 J: sub r4,r1,r3

  24. Reg Reg Reg Reg Reg Reg Reg Reg Reg Reg ALU ALU ALU ALU ALU Ifetch Ifetch Ifetch Ifetch Ifetch DMem DMem DMem DMem DMem EX WB MEM IF ID/RF I n s t r. O r d e r add r1,r2,r3 sub r4,r1,r3 and r6,r1,r7 or r8,r1,r9 xor r10,r1,r11 Data Hazard em R1 Time (clock cycles)

  25. I: sub r4,r1,r3 J: add r1,r2,r3 K: mul r6,r1,r7 Data Hazards • Write After Read (WAR)InstrJ escreve o operando antes que a InstrI o leia • Chamada “anti-dependência” (nomenclatura de compiladores). Devido ao reuso do nome “r1”. • Não ocorre no pipeline do MIPS: • Todas instruções usam 5 estágios, e • Leituras são no estágio 2, e • Escritas são no estágio 5

  26. I: sub r1,r4,r3 J: add r1,r2,r3 K: mul r6,r1,r7 Data Hazards • Write After Write (WAW)InstrJ escreve o operando antes que a InstrI o escreva. • Chamada “dependência de saída” (nomenclatura de compiladores). Devido ao reuso do nome “r1”. • Não ocorre no pipeline do MIPS: • Todas Instruções são de 5 estágios, e • Escritas são sempre no 5 estágio • (WAR e WAW ocorrem em pipelines mais sofisticados)

  27. Como Tratar os Data Hazards • Inserir instruções nops no código • Rearranjar o código em tempo de compilação • Stall o processador em tempo de execução (run-time) • Forward data

  28. Data Hazards – Solução por SW • Compilador reconhece o data hazard e troca a ordem das instruções (quando possível) • Compilador reconhece o data hazard e adiciona nops Exemplo: sub R2, R1, R3 ; reg R2 escrito por sub nop ; no operation nop and R12, R2, R5 ; resultado do sub disponível or R13, R6, R2 add R14, R2, R2 sw 100 (R2), R15

  29. Data Hazard Control: Stalls • Hazard ocorre quando a instr. Lê (no estágio ID) um reg que será escrito, por uma instr. anterior (no estágio EX, MEM, WB) • Solução: Detectar o hazard e parar a instrução no pipeline até o hazard ser resolvido • Detectar o hazard pela comparação do campo read no IF/ID pipeline register com o campo write dos outros pipeline registers (ID/EX, EX/MEM, MEM/WB) • Adicionar bubble no pipeline – Preservar o PC e o IF/ID pipeline register

  30. Processador MIPS Pipelined • Data Forwarding

  31. Processador MIPS Pipelined • Data Forwarding

  32. ID/EX EX/MEM MEM/WR NextPC mux Registers Data Memory ALU mux mux Immediate Processador MIPS Pipelined • HW para forwarding

  33. Processador MIPS Pipelined • HW para forwarding

  34. Processador MIPS Pipelined • Forward para o estágio Execute a partir de: • Memory stage ou • Writeback stage • Lógica de Forwarding para ForwardAE: if ((rsE != 0) AND (rsE == WriteRegM) AND RegWriteM) then ForwardAE = 10 else if ((rsE != 0) AND (rsE == WriteRegW) AND RegWriteW) then ForwardAE = 01 else ForwardAE = 00 • Lógica de Forwarding para ForwardBE similar, trocando rsE com rtE, e ForwardAE com ForwardBE

  35. Reg Reg Reg Reg Reg Reg Reg Reg ALU Ifetch Ifetch Ifetch Ifetch DMem DMem DMem DMem ALU ALU ALU Time (clock cycles) lwr1, 0(r2) I n s t r. O r d e r sub r4,r1,r6 and r6,r1,r7 or r8,r1,r9 Processador MIPS Pipelined • Data Hazard com Forwarding

  36. Reg Reg Reg Ifetch Ifetch Ifetch Ifetch DMem ALU Time (clock cycles) I n s t r. O r d e r lwr1, 0(r2) Bubble sub r4,r1,r6 ALU ALU Reg Reg DMem DMem Bubble and r6,r1,r7 Reg Reg Bubble ALU DMem or r8,r1,r9 Processador MIPS Pipelined • Data Hazard com Forwarding

  37. Processador MIPS Pipelined • Hardware para Stall

  38. Processador MIPS Pipelined • Lógica para Stall: lwstall = ((rsD == rtE) OR (rtD == rtE)) AND MemtoRegE StallF = StallD = FlushE = lwstall

  39. Processador MIPS Pipelined • Load Hazards - Software Scheduling Código para (a, b, c, d ,e, f na memória). a = b + c; d = e – f; Slow_code: LW Rb,b LW Rc,c ADD Ra,Rb,Rc SW a,Ra LW Re,e LW Rf,f SUB Rd,Re,Rf SW d,Rd Fast_code: LW Rb,b LW Rc,c LW Re,e ADD Ra,Rb,Rc LW Rf,f SW a,Ra SUB Rd,Re,Rf SW d,Rd

  40. Processador MIPS Pipelined Control Hazard • beq: o branch não é determinado até o 4 estágio do pipeline • Definições: • Branch delay slot(s): Instruções buscadas antes do branch ser determinado • Misprediction penalty: número de instruções flushed quando o branch é taken • Várias estratégias são usadas para lidar com control hazards: • Stall o pipeline • Rearranjar o código e por instruções “úteis” no(s) branch delay slot(s) • Reduzir o misprediction penalty(determinar o branch mais cedo no pipeline) • Flush pipeline quando o branch é taken

  41. Reg Reg Reg Reg Reg Reg Reg Reg Reg Reg ALU ALU ALU ALU ALU Ifetch Ifetch Ifetch Ifetch Ifetch DMem DMem DMem DMem DMem 10: beq r1,r3,36 14: and r2,r3,r5 18: or r6,r1,r7 22: add r8,r1,r9 36: xor r10,r1,r11 Processador MIPS Pipelined

  42. Instruction Fetch Execute Addr. Calc Memory Access Instr. Decode Reg. Fetch Write Back Next PC MUX Next SEQ PC Next SEQ PC MEM/WB ID/EX EX/MEM IF/ID Adder Zero? 4 RS1 Address Reg File MUX Memory RS2 Data Memory ALU MUX MUX Sign Extend WB Data Imm RD RD RD Processador MIPS Pipelined

  43. Processador MIPS Pipelined Exemplo: Impacto do Branch Stall no Desempenho • Se CPI = 1, 30% branches, 3-cycle stall CPI = 1.9! • Solução para minimizar os efeitos: • Determinar branch taken ou não o mais cedo, e • Calcular o endereço alvo do branch logo • MIPS branch: testa se regs = ou  • Solução MIPS: • Zero test no estágio ID/RF • Adder para calcular o novo PC no estágio ID/RF • 1 clock cycle penalty por branch versus 3

  44. Instruction Fetch Execute Addr. Calc Memory Access Instr. Decode Reg. Fetch Write Back Next SEQ PC Next PC MUX MEM/WB ID/EX EX/MEM IF/ID Adder Adder = 4 Address RS1 Reg File Memory RS2 Data Memory ALU MUX MUX Sign Extend WB Data Imm RD RD RD Processador MIPS Pipelined

  45. Processador MIPS Pipelined

  46. Processador MIPS Pipelined

  47. Processador MIPS Pipelined Alternativas para Branch Hazard #1: Stall até a decisão se o branch será tomado ou não #2: Predict Branch Not Taken • Executar a próxima instrução • “Invalidar” as instruções no pipeline se branch é tamado • Vantagem: retarda a atualização do pipeline • 47% dos branches no MIPS não são tomados, em média • PC+4 já está computado, use-o para pegar a próxima instrução #3: Predict Branch Taken • 53% dos branches do MIPS são tomados, em média • “branch target address” no MIPS ainda não foi calculado • 1 cycle branch penalty • Em outras máquinas esse penalty pode não ocorrer

  48. Processador MIPS Pipelined Alternativas para Branch Hazard #4: Delayed Branch • Define-se que o branch será tamado APÓS a uma dada quantidade de instruções branch instruction sequential successor1 sequential successor2 ........ sequential successorn branch target if taken • 1 slot delay permite a decisão e o calculo do “branch target address” no pipeline de 5 estágios • MIPS usa está solução Branch delay de tamanho n (n delay slots)

  49. Processador MIPS Pipelined Delayed Branch • Qual instrução usar para preencher o branch delay slot? • Antes do branch • Do target address ( avaliada somente se branch taken) • Após ao branch (somente avaliada se branch not taken)

  50. Processador MIPS Pipelined

More Related