Departamento de Automática

Transcripción

1 Departamento de Automática Tema 3 Paralelismo a nivel de instrucción (I) Prof. Dr. José Antonio de Frutos Redondo Dr. Raúl Durán Díaz Curso

2 Tema 3. Paralelismo a Nivel de Instrucción I Planificación de instrucciones y predicción de saltos Planificación estática (reordenación y desenrollado de bucles). Renombramiento de registros. Planificación dinámica (Algoritmo de Tomasulo). Predicción dinámica de saltos. Tabla de bits y tabla de contadores. BTB (Branch Target Buffer) Pila de direcciones de retorno. 3. Paralelismo a nivel de instrucción (I) 2

3 Reordenación de código Consiste en reordenar las instrucciones para eliminar parones. Hay que tener cuidado con las dependencias. Ejemplo: consideramos el siguiente programa que suma a un vector de 1000 componentes, en coma flotante, un valor escalar: for (i = 0; i < 1000; i = i + 1) x[i] = x[i] + s; En este bucle no hay dependencias entre iteraciones. 3. Paralelismo a nivel de instrucción (I) 3

4 Reordenación de código El código en ensamblador correspondiente al bucle es: bucle: ld f0,0(r1) addd f4,f0,f2 sd 0(r1),f4 subi r1,r1,8 bnez r1,bucle Suponemos la siguientes latencias: Productor Consumidor Latencia 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. 3. Paralelismo a nivel de instrucción (I) 4

5 Reordenación de código Con las latencias vistas, la ejecución del bucle es: instrucción ciclo bucle: ld f0,0(r1) 1 parón 2 addd f4,f0,f2 3 parón 4 parón 5 sd 0(r1),f4 6 subi r1,r1,8 7 parón 8 bnez r1,bucle 9 hueco de retardo 10 Tiempo de ejecución: 10 ciclos por iteración, 5 parones (50%) 3. Paralelismo a nivel de instrucción (I) 5

6 Reordenación de código Se puede reordenar el código, para eliminar parones: bucle: ld f0,0(r1) parón addd f4,f0,f2 subi r1,r1,8 parón bnez r1,bucle sd 8(r1),f4 Tiempo de ejecución: 7 ciclos (reducción del 33%) 2 parones (29%) 3. Paralelismo a nivel de instrucción (I) 6

7 Reordenación de código A pesar de la reordenación: El cuerpo de la iteración realiza los siguientes pasos: Cargar una componente del vector. Sumarle el escalar. Almacenar el resultado. El resto de ciclos (3, el 43%) es sólo recargo. Para reducir el porcentaje de recargo desenrollamos el bucle: Se copia el cuerpo del bucle varias veces para trabajar sobre varias componentes del vector en cada iteración. 3. Paralelismo a nivel de instrucción (I) 7

8 Desenrollado de bucles En cada iteración del nuevo bucle se realizan varias iteraciones del bucle original. El bucle original era: bucle: ld f0,0(r1) addd f4,f0,f2 sd 0(r1),f4 subi r1,r1,8 bnez r1,bucle 3. Paralelismo a nivel de instrucción (I) 8

9 Desenrollado de bucles Nueva versión del bucle: ciclo bucle: ld f0,0(r1) ;componente 1 1 addd f4,f0,f2 3 sd 0(r1),f4 6 ld f6,-8(r1) ;componente 2 7 addd f8,f6,f2 9 sd -8(r1),f8 12 ld f10,-16(r1) ;componente 3 13 addd f12,f10,f2 15 sd -16(r1),f12 18 ld f14,-24(r1) ;componente 4 19 addd f16,f14,f2 21 sd -24(r1),f16 24 subi r1,r1,32 ;control del bucle 25 bnez r1,bucle Paralelismo a nivel de instrucción (I) 9

10 Desenrollado de bucles Sin desenrollar (ni reordenar): 4 iteraciones supondrían 4 * 10 = 40 ciclos. Desenrollando: 1 iteración (lo equivalente) supone 28 ciclos (30% menos) La ganancia procede de: Eliminar las instrucciones de control del bucle en 3 de las 4 iteraciones desenrolladas. Eliminar el hueco de retardo vacío 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. 3. Paralelismo a nivel de instrucción (I) 10

11 Desenrollado de bucles Bucle desenrollado con reordenación de código: 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 addd f4,f0,f2 ;sumas addd f8,f6,f2 addd f12,f10,f2 addd f16,f14,f2 sd 0(r1),f4 ;almacenamientos sd -8(r1),f8 subi r1,r1,32 ;control del bucle sd 16(r1),f12 ;16-32=-16 bnez r1,bucle sd 8(r1),f16 ;8-32= Paralelismo a nivel de instrucción (I) 11

12 Desenrollado de bucles Reordenando se han rellenado los parones por dependencias con trabajo útil. Cada iteración se ejecuta ahora en 14 ciclos, 50% menos que en la versión desenrollada pero no reordenada. Si el número de iteraciones m no es múltiplo de n (factor de desenrollado), sustituimos el bucle original por dos consecutivos: El primero, con cuerpo igual al original, se ejecuta m mod n veces. El segundo, con cuerpo desenrollado n veces, se ejecuta m/n veces (división entera). 3. Paralelismo a nivel de instrucción (I) 12

13 Renombramiento de registros Se trata de una técnica para eliminar dependencias falsas. Básicamente consiste en implementar más registros de los que ve el programador. Los nombres que usa el programador son lógicos; los que usa la máquina, físicos. El hardware establece una correspondencia entre ellos. 3. Paralelismo a nivel de instrucción (I) 13

14 Renombramiento de registros Ejemplo de funcionamiento del renombrado. 1 or r5,r0,dir 2 ld r6,0(r5) 3 ld r8,8(r5) 4 ld r9,16(r5) 5 ld r7,24(r5) 6 add r1,r8,r9 7 add r8,r9,r7 8 st 0(r8),r1 9 ld r8,0(r6) Paralelismo a nivel de instrucción (I) 14

15 Renombramiento de registros 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 0(r8),r1 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 0(f7),f6 f8,0(f2) r5 f1 r6 f2 -- f3 r9 f4 r7 f5 r1 f6 -- f7 r8 f8 -- f9 3. Paralelismo a nivel de instrucción (I) 15

16 Renombramiento de registros 1 or f1,r0,dir 2 ld f2,0(f1) 3 ld f3,8(f1) 4 ld f4,16(f1) 5 ld f5,24(f1) 6 add f6,f3,f4 7 add f7,f4,f5 8 st 0(f7),f6 9 ld f8,0(f2) Paralelismo a nivel de instrucción (I) 16

17 Renombramiento de registros Paralelismo a nivel de instrucción (I) 17

18 Planificación dinámica Reordenación de la ejecución de instrucciones para evitar parones por hardware. Objetivo: eliminar parones innecesarios. Veamos el siguiente código: divd f0,f2,f4 addd f10,f0,f8 subd f12,f8,f14 La segunda instrucción no se puede ejecutar hasta que primera genere f0. Esto impide que se ejecute la tercera, aunque tenga todos sus datos preparados => parón innecesario. 3. Paralelismo a nivel de instrucción (I) 18

19 Planificación dinámica 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: lanzamiento: decodificación y comprobación de dependencias estructurales (en orden de programa). lectura de operandos: 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. La idea es que el código se reordena solo, de forma dinámica, y según la situación del cauce. 3. Paralelismo a nivel de instrucción (I) 19

20 Planificación dinámica Ventajas: 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. Inconvenientes: El hardware es bastante más complejo. Ahora se pueden dar las dependencias WAR y WAW. Hay que tener cuidado con las excepciones (interrupciones). 3. Paralelismo a nivel de instrucción (I) 20

21 Algoritmo de Tomasulo Robert Tomasulo IBM 360/91 (1967). Rastrea cuándo los operandos de una instrucción están listos para minimizar los parones por dependencias RAW. Introduce el renombrado de registros para minimizar los parones por dependencias WAW y WAR. Características malas del IBM 360: Pocos registros de coma flotante en doble precisión (4). Accesos a memoria lentos. Grandes atascos en coma flotante. El algoritmo de Tomasulo se diseño para contrarrestar estas características malas. 3. Paralelismo a nivel de instrucción (I) 21

22 Algoritmo de Tomasulo La unidad de coma flotante del IBM 360/91 podía trabajar de forma simultánea con: Tres operaciones para el sumador. Dos operaciones para el multiplicador. Usa estaciones de reserva, que almacenan las instrucciones que están pendientes de entrar a una UF (cada UF tiene la suya). La distribución de los resultados se efectúa directamente por medio del bus común de datos (CDB) sin necesidad de pasar por los registros. 3. Paralelismo a nivel de instrucción (I) 22

23 Algoritmo de Tomasulo 3. Paralelismo a nivel de instrucción (I) 23

24 Algoritmo de Tomasulo Con la estructura de la máquina, las fases del cauce son: lanzamiento, ejecución y almacenamiento. Lanzamiento: Se toma una instrucción de la cola. Si hay espacio en su estación de reserva, se coloca ahí. Si los operandos están en el banco de registros, se envían a la estación de reserva. Si no hay espacio en la estación de reserva se produce un parón estructural. Si los operandos no están en el banco de registros, se indican las unidades funcionales que los producen en Q j y Q k. Esta operación introduce un renombramiento de registros implícito. 3. Paralelismo a nivel de instrucción (I) 24

25 Algoritmo de Tomasulo Ejecución: Si falta algún operando, se vigila el CDB. Cuando están listos los dos, se ejecuta la operación. Almacenamiento: 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. 3. Paralelismo a nivel de instrucción (I) 25

26 Algoritmo de Tomasulo Implementación del renombrado del registros: Hay 11 fuentes de datos: 6 entradas del buffer de loads, 3 entradas en la estación de reserva de suma y 2 entradas en la estación de reserva 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 ya está listo) De esta manera se extiende el número de registros de 4 a Paralelismo a nivel de instrucción (I) 26

27 Algoritmo de Tomasulo Información que se almacena en la estación de reserva: Op: operación que se tiene que ejecutar. Q j,q k : estaciones de reserva que producen los operandos (0 si listo o no necesario). V j,v k : valor de los operandos. Ocup: si la entrada está ocupada. Sólo es válida la información de Q o V (no ambas a la vez). 3. Paralelismo a nivel de instrucción (I) 27

28 Algoritmo de Tomasulo Información que se almacena en cada registro y en los buffers de stores: Q i : estación de reserva que genera el valor que hay que enviar a memoria. V: valor que hay que enviar a memoria. 3. Paralelismo a nivel de instrucción (I) 28

29 Algoritmo de Tomasulo (Ejemplo) Vamos a analizar la ejecución del siguiente código: ld f6,34(r2) ld f2,45(r3) multd f0,f2,f4 subd f8,f6,f2 divd f10,f0,f6 addd f6,f8,f2 Suponemos las siguientes latencias: ld, sd: 3 ciclos addd, subd: 2 ciclos multd: 5 ciclos divd: 19 ciclos 3. Paralelismo a nivel de instrucción (I) 29

30 Algoritmo de Tomasulo (Ejemplo) Punto de partida: el código se encuentra en esta situación: Instrucción lanz. ejec. almac. ld f6,34(r2) sí 1 sí 2-4 sí 5 ld f2,45(r3) sí 2 sí multd f0,f2,f4 sí 3 subd f8,f6,f2 sí 4 divd f10,f0,f6 sí 5 addd f6,f8,f2 sí 6 OJO! Esta información no se encuentra físicamente en ninguna tabla. Se muestra para facilitar la comprensión. 3. Paralelismo a nivel de instrucción (I) 30

31 Algoritmo de Tomasulo (Ejemplo) Estaciones de reserva: UF Ocup Op V j V k Q j Q k 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 Estado de los registros: f0 f2 f4 f6 f8 f10 f12 f30 mult1 load2 add2 add1 mult2 3. Paralelismo a nivel de instrucción (I) 31

32 Algoritmo de Tomasulo (Ejemplo) Estado cuando multd está lista para escribir Inst lanz. ejec. almac. ld f6,34(r2) sí 1 sí 2-4 sí 5 ld f2,45(r3) sí 2 sí 3-5 sí 6 multd f0,f2,f4 sí 3 sí subd f8,f6,f2 sí 4 sí 7-8 sí 9 divd f10,f0,f6 sí addd f6,f8,f2 sí 6 sí La instrucción de suma ha podido terminar, porque el renombrado elimina la dependencia WAR con la división y la resta. Ojo al parón estructural del addd por almacenamiento simultáneo con el multd. 3. Paralelismo a nivel de instrucción (I) 32

33 Algoritmo de Tomasulo (Ejemplo) Estaciones de reserva: UF Ocup Op V j V k Q j Q k add1 no add2 sí add M[34+R(r2)]-M[45+R(r3)] M[45+R(r3)] add3 no mult1 sí mult M[45+R(r3)] R(f4) mult2 sí div M[34+R(r2)] mult1 Estado de los registros: f0 f2 f4 f6 f8 f10 f12 f30 mult1 add2 mult2 3. Paralelismo a nivel de instrucción (I) 33

34 Predicción dinámica de saltos En el tema anterior vimos cuatro posibilidades al encontrar un salto: Parar el cauce. Suponer que se toma. Suponer que no se toma. Ejecución retardada. Vimos que: 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 reducida efectividad. 3. Paralelismo a nivel de instrucción (I) 34

35 Predicción dinámica de saltos Suponer que el salto va a ir en un determinado sentido dependiendo de la historia del salto (en tiempo de ejecución) Objetivo: Adivinar en qué sentido va a ir cada salto. El problema de los esquemas utilizados antes es que eran estáticos: siempre hacen la misma predicción. Pero los saltos no se comportan así: No todos saltan en el mismo sentido. Bastantes saltos (analizados de forma individual) no saltan siempre en el mismo sentido. Información sobre la que se trabaja: El comportamiento anterior del salto (del salto concreto, o de todos los saltos, según el esquema) 3. Paralelismo a nivel de instrucción (I) 35

36 Tabla de bits Consiste en una tabla de bits a la que se accede con la parte baja de la dirección del salto. Ejemplo: si hay 1024 bits, se accede con los 10 bits inferiores de la dirección del salto. El bit está a 1 si la última vez el salto se tomó, a 0 si no. La predicción es que el salto se comporta como la última vez. Si se predice mal, se corrige la predicción. Presenta el problema de que a varios saltos les corresponde la misma entrada en la tabla. 3. Paralelismo a nivel de instrucción (I) 36

37 Tabla de contadores (TC) En lugar de un bit, las entradas de la tabla son contadores de 2 bits con saturación. Un posible algoritmo puede ser: Cuando un salto se toma, se incrementa (sin pasar de 3). Cuando no se toma, se decrementa (sin pasar de 0). La predicción se hace de la siguiente manera: Si el contador vale 2 ó 3, el salto se predice tomado. Si vale 0 ó 1, se predice no tomado. El acceso a la tabla se hace igual: con los bits inferiores de la dirección del salto. Cuando el salto se ejecuta, el valor del contador se actualiza según el algoritmo visto. 3. Paralelismo a nivel de instrucción (I) 37

38 Tabla de contadores (TC) Si la tabla es de n bits: Cuando un salto se toma, se incrementa (máximo: 2 n 1). Cuando no se toma, se decrementa (mínimo: 0). El acceso a la tabla se hace igual: con los bits inferiores de la dirección del salto. La predicción se hace de la siguiente manera: Si 2 n 1 contador 2 n 1, el salto se predice tomado. Si 2 n 1 1 contador 0, se predice no tomado. Cuando el salto se ejecuta, el valor del contador se actualiza según el algoritmo visto. 3. Paralelismo a nivel de instrucción (I) 38

39 Tabla de contadores (TC) Para mejorar el comportamiento del predictor, se utiliza la siguiente máquina de estados (válida para 2 bits): Salto tomado Predicción tomar 11 Salto tomado Predicción no tomar 01 Salto no tomado Salto tomado Salto no tomado Salto tomado Predicción tomar 10 Salto no tomado Predicción no tomar 00 Salto no tomado 3. Paralelismo a nivel de instrucción (I) 39

40 Tabla de contadores (TC) Rendimientos: TC con 4096 entradas (2 bits por entrada): 3. Paralelismo a nivel de instrucción (I) 40

41 Tabla de contadores (TC) Rendimientos: comparación entre TC con 4096 entradas TC con entradas ilimitadas (2 bits por entrada): 3. Paralelismo a nivel de instrucción (I) 41

42 Historia global Mejora en la predicción considerando la historia de varios saltos. Si se accede a la TC con la dirección del salto, entonces, para realizar la predicción, sólo se utiliza el comportamiento del salto concreto. A veces, sin embargo, el comportamiento de saltos próximos al que estudiamos nos da información útil. Por ejemplo: if (aa == 2) aa = 0; if (bb == 2) bb = 0; if (aa!= bb) { 3. Paralelismo a nivel de instrucción (I) 42

43 Historia global 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 Si los saltos 1 y 2 no se toman, el salto 3 se tomará (r1 y r2 son iguales) 3. Paralelismo a nivel de instrucción (I) 43

44 Historia global Para tener la historia en cuenta, utilizamos un predictor global, de m bits, y 2 m predictores de n bits para otros tantos saltos. En la tabla siguiente hacemos m = n = 2, por tanto tenemos un predictor global de 2 bits, y 4 predictores posibles de 2 bits, para cada salto. Para predecir un salto miramos dos cosas: cómo fueron los dos saltos anteriores? Eso nos permite elegir la columna correcta. cuáles son los últimos 4 bits de la dirección de la instrucción de salto? Eso nos permite elegir la celda correcta. La celda elegida contiene la predicción para el salto actual. 3. Paralelismo a nivel de instrucción (I) 44

45 Historia global 3. Paralelismo a nivel de instrucción (I) 45

46 Historia global 3. Paralelismo a nivel de instrucción (I) 46

47 Predicción dinámica de saltos Se plantea un problema: 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. Por lo tanto: necesitamos identificar los saltos antes. Para ello utilizamos otra tabla: el buffer de destinos de saltos ( branch-target buffer ) Esta tabla se va a acceder en la fase de búsqueda con el CP (de forma simultánea a la búsqueda de la instrucción) El acceso nos dirá si la instrucción que buscamos es un salto, (y si lo es, la dirección de destino). 3. Paralelismo a nivel de instrucción (I) 47

48 Branch Target Buffer (BTB) Se trata de una tabla de dos columnas: 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. Si encuentra el valor que se le pide: 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. Si no lo encuentra: no es un salto (o lo es pero no se ha ejecutado aún ninguna vez). Cuando se sabe que una instrucción es un salto, se almacenan su dirección y la de su destino en la tabla. 3. Paralelismo a nivel de instrucción (I) 48

49 Branch Target Buffer (BTB) 3. Paralelismo a nivel de instrucción (I) 49

50 Branch Target Buffer (BTB) Resumiendo el mecanismo de predicción: Tenemos el buffer de destinos de saltos (BTB), que nos dice si una instrucción (identificada por su dirección) es un salto, y el destino del salto. Tenemos la tabla de contadores (TC), que nos dice si el salto se va a tomar o no. En la fase de búsqueda hacemos tres accesos simultáneos: A la memoria, por la instrucción. Al buffer de destinos (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. 3. Paralelismo a nivel de instrucción (I) 50

51 Branch Target Buffer (BTB) Mecanismo de predicción (continuación): Si el BTB dice que no es un salto, se sigue la búsqueda secuencial. Si el BTB dice que es un salto, y la TC dice que no se toma, se hace lo mismo. Si el BTB dice que es un salto, y la TC dice que se toma, se sigue la búsqueda por el destino del salto. Cuando se ha ejecutado el salto, hay que actualizar la información de las tablas. Si era un salto y el BTB 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 toma, se decrementa. 3. Paralelismo a nivel de instrucción (I) 51

52 Pila de direcciones de retorno Qué hacemos con los saltos indirectos? La dirección de destino no está en el código de la instrucción. Por lo tanto, hay que hacer un acceso a memoria o a un registro. Además el destino puede ser variable: Ejemplos: retorno de subrutina, sentencias switch. El 85% de los saltos indirectos en los SPEC son retornos: resulta apropiado centrarse en ellos. 3. Paralelismo a nivel de instrucción (I) 52

53 Pila de direcciones de retorno Pila de direcciones de retorno Es una estructura LIFO en la CPU Almacena las direcciones de retorno: Se introduce una nueva cuando se ejecuta una instrucción de llamada a subrutina. Se retira con el retorno de la subrutina. 3. Paralelismo a nivel de instrucción (I) 53

54 Pila de direcciones de retorno Porcentajes de predicciones erróneas de la pila de retornos 3. Paralelismo a nivel de instrucción (I) 54