2EMHWLYRV 5HIHUHQFLDV

Transcripción

1 7HPD6HJPHQWDFLyQ,,,QWURGXFFLyQ DORV6XSHUHVFDODUHV 2EMHWLYRV 5HIHUHQFLDV $SURYHFKDPLHQWRGHXQDDUTXLWHFWXUDVHJPHQWDGD 3ODQLILFDFLyQGLQiPLFD 3UHGLFFLyQGLQiPLFDGHVDOWRV 5HQRPEUDGRGHUHJLVWURV 3UHGLFDFLyQ 3URFHVDGRUHV6XSHUHVFDODUHV (MHPSORHO3HQWLXP3UR 1 Objetivos 2EMHWLYRV &RQRFHUODVWpFQLFDVGHFRPSLODFLyQTXHSHUPLWHQVDFDUPiV UHQGLPLHQWRDXQDPiTXLQDVHJPHQWDGD &RQRFHUORVHOHPHQWRV\WpFQLFDVTXHVHSXHGHQDxDGLUDXQ SURFHVDGRUSDUDKDFHUPiVHIHFWLYDODVHJPHQWDFLyQ &RPSUHQGHUHOFRQFHSWRGHSURFHVDGRUVXSHUHVFDODUFRPR XQDH[WHQVLyQQDWXUDOGHOGHSURFHVDGRUVHJPHQWDGR 2 1

2 Segmentación de instrucciones Referencias 5HIHUHQFLDV Este tema está sacado de forma prácticamente íntegra (otra vez) del Hennessy-Patterson (la 2ª edición) Para algunas transparencias se han usado como modelo las de Al Davis Como complemento se puede mirar el Kai Hwang (todo como el tema anterior, porque es la continuación) Para ver más sobre predictores de saltos: &RPELQLQJ%UDQFK 3UHGLFWRUV 6FRWW0F)DUOLQJ:5/7HFKLFDO1RWH71MXQLR La descripción del Pentium Pro se puede mirar en los manuales de Intel (en cuanto a diseño, es prácticamente igual que el Pentium III) o en el libro: µ3hqwlxp3ur3urfhvvru6\vwhp $UFKLWHFWXUH 7RP6KDQOH\$GGLVRQ:HVOH\ Mirar también en la página de Intel. 3 Aprovechamiento de la segmentación 5HRUGHQDFLyQSODQLILFDFLyQGHOFyGLJR Consiste en reordenar las instrucciones para eliminar parones Hay que tener cuidado con las dependencias Ejemplo: a partir del bucle siguiente, que suma a un vector de 1000 componentes en coma flotante un valor escalar: for(i=1;i<1000;i=i+1) x[i] = x[i] + s; 4 2

3 Aprovechamiento de la segmentación (OFyGLJRHQHQVDPEODGRUFRUUHVSRQGLHQWHDOEXFOHHV Bucle:ld f0,0(r1) add f4,f0,f2 sd 0(r1),f4 subi r1,r1,8 bnez r1,bucle 6XSRQLHQGRODWHQFLDV 3URGXFWRU &RQVXPLGRU /DWHQFLD FP ALU FP ALU 3 ciclos FP ALU Store 2 ciclos Load FP ALU 1 ciclo Load Store 0 ciclos enteros: Load - ALU, 1 ciclo; resto 0 ciclos 5 Aprovechamiento de la segmentación &RQODVODWHQFLDVYLVWDVODHMHFXFLyQGHOEXFOHHV LQVWUXFFLyQ Bucle: ld f0,0(r1) 1 SDUyQ 2 addd f4,f0,f2 3 SDUyQ 4 SDUyQ 5 sd 0(r1),f4 6 subi r1,r1,8 7 bnez r1,bucle 8 SDUyQ 9 FLFOR 7LHPSRGHHMHFXFLyQFLFORVSRULWHUDFLyQSDURQHV 6 3

4 Aprovechamiento de la segmentación 6HSXHGHUHRUGHQDUHOFyGLJRSDUDHOLPLQDUSDURQHV Bucle: ld f0,0(r1) SDUyQ addd VXEL EQH] sd f4,f0,f2 UU U%XFOH (r1),f4 7LHPSRGHHMHFXFLyQFLFORVUHGXFFLyQGHOSDUyQ 7 Aprovechamiento de la segmentación $SHVDUGHODUHRUJDQL]DFLyQ el cuerpo de la iteración, lo que hace es: cargar una componente del vector sumarle el escalar almacenar el resultado el resto de ciclos (3, el 50%) es sólo recargo 3DUDUHGXFLUHOSRUFHQWDMHGHUHFDUJR ³GHVHQUROODPRV HOEXFOH se copia el cuerpo del bucle varias veces para trabajar sobre varias componentes del vector en cada iteración 8 4

5 Aprovechamiento de la segmentación 'HVHQUROODGRGHEXFOHV³ORRSXQUROOLQJ Consiste en solapar distintas iteraciones del mismo bucle Hay que tener cuidado con las dependencias Partimos del mismo bucle: Bucle:ld f0,0(r1) add f4,f0,f2 sd 0(r1),f4 subi r1,r1,8 bnez r1,bucle 9 Aprovechamiento de la segmentación 1XHYDYHUVLyQGHOEXFOH Bucle: ld f0,0(r1) ;componente 1 add f4,f0,f2 sd 0(r1),f4 ld f6,-8(r1) ;componente 2 add f8,f6,f2 sd -8(r1),f8 ld f10,-16(r1) ;componente 3 add f12,f10,f2 sd -16(r1),f12 ld f14,-24(r1) ;componente 4 add f16,f14,f2 sd -24(r1),f16 subi r1,r1,32 ;control del bucle bnez r1,bucle 10 5

6 Aprovechamiento de la segmentación 6LQGHVHQUROODUQLUHRUGHQDU 4 iteraciones supondrían 4 * 9 = 36 ciclos 'HVHQUROODQGR 1 iteración (lo equivalente) supone 27 ciclos (25% menos) /DJDQDQFLDSURFHGHGH eliminar las instrucciones de control del bucle en 3 de las 4 iteraciones desenrolladas eliminar el parón que hay después de la instrucción de salto en 3 de las 4 iteraciones En resumen: se elimina el recargo en 3 de las 4 iteraciones 11 Aprovechamiento de la segmentación $KRUDVHUHRUGHQDHOFyGLJRGHOEXFOHGHVHQUROODGR Bucle: ld f0,0(r1) ;componente 1 ld f6,-8(r1) ;componente 2 ld f10,-16(r1) ;componente 3 ld f14,-24(r1) ;componente 4 add f4,f0,f2 ;sumas add f8,f6,f2 add f12,f10,f2 add f16,f14,f2 sd 0(r1),f4 ;almacenamientos sd -8(r1),f8 sd -16(r1),f12 subi r1,r1,32 ;control del bucle bnez r1,bucle sd 8(r1),f16 ;8-32=

7 Aprovechamiento de la segmentación 5HRUGHQDQGRVHKDQUHOOHQDGRORVSDURQHVSRUGHSHQGHQFLDV FRQWUDEDMR~WLO&DGDLWHUDFLyQVHHMHFXWDDKRUDHQFLFORV PHQRVTXHHQODYHUVLyQUHRUGHQDGDSHURQRGHVHQUROODGD 'LILFXOWDG podemos desenrollar el bucle así, si se ejecuta un número de veces múltiplo de 4 (el número de iteraciones antiguas a las que equivale la nueva). 6ROXFLyQ si el número de iteraciones no es múltiplo de 4, sustituimos el bucle original por dos consecutivos: el primero, con FXHUSRLJXDO al original, se ejecuta QPRG veces el segundo, con FXHUSRGHVHQUROODGRYHFHV, se ejecuta Q veces 13 3ODQLILFDFLyQGLQiPLFD 2EMHWLYRHOLPLQDUSDURQHVLQQHFHVDULRV (como la estática, pero más flexible) Ej.: en el siguiente código: divd f0,f2,f4 addd f10,f0,f8 subd f8,f8,f14 La segunda instrucción no se puede ejecutar hasta que la primera genere f0 Esto impide que se ejecute la tercera, aunque tenga todos sus datos preparados => parón innecesario 'RVVROXFLRQHVPDUFDGRUHVµVFRUHERDUGLQJ \ HODOJRULWPRGH7RPDVXOR 14 7

8 7DQWRFRQPDUFDGRUHVFRPRFRQHODOJRULWPRGH7RPDVXOR se pretende que una instrucción con sus operandos disponibles no se quede paralizada si tiene posibilidad de ejecutarse (porque otra anterior esté bloqueada) para ello se divide la fase ID en dos: ODQ]DPLHQWR: decodificación y comprobación de dependencias estructurales OHFWXUDGHRSHUDQGRV: espera por operandos; cuando están listos, se leen y se pasa a ejecutar (no necesariamente respetando el orden del programa) de esta forma, una instrucción puede adelantar a otra que esté bloqueada por dependencias /DLGHDHVTXHHOFyGLJRVH³UHRUGHQD VRORGHIRUPDGLQiPLFD \VHJ~QODVLWXDFLyQGHOFDXFH 15 9HQWDMDV no sólo trabaja sobre dependencias estáticas, sino también sobre dinámicas el compilador es más sencillo además, la reordenación en tiempo de compilación sólo valía para el cauce concreto con el que se trabaja: ahora es más general,qfrqyhqlhqwhv el hardware es bastante más complejo (lo de siempre) ahora ya sí se pueden dar las dependencias EDL hay que tener cuidado con las excepciones (interrupciones) 16 8

9 0DUFDGRUHVµ6FRUHERDUGLQJ (CDC 6600, 1964) 17 (VQHFHVDULRPRGLILFDUODVHWDSDVGHOFDXFH(OIOXMRDKRUDHV %~VTXHGD: como antes /DQ]DPLHQWR: si su UF está libre, y no hay dependencias EDE con otra instrucción, la instrucción se envía a la UF; en caso contrario, el lanzamiento se bloquea /HFWXUDGHRSHUDQGRV: si los datos están listos, el marcador indica a la UF correspondiente que los lea. Esto permite la ejecución fuera de orden, garantizando que se respetan las dependencias LDE (MHFXFLyQ: puede durar varios ciclos. Cuando termina, la UF avisa al marcador. $OPDFHQDPLHQWR: el marcador comprueba que no hay dependencias EDL, y si no los hay, indica a la UF que actualice el banco de registros 18 9

10 &RPSRQHQWHVGHOPDUFDGRU (VWDGRGHODVLQVWUXFFLRQHV indica en qué fase se encuentran las instrucciones (VWDGRGHODV8)V ocupada/no ocupada operación que tiene que realizar operandos fuente para la operación (qué registros)(fj,fk) operando destino (qué registro) (fi) UF que genera cada operando fuente (qj,qk) Estado de los operandos fuente (listo/no listo) (rj,rk) (VWDGRGHORVUHJLVWURV UF que va a generar el siguiente valor del reg (en blanco si no usado) 19 (MHPSORGHHMHFXFLyQ Vamos a ejecutar el código: ld f6,34(r2) ld f2,45(r3) multdf0,f2,f4 subd f8,f6,f2 divd f10,f0,f6 addd f6,f8,f2 El cauce tiene una unidad de enteros y operaciones comunes, dos multiplicadores, un sumador y un divisor 20 10

11 6XSRQHPRVTXHODHMHFXFLyQVHHQFXHQWUDHQHOVLJXLHQWHHVWDGR,QVW ODQ] OHFW HMHF DOPDF ld f6,34(r2) sí sí sí sí ld f2,45(r3) sí sí sí multdf0,f2,f4 sí subd f8,f6,f2 sí divd f10,f0,f6 sí addd f6,f8,f2 21 (VWDGRGHODVXQLGDGHVIXQFLRQDOHV 8) RFXS RS IL IM IN TM TN UM UN int sí load f2 r3 no(*) mult1 sí mult f0 f2 f4 int no sí mult2 no add sí sub f8 f6 f2 int sí no div sí div f10 f0 f6 mult1 no sí (VWDGRGHORVUHJLVWURV I I I I I I I «I mult1 int add div (*) cuando una instrucción se ejecuta, sus operandos se ponen a no 22 11

12 (VWDGRFXDQGRPXOWG HVWiOLVWDSDUDHVFULELU,QVW ODQ] OHFW HMHF DOPDF ld f6,34(r2) sí sí sí sí ld f2,45(r3) sí sí sí sí multdf0,f2,f4 sí sí sí subd f8,f6,f2 sí sí sí sí divd f10,f0,f6 sí addd f6,f8,f2 sí sí sí (Hemos supuesto add: 2ciclos, mult: 10 ciclos y div: 40 ciclos) 23 (VWDGRGHODVXQLGDGHVIXQFLRQDOHV 8) RFXS RS IL IM IN TM TN UM UN int no mult1 sí mult f0 f2 f4 no no mult2 no add sí add f6 f8 f2 no no div sí div f10 f0 f6 mult1 no sí (VWDGRGHORVUHJLVWURV I I I I I I I «I mult1 add div 24 12

13 (VWDGRFXDQGRGLYG HVWiOLVWDSDUDHVFULELU,QVW ODQ] OHFW HMHF DOPDF ld f6,34(r2) sí sí sí sí ld f2,45(r3) sí sí sí sí multdf0,f2,f4 sí sí sí sí subd f8,f6,f2 sí sí sí sí divd f10,f0,f6 sí sí sí addd f6,f8,f2 sí sí sí sí 25 (VWDGRGHODVXQLGDGHVIXQFLRQDOHV 8) RFXS RS IL IM IN TM TN UM UN int no mult1 no mult2 no add no div sí div f10 f0 f6 no no (VWDGRGHORVUHJLVWURV I I I I I I I «I div 26 13

14 9HQWDMDVGHOHVTXHPDGHPDUFDGRUHVHQHO&'& 70% de mejora en programas en FORTRAN 150% de mejora en programas codificados a mano el coste total del marcador era aprox. el de una UF (es decir, muy bajo; el grueso del coste estaba en los buses) 7RGRHVWRDSHVDUGHTXH no había cachés no había memorias de semiconductores los compiladores eran muy tontos (comparados con los de hoy) 27 )DFWRUHVTXHOLPLWDQODFDSDFLGDGGHOPDUFDGRU SDUDHOLPLQDUSDURQHV (OSDUDOHOLVPRH[LVWHQWHHQODDSOLFDFLyQ si no hay instrucciones independientes, no se pueden eliminar los parones (OQ~PHURGHHQWUDGDVHQHOPDUFDGRU es decir, con cuántas instrucciones se puede trabajar a la vez (en el ejemplo, hasta el siguiente salto) (OQ~PHUR\WLSRGH8)V influye sobre la cantidad de parones estructurales /DH[LVWHQFLDGHDQWLGHSHQGHQFLDVHGO\GHSHQGHQFLDV GHVDOLGDHGH 28 14

15 $OJRULWPRGH7RPDVXOR IBM 360/91 (1967) Basado en el esquema de marcadores Incorpora el concepto de renombrado de registros (que elimina las dependencias EDL y EDE) Características malas del IBM 360: pocos registros de coma flotante en d.p. (4) accesos a memoria lentos grandes retardos en coma flotante El algoritmo de Tomasulo se diseño para contrarrestar estas características malas 29 /DXQLGDGGHFRPDIORWDQWHGHO,%0SRGtDWUDEDMDU GHIRUPDVLPXOWiQHDFRQ tres operaciones para el sumador dos operaciones para el multiplicador 6 loads 3 stores 8VDHVWDFLRQHVGHUHVHUYDTXHDOPDFHQDQODVLQVWUXFFLRQHVTXH HVWiQSHQGLHQWHVGHHQWUDUDXQD8)FDGD8)WLHQHODVX\D 'LIHUHQFLDVFRQHOPDUFDGRU cada ER controla cuándo pueden ejecutarse sus instrucciones los resultados van directamente de las ER a las UF, sin pasar por los registros 30 15

16 (VWUXFWXUDGHODXQLGDGGHFRPDIORWDQWHGHO,%0 31 &RQODHVWUXFWXUDGHODPiTXLQDODVIDVHVGHOFDXFHVRQ /DQ]DPLHQWR se toma una instrucción de la cola si hay espacio en su ER, se coloca ahí si los operandos están en el banco de registros, se envían a la ER si no hay espacio en la ER, hay un parón estructural (MHFXFLyQ si falta algún operando, se vigila el CDB cuando están listos los dos, se ejecuta la operación $OPDFHQDPLHQWR cuando termina la ejecución, los resultados se ponen en el CDB. De ahí van a los registros y a las UF que los esperen

17 'LIHUHQFLDVFRQHOPDUFDGRU no se comprueban las dependencias EDE y EDL: se eliminan al renombrar en la fase de lanzamiento no se espera a que los datos lleguen a los registros: el CDB los lleva a las UF que los necesitan los ORDGV y VWRUHV se tratan como unidades funcionales básicas,psohphqwdflyqghouhqrpeudgrghouhjlvwurv hay 11 fuentes de datos: 6 entradas del buffer de loads, 3 entradas en la ER de suma y 2 en la de multiplicación a cada operando en la fase de lanzamiento se le da un identificador de 4 bits, que indica qué fuente proporciona el dato (0 si listo) de esta manera, se extiende el nº de registros de 4 a 11 33,QIRUPDFLyQTXHVHDOPDFHQDHQODHVWDFLyQGHUHVHUYD Op: operación que se tiene que ejecutar Qj,Qk: ER que producen los operandos (0 si listo o no necesario) Vj,Vk: valor de los operandos Ocupado: si la entrada está ocupada 6yORHVYiOLGDODLQIRUPDFLyQGH4R9QRDPEDVDODYH],QIRUPDFLyQTXHVHDOPDFHQDHQFDGDUHJLVWUR\HQORVEXIIHUV GHVWRUHV Qi: ER que genera el valor que hay que enviar a memoria V: valor que hay que enviar a memoria 34 17

18 (MHPSORGHHMHFXFLyQ De nuevo vamos a ejecutar el código: ld f6,34(r2) ld f2,45(r3) multdf0,f2,f4 subd f8,f6,f2 divd f10,f0,f6 addd f6,f8,f2 35 3XQWRGHSDUWLGDHOFyGLJRVHHQFXHQWUDHQHVWDVLWXDFLyQ,QVW ODQ] HMHF DOPDF ld f6,34(r2) sí sí sí ld f2,45(r3) sí sí multdf0,f2,f4 sí subd f8,f6,f2 sí divd f10,f0,f6 sí addd f6,f8,f2 Vt 2-2HQHVWHFDVRHVWDLQIRUPDFLyQQRVHHQFXHQWUDItVLFDPHQWH HQQLQJXQDWDEOD6HPXHVWUDSDUDIDFLOLWDUODFRPSUHQVLyQ (En negrita las variaciones frente al modelo de marcador) 36 18

19 (VWDFLRQHVGHUHVHUYD 8) RFXS RS 9M 9N 4M 4N add1 sí sub M(34+R(r2)) load2 add2 sí add add1 load2 add3 no mult1 sí mult R(f4) load2 mult2 sí div m(34+r(r2)) mult1 (VWDGRGHORVUHJLVWURV I I I I I I I «I mult1 load2 add2 add1 mult2 37 (VWDGRFXDQGRPXOWG HVWiOLVWDSDUDHVFULELU,QVW ODQ] HMHF DOPDF ld f6,34(r2) sí sí sí ld f2,45(r3) sí sí sí multdf0,f2,f4 sí sí subd f8,f6,f2 sí sí sí divd f10,f0,f6 sí addd f6,f8,f2 sí sí Vt /DLQVWUXFFLyQGHVXPDKDSRGLGRWHUPLQDUSRUTXHHO UHQRPEUDGRHOLPLQDODGHSHQGHQFLD('/FRQODGLYLVLyQ \ODUHVWD 38 19

20 (VWDFLRQHVGHUHVHUYD 8) RFXS RS 9M 9N 4M 4N add1 no add2 no add3 no mult1 sí mult m(45+r(r3)) R(f4) mult2 sí div m(34+r(r2)) mult1 (VWDGRGHORVUHJLVWURV I I I I I I I «I mult1 mult2 39 3UHGLFFLyQGLQiPLFDGHVDOWRV (QHOWHPDDQWHULRUYLPRVSRVLELOLGDGHVDOHQFRQWUDUXQVDOWR parar el cauce suponer que se toma suponer que no se toma ejecución retardada 9LPRVTXH parar significa perder rendimiento suponer que se toma o no significa una gran penalización en caso de equivocarnos (una fracción considerable de las veces) la ejecución retardada tiene una efectividad limitada 40 20

21 6XSRQHUTXHHOVDOWRYDDLUHQXQGHWHUPLQDGRVHQWLGR tiene una fracción de fallo importante si se supone tomado, se tarda en calcular el destino 3(52 es transparente al programador si se acierta en el sentido, la penalización es la menor SRUORWDQWR hay que estudiar mejor esta solución 41 2EMHWLYR adivinar en qué sentido va a ir cada salto (OSUREOHPDGHORVHVTXHPDVXWLOL]DGRVHVTXHHUDQHVWiWLFRV siempre hacen la misma predicción (porque es estática, se hace a priori y no hay otra posibilidad) 3HURORVVDOWRVQRVHFRPSRUWDQDVt no todos saltan en el mismo sentido bastantes saltos (analizados de forma individual) no saltan siempre en el mismo sentido,qirupdflyqvreuhodtxhvhwudedmd el comportamiento anterior del salto (del salto concreto, o de todos los saltos, según el esquema) 42 21

22 (VTXHPDLQLFLDOOD7DEODGH%LWV &RQVLVWHHQXQDWDEODGHELWVDODTXHVHDFFHGHFRQOD GLUHFFLyQGHOVDOWR Ejemplo: si hay 1024 bits, se accede con los 10 bits inferiores de la dirección del salto (OELWHVWiDVLOD~OWLPDYH]HOVDOWRVHWRPyDVLQR /DSUHGLFFLyQHVTXHHOVDOWRVHFRPSRUWDFRPROD~OWLPDYH] 6LVHSUHGLFHPDOVHFRUULJHODSUHGLFFLyQ 3UHVHQWDHOSUREOHPDGHTXHDYDULRVVDOWRVOHVFRUUHVSRQGH ODPLVPDHQWUDGDHQODWDEODDOLDVLQJ 43 5HYLVLyQOD7DEODGH&RQWDGRUHV7& (QOXJDUGHXQELWODVHQWUDGDVGHODWDEODVRQFRQWDGRUHVGH ELWVFRQVDWXUDFLyQ cuando un salto se toma, se incrementa (sin pasar de 3) cuando no se toma, se decrementa (sin pasar de 0) (ODFFHVRDODWDEODVHKDFHLJXDOFRQORVELWVLQIHULRUHVGHOD GLUHFFLyQGHOVDOWR /DSUHGLFFLyQVHKDFHGHODVLJXLHQWHPDQHUD si el contador vale 2 ó 3, el salto se predice tomado si vale 0 ó 1, se predice no tomado &XDQGRHOVDOWRVHHMHFXWDHOYDORUGHOFRQWDGRUVHDFWXDOL]D VHJ~QHODOJRULWPRYLVWR 44 22

23 6HSODQWHDXQSUREOHPD hasta el fin de la fase de decodificación no se sabe si es un salto para entonces, ya podemos saber si se toma en muchos casos 3RUORWDQWRQHFHVLWDPRVLGHQWLILFDUORVVDOWRVDQWHV 3DUDHOORXWLOL]DPRVRWUDWDEODHOEXIIHUGHGHVWLQRVGHVDOWRV ( branch-target buffer ) (VWDWDEODVHYDDDFFHGHUHQODIDVHGHE~VTXHGDFRQHO&3 GHIRUPDVLPXOWiQHDDODE~VTXHGDGHODLQVWUXFFLyQ (ODFFHVRQRVGLUiVLODLQVWUXFFLyQTXHEXVFDPRVHVXQVDOWR \VLORHVODGLUHFFLyQDODTXHVDOWDVLVHWRPD 45 (O%UDQFK7DUJHW%XIIHU7'6%7% 6HWUDWDGHXQDWDEODGHGRVFROXPQDV en la primera (de memoria asociativa) se almacenan direcciones de saltos en la segunda, los sitios a los que se salta en esos saltos si se toman 6LHQFXHQWUDHOYDORUTXHVHOHSLGH la instrucción que estamos buscando (recordad: estamos en la fase de fetch) es un salto la entrada correspondiente de la segunda columna es el destino del salto 6LQRORHQFXHQWUDQRHVXQVDOWRRORHVSHURQRVHKD HMHFXWDGRD~QQLQJXQDYH] &XDQGRVHVDEHTXHXQDLQVWUXFFLyQHVXQVDOWRVHDOPDFHQDQ VXGLUHFFLyQ\ODGHVXGHVWLQRHQODWDEOD 46 23

24 (O%'6%7% 47 5HVXPLHQGRHOPHFDQLVPRGHSUHGLFFLyQ 7HQHPRVHOE~IIHU GHGHVWLQRVGHVDOWRV%'6TXHQRVGLFH VLXQDLQVWUXFFLyQLGHQWLILFDGDSRUVXGLUHFFLyQHVXQVDOWR \DGyQGHVDOWD 7HQHPRVODWDEODGHFRQWDGRUHV7&TXHQRVGLFHVLHOVDOWR VHYDDWRPDURQR (QODIDVHGHE~VTXHGDKDFHPRVWUHVDFFHVRVVLPXOWiQHRV a la memoria, por la instrucción al BDS (BTB), para ver si es un salto, y cuál es el destino a la TC, para ver si se toma el salto o no

25 0HFDQLVPRGHSUHGLFFLyQFRQW 6LHO%'6GLFHTXHQRHVXQVDOWRVHVLJXHODE~VTXHGDVHFXHQFLDO 6LHO%'6GLFHTXHHVXQVDOWR\OD7&TXHQRVHWRPDORPLVPR 6LHO%'6GLFHTXHHVXQVDOWR\OD7&TXHVHWRPDVHVLJXHOD E~VTXHGDSRUHOGHVWLQRGHOVDOWR &XDQGRVHKDHMHFXWDGRHOVDOWRKD\TXHDFWXDOL]DUOD LQIRUPDFLyQGHODVWDEODV si era un salto y el BDS no nos avisó, se habilita una entrada para este nuevo salto si el salto se toma, se incrementa la entrada correspondiente de la TC si no, se decrementa OJO: incrementos y decrementos con saturación 49 5HQGLPLHQWRV7&FRQHQWUDGDV 50 25

26 5HQGLPLHQWRVFRPSDUDFLyQHQWUH7&FRQ HQWUDGDV7&FRQHQWUDGDVLOLPLWDGDV 51 0HMRUDHQODSUHGLFFLyQODKLVWRULDJOREDO $FFHGHUDOD7&FRQODGLUHFFLyQGHOVDOWR!SDUDUHDOL]DUOD SUHGLFFLyQVyORVHXWLOL]DHOFRPSRUWDPLHQWRGHOVDOWRFRQFUHWR 3(52DYHFHVHOFRPSRUWDPLHQWRGHVDOWRVSUy[LPRVDOTXH HVWXGLDPRVQRVGDLQIRUPDFLyQ~WLO if(aa==2) aa=0; if(bb==2) bb=0; if(aa!=bb) {

27 En DLX: subi r3,r1,#2 bnez r3,l1 add r1,r0,r0 l1: subi r3,r2,#2 bnez r3,l2 add r2,r0,r0 l2: sub r3,r1,r2 beqz r3,l3 6LORVVDOWRV\QRVHWRPDQHOVDOWRVHWRPDUi U\UVRQLJXDOHV 53 8WLOL]DFLyQGHODKLVWRULDJOREDO 54 27

28 &RPSDUDFLyQGHUHQGLPLHQWRV 55 9DULDQWHVGHOSUHGLFWRUEDVDGRHQKLVWRULD (OHVTXHPDYLVWRHTXLYDOHDFRQFDWHQDUODKLVWRULDFRQOD GLUHFFLyQGHOVDOWR PROBLEMA: las tablas se hacen grandes enseguida: 10 bits de dirección + 6 de historia =>64K entradas (QOXJDUGHFRQFDWHQDUKDFHUOD;25 dirección historia = índice de esta forma, el tamaño de las tablas no se dispara 7DPELpQVHSXHGHXWLOL]DUXQDKLVWRULDSDUWLFXODUSDUDHOVDOWR 3DUDHOPLVPRFRVWHHOTXHPHMRUUHQGLPLHQWRGDHVHOVHJXQGR 56 28

29 &RPSDUDFLyQGHSUHGLFWRUHV, Gráfica tomada de: Combining Branch Predictors. Scott McFarling. Compaq WRL. 57 &RPSDUDFLyQGHSUHGLFWRUHV,, Gráfica tomada de: Combining Branch Predictors. Scott McFarling. Compaq WRL

30 4XpKDFHPRVFRQORVVDOWRVLQGLUHFWRV" /DGLUHFFLyQGHGHVWLQRQRHVWiHQHOFyGLJRGHODLQVWUXFFLyQ 3RUORWDQWRKD\TXHKDFHUXQDFFHVRDPHPRULDRDXQUHJLVWUR 3(25$Ò1HOGHVWLQRQRHVVLHPSUHHOPLVPR Ejemplos: retorno de subrutina, sentencias switch (OGHORVVDOWRVLQGLUHFWRVHQORV63(&VRQUHWRUQRV UHVXOWDDSURSLDGRFHQWUDUVHHQHOORV 59 3LODGHGLUHFFLRQHVGHUHWRUQR (VXQDHVWUXFWXUD/,)2HQOD&38 $OPDFHQDODVGLUHFFLRQHVGHUHWRUQR se introduce una nueva cuando se ejecuta una instrucción CALL se retira con el retorno 60 30

31 3RUFHQWDMHVGHDFLHUWRGHODSLODGHUHWRUQRV 61 Renombrado de registros 5HQRPEUDGRGHUHJLVWURV 6HWUDWDGHXQDWpFQLFDSDUDHOLPLQDUGHSHQGHQFLDV³IDOVDV (VDOJRSDUHFLGRDORTXHVHKDFtDFRQHODOJRULWPRGH 7RPDVXORDOOtVHKDFtDGHIRUPDLPSOtFLWDDKRUDHVH[SOtFLWR %ivlfdphqwhfrqvlvwhhqlpsohphqwdupivuhjlvwurvghorvtxh YHHOSURJUDPDGRU/RVQRPEUHVTXHXVDHOHOSURJUDPDGRU VRQOyJLFRVORVTXHXVDODPiTXLQDItVLFRV(O+ZHVWDEOHFH XQDFRUUHVSRQGHQFLDHQWUHHOORV 62 31

32 Renombrado de registros (MHPSORGHIXQFLRQDPLHQWRGHOUHQRPEUDGR or ld ld ld ld add add st ld r5,r0,dir r6,0(r5) r8,8(r5) r9,16(r5) r7,24(r5) r1,r8,r9 r8,r9,r7 r1,0(r8) r8,0(r6) or ld ld ld ld add add st ld f1,r0,dir f2,0(f1) f3,8(f1) f4,16(f1) f5,24(f1) f6,f3,f4 f7,f4,f5 f6,0(f7) f8,0(f2) 63 Renombrado de registros /DWDEODGHHTXLYDOHQFLDVDOILQDOGHOFyGLJRHV r5 f1 r6 f2 -- f3 r9 f4 r7 f5 r1 f6 -- f7 r8 f8 -- f

33 Predicación 3UHGLFDFLyQ 2EMHWLYRHOLPLQDUODSUHVHQFLDGHDOJXQRVVDOWRV Ejemplo: la función valor absoluto: a=abs(b); si b es positivo, a=b; si es negativo, a=-b; if(b<0) a=-b; else a=b; 65 Predicación (OFyGLJRHQHQVDPEODGRU cmpl r1,r3,r0 beqz r1,l1 ;saltar si r3 (b) es positivo sub r2,r0,r3 ;r2 (a) -r3 br L2 L1: sub r2,r3,r0 ;r2 r3 L2:

34 Predicación Introducimos en el repertorio una instrucción de transferencia condicional: cmovz transfiere el contenido de un operando al destino, si el segundo operando es cero. Su uso para este ejemplo: cmpl r1,r3,r0; r2:a; r3:b; sub r2,r0,r3; a -b cmovzr2,r3,r1; si r1==0 (b>0), a b (QHOFDVRSHRUVHHOLPLQDQVDOWRVHQHOPHMRU 67 Predicación (QJHQHUDOODSUHGLFDFLyQFRQVLVWHHQLQVWUXFFLRQHVTXHVH HMHFXWDQRQRGHSHQGLHQGRGHOYDORUGHXQRGHVXVRSHUDQGRV 6HSXHGHQLQFOXLUXQDVFXDQWDVGHORVWLSRVPiVXVDGRV WUDQVIHUHQFLDVXPD 2VHSXHGHDPSOLDUDWRGRHOUHSHUWRULRKDFLHQGRTXHVHDQ FRQGLFLRQDOHVLPSOtFLWDPHQWHVHJ~QXQYDORUSUHHVWDEOHFLGR XQUHJLVWURYDULRVXQFRQMXQWRGHUHJLVWURVRXQDHWLTXHWD GHOGDWR,PSRUWDQWHODLQVWUXFFLyQQRGHEHFDXVDUH[FHSFLRQHV HQJHQHUDOGHMDUUDVWURVGHVXH[LVWHQFLDVLODFRQGLFLyQ QRVHFXPSOH 68 34

35 Predicación 9HQWDMDV: elimina saltos, que implican parones no tiene prácticamente coste Hw.,QFRQYHQLHQWHV: no es transparente al compilador / programador sólo es útil para saltos cortos, del tipo if (else), con cuerpos pequeños si la condición no se cumple, se ha desaprovechado un ciclo 69 Procesadores Superescalares 3URFHVDGRUHVVXSHUHVFDODUHV $XPHQWDQODVSUHVWDFLRQHVODQ]DQGRYDULDVLQVWUXFFLRQHVHQ FDGDFLFOR /DOyJLFDGHFRQWUROVHYXHOYHPX\FRPSOHMD /DVLQVWUXFFLRQHVGHEHQFXPSOLUXQDVHULHGHUHVWULFFLRQHV SDUDSRGHUVHODQ]DUDODYH] no deben existir dependencias entre ellas (de datos, de control, estructurales) algunas máquinas no permiten lanzar un load hasta que se comprueba que no hay ningún store previo a la misma dirección 70 35

36 Procesadores Superescalares (O3HQWLXP lanza hasta 2 instrucciones por ciclo, pero: el segundo cauce es más simple =>dependencias estructurales no permite lanzar instrucciones con dependencias de datos realiza especulación en el primer salto que se encuentra (con una tabla de contadores sencilla) (O$OSKD lanza hasta 4 instrucciones por ciclo, pero: máx. 2 de enteros máx. 2 de coma flotante no permite el paso a loads hasta comprobar los stores especula el primer salto 71 Procesadores Superescalares 3URFHVDGRUHV9/,:9HU\/RQJ,QVWUXFWLRQ:RUG $JUXSDQYDULDVLQVWUXFFLRQHVHQXQDSDODEUDPX\ODUJD 7UDVODGDQODSODQLILFDFLyQDOFRPSLODGRUHVHOTXHDJUXSD ODVLQVWUXFFLRQHV 9HQWDMDV la lógica es más simple que para un superescalar,qfrqyhqlhqwhv la rigidez de la planificación (es estática) impide aprovechar todo el paralelismo de la aplicación en muchos casos 72 36

37 Procesadores Superescalares 3URFHVDGRUHV6XSHUHVFDODUHV$YDQ]DGRV 8WLOL]DQSODQLILFDFLyQGLQiPLFD\HMHFXFLyQIXHUDGHRUGHQ )DVHVYLVLyQJHQHUDO E~VTXHGD: acceden a caché, y obtienen varias instrucciones de una vez; las depositan en la cola de prebúsqueda GHFRGLILFDFLyQ: se toman instrucciones de la cola de prebúsqueda, se decodifican, y se identifican sus operandos UHQRPEUDPLHQWR: real (no como el alg. de Tomasulo). Las instrucciones se almacenan en el búffer de reordenamiento (Reorder Buffer) 73 Procesadores Superescalares )DVHVFRQW ODQ]DPLHQWRcuando sus operandos estén listos, y haya hueco en la UF que les corresponde, se ejecutan UHWLUDGDFRPPLW: las instrucciones se ejecutan fuera de orden, en cuanto están listos los operandos, pero no se eliminan del búffer de reordenamiento. Se retiran de él en el orden del programa. Con esto se consigue: acortar las cadenas de dependencias mantener la ilusión de ejecución secuencial (MHPSORVHO3HQWLXP3UR3,,3,,,HO$OSKD HO0,

38 Ejemplo: el Pentium Pro (MHPSORGHVXSHUHVFDODUHO3HQWLXP3UR &DUDFWHUtVWLFDV lanzado en 1995 frecuencia de 150 MHz arquitectura de 32 bits repertorio de instrucciones CISC juego de 40 registros (la arquitectura tiene 8) planificación dinámica, ejecución fuera de orden decodifica hasta 3 instrucciones por ciclo retira hasta 3 instrucciones ejecutadas por ciclo cauce de 11 etapas 75 Ejemplo: el Pentium Pro 'LDJUDPDGH EORTXHVGHO 3HQWLXP3UR 76 38

39 Ejemplo: el Pentium Pro 'HVFULSFLyQGHOFDXFH %~VTXHGD descompuesta en 3 sub-etapas: 1. cargar una línea de caché (32B) 2. identificar instrucciones, comprobar saltos, realizar predicción (si hay) 3. alinear instrucciones 'HFRGLILFDFLyQ descompuesta en 2 sub-etapas: 1. traducir a micro-operaciones (RISCificar) 2. copiar a la cola de instrucciones decodificadas (hasta 6 micro-operaciones) 7UDGXFFLyQGHRSHUDQGRV se determina la situación de los operandos fuente (en registros físicos o lógicos) 77 Ejemplo: el Pentium Pro 'HVFULSFLyQGHOFDXFHFRQW 52%: se busca una entrada en el ROB (búffer de reordenamiento) a la instrucción (máx. 3 por ciclo). Si los datos están listos, se copia la instrucción a la estación de reserva /DQ]DPLHQWR: cuando una instrucción de la ER tiene sus datos listos, y hay sitio en su UF, se envía (no necesariamente en orden) (MHFXFLyQ: el número de ciclos depende de la operación 5HWLUDGD: descompuesta en 3 sub-etapas: 1. si una instrucción se ha ejecutado, y todos los saltos anteriores han sido bien predichos, y se comprueba que la instrucción debía ser ejecutada, se marca para retirar 2. la instrucción se elimina del ROB, se actualizan los registros físicos implicados (máx. 3 por ciclo). Esto se hace en orden 78 39