TEMA 2 ILP BASADO EN PLANIFICACIÓN ESTÁTICA DE INSTRUCCIONES ÍNDICE

TEMA 2 ILP BASADO EN PLANIFICACIÓN ESTÁTICA DE INSTRUCCIONES ÍNDICE 2.1. Conceptos fundamentales: Grafo y tipos de dependencias, Bloques básicos, Límite teórico de ejecución (dataflow-limit), compatibilidad de las aplicaciones. 2.2. Planificación estática básica. Desenrollado de bucles. 2.3. Planificación estática avanzada: Segmentación software. 2.4. Ejecución predicativa, Planificación de trazas y Especulación software. 2.5. Enfoques del paralelismo: Procesadores VLIW. 2.6. Ejemplos reales TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 1

2.1. CONCEPTOS FUNDAMENTALES Definición de Planificación, secuenciamiento o reordenamiento (scheduling): reordenar instrucciones para evitar bloqueos. Objetivo: reducir Bloqueos de datos. for (i=0; i<n; i++) { ejercicio: hallar cuerpo del bucle } LF F2, 0(R1) MULTF F1, F2, F3 DIVF F2, F1, F4 ADDF F1, F2, F3 SF 0(R1), F1 ----------------------------------------- ADDI R1, R1, 4 SLT R2, R1, R7 BNEZ R2, bucle LF F2, 0(R1) MULTF F1, F2, F3 ADDI R1, R1, 4 DIVF F2, F1, F4 SLT R2, R1, R7 ADDF F1, F2, F3 SF -4(R1), F1 BNEZ R2, bucle TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 2

Tipos de dependencias de datos Dependencia real (registros) o RAW (read after write) o Es inevitable e inherente al algoritmo o son muy frecuentes Dependencias ficticias (registros) o WAW (write after write): dependencia de salida o WAR (write after read): se le llama antidependencia o Se pueden eliminar mediante renombrado de registros Dependencia real (memoria) o Analizar dinámicamente direcciones ejercicio: señalar tipos de dependencias en código anterior ejercicio: qué significa dinámicamente? Renombrado. Ejemplo MULTF F1, F2, F3 DIVF F2, F1, F4 ADDF F1, F2, F3 SF 0(R1), F1 MULTF F1, F2, F3 DIVF F20, F1, F4 ADDF F10, F20, F3 SF 0(R1), F10 TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 3

Conclusión: programa como grafo de dependencias reales. Pero existe un límite de CPI (data flow limit o límite de flujo de datos) o Solo se ven las fases de ALU y acceso memoria: EX/MEM o Fases IF ID WB etc. se hacen en paralelo MULTF F1, F2, F3 MULT DIVF F20, F1, F4 IF ID IF ID ADDF F10, F20, F3 IF ID SF 0(R1), F10 Tiempo TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 4 DIV Bypass y Registros temporales ADD Planificación estática limitada por saltos (es difícil cruzarlos ). Bloques básicos: barreras de Planificación for (i=0; i<n ; i++) { if (a[i]<0) { } } else { } b[i]=-a[i]; b[i]=a[i]; WB WB MEM ejercicio: renombrar registros para eliminar dep. ficticias en bucle anterior. ATENCION: R1

Importancia de planificación estática Usar un buen compilador (incluso si CPU es muy dinámica) Buscar flags de optimización del compilador Compilador nativo de intel : icc 12 (ahora Composer XE) NOTA: esta gráfica no es de un VLIW, sino de Intel Xeon: familia Intel para servidores (actualmente similar a Core i7) http://software.intel.com/en-us/articles/intel-composer-xe/ TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 5

2.2 PLANIFICACIÓN ESTÁTICA. DESENROLLADO DE BUCLES. EJEMPLO / RESUMEN DE DESENROLLADO Bucles: más del 90% t. de ejec. Suponemos bucle paralelizable (iteraciones independientes). Ejemplo: double s, x[m], y[m]; int i; for (i=0 ; i<m ; i++ ) y[i]= x[i] * s ; Desenrollado (en alto nivel) : for (i=0 ; i<m%3 ; i++) y[i]= x[i] * s; //start-up (prólogo o cabecera) // sup. tiempo de ejecución pequeño (M es grande) for ( ; i<m ; i+=3 ) { y[i+0]= x[i+0] * s ; y[i+1]= x[i+1] * s ; y[i+2]= x[i+2] * s ; } TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 6

Pasos para el Desenrollado (bajo nivel) bucle_orig: LD F2, 0(R1) ; Instrucciones útiles MULTD F4, F2, F24 ; F24 contiene el valor de s SD (R3)0, F4 ;---------------------- ADDI R1, R1, 8 ; Instrucciones de overhead (control bucle) ADDI R3, R3, 8 SLTI R7, R1, fin_array_x; constante apunta al final de x[m] BNEZ R7, bucle_orig o instr. de overhead (de control del bucle) o instr. útiles de cálculo sobre estructuras de datos (p ej vectores) casi no hay dependencias entre ambos grupos Reordenación evidente TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 7

bucle_intermedio2: // Desenrollado del bucle principal LD F2, 0(R1) MULTD F4, F2, F24 ; F24 contiene el valor de s SD (R3)0, F4 LD F2, 8(R1) MULTD F4, F2, F24 SD (R3)8, F4 LD F2, 16(R1) MULTD F4, F2, F24 SD (R3)16, F4 ;---------------------- ADDI R1, R1, 8*3 ADDI R3, R3, 8*3 SLTI R7, R1, fin_array_x BNEZ R7, bucle_intermedio2 TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 8

Se renombran registros para evitar dependencias ficticias WAR, WAW. Usamos notación con primas ( ) por simplicidad bucle_intermedio3: LD F2, 0(R1) MULTD F4, F2, F24 ; F24 contiene el valor de s SD (R3)0, F4 LD F2, 8(R1) MULTD F4, F2, F24 SD (R3)8, F4 LD F2, 16(R1) MULTD F4, F2, F24 SD (R3)16, F4 ;---------------------- ADDI R1, R1, 8*3 ADDI R3, R3, 8*3 SLTI R7, R1, fin_array_x BNEZ R7, bucle_intermedio3 TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 9

Se entrelazan las instrucciones de las distintas iteraciones bucle_desenrollado: LD F2, 0(R1) LD F2, 8(R1) LD F2, 16(R1) MULTD F4, F2, F24 ; F24 contiene el valor de s MULTD F4, F2, F24 MULTD F4, F2, F24 SD (R3)0, F4 SD (R3)8, F4 SD (R3)16, F4 ;---------------------- ADDI R1, R1, 8*3 ADDI R3, R3, 8*3 SLTI R7, R1, fin_array_x BNEZ R7, bucle_desenrollado TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 10

Opcionalmente se colocan instrucciones tras la más larga (para evitar ciclos de bloqueo) bucle_desenrollado_opc: LD F2, 0(R1) LD F2, 8(R1) LD F2, 16(R1) MULTD F4, F2, F24 ; F24 contiene el valor de s MULTD F4, F2, F24 MULTD F4, F2, F24 ADDI R1, R1, 8*3 SD (R3)0, F4 SD (R3)8, F4 SD (R3)16, F4 SLTI R7, R1, fin_array_x ; ADDI R3, R3, 8*3 BNEZ R7, bucle_desenrollado_opc Prestaciones máximas si desenrollo infinitas veces x[0]= x[0] * s ; x[1]= x[1] * s ; x[m-1]= x[m-1] * s ; ejercicio: hacerlo para otro bucle de vectores TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 11

Aceleración: o ATENCIÓN! al reducir el número de instrucciones, el CPI no es buena medida de rendimiento. o Si se puede usar Ciclos / elem. procesado del vector Instr./elem vector Bucle original (3 instr útiles + 4 instr overhead) / elem = 7 instr /elem. Bucle desenrollado (3 iter.) (3*3 instr útiles + 4 instr overhead) / 3 elem vector = = (3 instr útiles + 4/3 instr overhead) /elem= 4.33 instr/elem Fsaltos 1/7 = 14.3% 1/13 = 7.7% 0% Tam código estático (bytes) Desenrollado infinitas iteraciones (K ) (3*K instr útiles + 4 instr overhead) / K elem vector = (K ) = 3 instr útiles/elem 7 * 4 13 * 4 3 * K * 4 Notas Desprecio iteraciones de prólogo Prestaciones máximas. Tamaño de código estático máximo ejercicio: hallar A entre las 3 columnas si CPI=1.4,1.1,1.0 TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 12

CONCLUSIONES: - Se han reducido las instr. overhead o estamos rescribiendo el código fuente de leng. iterativo para hacerlo más rápido - Se aumenta las posibilidades de planif. estática, en cuanto se reducen el porcentaje de saltos o por cada salto, hay más instr. de otro tipo - Se necesitan más registros (en RISC los hay) - Se ha de conocer la endoarquitectura de la CPU (duración de U.F., existencia de bypass, etc.) o compatibilidad en entredicho (se verá en VLIW). TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 13

2.3. Planificación estática avanzada Bucles no paralelizables: gran variedad de casos. Aquí ejemplos ilustrativos Hay una dependencia entre la iteración actual i y las anteriores. o Serie de Fibonacci (serie con recurrencia: a i+k =f(a i ) ) for (i=2;i<m; i++) x[i]=x[i-1]+x[i-2]; //(2 Load, 1 Store)/1 elem // Si desenrollo: for (i=2;i<m; i+=3) { x[i]=x[i-1]+x[i-2]; x[i+1]=x[i]+x[i-1]; x[i+2]=x[i+1]+x[i]; } // En total:(2 Load,3 Store)/3 elem o Se obtiene cierta aceleración por eliminar instrucciones. o Para a i+k =f(a i ), si k es grande puedo desenrollar k veces: for (i=0;i<m; i++) x[i+4]=x[i]*s; // desenrollo 4 iteraciones: for (i=0;i<m; i+=4) { x[i+4]=x[i+0]*s; x[i+5]=x[i+1]*s; x[i+6]=x[i+2]*s; x[i+7]=x[i+3]*s; } TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 14

Operaciones que cumplen propiedad asociativa o Sumatorio, producto múltiple, búsqueda de mínimo/máx de un vector, etc. o Existe dependencia en la variable acumuladora o Si se rescribe, desaparece. Por ej con acumuladores parciales: - for (i=0;i<m;i++) t = t + y[i]; - for (i=0;i<m; i+=3){ t0 += y[i+0]; t1 += y[i+1]; t2 += y[i+2]; } t = t0 + t1 + t2; Ejercicio: Desenrollar el Producto escalar de dos vectores ejercicio: pensar en búsqueda de mínimo/máx de un vector var. Acumuladoras de y[0] y[m/3], y[m/3] y[2m/3-1], y[2m/3] y[m-1], TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 15

2.3. Segmentación software o encadenamiento de iteraciones (software pipelining). o bucle paralelizable o no hay registros suficientes (CISC) para desenrollar, o o no interesa tamaño grande de código. Recordemos el mismo ejemplo: for (i=0 ; i<m ; i++ ) y[i]= x[i]*s; bucle_orig: ; instr útiles LD F2, 0(R1) MULTD F4, F2, F24 ; F24 contiene el valor de s SD (R3)0, F4 ; instr overhead a continuación (increm. punteros, saltos, comp.) ADDI R1, R1, 8 ADDI R3, R3, 8 SLTI R7, R1, fin_array_x; constante apunta al final de x[m] BNEZ R7, bucle_orig TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 16

Software pipelining: Esquema Esquema en la siguiente tabla: instr. útiles iter 0 LD 0 MULTD 0 SD0 iter 1 LD 1 MULTD 1 SD 1 iter 2 LD 2 MULTD 2 SD 2 iter 3 LD 3 MULTD 3 SD 3 iter 4 LD 4 MULTD 4 SD 4 prólogo iteraciones reordenadas epílogo De la ejecución normal (flechas rojas) cambio a Sw pipelining (flechas verdes). TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 17

Software pipelining: Ejemplo Prólogo: LD 0 MULTD 0 LD 1 Bucle_sw_pp: SD 0 (K) MULTD 1 (K+1) LD 2 (K+2) instr overhead (contendrán el salto a etiqueta Bucle_sw_pp) Epílogo: SD M-2 MULTD M-1 SD M-1 // se alejan las dependencias reales (van de una iter. a la siguiente) NOTAS: o las instr overhead deberán modificar las constantes (offset) convenientemente (no es fácil). o Habrá otras instr overhead en el prólogo y epílogo. o Se presupone que al menos se van a ejecutar dos iteraciones. TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 18

Software pipelining más desenrollado Desenrollando 2 iteraciones (no se dibujan las instr overead por simplificar el esquema) PRÓLOGO BUCLE EPÍLOGO LD 0 MULTD 0 LD 1 MULTD 1 LD 2 LD 3 SD 0 (K) SD 1 (K+1)... MULTD 2 (K+2) MULTD 3 (K+3)... SDM-4 SD M-3 LD 4 (K+4) LD 5 (K+5)... MULTDM-2 SD M-2 MULTD M-1 SD M-1 Sw pipelining: ejecución por columnas (flecha verde). Práctica 1: CCS (compilador familia TMS320) puede usar esta técnica TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 19

2.4. Ejecución predicativa, LEMA: Más planificación estática si aumenta nº medio instrucciones entre 2 saltos. Solución: Transformar dependencias de control en dependencias de datos. Útil sobre todo para saltos difíciles de predecir (if else) Idea: Instrucciones Condicionadas o Predicadas : sólo se ejecutan si se cumple una condición. Gran variedad en máquinas reales. Todas similares a: CMOVZ Rd,Rf,Rcond; equivale a if (Rcond==0) Rd=Rf; CMOVNZ Rd,Rf,Rcond; equivale a if (Rcond!=0) Rd=Rf; Ejemplo: Rb = abs(ra): Rb=Ra; if (Ra<0) Rb=-Rb; Addi Rb,Ra,0 Comparar si fuera así: Slti Rcond,Rb,0 //Rcond=1 si Rb<0 if (Ra<0) Rb=-Ra; Beqz Rcond,sigue else Rb=Ra; Sub Rb,R0,Rb // sólo se ejecuta si NT sigue: Salto: difícil acertar en su predicción. Si uso CMOVZ Addi Rb,Ra,0 Sgei Rcond,Rb,0 //Rcond=0 si Rb<0 Sub Rd,R0,Rb // inst que siempre se ejecuta CMOVZ Rb,Rd,Rcond TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 20

Instrucciones Condicionadas o Predicadas (II) Otro ejemplo: k = min(c,m,y); mínimo de 3 valores (usado en conversión RGB CMYK k=c; if (k>m) k = m; if (k>y) k = y; ADDI Rk, Rc, 0 SGT R1cond, Rk, Rm CMOVNZ Rk, Rm, R1cond SGT R2cond, Rk, Ry CMOVNZ Rk, Ry, R2cond Instr predicadas completas (full predication) Arquitectura ARM (casi toda instrucción) Intel VLIW Itanium IA-64 (casi toda instrucción) Muchos otros VLIW, como DSP TMS320C6713 (práctica) Ejemplo: Rb = abs(ra): Rb=Ra; if (Ra<0) Rb=-Rb; Addi Rb,Ra,0 Slti Rcond,Rb,0 //Rcond=1 si Rb<0 [Rcond] Sub Rb,R0,Rb // se ejecuta Sub pero sólo modifica // el registro destino Rb si Rcond!=0 TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 21

Instrucciones Predicadas (III): caso general if else con n variables de salida: if (cond==0) { x1 =... x2 =...... xn=... } else { y1 =... y2 =...... yn=... } Seqi Rcond, cond, 0 [Rcond] Oper Rx1,... [Rcond] Oper Rx2,...... [Rcond] Oper Rxn,... [!Rcond] Oper Ry1,... [!Rcond] Oper Ry2,...... [!Rcond] Oper Ryn,... Donde Oper es la última operación que se asigna a la variable de salida Se ejecutarían aprox. doble número de instr. En teoría pueden desaparecer todos los if else, pero: o Compiladores usuales: sólo predican 3 o 4 instrucciones o Compiladores para VLIW: predican más (CCS de TMS320 hasta 7 instr.) Más ejemplos Procesado Condicional: tema 4 PARALELISMO DATOS (DLP) TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 22

2.4. Planificación de trazas y (I) Concepto de Planificación de trazas: Planificar (reordenar) instrucciones a través de la traza de ejecución más probable, cruzando saltos Se usa mucho para proc. VLIW //CÓDIGO EJEMPLO Instr previas; If (cond) { x=x+s+t; otras instr del if; } else { y=y+s+u; otras instr del else; } ejercicio: dibujar diagrama flujo Posible traducción (no completa): Instr previas; //varios LW If (cond) { ADD Rst, Rs, Rt ADD Rx, Rx, Rst SW 0(RBx), Rx otras instr del if; } else { ADD Rsu, Rs, Ru ADD Ry, Ry, Rsu SW 0(RBy), Ry otras instr del else; } TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 23

Planificación de trazas y (II) Cambio inocuo que permite tener más instr antes del if Instr previas; ADD Rst, Rs, Rt ADD Rsu, Rs, Ru If (cond) { ADD Rx, Rx, Rst SW 0(RBx), Rx otras instr del if; } else { ADD Ry, Ry, Rsu SW 0(RBy), Ry otras instr del else; } O también se podría (barajar estas posibilidades según convenga): Instr previas; ADD Rst, Rs, Rt ADD Rsu, Rs, Ru ADD Rx, Rx, Rst ADD Ry, Ry, Rsu If (cond) { SW 0(RBx), Rx otras instr del if; } else { SW 0(RBy), Ry otras instr del else; } TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 24

Planificación de trazas y Especulación software (III) Concepto de especulación de instr. Cambio especulativo. Si apuesto (en tiempo compilación) que caso T (cond. cierta) es más probable: Instr previas; // LW Rx, 0(RBx) ADD Rst, Rs, Rt ADD Rxnuevo, Rx, Rst SW 0(RBx), Rxnuevo if (cond) { Pensar otro ejemplo de planif. trazas otras instr del if;/*incluso estas instr se podrían sacar del cuerpo del if*/ } else { SW 0(RBx), Rx /*deshace lo especulado */ ADD Rsu, Rs, Ru ADD Ry, Ry, Rsu SW 0(RBy), Ry otras instr del else; } Existe gama catalogada de técnicas de planificación de trazas, en función de si hay saltos hacia fuera de un bloque básico o hacia adentro. Esta técnica, combinada con la predicación, permite múltiples reordenaciones Atención: Qué ocurre si llega una interrupción tras SW 0(RBx), Rxnuevo? TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 25

Procesadores LIW o VLIW Reducir N inst. Very Long Instruction Word IDEA: Trasladar la complejidad de la emisión (y planificación) al compilador o Compilador agrupa varias operaciones (instrucciones RISC), en macroinstrucciones VLIW: hasta p operaciones en paralelo (p slots ) o Necesita técnicas avanzadas de planificación (scheduling) estática o No tienen algoritmo de planificación dinámica (in-order-execution). Instrucciones EX IF ID EX ME WB EX EX IF ID EX ME WB EX OPC= operaciones/ciclo (pues CPI no indica nada) Tiempo IPC ideal = 1 OPC ideal = p OPC <= p (slots vacíos) % slots vacíos si OPC=2<p=3 IF: normalmente 64, 128, 256 bits ID: típicamente p= 3 a 8 operaciones EX y MEM: al menos tantas UF como p. WB: numerosos puertos del fichero de registros (normalmente más de 10, con ID) TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 26

Implementación de VLIW EMISIÓN TOTALMENTE ESTÁTICA: o No detecta riesgos (en tiempo de ejecución) o Nunca bloquea la máq. CPI = 1+CPI MEM siempre o Compatibilidad en entredicho: compilador debe conocer la arquitectura (la duración de las operaciones). ALGO DE EMISIÓN DINÁMICA (la estática ayuda): > Ciertos bits especifican posibles dependencias y paralelismo de instr. > Puede haber bloqueos calcular el OPC no es tan fácil Los 1º VLIW tenían instr muy rígidas: obligaban a recompilar el código. Los actuales tienen instr más flexibles y complejas: compatibilidad: no necesitan recompilar (aunque sería mejor). Ventajas VLIW: Ahorro hardware permite complicar otros recursos: o 128 registros GPR de 64 bits, 128 reg FP, etc. en Itanium. o Menor consumo atractivo en sistemas empotrados (embedded media processors). Mucha Variedad: Sólo INT, orientado a FP, etc. Empotrar un VLIW full-custom en un SoC (system-on-a-chip, explicado en Máster MICR) Desventajas VLIW: mayor tamaño del código. Caché de instr. desperdiciado Proponer 3 y 5 slots para balancear bien el SAXPY o Tecn estáticas carecen de información de ejecución (ej. BTB, RAW memoria, ) TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 27

Ejemplo: código RISC VLIW CON EMISIÓN TOTALMENTE ESTÁTICA Código RISC escalar :bucle lf f1, 0(r11) lf f2, 0(r12) multf f3, f1, f2;; addi r11, r11, 4 addi r12, r12, 4 subi r8, r11, vec2 /*apunta al final del vector 1 */ rbnez r8, bucle /* instr de hueco */ addf f31, f31, f3 Qué hace este código? Para dos vectores apuntados por r11, r12 código (sin desenrollar) VLIW-RISC :bucle addi r11, r11, 4 lf f1, 0(r11) lf f2, 0(r12) nop nop;; addi r12, r12, 4 nop nop nop nop;; nop nop nop nop nop;; subi r8, r11, vec2 nop nop nop multf f3, f1, f2;; nop nop nop nop nop;; nop nop nop nop nop;; nop nop nop nop nop;; bnez r8, bucle nop nop nop nop;; /* instr de hueco */ Nop nop nop addf f31, f31, f3 nop;; Hallar OPC, y Tam efectivo caché si OPC<p TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 28

Ejemplo 2: TMS320C6713 DSP (Digital Signal Processor) De Texas Instrument Juego instr. RISC Macroinstrucciones 256 bits: IPC ideal hasta 8 instr. (operaciones) por ciclo Arquitectura muy ortogonal o Casi todos los reg. Valen para todo o No hay restricciones en las instr. Exactamente 8 U.F. (una por instrucción/operación ): o 2 grupos ( Data Paths ) de 4 UF cada una - 16 reg. (32 bits) por cada grupo: A0-A15 y B0-B15 o UF agrupadas por slots. A grosso modo (más detalles en práctica 1) Slots para operaciones INT Slots para operaciones FP 2 Ld/St 2 Ld/St 2 MULT 2 MULT FP 4 INT 4 varias (2 de ADDFP, otras: CMP, conversión ) Caché L1 separada instr y datos o 2 puertos cache datos (32 bits ancho) TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 29

ESQUEMA TMS320C67x TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 30

Empaquetamiento de 8 instrucciones Se pueden ejecutar varias en paralelo o de una en una (en serie) Empaquetamiento reduce tamaño de código F.P. Fetch packet : o son 256 bits (8 instr.) E.P. Execution packet : o grupo de instr. que se pueden ejecutar en paralelo (de 1 a 8) El bit p indica si se paraleliza con la sig. TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 31

CADENA (PIPELINE) PG: Program address generate PS: Program address send PW: Program access ready wait PR: Program fetch packet receivee DP: Instruction dispatch (parallell detection) DC: Instruction decode E1 a E10: operands read, execution and WB (duración variable según instr.) TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 32

EJEMPLO DE EMPAQUETAMIENTO Y EJEC.DE INSTR. Ejemplo: o Fetch Packet número n con 3 E.P. o Resto de F Fetch Packets con un solo E.P. (8 instrucciones en paralelo totalmente) instruction A ;EP k FP n instruction B ; instruction C ;EP k+1 FP n instruction D instruction E instruction F ;EP k+2 FP n instruction G instruction H Cuántos ciclos durará el FetchPacket n?... OTRAS FPs con EP de k + 3 a k + 8 (8 instr. En paralelo) indica que se ejecuta en paralelo con la anterior. Ver cronograma (trivial) en pag. Sig. TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 33

CRONOGRAMA PARA EL EJ. Bloqueo (stall) debido a ejecución en serie de E.P. k, k+1,k+2 El cronograma supone duración máxima de las UF Tipo de instr. Duración Otras duraciones INT E1 Saltos : hueco de 5 ciclos MULT (INTEGER), CMP FP E2 Fallo Cache : STORE E3 bloqueo total de 2 ciclos LOAD E5 ADDFP E7 MULFP E10 TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 34

PRESTACIONES MEDIAS familia C6000 200 MHz por 8 instr = 1600 MIPS pico (peak) Típicamente IPCreal_medio 0.6 * IPCideal Consumo medio 1300mW MIPS/mW (pico) = 1600 /1300 = 1.23 MIPS/mW MIPS/mW (real_medio) = 0.6 * 1600 /1300 = 0.74 MIPS/mW EJEMPLO Fusión bucles Importancia del balanceo de instrucciones del código frente a slots (UF) del procesador: La resolución de ecuaciones lineales por eliminación gaussiana, implica el cálculo de muchos bucles SAXPY, donde uno de los vectores es siempre el mismo (x[]). Se pide comparar para un TMS320 el empaquetamiento de 4 bucles SAXPY frente a un SAXPY de 4 sentencias donde x[] siempre es el mismo. Suponer que todo riesgo lo evita el compilador. UF agrupadas por slots. A grosso modo (más detalles en práctica 1) Slots para operaciones INT Slots para operaciones FP 2 Ld/St 2 Ld/St 2 MULT 2 MULT FP 4 INT 4 varias (2 ADDFP, otras: CMP, conversión ) for (i=0; i<n; i++) { y[i]= a * x[i] + y[i];} //SAXPY TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 35

Procesadores VLIW (actuales) - TMS C6000 DSP (Texas Instruments). Práctica - TriMedia media (NXP, antes Philips Semiconductors). p= 5 a 8 slots Tamaño de macroinstrucción variable (código comprimido) Muy parecido a VLIW con emisión totalmente estática - SHARC DSP (Analog Devices), Super Harvard Architecture Single-Chip Computer. Arq. Harvard Alta relación MFLOPS/W. Tiene un secuenciador de programa que controla el flujo de ejecución (previamente programado p ej con bucles). p= 8: 2 clusters de 4 operaciones (FP, 2 ALU, 1 Ld/St) - STMicroelectronics ST200 (Hewlett-Packard Laboratories y STMicroelectronics). p= 8: 2 clusters de 4 operaciones (FP, 2 ALU/MULT, 1 Ld/St) - Itanium (Intel, IA-64): Tres slots de 41 bits más 5 bits para especificar que UF requiere cada slot y las posibles dependencias. Tiene muchos tipos de instrucciones que resumimos aproximadamente en: Acc. Memoria /salto Cualquiera/ Inm32 Cualquiera excepto acc. mem./inm32 TEMA 2. ILP BASADO EN PLANIFICACIÓN ESTÁTICA SPD: Sistemas Paralelos y Distribuidos 3º GIC. pág 36