TEMA 4: PARALELISMO A NIVEL DE DATOS (DLP). · Tb existían operaciones entre Reg vectoriales y escalares Tb registros especiales de control del número de elem. (iteraciones) Ej

Dpto. Arquitectura y Tecnología de Computadores. Univ. Sevilla. www.atc.us.es SPD TEMA 4: PARALELISMO A NIVEL DE DATOS (DLP). Pág 1

TEMA 4: PARALELISMO A NIVEL DE DATOS (DLP). ÍNDICE:

4.1. Introducción: Aplicaciones científicas y multimedia. 4.2. Arquitecturas vectoriales segmentadas clásicas. 4.3. Extensiones multimedia y núcleos SIMD.

4.4. Técnicas de vectorización. • Bucles paralelizables • Procesado condicional • Precarga software • Temporización • Modelo del Tejado


4.1. Introducción: Aplicaciones científicas y multimedia

� Multimedia “publicitario”. � Más correcto: Arquitecturas SIMD (Single Instruction Multiple Data) o de

paralelismo de datos � DLP (Data Level Parallelism) en lugar de ILP. � Vectores/Matrices � igual operación sobre múltiples elementos � Código científico y multimedia (procesamiento imágenes, sonido, etc.)


4.2 Arquitecturas vectoriales segmentadas clásicas. � ORIGEN: Años 70 Arquitecturas Vectoriales (supercomputadores, Ej: CRAY).

• Sólo existían programas de Problemas científico-técnicos � Procesador Vectorial: Registros e Instrucciones Vectoriales

o Múltiples datos por registros (ej. 256 doubles: 2KB cada registro!!! ) o instrucciones que operan sobre registros completos.

� Ingeniosas cadenas (pipeline) para operar con elem. de registro vectorial � Tb existían operaciones entre Reg vectoriales y escalares � Tb registros especiales de control del número de elem. (iteraciones) Ej. DAXPY en ensamblador vectorial:

LDV VX,(RX)

LDV VY,(RY)

MULDV VX,VA,VX //previamente se replicó la cte ‘a’ en VA

ADDDV VX,VX,VY

SDV (RY),VX

� Parecía que en los 90s habían “muerto” pero…


Ejemplos Procesadores Vectoriales Actuales � Supercomputadores, lista www.top500.org

• Benchmark usado: LINPACK, Álgebra Lineal (solución sistema de ecc lineales)

• Se usan para programas científicos (simulación meteorológica, etc.) • Suelen ser Multicomputadores (tema 3) de miles de procesadores. PERO:

� Nov. 2002 Earth Simulator (NEC, Japón). • Al fabricarlo 5 veces más rápido que el segundo del www.top500.org . • Durante tres años supercomputador más potente. • 5120 CPUs vectoriales 500 MHz fabricados por NEC Corporation

� Nov. 2010. Primero en top500 “Tianhe-1A” 2.93Ghz • Mezcla de Procesadores (total: 186368 cores):

� 14336 Intel Xeon X5670 (CPU) � 7168 Nvidia Tesla M2050 (GPU con tratamiento DLP masivo junto a

ingenioso paralelismo de hilos). • Operaciones FP por Seg : 2507 petaflops (Rmáx), 4669 petaflops (Rpeak)

� Nov. 2011: el primero es otra vez un Multicomputador (tema 3): un total de 705,024 cores (SPARC64, 8 cores por procesador a 2.0 Ghz)

NOTA: Los propias ediciones de Hennessy & Patterson van poniendo en apéndices o en texto principal los proc. Vectoriales ¡!!!


4.3. Extensiones multimedia y núcleos SIMD. Ejemplos Núcleos Vectoriales SIMD Actuales

Intel: (128 bits) Streaming SIMD Extensions (SSE) (1999) � (128 bits) SSE2 (2001) � SSE3 (2004) � SSE4 (2006) � (256 bits) Advanced Vector Extensions (AVX) (2008)

SPARC: Visual Instruction Set (VIS) (64 bits) MIPS: MDMX � MIPS-3D (64 bits) POWER: AltiVec, VSX (128 bits) AMD: 3DNow! Pro (128 bits) fueron abandonadas en 2010

XOP and FMA4 (128 o 256 bits): compatibilidad con SSE4 Henn-Patt 5ª Ed afirma que se podrían doblar su tamaño cada 4 años

¿muy optimista visto los últimos años?


Modelo Núcleo Multimedia (SIMD): RISCMM Similar a vectorial pero: � Registros con menor número de elementos (de 2 a 16) � Diferentes tipos de datos (char, 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: RISCMM. Basado en SSE/SSE2/SSE3 de Intel.

Similar a otras arquitecturas multimedia.

� Modelo de registros (de 128 bits). En total 1 Kbit MM0 Float3 Float2 Float1 Float0 MM1 ... ... ... ... MM2

...

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


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 (Streaming SIMD

Extensions) pero con 3 operandos (como en RISC 32 BITS). � 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)

SUFIJOS ss sd ps pd


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}


Tipos de Instrucciones: Lógicas Bit a Bit � Son operaciones entre registros bit a bit. Supondremos que sólo existen en

versión de registro completo (sufijo 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={0x80000000, 0x80000000, 0x80000000, 0x80000000} 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={0x80000000, 0x80000000, 0x80000000, 0x80000000} 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.


Tipos de Instrucciones: Comparaciones � Estas operaciones son muy similares a las instrucciones de comparación del

RISC 32 bits (scc Rd,Rs1,Rs2). cc = código de condición � 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. o Si la condición de comparación es Falsa, todos los bits de la componente

correspondiente del registro destino se pone a valor 0. o Si la condición es Verdadera, todos los bits de la componente

correspondiente del registro destino se ponen a 1. o Ejemplo: cmpgeps MM0,MM1,MM2. 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 poner todo a 1 o todo a 0? Las instrucciones de comparación

(junto a las lógicas de bits) serán la base del “procesado condicional” en los procesadores con extensiones multimedia. Este tema se estudiará en un apartado posterior.


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 ld{p}{s|d} , st{p}{s|d} corresponden en

realidad a una misma 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.

� CUIDADO: Alineación en frontera de 16 bytes requerida. Dirección múltiplo de 16 (el último dígito hexadecimal es 0). En algunos núcleos multimedia existen Ld/St para accesos no alineados.

� Las versiones escalares de las instrucciones de carga y almacenamiento ld{s}{s|d} , st{s}{s|d} 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).


Movimiento de Datos: Barajado (shuffle) � 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.

� Uso común: replicar la componente menos significativa en todas las componentes de un registro (selector=0): shufps MM0,MM0,0. o Ú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 Multimedia). � Ejemplo: descripción barajado Intel SS3

� 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,00011011.

El selector debe leerse como 00|01|10|11(2 ó, en decimal, 0|1|2|3.

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

� Otros ejemplos: rotar o dar la vuelta al orden de los elementos

o La versión de doble precisión shufpd emplea un selector de dos campos (cada uno de un bit) para

seleccionar las dos componentes de forma análoga.


4.4. Técnicas de vectorización: 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

� Ejercicio: desenrollar código anterior


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 de bits y las instrucciones de comparación.

� ¿Hasta qué tamaño del cuerpo del if es rentable este procesado condicional?: o 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 N ramas, pero (actualmente) no suele traer cuenta por lo anterior.

� Ej: si en cada rama hay vectores de salida diferentes: trabajar con ambos EJER � 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];


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. Ambas ramas son independientes; se pueden ejecutar en paralelo: más ILP (deben existir suficientes UF: CPU actuales 2 o 3 de SSE)


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. En IEEE754 0.0 es caso

//especial con todos los bits 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 tuviéramos registros suficientes) � Ejercicio: Pensar en como se haría usando CMOVZps, CMOVNZps.


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 sean fáciles de predecir. � 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.EJERC: bucle simple

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

� En Intel 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.

� No abusar de prefetch: podrían consumir AB inútilmente


Temporización con Instrucciones Multimedia. � Generalmente Planificación dinámica para GPP, pero estática para DSP � 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 multps, addps, etc realizan 4 operaciones en coma flotante mientras multpd, addpd, 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)


Rendimiento de pico: Modelo del Tejado � “Roofline model”. Propuesto en 2009 (Ver Henn-Patt 5ª Ed.) � Calcula Rendimiento de pico para:

o FP: float (SP) o double(DP) o Bucle paralelizable o Zancada unidad (datos contiguos en memoria) o Se usan núcleos SIMD de forma ideal. o Grado superescal. m suficientemente grande para que no suponga cota

� ¿Cuáles son los Límites del rendimiento (máximo)? EJEMPLO SAXPY LFx LFy MULTF ADDF SFy 4 instr. overhead

Ldps x Ldps y MULTps ADDps Stps y 4 instr. overhead

limitaciones actuales de hw (1 core): - m=4. - 2 UF FP ó 2 UF MMX - ABMEM = 16 GB/s. fCPU = 3 GHz

� Suele ser el ABMEM

� Nº UF de Oper. Aritméticas � Nº UF * fCPU (supone 1 dato por ciclo)

� Acceso a jerarquía memoria: ABMEM * DA , es decir: G Byte/s * FLOP/Byte o DA es la densidad aritmética (arithmetic intensity): Nº oper. FP dividido por

bytes accedidos (Sólo depende del algoritmo, independiente de hw).


Ejemplo Rendimiento de pico: Modelo del Tejado Intel Core i7 Nehalem (2.666 GHz, 2 cores, 2 UF AVX 256 bits: VMULT,VADD) � Nº UF * fCPU: 2.666 GHz * 2 cores * 2 UF AVX * 256/64 = 42.6 GFLOPs � DAXPY Double precision:

o LDx LDy MULTD ADDD SD � o DA = 2 FLOP / 24 bytes = 1/12

� ABMEM * DA : 16.4 GB/s*1/12 = 1.36 GFLOPs

ABRAM limita (y en la realidad puede no llegar a ABRAM máxima) � No es fácil imaginar un algor. que

tenga DA > 42.66/16.4 = 2.6 para que ABRAM no sea el factor limitante. o 8 bytes � más de 20 FLOP

� Si datos en L1: ABL1 puede no ser el factor limitante: 2 puertos * 128 bits * 2.666 GHz = 85.33 GB/s o DA > 42.66/85.33 GB/s = ½

ABL1=85.3 GB/s

DA


Otros DLP: GPU • GPU (Graphics Processing Units): sólo para DLP masivo • Científicos usaron tarjetas gráficas para computar: los fabricantes

generalizaron la cadena gráfica para computar (casi) cualquier código • El Thread Scheduler (planificador de hilos) lleva el control del paralelismo.

o Se estudian en Asignatura CAP del MICR (Máster Ing. Computadores y Redes)

Documents

TEMA 4: PARALELISMO A NIVEL DE DATOS (DLP). · Tb existían operaciones entre Reg vectoriales y escalares Tb registros especiales de control del número de elem. (iteraciones) Ej