TEMA 2: ARQUITECTURAS MULTIMEDIA Y VECTORIALES.

Transcripción

1 TEMA 2: ARQUITECTURAS MULTIMEDIA Y VECTORIALES. ÍNDICE: Introducción Concepto Procesadores Vectoriales Modelo Núcleo Multimedia Instrucciones Ensamblador Ejemplo completo: bucle SAXPY Procesado Condicional Instruc. de Carga y Almacenamiento específicas Temporización con Instrucciones Multimedia

2 Introducción Multimedia publicitario. Más correcto: Arquitecturas para paralelismo de datos. DLP (Data Level Parallelism) en lugar de ILP. Origen: Años 70 Arquitecturas Vectoriales (supercomputadores, Ej: CRAY). Problemas científico-técnicos Vectores/Matrices igual operación sobre múltiples elementos Procesador Vectorial: Registros e Instrucciones Vectoriales Múltiples datos por registros (ej. 256 doubles) e instrucciones que operan sobre registros completos. Ej. DAXPY en ensamblador vectorial: LDV VX,(RX) LDV VY,(RY) MULTV VX,VA,VX ADDV VX,VX,VY STV (RY),VX // existen instr especiales que definen el núm elem de Reg

3 Concepto Procesadores Vectoriales DAXPY: No hay bucle (ni salto) Incremento de punteros es inherente a Ldv, Stv. Las unidades funcionales vectoriales proporcionan un dato/ciclo (tras cierta latencia). Una unidad func. empieza a operar en cuanto dispone del primer dato (encadenamiento) El secuenciamiento es estático. Se permiten varios accesos simultáneos a distintas posiciones de memoria. La memoria proporciona varios datos por ciclo. Se emplean memorias multimódulo (bancos) complejas y costosas. Ejemplo actual Earth Simulator (NEC, Japón). Al fabricarlo en 2002, 5 veces más rápido que el segundo del Durante Muchos años supercomputador más potente. Específico para programas científicos (simulación meteorológica) Ejemplo benchmark más usual: LINPACK, Álgebra Lineal (solución sistema de ecc lineales: determinantes)

4 Latencias: Ld/St: 2 ciclos MULTFP: 3 ciclos ADDFP: 3 ciclos Cronograma DAXPY en Proc vectorial T1 T2 T3 T4 T5 T6 T7 T8 LDV IF ID EX ME1 1 ME1 2 ME1 3 ME1 4 ME1 5 ME2 1 ME2 2 ME2 3 ME2 4 ME2 5 LDV IF ID EX ME1 1 ME1 2 ME1 3 ME1 4 ME1 5 ME2 1 ME2 2 ME2 3 ME2 4 ME2 5 MULV IF ID - MU1 1 MU1 2 MU1 3 MU1 4 MU1 5 MU2 1 MU2 2 MU2 3 MU2 4 MU3 1 MU3 2 MU3 3 ADDV IF - ID - - AD1 1 AD1 2 AD1 3 AD1 4 AD1 5 AD2 1 AD2 2 AD2 3 AD2 4 SV - IF - - ID - ME1 1 ME1 2 ME1 3 ME2 1 ME2 2 (el resto de bypasses se producen en los ciclos sucesivos a los primeros)

5 Modelo Núcleo Multimedia Similar a vectorial pero: Registros con menor número de elementos (de 2 a 16) Diferentes tipos de datos (int, float, double ) Operaciones realizadas sobre todo un registro a la vez La temporización se obtiene de forma análoga a los escalares (número de iteraciones menor). Modelo que proponemos: DLXMM. Basado en SSE/SSE2 de Intel. Similar a otras arquitecturas multimedia. Modelo de registros (de 128 bits) MM0 Float3 Float2 Float1 Float0 MM MM MM7 Double1 Double0 Los registros pueden emplearse para contener 4 flotantes de simple precisión float (4x32), o 2 de doble precisión double (2x64).

6 Instrucciones Ensamblador Veremos instrucciones con operandos en coma flotante (Para enteros serían análogas) Existen operaciones que operan sobre el registro completo y otras sólo sobre su parte menos significativa. Emplearemos una notación similar a la de Intel para SSE/SSE2 pero con 3 operandos (como en DLX). Para instrucciones que operan sobre todos los elementos de un registro multimedia: OPER p{s d} MMd,MMs1,MMs2 La p (packet) indica que la instrucción opera sobre múltiples datos empaquetados en un solo registro multimedia. Las instrucciones que operan sobre 4 flotantes de simple precisión incluyen el identificador de datos s, las que operan sobre datos de doble precisión incluyen el identificador de datos d. Las instrucciones que operan sobre un único dato en la parte menos significativa del registro, sustituyen la p (packed) por s (scalar): OPER s{s d} MMd,MMs1,MMs2 NOTA: En Intel sólo hay 2 operandos (el segundo puede estar en memoria)

7 Tipos de Instrucciones: Aritméticas Similares a las existentes en modo escalar. Usaremos notación vectorial C para registros Multimedia. Si MM6={1.0,2.0,3.0,4.0}, 1.0 estaría en componente 0 (la más baja). Multiplicación: mult{p s}{s d} MMd,MMs1,MMs2. o Ej: Multps MM0,MM1,MM2 Si MM2={1.0,2.0,3.0,4.0} y MM1={0.5,-1.0,-1.0,0.25} tendríamos: MM0={0.5,-2.0,-3.0,1.0} División: div{p s}{s d} MMd,MMs1,MMs2. o ej: divpd MM0,MM1,MM2 Si MM2={1.0, 4.0}, MM1={0.5,8.0} MM0={1.0,5.0} MM0={0.5,2.0} Suma: add{p s}{s d} MMd,MMs1,MMs2. o ej: addss MM0,MM1,MM2 Si MM2={1.0,2.0,3.0,4.0}, MM1={0.5,-1.0,-1.0,0.25} MM0={1.0,2.0,3.0,4.0} tendríamos: MM0={1.5,2.0,3.0,4.0} Resta: sub{p s}{s d} MMd,MMs1,MMs2. o ej: subsd MM0,MM1,MM2 Si MM2={1.0, 4.0}, MM1={0.5,8.0} MM0={1.0,2.0} MM0={-0.5,2.0}

8 Tipos de Instrucciones: Lógicas Son operaciones entre registros bit a bit. Supondremos que sólo existen en versión de registro completo (p, 128 bits). Aunque puede indicarse el tipo de dato {s d} en realidad corresponden a la misma instrucción (opcode) para los 3 tipos de datos. And: andp{s d} MMd,MMs1,MMs2. ej: Andps MM0,MM1,MM2 Si MM2={0x7FFFFFFF, 0x7FFFFFFF,x7FFFFFFF, 0x7FFFFFFF } y MM1={0.5,- 1.0,-1.0,0.25} tendríamos valor absoluto: MM0={0.5,1.0,1.0,0.25} //Recordar que el bit más significativo es el signo en float (formato IEEE754) Or: orp{s d} MMd,MMs1,MMs2. ej: orps MM0,MM1,MM2 Si MM2={0x , 0x , 0x , 0x } y MM1={0.5,-1.0,-1.0,0.25} tendríamos: MM0={-0.5,-1.0,-1.0,-0.25}. // Este ejemplo calcula el valor absoluto cambiado de signo. Xor: xorp{s d} MMd,MMs1,MMs2. ej: xorps MM0,MM1,MM2 Si MM2={0x , 0x , 0x , 0x } y MM1={0.5,-1.0,-1.0,0.25} tendríamos: MM0={-0.5,1.0,1.0,-0.25}. //Este ejemplo cambia el signo.

9 Tipos de Instrucciones: Comparaciones Estas operaciones son muy similares a las instrucciones de comparación del dlx (scc Rd,Rs1,Rs2). Emplearemos la terminología SSE denominándolas: cmp{gt ge eq le lt ne}{p s}{s d}. Estas instrucciones realizan la comparación componente a componente de los registros fuente. Si la condición de comparación no se cumple la componente correspondiente del registro destino se pone a valor 0. Si la condición se cumple todos los bits de la componente correspondiente del registro destino se ponen a 1. Ejemplo: cmpgeps MM0,MM1,MM2. o Si MM2={1.0,2.0,3.0,4.0 } y MM1={0.5,10.0,-1.0,25.0} tendríamos: MM0={0,0xFFFFFFFF,0, 0xFFFFFFFF } Para qué sirve todo a 1? Las instrucciones de comparación serán la base del procesado condicional en los procesadores con extensiones multimedia. Este tema se estudiará en un apartado posterior.

10 Instrucciones de Acceso a memoria En el caso de las instrucciones de carga y almacenamiento, existen versiones vectoriales (p) y escalares (s). Las versiones vectoriales ldps{s d}, stps{s d} corresponden en realidad a una sola instrucción que transfiere 16 bytes (128 bits) desde memoria a registro o viceversa. Los modos de direccionamiento suelen ser análogos a los de las instrucciones escalares. Las versiones escalares de las instrucciones de carga y almacenamiento transfieren: o 4 bytes en el caso de operandos s (simple precisión) o 8 bytes en el caso de operandos d (doble precisión).

11 Movimiento de Datos: Barajado (shuffle) Existen instrucciones de barajado que permiten almacenar en cada componente de un registro destino, cualquiera de las de un registro fuente. El formato es: shufp{s d} MMd,MMs, selector. Para simple precisión, el selector es una constante de 8 bits agrupados en 4 parejas. o Las dos parejas menos significativas indican qué componente del registro destino se eligen para las componentes 0,1 del propio registro destino. o Las dos parejas más significativas indican qué componente del registro fuente se eligen para las componentes 2,3 del registro destino o Ej. Shufps MM1,MM2, El selector debe leerse como (2 ó, en decimal, En el ejemplo, MM1 cargará su componente 0 con la componente 3 (11 (2 ) de MM1, su 1 con la 2 de MM1, su 2 con la 1 de MM2 y su 3 con la 0 de MM2. Así si MM2={0.5,10.0,-1.0,25.0}, MM1={8.0,-7.0,6.0,-5.0}, MM1={-5.0,6.0,10.0,0.5}. Un uso común de shufps es replicar la componente menos significativa en todas las componentes de un registro. Útil para multiplicar un vector por un escalar (no existen instrucciones de multiplicación de escalar por vector en la mayoría de CPU s MM. Para replicar la comp. 0 de MM0 en todas sus componentes usamos la instrucción: shufps MM0,MM0,0. También sirve para rotar o dar la vuelta al orden de los elementos La versión de doble precisión shufpd emplea un selector de dos campos (cada uno de un bit) para seleccionar las dos componentes existentes en este caso.

12 Ejemplo completo: bucle SAXPY R4 apunta al vector x, R1 apunta al vector y, R2 apunta el final del vector x, R3 apunta a la constante a. Ldss MM2,(R3) //Carga a en la componente baja de MM2 Shufps MM2,MM2,0 //Replica a en todas las componentes de MM2 Saxpy: ldps MM0,(R4) //Carga 4 componentes de x en MM0 Ldps MM1,(R1) //Carga 4 componentes de y en MM1 Multps MM0,MM0,MM2 //multiplica las componentes de x por a Addps MM0,MM0,MM1 //y+a*x Stps (R1),MM0 //almacena y Addi R1,R1,16 Addi R4,R4,16 //Actualiza punteros Seq R5,R4,R2 //Fin de x? Beqz R5,Saxpy //si no hemos acabado, seguimos

13 Procesado Condicional Cuando empleamos instrucciones multimedia no es posible implementar las estructuras if mediante saltos, dado que diferentes componentes del registro pueden satisfacer o no las condiciones. Esto implica que las estructuras if deben implementarse transformando las dependencias de control en dependencias de datos utilizando, para ello, las instrucciones lógicas y las instrucciones de comparación. Hasta qué tamaño del cuerpo del if es rentable este procesado condicional?: No muchas instrucciones (se ejecutarían demasiadas operaciones inútiles) Qué ocurre si hay N ramas (N>2) (varios if/else)? En teoría se pueden generar las 2 N combinaciones, pero no suele traer cuenta (actualmente) por lo anterior. El método para realizar esta transformación lo explicaremos mediante un ejemplo: Supongamos el código: int i; float x[10000],y[10000]; for(i=0;i<10000;i++) if (x[i]>0) x[i]=x[i]+y[i]; else x[i]=x[i]-y[i];

14 Procesado Condicional: Ejemplo (I) En este caso hay que (ver figura): 1. Crear una máscara correspondiente al resultado de la comparación x[i]>0 (cond. Cierta) y otra correspondiente a la condición opuesta (cond. Falsa). 2. Calcular los x[i] correspondientes a que se cumpla la condición if y hacer and con la máscara correspondiente. 3. Calcular los x[i] correspondientes a la condición else y hacer and con la máscara correspondiente. 4. Hacer or con los valores obtenidos de las dos operaciones and (cada uno de ellos contiene ceros donde el otro contiene valores). 5. Este es el valor que se almacena.

15 Procesado Condicional: Ejemplo (II) Código suponiendo que: R4 vector x, R1 vector y R2 al final del vector x (sig byte) xorps MM0,MM0,MM0 //Pone MM0 a 0 Bucle: ldps MM1,(R4) //Carga 4 comp. de x. Ldps MM4,(R1) //Carga 4 comp. de y. Cmpgtps MM2,MM1,MM0 //MM2 es la máscara cond. cierta. Cmpleps MM3,MM1,MM0 //MM3 es la máscara cond. falsa Addps MM5,MM1,MM4 //MM5 contiene x+y Subps MM6,MM1,MM4 //MM6 contiene x-y Andps MM5,MM2,MM5 //and cond. Cierta. Andps MM6,MM3,MM6 //and cond. Falsa Orps MM5,MM5,MM6 //Resultado a almacenar. Stps (R4),MM5 Addi R4,R4,16 Addi R1,R1,16 Seq R3,R4,R2 Beqz R3,Bucle Ejercicio: desenrollar código anterior (si tenemos registros suficientes)

16 Instruc. de Carga y Almacenamiento específicas Además de las instrucciones ld{p s}{s d} y st{p s}{s d} (se comportan básicamente como instrucciones ld/st estándar), la mayoría de procesadores con extensiones multimedia implementan algunas instrucciones de carga y almacenamiento específicas para intentar aprovechar algunas peculiaridades de las aplicaciones multimedia. En lo que respecta al almacenamiento muchas aplicaciones multimedia calculan datos que no vuelven a reutilizarse hasta al cabo de un número grande de ciclos de reloj. Así, por ejemplo, en el código C: double x[1000],y[1000],z[1000]; int i; for(i=0;i<1000;i++) z[i]=x[i]+y[i]; Si tenemos un caché de datos de primer nivel de 8KB y los vectores x e y (o al menos la mayoría de sus componentes) ya estaban previamente en el caché, debido a un bucle anterior, si utilizamos instrucciones stpd para almacenar las componentes de z, estas expulsarán a componentes de x e y del caché empeorando notablemente el tiempo de ejecución de la aplicación.

17 Uso de instruc. de Almacenamiento no temporal En general, cuando una aplicación multimedia escribe un dato que no va a ser utilizado en el futuro próximo, no conviene escribirlo en los cachés Excepción: si el dato que vamos a escribir ya está en el caché, pues, en este caso, evidentemente hemos de actualizarlo allí. La solución empleada habitualmente en los procesadores con extensiones multimedia es la utilización de instrucciones de almacenamiento no temporal que emplean una política de escritura en caché no write allocate que, a diferencia de la política habitual write allocate, en el caso de un fallo de caché en escritura escribe la componente directamente en memoria. Instr almacenamiento no temporal: ntst{p s}{s d} (prefijo nt) Nota: si almacenamos usando instrucciones de almacenamiento no temporal, componentes que ya están en el caché, el comportamiento será idéntico a las instrucciones de almacenamiento convencionales. double x[1000],y[1000]; int i; for(i=0;i<1000;i++) x[i]=x[i]+y[i]; Al escribir x[i], estará ya en caché, pues ha sido cargada previamente por alguna ldpd. Por tanto, al acertar en caché, la ntstpd tendrá el comportamiento habitual de un stpd.

18 Uso de instruc. de precarga (software) En las aplicaciones multimedia es habitual que los próximos datos que necesite el programa, no sean los últimos accedidos, pero que sea fácil de predecir cuáles serán. En general, el programador es quien mejor conoce qué datos se necesitarán en el futuro. Por ello, en muchos casos, conviene precargar datos en el caché y, así, asegurar que las cargas posteriores acertarán en el mismo. Una técnica tradicional en RISC consiste en usar instrucciones ld R0,(Ra) (R0 no puede escribirse; vale siempre 0) para hacer cargas con tal fin. El inconveniente de usar instrucciones Load es que pueden generar excepciones (fallos de página, accesos a zonas protegidas) no deseadas. Para evitar el problema de las excepciones, los procesadores con extensiones multimedia suelen implementar instrucciones específicas de precarga (prefetch). Son equivalentes a ld R0,(Rx) pero no provocan excepciones. Si el acceso provocara excepciones no se realizaría. Hay instr. prefetch para L1 y L2, o sólo para L2 Más tarde cuando el procesador ejecute la instrucción de carga: o Se acertará en caché, o O se accederá a memoria y se atenderán las excepciones si se producen.

19 Temporización con Instrucciones Multimedia. En los procesadores vectoriales existen instrucciones de carga/almacenamiento cuya zancada (distancia entre los elementos que se van a cargar en un mismo registro vectorial) puede definirse. En los multimedia aún no existen. Esto supone un inconveniente si usamos vector de estructuras (AOS) en lugar de estructura de vectores (SOA). A diferencia del caso de los procesadores vectoriales, las instrucciones multimedia se comportan como instrucciones habituales de un procesador convencional no existiendo ninguna diferencia importante en el cálculo del tiempo de ejecución de un programa. Las únicas diferencias estarían en el cálculo del rendimiento en MFLOPs. Tener en cuenta que las operaciones mutlps, addps, etc realizan 4 operaciones en coma flotante mientras mulpd, addps, etc. realizan 2. Las comparaciones y operaciones lógicas no se tienen en cuenta en el cálculo del rendimiento en MFLOPs. Cuando se usa procesado condicional, se ejecutan las dos ramas del if. Realmente, una de las ramas se ejecuta inútilmente. De esa forma, se suele medir el rendimiento calculando MFLOPs útiles (en lugar de MFLOPs totales)