SIMD (Organización del Computador II)

La tecnología MMX de Intel es un set de instrucciones SIMD (Single Instruction Multiple Data) que permite paralelizar ciertas operaciones sobre conjuntos de datos, otros ejemplos de SIMD son el conjunto de instrucciones 3DNow! de AMD, SSE, SSE2, SSE3 y SSE4 de Intel, Altivec de IBM (PowerPC), etc.

Como obviamente no podía ser de otra forma Itanium tiene su propio set de instrucciones SIMD, el cual es casi el mismo que MMX. Al igual que MMX no presenta un juego de registros separados para implementar estas instrucciones, si no que ( a diferencia de MMX dónde se utilizan los registros del FPU a través de un "alias" ) se usan los registros generales. Estos set de instrucciones SIMD permiten operar en múltiples datos de tipo entero en paralelo, también hay otras instrucciones SIMD para operar con datos de tipo punto flotante en paralelo.

Hints

Todas las instrucciones llevan un sufijo 1, 2 o 4 segun si se trabajan los datos de a Byte, Word, o DoubleWord.

PADD1 r1 = r2, r3 //Suma de a byte el registro 2 y 3, y devuelve el resultado en 1

No todas las instrucciones soportan todos los tamaños de datos de entrada. Ej PMIN y PMAX no soporta DW.

El PADD si se pasa da la vuelta, hay hints para saturar con y sin signo.

• SSS Satura con signo
• UUU Satura sin signo
• UUS Toma los datos sin signo y el resultado lo satura con signo (a 7F para 1 byte)

Ciertas instrucciones tienen el hint l o r para indicar si se toma la parte izquierda o derecha del registro para operar. Ej PMPY.

Instrucciones varias

PMIN/PMAX

Efectuan una comparacion, pero en lugar de dejar una mascara de 1s o 0s, deja el valor del minimo (o maximo) en cada parte del resultado.

PMPY

Toma las partes izquierda o derecha de las unidades (byte, word) determinadas y guarda el resultado de su multiplicacion en una unidad mas grande.

PMPYSHR

Efectua una multiplicacion (unsigned) y luego shiftea (logico) a derecha el resultado. Recibe como 3er parametro la cantidad de posiciones a shiftear. No deja el resultado en una unidad mayor a la que se uso para los datos. Soporta solo words, y deja los resultados en words, tirando los 16 bits menos significativos. El shift se ejecuta antes de truncar, se puede usar un shift de 16 para obtener las partes altas.

Shifts

Son PSHL, PSHR (aritmeticos) y PSR.U (logico o unsigned). Soportan registro o inmediato para la cantidad de bits a shiftear.

PSHLADD

Hace lo mismo que su par sin P, shiftea a izquierda (multiplica) y luego suma. Solo soporta words. Existe el equivalente para shift a derecha.

PAVG

Hace el promedio en paralelo. Sin hints, redondea hacia arriba, con RAZ, redondea a cero.

PACK

PACK2 va de word a byte y PACK4 de double a word (chequear!). Recibe los hints SSS o USS para saturar, con o sin signo.

UNPACK

Idem anterior para desempacar.

MIX

Recibe todos los tamaños y el hint izq/der. Si es a derecha, toma las partes derechas (bajas) de las unidades vistas de a pares y las mezcla, bajando primero el 1er operando y luego el 2do. Idem para izquierda.

MUX

Toma 1 o 2 como tamaño, un destino, un operando y una operacion. En lugar de una operacion puede recibir una mascara que indica como alterar el orden de las unidades, solo para 16 bits. Las operaciones posibles son:

@REV

Invierte el registro byte a byte o word a word (reverse)

@MIX

Hace un mix entre las dos mitades del registro (mix)

@SHUF

Intercala las dos mitadas del registro (shuffle)

@ALT

Baja primero todas las partes izquierdas y luego las derechas (alternate)

@BRCAST

Copia el byte o word mas bajo del registro en el destino (broadcast)

PSAD

Parallel Sum of Absolute Difference. Solo trabaja de a byte. Hace la resta byte a byte, le toma el valor absoluto, hace la suma de esos valores absolutos y guarda el resultado en la word baja del registro destino. Las demas partes guardan las sumas parciales.

PCMP

Operacion de comparacion, solo soportan eq o gt (con signo), esta para todos los tamaños. Igual que en IA32, deja como resultado todo 1s si es verdadero o todo 0s si es falso.

Logicas

No hay instrucciones SIMD para operaciones logicas, se usan las de uso general, puesto que se comportan bit a bit siempre.

Ejercicio

Se tienen dos vectores V,W de n elementos de 16 bits sin signo. Se quiere construir un nuevo vector X de n-1 posiciones donde X[i] = V[i]*W[i+1] + V[i+1]*W[i]. Los elementos de X son de 64 bits para que entre el resultado.

ld8 loc1 = [in0]			//loc1 = V3 V2 V1 V0
ld8 loc2 = [in1]			//loc2 = W3 W2 W1 W0

mux2 loc2 = loc2, 0x4E	//Reordena los registros con la mascara 01 00 11 10
                       //loc2 = W2 W3 W0 W1

pmpy2.l loc3 = loc1, loc2	//loc3 = V3*W2 V1*W0
pmpy2.r loc4 = loc1, loc2	//loc4 = V2*W3 V0*W1

mix4.r loc5 = r0, loc3		//loc5 = 0 V1*W0
mix4.r loc6 = r0, loc4		//loc6 = 0 V0*W1

add loc7 = loc5, loc6		//loc7 = V1*W0 + V0*W1

mix4.l loc5 = r0, loc3		//loc5 = 0 V3*W2
mix4.l loc6 = r0, loc4	        //loc6 = 0 V2*W3

add loc8 = loc5, loc6		//loc8 = V3*W2 + V2*W3

Etc...

Observar que la complejidad adicional del ejercicio (mix4 + add), se debe a estar pidiendo 64 bits para un resultado de 33, generalmente mmx se usa cuando se desea saturar, para ello se podria haber usado padd directamente.