1 / 67

Arquitecturas Paralelas Curso 13/14

Arquitecturas Paralelas Curso 13/14. Horas 6 6 8 6 3. INTRODUCCIÓN CONECTIVIDAD MÁQUINAS MIMD MÁQUINAS SIMD y SIMT SUPERESCALARES. arqPar Temario Super- 2. SUPERESCALARES Límites de las arquitecturas escalares “Pipeline” Visión global de una arquitectura Superescalar

amato
Download Presentation

Arquitecturas Paralelas Curso 13/14

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. Arquitecturas Paralelas Curso 13/14 Horas 6 6 8 6 3 • INTRODUCCIÓN • CONECTIVIDAD • MÁQUINAS MIMD • MÁQUINAS SIMD y SIMT • SUPERESCALARES

  2. arqPar Temario Super-2 • SUPERESCALARES • Límites de las arquitecturas escalares “Pipeline” • Visión global de una arquitectura Superescalar • Flujo de instrucciones • Flujo de datos en registros • Flujo de datos en memoria • Microarquitectura del Pentium II, III y 4 • Microarquitectura del Core 2 • Bibliografía: • “Modern Processor Design. Fundamentals of Superscalar Processors” • J. P. Shen y M. H. Lipasti McGraw-Hill-2004 [Caps. 4 y 5] • “Processor Microarchitecture: An Implementation Perspective” • A. González, F. Latorre y G. Magklis - 2011

  3. arqPar Límites de las arquitecturas escalares “Pipeline” Super-3 ¡ Demasiado rígido ! ¿Alcanzable? • Aplicable a: • Instrucciones • Aritmética • Acceso a • memoria  d ¡ Todas las instrucciones siguen mismo camino a la misma marcha, salvo parones ! • Límite superior IPC=1=CPI • Unificación ineficiente en un único pipeline • Pérdida de eficiencia por ejecución tan “en orden”

  4. arqPar Límite superior IPC=1=CPI ¿Realidad? Super-4 ketapas dn, dn-1,..., d2, d1 d’n, d’n-1,..., d’2, d’1 Sin Pipeline k  T1 Tk n k k+n–1 n k  (k+n–1)  = = Lim Sk = k n  ¿ Es ésto tan bueno ? • 1987 – Agerwala y Cocke => CPI ≈ 1,77 .. 1,15 ¿ Qué rendimiento se espera ? Sk = • Límites tecnológicos: • k  (2..15..); < 10 •  k =>  n

  5. arqPar Límite superior IPC=1=CPI ¿Realidad? Super-5 Aceleración como función de ‘k’ y ‘n’ SK Sk = n k k+n–1 n Necesario n45 para eficiencia 90% Necesario n89 para eficiencia 90% ¿Puedo alimentar el pipe con tantas instrucciones seguidas? ¡ Saltos ! 1 cada 5/6 Inst. Predicción OK => 90% ¿Conclusión?

  6. arqPar Unificación ineficiente en un único pipeline Super-6 Operaciones: ALU F D I E W F F D D I I E E M E W W M W F D I E E Unificación imposible o muy ineficiente + Load/Store Operaciones:Coma flotante, Coma fija (mul,div) => Multiciclos

  7. arqPar Ejecución “en orden” ineficiente Super-7 I8 I7 I6 I5 I4 I3 I2 F D I E E E W Prog. ejemplo 16 11 1 6 21 2 17 22 7 12 13 23 8 3 18 19 4 14 9 24 20 10 25 15 5 r1 = M[Y] F F D D I I E E E E E E W W r2 = M[Z] r3 = r1+r2 F D — — — — — — — — — — — — — — — — — — — — — I E E E W I1 I2 I3 I4 I5 I6 I7 I8 M[X] = r3 26 F ? D ? I E E E W r4 = M[B] RAW r5 = M[C] r6 = r4*r5 F D M[A] = r6 F D F D I I F I I E E E E D E E E E E E E E W W W W ¿Es necesario retener a I5, I6, … ? ¡ Permitir ejecución fuera de orden !

  8. arqPar Ejecución “en orden” ineficiente Super-8 Programa ejemplo 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 I1: r1 = M[Y] I2: r2 = M[Z] I3: r3 = r1+r2 I4: M[X] = r3 — — I5: r4 = M[B] ? I6: r5 = M[C] I7: r6 = r4*r5 I8: M[A] = r6 — — F F F F F F D D D D D D I I I I I I F D I E E E W E E E W — — — — — — — — — — — — E E E E E E E E E E E E E E E W W W W W F D I E E E W Permitiendo ejecución fuera de orden: 26 a 19 ciclos

  9. arqPar Visión global … (Escalar => Superescalar) Super-9 Pipelines paralelos IF ID RD ALU MEM WB Grado = 3 • Romper límite IPC=1 • Paralelismo temporal y espacial • Coste hw adicional: • S2 Crossbar entre etapas • Accesos paralelos Reg y Cache • ¿Rendimiento IPC? Teórico Observado Unos  1,58..8 Otros  51..90 2  0,6..1,45 4  1 .. 2 6  1,2..2,3 Pentium4 Core2 Itanium PowerG5 3 4 6 8

  10. arqPar Visión global … (Escalar => Superescalar) Super-10 • ¿Rendimiento IPC? Observado 2  0,6..1,45 4  1 .. 2 6  1,2..2,3 • Simulación con: • PTLsim/X arquitectura tipo x86-64 grado 4 • SPEC CPU2006 • 200 millones de instrucciones simuladas: datos “Fetch”

  11. arqPar Visión global … (Escalar => Superescalar) Super-11 Pipelines diversificados IF ID RD EX ALU MEM1 FP1 BR MEM2 FP2 FP3 WB • Evitar unificación ineficiente • Diseño adhoc + eficiente: • Mejor latencia • Menos hardware • Control cauces EX: • Distribuido e independiente • ¿Cuánta diversidad? 1965 CDC6600 10 1990 M88110 10 1995 Pentium 2 2000 Itanium 23 2006 Core 2 14

  12. arqPar Visión global … (Escalar => Superescalar) Super-12 IF en orden ID RD Dispatch buffer EX ALU MEM1 FP1 BR MEM2 FP2 fuera de orden FP3 WB Reorder buffer en orden • Permitir ejecución fuera de orden => Pipelines dinámicos

  13. arqPar Visión global … (Modelo Superescalar) Super-13 Extraer Buffer de instrucciones Decodificar Buffer de dispatch Cada instrucción a U.F. adecuada Forzar terminación en orden Optimizar acceso a memoria Despachar Buffer de issuing Ejecutar Buffer de completar Completar Buffer de store Retirar

  14. arqPar Visión global … (Modelo Superescalar) Super-14 L/S Queue CacheI CacheD Reorder Buffer Registros Issue Queue Write Back Fetch Decode Rename Issue Execute Commit Fig. 1.1 “Processor Microarchitecture. An Implementation Perspective”

  15. arqPar Visión global … (Etapa Fetch) Super-15 CACHE I F D E W rol sub add mul add xor sub mov 4 4 E W E W or bra --- --- E W 8 --- add call --- • Caché extendida “línea = 8 Inst.” • Caché autoalineada Bancos de memoria 0 1 2 3 PC --- --- sub lsl add load asr sub para etapa D guardar --- --- sub lsl asr sub add load add load asr sub add load --- --- --- --- --- --- Buffer --- asr sub para etapa D sub lsl add load • ¡ La etapa Fetch no es trivial ! (Caché simple “línea = 4 Inst.”)

  16. arqPar Visión global … (Etapa Decodificación) Super-16 Memoria principal Lógica Pre Deco. Cache I F D 4 4 Saltos Independencia Inst1 Inst2 Inst3 Inst4 4b 4b 4b 4b Inst4 Inst1 Inst2 Inst3 Tiene su sobrecarga • ¡ Mucho trabajo ! • Identificar las instrucciones concretas y su tipo • Detectar dependencias con instrucciones cercanas • Identificar saltos • Leer operandos RISC lo facilita mucho • ¿Acelerar? => Predecodificación (parcial) previa [miss cacheI]

  17. arqPar Visión global … (Etapa Decodificación) Super-17 µop RISC

  18. arqPar Visión global … (Etapa Decodificación) Super-18 CISC add [eax], ebx ld r0, ds:[eax] add r1, r0, ebx st ds:[eax], r1 RISC

  19. arqPar Visión global … (Etapa Despachar) Super-19 • Decidir a qué U.F. enviar cada instrucción Extraer • Buffer de espera operando(s) no disponible(s) I5: r4 = M[B] Tomasulo Decodificar I6: r5 = M[C] central Estación de reserva I7 I7: r6 = r4*r5 Despachar distribuidas I6 ALU MEM1 FP1 BR dispatch I5 MEM2 FP2 issue FP3 ALU MEM1 FP1 BR Reorder buffer “Completar” MEM2 FP2 FP3 • Transición centralizado a distribuído

  20. arqPar Visión global … (Etapa Ejecutar) Super-20 ALU TI SuperSPARC FPU IBM RS/6000 • Salto • Load / Store • Multimedia (a+e+1) + (b+f+1) + 2 2 (c+g+1) + (d+h+1) 2 2 Instrucciones % Tipo 40 ALU Regla 4 / 2 / 4 20 saltos 4 40 load/store • Tendencia a diversificar más => más U.F. más especializadas • ¿Cuántas U.F. de qué tipo? • U.F. > Grado • O(N2)

  21. arqPar Visión global … (Etapa Ejecutar) Super-21 Instrucciones % Tipo 40 ALU 20 saltos 40 load/store • ¿Cuántas U.F. de qué tipo? • Simulación con: • PTLsim/X arquitectura tipo x86-64 grado 4 • SPEC CPU2006 • 200 millones de instrucciones simuladas: datos “Commit”

  22. arqPar Visión global … (Etapas Completar y Retirar) Super-22 F R O N T E N D E X E C C U O T R I E O N B A C K E N D Excepciones precisas Estado máquina Prioridad a load vs store Estado memoria

  23. arqPar Flujo de instrucciones (Problemática de los saltos) Super-23 • Por simplicidad: F D E W I1, I2, I3, I4, I5, I5, I6 vs I1, I2, I3, I5, I6 1 2 3 4 5 6 7 8 9 10 I1: r1 = M[A] F F F F F F F D D D D D D D E E E E E E E W W W W W W W I2: r3 = r3-1 I3: beq I5 I4: r2 = r2+r4 I5: r5 = r5-r6 I5: r5 = r5-r6 I6: M[B] = r5 Programa ejemplo I1: r1 = M[A] I2: r3 = r3-1 I3: beq I5 I4: r2 = r2+r4 I5: r5 = r5-r6 I6: M[B] = r5 ! Hasta fin ciclo 5 no se sabe dirección del salto ! ¿Cómo afecta a nuestro modelo?

  24. arqPar Flujo de instrucciones (Penalización por saltos) Super-24 ? Modo de direccionamiento desp(PC) (Ri) • bra 55(R5) desp(Ri) salto ¿ Perder siempre 3 ciclos ? 21 Instrucciones • Incondicionales: bra 28(PC) => Determinar dirección destino • Condicionales: beq 55(R5) => + Evaluar condición de saltar • bra 28(PC) • bra (R5)

  25. arqPar Flujo de instrucciones (Penalización por saltos) Super-25 ¿ Flags, Registros ? Registro Cond. Registros generales salto • Incondicionales: bra 28(PC) => Determinar dirección destino • Condicionales: beq 55(R5) => + Evaluar condición de saltar ¡ Demasiada pérdida !

  26. arqPar Flujo de instrucciones (Técnicas especulativas) Super-26 Cache Inst. Branch Target Buffer Dir. Inst. Salto Dir. Destino Historia T T TT/T NT/T 0 1 N N PC T Saltar TN/T NN/N T + Mux N N Saltar FSM • Predecir (especular) • Dirección del salto • Condición del salto • Mecanismo para validar acierto o fracaso • Mecanismo de recuperación ante un fallo El salto sigue su ejecución $00F5A4 $00F5AC $00F5A4: beq 4(PC) • Hit BTB 86,5% • ¿ Aliasing ? OK 86,8 .. 97,0

  27. arqPar Flujo de instrucciones (Técnicas especulativas) Super-27 a a Retirar éstas • Mecanismo de recuperación ante un fallo ¿ Gestión de etiquetas ? T (tag 01) T 01 01 01 inst1 inst2 inst3 inst1 inst2 inst3 01 01 01 + ¡Redirigir! (tag 02) N N T b b inst7 inst8 inst4 02 02 inst4 (tag 03) T T T c c e inst5 inst6 inst5 inst6 03 03 03 03 inst9 01 ¡Etiquetar! ¡Anular! d d f

  28. arqPar Flujo de instrucciones (Técnicas especulativas) Super-28 PowerPC 604 • BTB dividida en dos • BTAC [64] saltos tomados y 1 ciclo • BHT [512] correctora y 2 ciclos • Actualización en Back-End • Estación de reserva Branch [4]

  29. arqPar Flujo de instrucciones (¿Qué se consigue?) Super-29 Aritmética Coma flotante Media 4% Aritmética Entera Media 11% Más frecuentes los bcc • 2 bits historia y 4K entradas [Hennesy …]

  30. arqPar Flujo de instrucciones (Otras técnicas especulativas) Super-30 Apenas mejora • ¿Cómo mejorar en la condición? • Más bits de historia • Más saltos recordados • Mejorar la función de predicción • Predictores correlacionados Historia de otros saltos influyen en la predicción del salto actual [globalidad] if (d==0) d = 1; if (d==1) ------ • Predictores múltiples: local + global …. Local 2 bits => 7% Correlacionado => 4% Múltiple => 3%

  31. arqPar Flujo de instrucciones (Otras técnicas especulativas) Super-31 • Algunos problemas del predictor simple con 2 bits de historia: • Sea un patrón de salto => T N T N T N T N T……… ¿Guardar dos+ comportamientos? Historia 0 0 1 Historia PC 0 0 PC 1 0 1 0 0 1 1 0 50% T Registro histórico de saltos con desplazamiento 1 1 NT/T NN/N N T ¿Cuántos? Idealmente uno por salto TN/T TT/T

  32. arqPar Flujo de instrucciones (Otras técnicas especulativas) Super-32 • Algunos problemas del predictor simple con 2 bits de historia: • 2 instrucciones distintas y mismo patrón de saltos => ¡Aliasing! Historia $A350 bne 4(PC) PC 1 0 1 0 1 0 1 0 1 0 1 0 $B684 beq 8(PC) ¿Guardar dos+ historias?

  33. arqPar Flujo de instrucciones (Otras técnicas especulativas) Super-33 • 1992 Yeh y Patt => Predictor adaptativo de dos niveles PC • g Global [1] • p Individual [1 * bcc] • s Shared [n * bcc] Adaptativo • G Global [1] • P Individual [varios] 90%  95..97% PentiumPro GAg, PAg, PAs

  34. arqPar Flujo de instrucciones (Otras técnicas especulativas) Super-34 • 1993 Scott McFarling => Predictor gshare Además: Return Address Stack DEC Alpha 21264 • ISCA’04 Ayosé Falcon y … => Prophet/Critic hybrid branch predictor

  35. arqPar Visión global … (Etapa Ejecutar) Super-35 90%  95..97% GAg, PAg, PAs • Simulación con: • PTLsim/X arquitectura tipo x86-64: bimodal(2)+Gshare • SPEC CPU2006 • 200 millones de instrucciones simuladas: cond, indir, ret

  36. arqPar Flujo de datos en registros Super-36 • Instrucción ALU típica: Riesgo estructural Ri = Fn (Rj, Rk) Dependencias de nombre WAW WAR Dependencias de datos RAW r1 = r2 + r3 ----- r2 = r4 + r5 r1 = r2 + r3 ----- r4 = r1 + r5 r1 = r2 + r3 ----- r1 = r4 + r5 ¡ Ficticias !

  37. arqPar Flujo de datos en registros Super-37 • ¿Cómo se generan WAR y WAW? for (i=0; i<N; i++ { X[i] = Y[i] + Z[i]; A[i] = B[i] * C[i]; } + * + * Estático r4 = M[Y] r5 = M[Z] r6 = r4+r5 M[X] = r6 r7 = M[B] r8 = M[C] r9 = r7*r8 M[A] = r9 r4 = M[Y] r5 = M[Z] r6 = r4+r5 M[X] = r6 r4 = M[B] r5 = M[C] r6 = r4*r5 M[A] = r6 ?

  38. arqPar Flujo de datos en registros Super-38 • ¿Cómo se generan WAR y WAW? for (i=0; i<N; i++ { X[i] = Y[i] + Z[i]; } ¡ Más parones ! r4 = M[Y] r5 = M[Z] r6 = r4+r5 M[X] = r6 ----- r4 = M[Y] r5 = M[Z] r6 = r4+r5 M[X] = r6 Estático Iteración i Iteración i+1 r4 = M[Y] r5 = M[Z] r6 = r4+r5 M[X] = r6 Dinámico ¿ Solución ? ¡ Más registros ! vs Tomasulo

  39. arqPar Flujo de datos en registros Super-39 • Registros de Arquitectura ARF (pocos) + Renombrado RRF (más) r4 = M[Y] r5 = M[Z] r6 = r4+r5 M[X] = r6 ----- r4 = M[Y] r5 = M[Z] r6 = r4+r5 M[X] = r6 r4 = M[Y] r5 = M[Z] r6 = r4+r5 M[X] = r6 ----- s4 = M[Y] s5 = M[Z] s6 = s4+s5 M[X] = s6 ¡ Asignación única [ventana de instrucciones] ! Reorder Buffer Intel Core 2 Rename Buffer IBM Power 3 ARF y RRF mezclados Pentium 4 ¿ Cómo ?

  40. arqPar Flujo de datos en registros Super-40 • Renombrado de registros a través del ROB Busy Free Tag Dato Atributos instrucción Dato V 1257 0 6376 1 0 4321 9254 1 1 ARF ROB ???? 0 0 • ¿Leer un operando en Ri PreIssue? RRF ¿Todas las instrucciones con registro destino? • Valor de ARF “1257” • Valor no disponible ¡Parón en estación de reserva “Tag”! • Valor de RRF “6376” • “Commit” => Actualizar RRF en ARF

  41. arqPar Flujo de datos en registros Super-41 • Renombrado de registros a través del Rename Buffer Busy Free ¿Evitable doble escritura? RRF  ARF Tag Dato Dato V RRF ARF • Renombrado ARF y RRF mezclados (IBM RS6000 FPU 32+8=40) OP T S1 S2 S3 OP T S1 S2 S3 ¿ Fload R2  M[] ? FAD 3 2 1 FAD 3 2 1 ¿Excepción y fallo predicción? Libres 5 ? Map Table 325 : 406 36 32 33 37 38 34 35 39 R2:R2 R2:R32 2 Pendientes commit 6

  42. arqPar Flujo de datos en memoria Super-42 • Problemática del acceso a memoria disponible r1 r1 $000F3A58 ld r2,35(r1) $000F3A8D TLB 1 000F3 3F25 ¿ st r3,20(r4) ? $3F25A8D

  43. arqPar Flujo de datos en memoria Super-43 • ¿Ejecución en orden de los accesos a memoria? DAXPY :: LINPAC Y(i) = A * X(i) + Y(i) F0  LD,a R4  ADDI,Rx,#512 ;last address Loop: F2  LD,0(Rx) ;load X(i) F2  MULTD,F0,F2 ;A*X(i) F4  LD,0(Ry) ;load Y(i) F4  ADDD,F2,F4 ;A*X(i)+Y(i) 0(Ry)  SD,F4 ;store into Y(i) Rx  ADDI,Rx,#8 ;inc. index to X Ry  ADDI,Ry,#8 ;inc. Index to Y R20  SUB,R4,Rx ;compute bound BNZ,R20,Loop ;check if done LD SD LD MULTD ADDD 1ª iteración 2ª iteración ¿Fuera de orden? ld, multd, ld, addd, sd ld, multd, ld, addd, sd

  44. arqPar Flujo de datos en memoria Super-44 • Load Bypassing, Load Forwarding y colas LSQ Store X Store Y Load Z ld st STQ LDQ STQ L1D reissue Load bypassing Load forwarding • Tag con menos bits “aliassing” Store X Store Y Load X ? • Forwarding  Tag Addr completa • Predictor de dependencia LdSt 11..19% 1..4%  Mejoras

  45. arqPar Flujo de datos en memoria Super-45 • Load Bypassing, Load Forwarding y colas LSQ [Completo] ¿ Puede reducirse el consumo ? STQ LDQ

  46. arqPar Flujo de datos en memoria Super-46 • LSQ [Reducir Consumo en L1D] Nicolaescu y otros ISLPED 2003 • ¡ Parten de LSQ unificada ! Serializar acceso: LSQ miss L1D ¿Cómo evitar acceso inútil LSQ+L1D? ¡ Baja tasa de forwarding < 15% ! LSQ Edad L/S Dir. Dato 2 L 16 Antiguo 3 S 18 X’ L1D Dir. Dato 4 S 20 Y’ 5 L 14 14 Z’ 14 Z 6 S 20 8 L 18 X --- --- 9 S Reciente issue 20 Y Y’ Reloj

  47. arqPar Flujo de datos en memoria Super-47 • LSQ [Reducir Consumo en L1D] Nicolaescu y otros ISLPED 2003 • ¡ Parten de LSQ unificada ! Serializar acceso: LSQ miss L1D ¿Cómo evitar acceso inútil LSQ+L1D? ¡ Baja tasa de forwarding < 15% ! LSQ Edad L/S Dir. Dato 2 L 16 Antiguo 3 S 18 X’ L1D Dir. Dato 4 S 20 Y’ 5 L 14 ¡ Un ciclo más el 85% de los loads ! 14 Z’ 14 Z 6 S 20 8 L issue 18 X --- --- 9 S Reciente 20 Y ¿ En x86 ? Z Miss Reloj

  48. arqPar Flujo de datos en memoria Super-48 • ¿Cuánto forwarding? • Simulación con: • PTLsim/X arquitectura tipo x86-64: LSQ [LQ.48+SQ.32] • SPEC CPU2006 • 200 millones de instrucciones simuladas

  49. arqPar Flujo de datos en memoria Super-49 • LSQ [Reducir Consumo en L1D] Nicolaescu y otros ISLPED 2003 ¿Cómo evitar acceso inútil LSQ+L1D? ¡ Baja tasa de forwarding < 15% ! Usar LSQ libre [ld/st commited] como una cache LSQinfrautilizada dirvalor dirvalor ¡ Pasan a medir 6,3%+[45,5% | 27,0%] ! ld/st Ld x x ¡ Un ciclo más +50% de los loads ! ¡ 2% t ! ¡ 98% t !

  50. arqPar Flujo de datos en memoria Super-50 • LSQ [Reducir Consumo en L1D] Carazo y otros JCSC Dic 2012 Predictor de forwarding ¿Cómo evitar acceso inútil? ¡ Baja tasa de forwarding < 15% ! [LDQ+STQ]Cached + x86-64 forward STQ en vuelo Ahorro Wat HIT STQ cacheada Predicho: SI FWD L1D + 1 ciclo LDQ cacheada Predictor de forwarding MISS load forward STQ en vuelo = ciclos y Wat MISS Predicho: NO FWD STQ cacheada LDQ cacheada L1D HIT = ciclos y Wat

More Related