tema 2 ilp basado en planificaciÓn estÁtica de ......tema 2.ilp basado en planificaciÓn estÁtica...

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

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


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++) { }

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

ejercicio: hallar cuerpo del bucle


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

MULTF F1, F2, F3

DIVF F20, F1, F4

ADDF F10, F20, F3

SF 0(R1), F10

MULTF F1, F2, F3

DIVF F2, F1, F4

ADDF F1, F2, F3

SF 0(R1), F1

Renombrado.

Ejemplo

ejercicio: señalar tipos de dependencias en código

anterior

ejercicio: ¿qué significa dinámicamente?


• 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 DIVF F20, F1, F4 ADDF F10, F20, F3SF 0(R1), F10 Tiempo

MULTDIV

ADD

MEM

Bypass y Registros temporales

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) {

b[i]=-a[i]; } else {

b[i]=a[i]; }

}

ejercicio: renombrar registros para eliminar dep. ficticias en

bucle anterior. ATENCION: R1

IF ID IF ID IF ID

WB WB


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/


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 ;

}


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


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


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


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


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


• 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

Bucle original Bucle desenrollado (3 iter.)

Desenrollado“infinitas” iteraciones (K→∞)

Instr./elem vector

(3 instr útiles + 4 instr overhead) / elem = 7 instr /elem.

(3*3 instr útiles + 4 instr overhead) / 3 elem vector = = (3 instr útiles + 4/3 instr overhead) /elem= 4.33 instr/elem

(3*K instr útiles + 4 instr overhead) / K elem vector = (K→∞) = 3 instr útiles/elem

Fsaltos 1/7 = 14.3% 1/13 = 7.7% 0%

Tam código estático (bytes)

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


• 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).


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: ai+k=f(ai) ) 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 ai+k=f(ai) , 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; }


• 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],


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


Software pipelining: Esquema Esquema en la siguiente tabla: instr. útiles

iter 0 LD0 MULTD0 SD0

iter 1

LD1 MULTD1 SD1




← prólogo →← iteraciones reordenadas→ … ← epílogo → De la ejecución normal (flechas rojas) cambio a Sw pipelining (flechas verdes).


Software pipelining: Ejemplo Prólogo: LD0 MULTD0 LD1

Bucle_sw_pp: SD0 (K) MULTD1 (K+1) LD2 (K+2)

instr overhead (contendrán el salto a etiqueta Bucle_sw_pp)

Epílogo: SDM-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.


Software pipelining más desenrollado Desenrollando 2 iteraciones (no se dibujan las instr overead por simplificar el esquema) PRÓLOGO BUCLE EPÍLOGO

LD0

LD1 MULTD0

MULTD1SD0 (K)

SD1 (K+1) ...

LD2

LD3 MULTD2 (K+2)

MULTD3 (K+3) ... SDM-4

SDM-3

LD4 (K+4)

LD5 (K+5) ... MULTDM-2

MULTDM-1SDM-2

SDM-1 Sw pipelining: ejecución por columnas (flecha verde).

Práctica 1: CCS (compilador familia TMS320) puede usar esta técnica


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 Slti Rcond,Rb,0 //Rcond=1 si Rb<0

Beqz Rcond,sigue 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

Comparar si fuera así: if (Ra<0) Rb=-Ra;

else Rb=Ra;


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


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)


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;

}

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; }

ejercicio: dibujar diagrama flujo


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;

}


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) { 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?

Pensar otro ejemplo de planif. trazas


Procesadores LIW o VLIW • Reducir Ninst . “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

IF

ID EX

ME

WB EX

EX

Tiempo

IF

ID EX

ME

WB

EX

EX

IPCideal = 1 OPCideal = p OPC <= p (slots vacíos)

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)

% slots vacíos si OPC=2<p=3

OPC= operaciones/ciclo (pues CPI no indica nada)


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+CPIMEM 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 o Tecn estáticas carecen de información de ejecución (ej. BTB, RAW memoria,…)

Proponer 3 y 5 slots para balancear bien el SAXPY


Ejemplo: código RISC VLIW CON EMISIÓN TOTALMENTE ESTÁTICA Código RISC escalar código (sin desenrollar) VLIW-RISC

: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

: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

¿Qué hace este código? Para dos vectores apuntados por r11, r12


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)


ESQUEMA TMS320C67x


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

•••••••

A 2. ILP BASAD

• PG: Pro• PS: Pro• PW: Pro• PR: Pro• DP: Ins• DC: Ins• E1 a E1

DO EN PLANIF

ogram adogram adogram acogram festruction struction 10: operan

FICACIÓN ESTÁ

CA

dress genddress senccess readtch packedispatchdecode nds read,

ÁTICA

DENA

nerate nd dy wait et receive

h (parallel

, executio

SPD

A (PIPE

e l detectio

on and W

D: Sistemas P

ELINE

on)

WB (durac

Paralelos y Di

E)

ción varia

istribuidos 3º

able segú

GIC. pág 3

ún instr.)

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 ... 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.

¿Cuántos ciclos durará el FetchPacket n ?


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


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


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 de ......tema 2.ilp basado en planificaciÓn estÁtica...

Documents