Extensiones Multimedia

Extensiones multimedia
Estructura de computadores
Computer Structure 1 Higher Polytechnic School of Alcoy

Contenidos:
1. Introducción.
2. SIMD en los procesadores Intel.
2.1. MMX.
2.2. SSE.
2.3. AVX.
3. Otras extensiones SIMD.
4. Programación.

1. Introducción

1. Introducción
● A mediados de los 90, las aplicaciones multimedia se hicieron cada vez más
populares (compresión gráficos, síntesis de audio, procesamiento de
imágenes).
● Tales aplicaciones requieren un fuerte procesamiento matemático y

formatos de datos muy específicos.
● Los procesadores actuales tienen registros de datos de 32, 64, 128 bits de
ancho o más, pero sólo una fracción de ellos se utiliza en aplicaciones de
cálculo intensivo de computación (8, 16 bits).
● Aparecieron las extensiones multimedia, como una versión limitada del

paralelismo SIMD.
1. Introducción
● Taxonomía de las arquitecturas paralelas (clasificación de Flynn)
DS1
PU1 MU1
● SISD DS2
PU2 MU2
● SIMD IS
CU
● MISD DS3
PU3 MU3
● MIMD
DSn
PUn MUn
La misma instrucción es ejecutada por "múltiples procesadores" utilizando

diferentes flujos de datos.
Inicialmente se concibió para optimizar los cálculos científicos.

1. Introducción
● Procesamiento SIMD, dos opciones (+1):
○ Extensiones multimedia (MMX, SSE, SSE2, AVX, etc.)
○ Procesadores vectoriales.
● Extensiones multimedia:
○ Registros anchos de p bits (p=64, p=128, etc.).
○ Un registro contiene n datos de p/n bits cada uno.
■ Con p=64 bits → 2 datos de 32 / 4 datos de 16…
■ Con p=128 bits → 2 datos de 64 / 4 datos de 32 / 8 datos de 16…
○ ALU ancha de p bits particionable en n unidades de p/n bits de ancho.
○ En una operación en la ALU se hacen n operaciones en paralelo
(subword parallelism).

1. Introducción
● SIMD (Single Instruction Multiple Data)
○ Ejecutar la misma instrucción en múltiples elementos de datos.
○ También conocido como sub-word parallel instructions.
○ También conocido como short vector instructions.

1. Introducción
● Taxonomía de las arquitecturas paralelas (clasificación de Flynn)
SCALAR VECTOR
(1 operación) (N operaciones)
v1 v2
r1 r2
add.vv v3, v1, v2

+
+
v3
r3
longitud del vector
add r3, r1, r2

1. Introducción
● Ejemplos de procesamiento masivo de datos (LiDAR, imágenes, audio):

1. Introducción
● Ejemplos de procesamiento masivo de datos (LiDAR, imágenes, audio):
Menos volumen Más complejo

Volumen de datos a
sofisticación del
Complejidad y
tratamiento
procesar
Más volumen Menos complejo

1. Introducción
¿Limitados al procesamiento multimedia?
● Standard benchmark kernels (multiplicación de matrices, FFT, Convolución,

Ordenación).
● Compresión con pérdidas (JPEG, vídeo y audio MPEG).
● Compresión sin pérdidas (RLE, Differencing, LZW).
● Criptografía (RSA, DES/IDEA, SHA/MD5).
● Reconocimiento de voz y escritura.
● Sistemas operativos/redes (memcpy, memset, paridad, suma de comprobación o
checksum).
● Bases de datos (hash/join, data mining, image/video serving).
● Soporte de lenguajes en tiempo de ejecución (stdlib, grabage collection).

1. Introducción
¿Cuáles son las características comunes de estas aplicaciones?
● Pequeños tipos de datos propios: byte (8 bits), word (16 bits), dword (integer or
float, 32 bits).
● Hay que aplicar muchas operaciones aritméticas y lógicas sobre un elevado
número de operandos de pequeño tamaño (paralelismo): La misma operación se
ejecuta simultáneamente sobre N>1 elementos de un vector.
● Los algoritmos requieren aritmética de saturación, si se produce un
desbordamiento, se toman valores límite.
● Patrones de acceso a memoria regulares y recurrentes.
● Operaciones recurrentes y localizadas sobre los datos.
● Computacionalmente intensivo: se ejecuta durante largos periodos de tiempo.

1. Introducción
● Muchas formas de introducir la vectorización en los programas:
Assembler code Control del programador
Vector intrinsic (mm_add_ps())
SIMD intrinsic class (F32vec4 add)
Manual CPU dispatch (__declspec(cpu_dispatch...))
User mandated vectorization (SIMD directive)
Compiler: auto vectorization hints (#pragma ivdep…)
Cilk plus array notation
Compiler: Fully automatic vectorization
Use performance libraries (IPP, MKL, etc.) Facilidad de uso

1. Introducción
● ¿Cómo se ha llevado a cabo la selección de las nuevas instrucciones?
○ Análisis coste-beneficio realizado sobre un conjunto de aplicaciones

existentes y futuras aplicaciones multimedia y de comunicaciones.
○ Este análisis mostró que, en la mayoría de los casos unas pocas rutinas
se llevan la mayor parte del tiempo:
■ (el 10% del código se lleva el 90% del tiempo de ejecución)

■ Optimizar según criterios de rendimiento como la ley de Amdahl.
● Un conjunto de prioridades.

1. Introducción
¿Cómo ha tenido lugar la selección de las nuevas instrucciones?
● Prioridad 1: Mejorar significativamente el rendimiento en aplicaciones

multimedia, las comunicaciones y en las aplicaciones de Internet.
● Prioridad 2: Mantener la compatibilidad con el software ya existente.
● Prioridad 3: Proporcionar una forma fácil de migrar las aplicaciones.
● Prioridad 4: Tecnología sencilla para poder integrarse fácilmente en futuras
tecnologías y mejoras de la frecuencia de reloj.
● Prioridad 5: Tecnología general de forma que pueda hacer frente a nuevos
algoritmos o a cambios en los existentes.

2. SIMD en los procesadores Intel


● MMX (extensiones multimedia).
● SSE (Streaming SIMD Extensions).
● AVX (extensiones vectoriales avanzadas).


● SIMD: Evolución continua. Implementaciones más recientes:


2.1. MMX


2.1. MMX
● Introducida por Intel en el año 1997.

● Mejora en aplicaciones multimedia de hasta un 60%.
● Mejora en procesado de imágenes, texturas, compresión y descompresión de audio y
vídeo.
● Mejora en las comunicaciones.
● Sin necesidad de cambiar el Sistema Operativo.
● Más caché y buffers de precarga.
● Trabaja con enteros.


2.1. MMX
● 8 registros: mm0-mm7. Situados en la unidad FP. Registros superpuestos.

79 63 0
11...1111 mm0
11...1111 mm1
11...1111 mm2
11...1111 mm3
11...1111 mm4
11...1111 mm5
11...1111 mm6
11...1111 mm7
● Los registros sólo pueden utilizarse para una cosa al mismo tiempo.
● Necesidad de vaciar los registros: EMMS (Empty MMX state).
● Después de ejecutar las instrucciones MMX y antes de ejecutar las instrucciones de punto flotante.

2.1. MMX
● Los registros MMX pueden ser direccionados directamente en las instrucciones MMX
mediante sus nombres mmi.
● La utilización compartida de los registros de coma flotante y MMX previene la ejecución

simultánea de código con ambos tipos de datos.
● Este mapeo implica una compatibilidad total con los sistemas operativos existentes.
No se requirieron nuevos registros o estados para esta tecnología.


2.1. MMX
● Una solución eficaz debe abordar los siguientes temas:

○ Packed data format.
○ Wraparound and saturation arithmetics.
○ Conditional execution.
○ Data repositioning.
○ Data alignment.
○ Fixed point arithmetic.


2.1. MMX
Formato de datos empaquetados (Packed data format). Característica principal: tamaño reducido
de los datos. Aplicación de la misma operación sobre un conjunto de datos adyacentes. ¿Cuántos
datos se van a procesar en paralelo? Depende de las características de la organización natural y la
alineación de los datos en las aplicaciones.
8 8 8 8 8 8 8 8
● Packed byte. 8 bytes in 64 bits
○ Signed: 0x80-0x7F 16 16 16 16
○ Unsigned: 0x00-0xFF
● Packed word. 4 words
○ Signed: 0x8000-0x7FFF 32 32
○ Unsigned: 0x0000-0xFFFF
● Packed double word. 2 dword

64
● Packed quadword. 1 qword


2.1. MMX
Aritmética de saturación y envolvente (Wraparound and saturation arithmetic). En un modelo

de modelo computacional convencional, si el resultado supera el valor máximo representable por
el operando de destino (overflow, underflow), el valor truncado/saturado se almacena en su lugar.
Wraparound (aritmética modular) Saturación
1 1 0 0 1 1 0 1 205 1 1 0 0 1 1 0 1 205
+ 0 1 0 0 0 0 0 1 65 + 0 1 0 0 0 0 0 1 65
1 0 0 0 0 1 1 1 0 270 1 1 1 1 1 1 1 1 255
Utiliza el valor máximo.

1 0 0 0 0 1 1 1 0
14
Retira los bits sobrantes


2.1. MMX
● Ejecución condicional (Conditional execution). ¿Qué podemos hacer cuando una operación
sólo se ejecuta si el operando satisface alguna condición?
if (condition) Ra=Rb; else Ra=Rc;
● Convertir una ejecución condicional en una asignación condicional:
Ra=(Rb AND Rx) OR (Rc ANDNOT Rx)
● Ejemplo (la máscara Rx dependerá de la condición):
0xFF 0x00 0x00 0xFF Rx 0xFF 0x00 0x00 0xFF Rx

Rb3 Rb2 Rb1 Rb0 Rb Rc3 Rc2 Rc1 Rc0 Rc
AND ANDNOT
Rb3 0x00 0x00 Rb0 0x00 Rc2 Rc1 0x00
OR
Ra Rb3 Rc2 Rc1 Rb0


2.1. MMX
● Reposicionamiento (data repositioning). Necesidad de reubicar o combinar datos

empaquetados.
● La representación de entrada o salida puede no ser la ideal para maximizar el rendimiento.
● Necesidad de cálculos intermedios con una resolución mayor que para los datos finales.
63 Palabra clave 1 31 Palabra clave 0 0
Fuente
Destino
Destino
Palabra 3 Palabra 2 Palabra 1 Palabra 0


2.1. MMX
● Alineación de datos (data alignment) (ver https://developer.ibm.com/articles/pa-dalign/).

○ Los datos alineados en la memoria son más eficientes para la CPU. Algunas
instrucciones sólo funcionan con datos alineados, y alineación puede ser forzada:
__declpsec(align(n)) <data type declaration>
○ Hay datos no alineados, al menos para los registros SIMD. Por lo tanto es necesario
proporcionar un acceso eficiente a datos no alineados.
○ Soluciones:
■ Dar soporte a ese acceso con hardware/instrucciones.
■ Solución habitual: limitar el acceso a los datos no alineados y extraer la información
necesaria mediante operaciones explícitas (desplazamientos lógicos y operaciones
OR).


2.1. MMX
● Aritmética de coma fija. (Fixed point arithmetic)

○ Con las aplicaciones mencionadas, el formato simple IEEE 754 tiene una precisión muy superior a la necesaria.
○ Las operaciones en coma flotante no son rentables.
○ Operar con aritmética de coma fija.
Campo de 8 bits
La posición de la coma está bajo la
responsabilidad del usuario.
Sign Bit Implied binary
point
Parte Entera Parte Fraccional
Sign Bit (0= +, 1 = -) +2-4 = +0.0625

2
+2 = +4 +2-3 = +0.125
1
+2 = +2 +2-2 = +0.25
0
+2 = +1 +2-1 = +0.5
Binario de 8 bits de signo-magnitud 1.3.4 representación en coma fija


2.1. MMX
● 57 nuevas instrucciones.
● Todas las instrucciones MMX, excepto EMMS, operan con dos operandos, destino (DEST, primer
operando) y el origen (SRC, segundo operando). Suelen ser operandos de 64 bits (mm/m64).
● Sintaxis: prefix-operation-suffix DEST, SRC (DEST operand is overwritten by result, DEST = DEST
OPERATION SRC).
○ Prefijo: p (para datos empaquetados).

○ Sufijo:
■ Tipos de datos utilizados en la instrucción: B, W, D, Q (byte empaquetado, word, doubleword,

quadword). Las instrucciones con diferentes tipos de datos de entrada y de salida tienen dos sufijos
de tipo de datos.
■ Aritmética con signo/sin signo y saturación o envoltura en operaciones de suma/resta:
● US: Unsigned saturated
● S: Signed saturation (void for wraparound).
○ Ejemplo: PADDUSB: add packed unsigned integer bytes with unsigned saturation (P-ADD-US-B).


2.1. MMX
Type Wraparound Signed saturation Unsigned saturation
Data transfer (register to

register, load from memory, MOVD, MOVQ
store to memory)
INSTRUCCIONES
PADDSB,
Arithmetic (addition, PADDB, PADDW, PADDD,
PADDSW, PADDUSB, PADDUSW,
subtraction, multiplication, PSUBB, PSUBB, PSUBD,
PSUBSB, PSUBUSB, PSUBUSW
multiply and add) PMULL, PMULH, PMADD
PSUBSW
Comparison PCMPEQB, PCMPEQW, PCMPEQD, PCMPGTB, PCMPGTW, PCMPGTW
PACKSSDW,
Conversion (pack) PACKUSWB
PACKSSWB
Conversion (unpack) PUNPCKHBW, PUNPCKHWD, PUNPCKHDQ, PUNPCKLBW, PUNPCKLWD, PUNPCKLDQ
Logical instructions PAND, PANDN, POR, PXOR
Shift and rotate instructions PSLLD, PSLLQ, PSLLW, PSRAD, PSRAW, PSRLD, PSRLQ, PSRLW


2.1. MMX
Instrucciones de transferencia de datos (mm: registro MMX, m64: datos de memoria de 64 bits).
● MOVQ mm,mm/m64
● MOVQ mm/m64,mm
Copia 64 bits del operando origen al operando destino. El destino y los operandos de origen pueden ser
registros MMX u operandos de memoria de 64 bits.
Para direccionar operandos en memoria se utilizan los general purpose CPU registers: EAX, EBX, ECX,
EDX, EBP, ESI, EDI y ESP (los registros MMX no pueden utilizarse para direccionar la memoria). MOVQ no
puede transferir datos de memoria a memoria.
Ejemplos: movq mm1, [eax] (m64 memory to mm register)

movq mm3, mm2 (mm register to mm register)
movq Vector, mm5 (mm register to m64 memory)


2.1. MMX
Instrucciones de transferencia de datos (r/m32: datos de registro o memoria de 32 bits).

● MOVD mm,r/m32
● MOVD r/m32, mm
● Copia 32 bits del operando origen al operando destino. El destino y los operandos fuente pueden ser
registros MMX, operandos de memoria de 32 bits de 32 bits o registros enteros de 32 bits. MOVD no
puede transferir datos de un registro MMX a un registro MMX, de memoria a memoria, o de un registro
entero a un registro entero.a un registro de enteros. Cuando el operando de destino es un registro MMX, el
operando de origen de 32 bits se escribe en los 32 bits de orden inferior del registro de destino de 64 bits,
y el de 64 bits del registro de destino, y los 32 bits de orden superior del registro de destino se llenan de
ceros. Cuando el operando fuente es un registro MMX, los 32 bits de 32 bits de orden bajo del registro
MMX se escriben en el registro entero de 32 bits o en la de 32 bits.
Ejemplos:
movd eax, mm0 (eax: registro de 32 bits de la CPU)
movd mm0, [ecx] (carga 4 bytes desde la dirección ecx)
movd [r2], mm0 (almacena los 4 bytes inferiores de mm0 en la dirección r2)

2.1. MMX
Instrucciones aritméticas
● Suma: PADD[B,W,D][SB,SW][USB,USW] mm,mm/m64. Las instruccione PADD (Packed Add)
añaden los elementos de datos del operando de origen a los elementos de datos del registro
de destino,y el resultado se escribe en el registro de destino. Si el resultado excede el límite
de rango de datos para el tipo de datos, se envuelve(opción por defecto). PADD admite bytes
empaquetados (PADDB), palabras empaquetadas palabra empaquetada (PADDW) y palabra
doble empaquetada (PADDD).
Ejemplo:
PADDB mm1, mm2 Se suman ambos y el resultado queda registrado en mm1
Suma de bytes, con signo, complemento a dos, con envolvente.
(mm1=0x0323F456E0BACD80)
(mm2=0x11FE3852658241E0)
● Resultado: mm1=0x14212CA8453C0E60


2.1. MMX
Instrucciones aritméticas. Suma.
mm1= … 1 1 0 0 1 1 0 1 1 0 0 0 0 0 0 0
mm2= … 0 1 0 0 0 0 0 1 1 1 1 0 0 0 0 0
(Sólo se muestran 2 bytes de los 8)
-51 (CDh) -128 (80h)
-128-32=-160(9 bits) = 96 65 (41h) -32 (E0h)

después de la envoltura:
14 (0Eh) 96 (60h)
1 0 1 1 0 0 0 0 0


2.1. MMX
Instrucciones aritméticas. Suma. Interpretación Complemento a dos
1 1 0 0 1 1 0 1 1 0 0 0 0 0 0 0
- 51 205 - 128 128
0 1 0 0 0 0 0 1 1 1 1 0 0 0 0 0
65 65 - 32 224


2.1. MMX

- 51 - 128
PADDSB mm1,mm2
+ 65 - 32
(Suma de bytes, con saturación con signo)
14 - 128
205 128
PADDUSB mm1,mm2
+ 65 224
(Suma de bytes, con saturación sin signo saturación)
255 255


2.1. MMX

- 12928
(Envolvente
PADDW mm1,mm2
8432 y saturación
(Suma de palabras, con signo, con envoltura) +
coinciden)
PADDUSB mm1,mm2 - 4496
(Suma de palabras, con saturación con signo)
52608
PADDUSW mm1,mm2
+ 8432
(Suma de palabras, con saturación sin signo)
61040
La saturación no permite utilizar tipos de datos de doble palabra (Double word).


2.1. MMX
Instrucciones aritméticas. Resta. PSUB[B,W,D][SB,SW][USB,USW] mm,mm/m64. Las

instrucciones PSUB (Packed Subtract) resta los elementos de datos del operando operando
de origen de los elementos de datos del registro de destino, y el resultado se escribe en el
registro de destino. Si el resultado excede el límite de rango de datos para el tipo de datos,
se envuelve (opción por defecto). PSUB admite bytes empaquetados (PSUBB), palabras
empaquetadas (PSUBW), y doble palabra empaquetada (PSUBD).
Ejemplo:
PSUBB mm1, mm2 (mm1 = mm1 - mm2)

Sustracción de bytes, con signo, complemento a dos, con envoltura.
(mm1=0x0323F456E0BACD80)
(mm2=0x11FE3852658241E0)
Resultado: mm1=0xF225BC047B388CA0

2.1. MMX
Instrucciones aritméticas. La sustracción.

● PSUBS(Packed Subtract with Saturation). Estas instrucciones restan los elementos de
datos con signo del operando fuente de los elementos de datos con signo del operando
de destino. Los resultados se saturan hasta los límites de datos con signo. PSUBS
admite bytes empaquetados (PSUBSB) y palabra empaquetada (PSUBSW).
● PSUBUS(Packed Subtract Unsigned with Saturation). Como anterior, pero con datos sin
signo. PSUBUS admite byte empaquetado (PSUBUSB), y palabra empaquetada
(PSUBUSW).
Ejemplos:
PSUBSB mm1, mm2
Resultado: mm1=0xF225BC047B388CA0
PSUBUSB mm1, mm2
Resultado: mm1=0x0000BC047B388C00

2.1. MMX
Instrucciones aritméticas. Resta. Ejemplo: Truncamiento y aritmética de saturación,

aumentando el brillo en C y MMX.


2.1. MMX
Instrucciones aritméticas. Resta.
MOVQ mm1, A //move 8 pixels of image A

MOVQ mm2, B //move 8 pixels of image B
MOVQ mm3, mm1 // mm3=A
PSUBSB mm1, mm2 // mm1=A-B
PSUBSB mm2, mm3 // mm2=B-A
POR mm1, mm2 // mm1=|A-B|


BYTE *dst;
2.1. MMX
int x, y,temp;
Instrucciones aritméticas. Resta. Ejemplo: Truncamiento dst=(BYTE*) imageData;
y aritmética de saturación, aumentando el brillo en C y MMX. __int64
mask=0x1919191919191919;
for (y=0; y<TY; y++)
BYTE *dst; {
int x, y,tp; for (x=0; x<TX; x+=8)
dst=(BYTE*) imageData; __asm
for (y=0; y<TY; y++) { {
for (x=0; x<TX; x++) {
tp=(*dst)+25; mov eax, dst
*dst++=tp; movq mm0,[eax]
//*dst++=(tp>255?255:tp); paddusb mm0,mask
// for saturation movq [eax],mm0
} add dst,8
} }
}
__asm emms

2.1. MMX
Instrucciones aritméticas. Multiplicación.

PMULLW mm, mm/m64 (Packed Multiply Low). Multiplica las cuatro palabras con signo de
los operandos origen y destino y escribe los 16 bits de orden inferior de los resultados
intermedios de 32 bits.
w13 w12 w11 w10 mmi
x w23 w22 w21 w20

mmj
31 1615 0 31 1615 0
w13 * w23 w12*w22 w11*w21 w10*w20

31 1615 0 31 1615 0
mmi w13*w23[0..15] w12*w22[0..15] w11*w21[0..15] w10*w20[0..15]


2.1. MMX

PMULHW mm, mm/m64 (Packed Multiply High). Multiplica las cuatro palabras con signo de
los operandos origen y destino y escribe los 16 bits de orden superior de los resultados
intermedios de 32 bits.
w13 w12 w11 w10 mmi
x w23 w22 w21 w20

mmj
31 1615 0 31 1615 0
w13 * w23 w12*w22 w11*w21 w10*w20

31 1615 0 31 1615 0
mmi w13*w23[31..16] w12*w22[31..16] w11*w21[31..16] w10*w20[31..16]


2.1. MMX

PMADDWD mm,mm/m64 (Multiplicación y suma empaquetada).Multiplica las 4 palabras con
signo del operando destino por las cuatro palabras con signo del operando origen. Las dos
palabras de orden superior se suman y se almacenan en la palabra doble superior del
operando de destino, y las dos palabras de orden inferior se suman y almacenan en la
palabra doble inferior del operando destino.
a3 a2 a1 a0
b3 b2 b1 b0
a3*b3+a2*b2 a1*b1+a0*b0


2.1. MMX
● Instrucciones de comparación. Igualdad.

PCMPEQ[B,W,D] mm,mm/m64 (Comparación empaquetada para igualdad) Compara
los datos con signo de los operandos origen y destino, y si son iguales, el elemento
correspondiente se pone a todos los 1's, y si son diferentes, se pone a todos los 0's.
PCMEQ admite bytes empaquetados(PCMPEQB), palabra empaquetada (PCMPEQW) y
palabra doble empaquetada(PCMPEQD). Puede utilizarse para inicializar un registro a
todos los 1's:
PCMEQB mm0, mm0 (mm0=0xFFFFFFFFFFFF)
La comparación "no igual" no está implementada en MMX.


Aci no son unos, xq está agrupat per
paquets, de dos en dos, o tot el paquet es
igual o van a ser ceros
2.1. MMX Si son iguales, unos

Si son difrentes, ceros
Instrucciones de comparación. Igualdad. PCMPEQB mm1, mm2

b7 b6 b5 b4 b3 b2 b1 b0
00001111 10101010 11110000 00000000 11111111 11110000 11110000 11111111

mm1
11110000 01010101 11110000 00000000 11111111 00000000 00000000 11111111

mm2
00000000 00000000 11111111 11111111 11111111 00000000 00000000 11111111

mm3
PCMPEQW mm1, mm2
w3 w2 w1 w0
00001111 10101010 11110000 00000000 11110000 11110000 11110000 11111111

mm1
11110000 01010101 11110000 00000000 11111111 00000000 00000000 11111111

mm2
00000000 00000000 11111111 11111111 00000000 00000000 00000000 00000000

mm3

2.1. MMX
Instrucciones de comparación. Mayor que.
PCMPGT[B,W,D] mm,mm/m64 (Comparación empaquetada mayor que). Compara los

datos con signo de los operandos destino y origen, y si el destino es mayor que el
origen, el elemento correspondiente se pone a todos los 1's, de lo contrario se pone a
todos los 0's. Admite bytes empaquetados (PCMPGTB), palabras empaquetadas
(PCMPGTW)y doble palabra empaquetada (PCMPGTD).
Otras comparaciones como "mayor o igual", "menor que" o "menor o igual" no están
implementadas en MMX.

El primer digito indica el signo, si es 1 es

negativo, por tanto el numero es -111111
2. SIMD en los procesadores Intel. Por tanto, como el de arriba tiene que ser
mayor que, es mayor 1111 que un numero
2.1. MMX
negativo, entonces la respuesta son unos
Instrucciones de comparación. Mayor que. PCMPGTB mm1, mm2

b7 b6 b5 b4 b3 b2 b1 b0
10000000 00000000 00000000 11111111 00000000 00000011 00000010 00001111

mm1
01110000 00000000 00000000 00001111 0000000 00000010 00000011 11111111

mm2
00000000 00000000 00000000 00000000 00000000 11111111 00000000 11111111

mm1
Igual que antes, lo hacemos por agrupaciones de dos PCMPGTW mm1, mm2
w3 w2 w1 w0
10000000 00000000 00000000 11111111 00000000 00000011 00000010 00001111

mm1
01110000 00000000 00000000 00001111 00000000 00000010 00000011 11111111

mm2
00000000 00000000 11111111 11111111 11111111 11111111 00000000 00000000

mm1

2.1. MMX
Instrucciones de comparación.
Mayor que. Binarización de imágenes
ejemplo.


2.1. MMX __int64
mask=
Instrucciones de comparación. 0xFFFFFFFFFFFFFFFF
Ejecución condicional ;
for (y=0; y<TY; y++) {
Ejemplo de binarización en C y MMX for (x=0; x<TX; x+=8)
__asm
BYTE *dst;
{
int x, y,tp;
mov eax, dst
dst=(BYTE*) imageData;
movq mm0,[eax]
for (y=0; y<TY; y++) {
pcmpgtb mm0,mask
for (x=0; x<TX; x++) {
movq [eax],mm0
if (*dst
add dst,8
>=128
}
)*dst=0;
}
else *dst=255;
__asm
dst++;
emms
}
}


2.1. MMX
Instrucciones de comparación.
Ejercicio: La interpretación de los operandos como datos con signo dificulta la operación de
binarización cuando el umbral no es 128, como se puede observar en el siguiente diagrama
0 128 200 255
0 127 - 56 -1
0 64 255
0 127- 128 -1
Implementar rutinas que permitan realizar la binarización con valores de umbral diferentes a
128

2.1. MMX
Instrucciones de conversión o reubicación. Empaquetar y desempaquetar.

● Hay casos en los que:
○ Los elementos de los datos empaquetados pueden necesitar ser reposicionados dentro de los datos
empaquetados, o los elementos de dos operandos de datos empaquetados pueden necesitar fusionarse.
○ La entrada o la representación de salida deseada de un dato puede no ser ideal para maximizar el
rendimiento del cálculo.
○ Es necesario realizar cálculos intermedios en un formato más amplio (quizás en formato de palabra
empaquetada), mientras que el resultado se presenta en formato de formato de bytes.
● Necesidad de extraer algunos elementos de un tipo de datos empaquetados y escribirlos en una
posición/tamaño diferente en el resultado empaquetado. Soluciones:
○ Proporcionar instrucciones que toman dos operandos de datos empaquetados y permitan la fusión de sus
bytes en cualquier orden arbitrario en el destino. Esta solución general es costosa de implementar, ya que
requiere una conexión de barra cruzada completa.
○ La tecnología MMX define instrucciones que requieren una red relativamente sencilla de swizzle red y que,
sin embargo, permiten el reposicionamiento y la combinación eficientes de elementos de operandos de datos
empaquetados en la mayoría de los casos.


2.1. MMX
Instrucciones de conversión o reposición. Empaquetar.

PACKUSWB empaqueta y satura cuatro palabras con signo del operando fuente y cuatro
palabras con signo del operando de destino en ocho bytes sin signo almacenados en el operando
de destino. Si el valor con signo de la palabra es mayor o menor que el rango de un byte sin
signo, el valor se satura (en el caso de un desbordamiento a 0xFF y en el caso de un
desbordamiento a 0x00). De la segunda variable, es decir, mm7
empezamos empaquetando, luego mm0
Si el paquete de 16 se puede representar en
uno de 8, lo hago
● Ejemplo de instrucción: PACKUSWB mm0, mm7
Antes:
mm0=|0000000100000001|0000001000000010|0000000001111111|1000000000010000|
mm7=|0000000000000000|0000000000000000|0000000000000000|0000000000000000|
Después:
mm0=|00000000|00000000|00000000|00000000|11111111|11111111|01111111|00000000|
mm0 = 0x00000000FFFF7F00


2.1. MMX
Instrucciones de conversión o reposición. Desempaquetar.

Las instrucciones PUNPCKH (Unpack High Packed Data) desempaquetan e intercalan los de datos
de orden alto de los operandos de destino y origen en el operando de destino destino, ignorando
los elementos de datos de orden inferior. Admite el empaquetado de bytes (PUNPCKHBW),
palabra empaquetada (PUNPCKHWD) y palabra doble empaquetada (PUNPCKHDQ) como tipos
de datos de origen.
● Ejemplo de instrucción: PUNPCKHBW mm1, mm2
mm1 0x07 0x05 0x03 0x01 0xF7 0xF5 0xF3 0xF1
mm2 0x08 0x06 0x04 0x02 0xF8 0xF6 0xF4 0xF2
mm1 0x08 0x07 0x06 0x05 0x04 0x03 0x02 0x01
mm1 0x0807 0x0605 0x0403 0x0201


2.1. MMX
Instrucciones de conversión o reposición. Desempaquetar.

Las instrucciones PUNPCKL (Unpack Low Packed Data) desempaquetar e intercalan los elementos
de datos de orden bajo de los operandos destino y origen en el operando destino destino. Al
desempaquetar desde un operando de memoria, sólo se accede a 32 bits. En admite el
empaquetado de bytes (PUNPCKLBW), de palabras (PUNPCKLWD) y de (PUNPCKLDQ).
● Ejemplo de instrucción: PUNPCKLBW mm1, mm2
mm1 0x07 0x05 0x03 0x01 0xF7 0xF5 0xF3 0xF1
mm2 0x08 0x06 0x04 0x02 0xF8 0xF6 0xF4 0xF2
mm1 0xF8 0xF7 0xF6 0xF5 0xF4 0xF3 0xF2 0xF1
mm1 0xF8F7 0xF6F5 0xF4F3 0xF2F1


2.1. MMX
Instrucciones lógicas.
● PAND mm,mm/m64: Bitwise Logical AND (DEST ← DEST AND SRC))
● PANDN mm,mm/m64: Bitwise Logical AND NOT (DEST ← (NOT DEST) AND SRC). Realiza un NOT
lógico por bits del operando destino (primer operando), luego realiza un AND lógico a nivel de bits del
operando fuente (segundo operando) y el operando de destino invertido. El resultado se almacena en el
operando de destino. Cada bit del resultado se pone a 1 si el bit correspondiente en el primer operando
es 0 y el bit correspondiente en el segundo operando es 1; en caso contrario, se pone a 0.
● POR mm,mm/m64: OR lógico a nivel de bits (DEST ← DEST OR SRC))
● PXOR mm,mm/m64: Bitwise Logical Exclusive OR (DEST ← DEST XOR SRC))
Destino Fuente PAND PANDN POR PXOR
0 0 0 0 0 0
0 1 0 1 1 1
1 0 0 0 1 1
1 1 1 0 1 0


2.1. MMX
Instrucciones lógicas.
Ejemplo:
Valor absoluto: if (a>b) then c=a-b else c=b-a
No hay instrucción MMX para valor absoluto o ejecución condicional.
Alternativa: c=(a-b) OR (b-a)
(Operandos en mm0 y mm1)
MOVQ mm2,mm0
PSUBUSB mm0,mm1
PSUBUSB mm1,mm2
POR mm0,mm1


2.1. MMX
Instrucciones de desplazamiento.
PSLL[W,D,Q] mm,mm/m64 o mm,imm8 (Packed Shift Left Logical). Estas instrucciones desplazan
los bits del primer operando hacia la izquierda en la cantidad de bits especificados en el operando
fuente. Los bits de orden inferior vacíos se ponen a cero. Si el valor especificado por el segundo
operando es mayor que 15 (para palabras), 31 (para palabras dobles) o 63 (para palabras
cuádruples), entonces el destino se destino se pone a todos los ceros. El operando destino es un
registro MMX, mientras que el operando fuente puede ser un registro MMX, un operando de
memoria de 64 bits o un operando inmediato de 8 bits. PSLL admite la palabra empaquetada
(PSLLW), palabra doble empaquetada (PSLLD) y palabra cuádruple (PSLLQ). Ejemplo:
mm2(64 bits, 4 palabras), antes:

|0000100001001100|0000000000011111|0000011000001100|1111110000000000|
PSLLW mm2,1 (desplazamiento lógico empaquetado a la izquierda en 1)
mm2(64bits, 4 palabras), después:
|0001000010011000|0000000000111110|0000110000011000|1111100000000000|

2.1. MMX
PSRL[W,D,Q] mm,mm/m64 o mm,imm8 (Packed Shift Right Logical).
Estas instrucciones desplazan los bits del primer operando a la derecha en la cantidad de bits
cantidad de bits especificada en el operando fuente. Los bits de orden superior vacíos se ponen a
cero. Si el valor especificado por el segundo operando es mayor que 15 (para palabras), 31 (para
palabras dobles), o 63 (para palabras cuádruples), entonces el destino se pone a todos los ceros. El
operando destino es un registro MMX, mientras que el operando fuente puede ser un registro MMX,
un operando de memoria de 64 bits o un operando inmediato de 8 bits. PSRL admite la palabra
empaquetada (PSRLW), de doble palabra (PSRLD) y de cuatro palabras (PSRLQ). Ejemplo:
mm4(64 bits, 4 palabras), antes:

|0000100001001100|0000000000011111|0000011000001100|1111110000000000|
PSRLW mm4,5 (desplazamiento lógico empaquetado a la derecha en 5)
mm4(64 bits, 4 palabras), después:
|0000000001000010|0000000000000000|0000000000110000|0000011111100000|


2.1. MMX
PSRA[W,D] mm,mm/m64 o mm,imm8 (Packed Shift Right Arithmetic). Estas instrucciones
desplazan los bits del primer operando a la derecha en la cantidad de bits especificada en el
operando fuente. Los bits de orden superior vacíos de cada elemento se llenan con el valor inicial
del bit de signo del elemento de datos. Si el valor especificado por el segundo operando es mayor
que 15 (para palabras), o 31 (para palabras dobles), cada elemento de destino se rellena con el
valor inicial del bit de signo del elemento. El operando de destino es un registro registro MMX,
mientras que el operando fuente puede ser un registro MMX, un operando de memoria de 64 bits, o
un operando inmediato de 8 bits. Esta instrucción admite los tipos de datos de palabra
empaquetada (PSRAW) y de palabra doble empaquetada(PSRAD) de datos.
Simplemente cojo los 5 de la derecha de cada
mm4(64 bits, 4 palabras), antes: paquete, los quito, lo resultante lo desplazo, y a la
izquierda del paquete lo relleno de 0's
|0000100001001100|0000000000011111|1000011000001100|1111110000000000|
PSRAW mm4,5 (desplazamiento aritmético empaquetado a la derecha en 5)
mm4(64 bits, 4 palabras), después:
|0000000001000010|0000000000000000|1111110000110000|1111111111100000|

2.2. SSE


2.2. SSE
SSE: Streaming SIMD Extension (Pentium III, 1999)
● La arquitectura MMX facilitó algunas operaciones de (vídeo, audio), pero reutilizaba

los registros de punto flotante de punto flotante, por lo que la CPU no podía trabajar
con datos punto flotante y datos SIMD simultáneamente. Sólo funcionaba con
enteros.
● Las operaciones en coma flotante son la base de la geometría 3D. La mejora de este
tipo de operaciones es esencial para mejorar el rendimiento de las aplicaciones 3D.
● Solución: Ampliación del conjunto de instrucciones SSE. Ocho nuevos registros de

128 bits: XMM0, XMM1, ..., XMM7.


2.2. SSE

● Un nuevo registro de 32 bits: MXCSR (bits de control y estado para operaciones
realizadas en los registros XMM).
● Instrucciones que guardan y restauran el estado del registro MXCSR de los registros
MXCSR.
● Nuevas operaciones de números enteros que funcionan en los registros MMX.
● Instrucciones MMX aplicadas a registros XMM de 128 bits.
● Tres tipos de datos para vectores SSE:
○ Entero (16 bytes, 8 palabras, 4 dwords, 2 qword, 1 dqword).

○ Punto flotante de precisión simple (32 bits) (4 floats).
○ Punto flotante de doble precisión (64 bits) (2 dobles)


2.2. SSE

● Define 3 tipos de instrucciones:
○ Scalar: opera sobre los bits [31..0] de los registros de 128 bits, el resto permanece
sin cambios (sufix -ss).
○ Empaquetada: opera sobre cuatro valores de punto flotante de 32 bits en paralelo
(sufijo -ps).
○ Empaquetado: opera con dos valores de coma flotante de 64 bits en paralelo (sufijo
-pd).
○ Instrucciones enteras SIMD de 64/128 bits: Extensión MMX.
● Evolución: SSE2, SSE3, SSSE3, SSE4 (SSE4.1, SSE4.2).
○ Operación sobre registros XMM en lugar de registros MMX.
○ Más instrucciones.
○ Operaciones horizontales: en lugar de utilizar datos de diferentes operandos, la
instrucción utiliza los datos del mismo vector.

2.2. SSE
● Nuevas instrucciones:
○ Conjunto de instrucciones de enteros (instrucción de nuevos medios) que operan
sobre el conjunto anterior de registros MMX de 64 bits registros..
○ Nuevas operaciones SIMD en coma flotante de precisión simple (32 bits), que
operan sobre un nuevo conjunto de registros de 128 bits de 128 bits. Pueden
operar con datos empaquetados o escalares escalares. Nuevos 8 registros
XMM0-XMM7.
○ Instrucciones de acceso a la memoria: gestión de la caché y minimización de la
contaminación de la caché.
○ Instrucciones de conversión de formato numérico.

2.2. SSE
Registros SSE.
127 0
xmmm3 4x flotantes
2x dobles
xmmm3
16x bytes
xmmm3 8x palabras
4x palabras dobles
xmmm3 2x palabras cuádruples
…
xmm7/15
Depende de la versión de SSE


2.2. SSE
Registros de propósito general. Los operandos de registro en el modo de 64 bits

pueden ser cualquiera de los siguientes:
● Registros de propósito general de 64 bits (RAX, RBX, RCX, RDX, RSI, RDI, RSP, RBP,
o R8-R15).
● Registros de propósito general de 32 bits (EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP, o
R8D-R15D).
● Registros de propósito general de 16 bits (AX, BX, CX, DX, SI, DI, SP, BP, o
R8W-R15W).
● Registros de propósito general de 8 bits: AL, BL, CL, DL, SIL, DIL, SPL, BPL, AL, BL,
CL, DL, AH, BH, CH, DH.
● Registros de segmento (CS, DS, SS, ES, FS y GS).
● Registros FPU x87 (ST0 a ST7).

2.2. SSE
Tipo Envolvente Saturación con signo Saturación sin signo

register, load from memory, MOVDQA, MOVDQU, MOVDQ2Q, MOVQ2DQ, MOVAPS, MOVUPS
store to memory)
INSTRUCCIONES
PAVGB, PAVGW, PMAXUB, PMAXUW, PMAXSB, PMAXSW,

Aritmética (suma, PMINUB, PMINUW, PMINSB, PMINSW, PADDQ, PSUBQ
sustracción, multiplicación, ADDPS, SUBPS, MULPS, DIVPS,
multiplicar y sumar) MAXPS, MINPS, RCPPS, SQRTPS, RSQRTPS
Comparación
VPSHUFB, VPSHUFW,
Conversión (paquete)
VPSHUFD
Conversión (desempaquetar)
Instrucciones lógicas
Desplazamiento y rotación
instrucciones


2.2. SSE
Transferencia de datos. Mover doble quad alineado o sin alinear.

● MOVDQA/MOVDQU xmm,xmm/m128. El MOVDQA y el MOVDQU se utilizan para
mover 128 bits de datos entre registros XMM o entre un registro XMM y datos de
128 bits en memoria. No es posible mover datos entre dos posiciones de memoria
directamente. La opción A es para datos alineados en memoria de 16 bytes, más
rápida que la versión no alineada con U.
Ejemplo:
unsigned char dato1[16]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};

movdqu xmm0, dato1
xmm0=0x100F0E0D0C0B0A090807060504030201
(uint128)


2.2. SSE
Transferencia de datos. Mueve palabras cuádruples (entre los registros MMX y SSE).
● MOVDQ2Q mm, xmm. Mueve la palabra cuádruple inferior del operando fuente al
operando de destino. El operando fuente es un registro XMM y el operando de destino es
un registro MMX.
MMX XMM
63 0 127 64 63 0
● MOVQ2DQ xmm, mm.. Mueve la palabra cuadrada del operando fuente a la palabra
cuadrada baja del operando destino. La palabra se pone a 0.
XMM MMX
0000 . . . . . . . . . . . . . 000000 63 0 63 0


2.2. SSE
Transferencia de datos. Mover valores de punto flotante de precisión simple alineados

de precisión…
● MOVAPS xmmi, xmmj/m128. Mueve valores empaquetados de punto flotante de

precisión simple de xmmj/m128 a xmmi, o al revés. al revés. Cuando el operando
origen o destino es un operando de memoria de memoria, la dirección debe estar
alineada en un límite de 16 bytes.
● MOVUPS xmmi, xmmj/m128. Mueve valores de punto flotante de precisión simple

empaquetados de xmmj/m128 a xmmi, o al revés. al revés. Cuando el operando
origen o destino es un operando de memoria la dirección no tiene que estar alineada


2.2. SSE
Instrucciones aritméticas (además de las instrucciones MMX). Media empaquetada.

● PAVG[B][W] mm,mm/m64 o xmm,xmm/m128. Suma los datos sin signo de los
operandos origen y destino, incluyendo un bit adicional oculto (valor=1,
redondeado), y el resultado, la promedio de cada par de datos, se almacena en el
operando destino.
● PAVGB: Destino[i+7..i] = (Origen[i+7..i] + Destino[i+7..i] +1)>>1;
● PAVGW: Destino[i+15..i] = (Origen[i+15..i] + Destino[i+15..i] +1)>>1;
● Ejemplo:
mm0=0x0202020202020202
mm1=0x0303030303030303
PAVGB mm0, mm1
mm0=0x030303030303 (media de 03h+02h+1)

2.2. SSE
Instrucciones aritméticas. Máximo/Mínimo de datos del paquete..

● PMAX[S][U][B][W] mm,mm/m64 o xmm,xmm/m128.
PMIN[S][U][B][W] mm,mm/m64 o xmm,xmm/m128.
Calcula el máximo/mínimo de enteros empaquetados con/sin signobyte/palabra.i
● (Destino[i+7..i] > Origen[i+7..i]) Destino[i+7..i] =
Destino[i+7..i]; si no, Destino[i+7..i] = Origen[i+7..i];
● Ejemplo:
mm0=0x0102030405060708
mm1=0x0807060504030201
PMAXUB mm0, mm1
mm0=0x0807060505060708

2.2. SSE
Instrucciones aritméticas. Suma, resta y multiplicación.

● PADDQ xmm,xmm/m128. Suma las dos palabras cuádruples con signo en los operandos
destino y origen, y almacena el resultado en el operando destino. Aplica el wraparound en caso
de desbordamiento.
● PSUBQ xmm,xmm/m128. Resta las dos palabras cuádruples con signo en los operandos
destino y origen, y almacena el resultado en el operando operando destino (Destino = Destino -
Origen). Aplica wraparound si hay desbordamiento.
● PMULUDQ xmm,xmm/m128. Multiplica los enteros sin signo empaquetados enteros de doble
palabra sin signo en los operandos destino y origen, y almacena los resultados de cuatro
palabras en los operandos de destino.
xmmi 127 96 95 64 63 32 31 0
x x
xmmj 127 96 95 64 63 32 31 0
xmmi 127 64 63 0


2.2. SSE
Instrucciones aritméticas. Suma, resta y multiplicación(punto flotante, precisión simple

32 bits, sufijo -ps).
● ADDPS xmm,xmm/m128. Suma cuatro valores de coma flotante de precisión simple
empaquetados de coma flotante de los operandos origen y destino y almacena almacena los
resultados en el operando de destino.
● SUBPS xmm,xmm/m128. Resta cuatro valores empaquetados de coma flotante de precisión
simple de punto flotante en el operando fuente del operando destino y almacena los
resultados en el operando destino. y almacena los resultados en el operando de destino.
● MULPS xmm,xmm/m128. Multiplica cuatro valores de coma flotante de precisión simple
empaquetados de punto flotante en el operando fuente por los cuatro valores en el operando
operando de destino y almacena los resultados en el operando de destino.
● DIVPS xmm,xmm/m128. Divide cuatro valores de coma flotante de precisión simple
empaquetados de precisión simple en el operando destino por los cuatro del operando
operando fuente y almacena los resultados en el operando destino. operando destino. Aplica el
wraparound en caso.

2.2. SSE
Instrucciones aritméticas. Suma, resta y multiplicación

(punto flotante, precisión simple 32 bits, sufijo -ps).
● MAXPS xmm,xmm/m128. Devuelve los valores máximos empaquetados de punto
flotante de precisión simple.
● MINPS xmm,xmm/m128. Devuelve los valores mínimos de coma flotante de precisión
simple empaquetados. de precisión simple.
● RCPPS xmm,xmm/m128. Calcula los recíprocos de los valores empaquetados de punto
flotante de precisión simple en el operando fuente y los resultados son almacenados en
el operando destino (x → 1/√x).
● SQRTPS xmm,xmm/m128. Calcula las raíces cuadradas de valores de coma flotante de
precisión simple empaquetados (x → √x).
● RSQRTPS xmm,xmm/m128. Calcula los recíprocos de las raíces cuadradas de valores
empaquetados de punto flotante de precisión simple en el operando fuente y los
resultados se almacenan en el operando de destino (x → 1/√x).

2.3. AVX


2.3. AVX
● Registros AVX (tipos de 128, 256 y 512 bits).

127 0
xmmm0
xmmm1 16x flotantes
…
xmm7/15 8x dobles
255 0 64x bytes
ymm0 32x palabras
ymm1 16x palabras dobles
…
8x palabras cuádruples
ymm7/15
511 0
zmm0
zmm1
…
zmm7/15


2.3. AVX
Nuevas características:
● Instrucciones de tres operandos. Instrucciones como
A = A+ B se convierten en A = B + C.
● Algunas instrucciones de cuatro operandos.
● Se han relajado los requisitos de alineación de la memoria.
● Nuevas instrucciones Fused-Multiply-Add (FMA), como
A = A * B + C.
● Nuevas instrucciones para el estándar de cifrado avanzado (AES).
● Diseñado para soportar registros de 1024 bits en el futuro.
● Superposición de registros: si se admiten 512 bits pero trabajando con versiones
anteriores (registros de 256 o 128 bits registros), se utilizan las partes inferiores de
los 512 bits.
● Instrucciones codificadas con un prefijo VEX.


2.3. AVX
Nuevas características:
● Extiende algunas instrucciones SSE a AVX. Ejemplo:
○ ADDPS xmm, xmm/m128 se convierte en VADDPS ymm, ymm/y256..
● Algunas instrucciones son nuevas en AVX (sólo VEX).
● Instrucciones aritméticas: sumar, restar, multiplicar, dividir, raíz cuadrada, mínimo,
máximo, redondeo.
● Instrucciones de comparación: 32 tipos de comparación.
● Conversión y reposicionamiento: Empaquetar, desempaquetar, barajar, insertar y
extraer datos.
● Requiere el modo de 64 bits. No es compatible con todos los procesadores
procesadores y sistemas operativos actuales. El uso de la instrucción CPUID es
imprescindible.

2.3. AVX
Se añade el prefijo V a casi todas las instrucciones SSE anteriores

Tipo Envolvente Saturación con signo Saturación sin signo

register, load from memory, VMOVDQA, VMOVDQU, VMOVDQ2Q, VMOVQ2DQ, VMOVAPS, VMOVUPS
store to memory)
INSTRUCCIONES
VPAVGB, VPAVGW, VPMAXUB, VPMAXUW, VPMAXSB, VPMAXSW, VPMINUB,

Aritmética (suma, VPMINUW, VPMINSB, VPMINSW, VPADDQ, VPUSBQ
sustracción, multiplicación, VADDPS, VSUBPS, VMULPS, VDIVPS,
multiplicar y sumar) VMAXPS, VMINPS, VRCPPS, VSQRTPS, VRSQRTPS
Comparación
Conversión (paquete) VPSHUFB, VPSHUFW, VPSHUFD
Conversión (desempaquetar)
Instrucciones lógicas
Desplazamiento y rotación
instrucciones


2.3. AVX
Instrucciones AVX genéricas.

● Incluye el prefijo V en la mayoría de las instrucciones de generaciones.
● Las instrucciones AVX pueden aplicarse a los registros xmm (128 bits) ymm (256
bits) o incluso zmm (512 bits).
Ejemplo:
VMOVAPS xmm1, xmm2/m128

VMOVAPS ymm1, ymm2/m256
VMOVAPS zmm1, zmm2/m512
(Mueve 4, 8 o 16 valores de coma flotante de precisión simple del operando origen

al operando destino)

2.3. AVX
Instrucciones aritméticas. Suma, resta y multiplicación.

● VPADD[S][US][B][W] ymm1, ymm2, ymm3/m256. Suma datos empaquetados de 8/16 bits
con signo en ymm2 e ymm3/m256, y almacena los resultados saturados (con o sin signo) en
ymm1.
● VPSUB[S][US][B][W][D] ymm1, ymm2, ymm3/m256. Subraya los datos empaquetados de
8/16 bits con signo en ymm3/m256 desde ymm2, y almacena los resultados saturados (con o
sin signo) en ymm1.
● VPMULDQ ymm1, ymm2, ymm3/m256. Multiplica los enteros enteros con signo y almacena
los resultados de cuatro palabras en ymm1.
255 224 223 192 191 160 159 128 127 96 95 64 63 32 31 0
x x x x
255 224 223 192 191 160 159 128 127 96 95 64 63 32 31 0
255 192 191 128 127 64 63 0


2.3. AVX
Instrucciones de barajado. Mezcla de datos en el lugar de destino operando (poner los

datos en cualquier lugar, en cualquier orden).
● PSHUFB xmm1, xmm2/m128. Baraja los bytes de xmm1 según el contenido de xmm2, y
almacena el resultado en xmm1. Esta instrucción utiliza los niveles inferiores del
operando fuente como índice para copiar los bytes en el operando destino. Se copia un 0
si el byte de origen es mayor que 127. Ejemplo:
xmm0=(10,11,8,6,6,4,128,15,11,14,12,14,5,5,7,2)
xmm1=(105,17,122,47,40,54,224,73,24,144,49,154,46,109,13,98)
PSHUFB xmm1, xmm0

(98 corresponde al índice 0, 13 al 1, 109 al 2, 46 al 3, 154 al 4, ...)
xmm0=(54,40,73,144,144,154,0,105,40,17,47,17,49,49,24,109)
● VPSHUFB ymm1, ymm2, ymm3/m256. Baraja los bytes en ymm2 según el contenido de
ymm3, y almacena el resultado en ymm1.
3. Otras extensiones SIMD

3. Otras extensiones SIMD
● ¡3DNow! Instrucciones SIMD en los procesadores AMD para aplicaciones

multimedia y de coma flotante intensivas.
● NEON. Instrucciones SIMD en procesadores ARM para dispositivos Android.
● VMX/AltiVec. Power Vector Media Extensión, instrucciones SIMD en los

procesadores PowerPC. Utilizado en los ordenadores y XBox 360.
● MDMX, MIPS-3D. Instrucciones SIMD para procesadores MIPS para acelerar

aplicaciones multimedia.

4. Programación

4. Programación
● Muchas formas de introducir la vectorización en los programas:
"Debo tener el compilador de Intel, ha acelerado nuestra aplicación

por dos".
"He dejado de utilizar el compilador de Intel. Cada vez que envío el

producto a un cliente, se quejan de que la aplicación se bloquea".

4. Programación
Muchas formas de introducir la vectorización en los programas:
● Multiversiones de funciones. Las funciones críticas o frecuentes pueden

programarse en varias versiones para adaptarse a las capacidades específicas de la
CPU que ejecuta el programa que las contiene.
● Despacho de la CPU: Detección durante el tiempo de ejecución de las capacidades

de la CPU y llamar a la versión adecuada de la función. Utilizar la instrucción CPUID.
● Cargas adicionales: trabajo de codificación extra, implementación de de los

mecanismos de envío.

4. Programación
● Lenguaje ensamblador
○Permite utilizar plenamente las posibilidades SIMD.
○ Difícil de programar. Requiere un conocimiento profundo del Modo de
funcionamiento SIMD.
● Compilador intrínseco o macros SIMD
○ Funciones que permiten acceder a las instrucciones MMX desde un lenguaje de
programación de alto nivel.
○ También requieren un conocimiento profundo de SIMD.
○ Ejemplo:
_m64 (contenido del registro MMX)
_m128 (4 FP de precisión simple)
_m128 (2 FP de doble precisión)
_m128i (enteros empaquetados 8, 16, 32 o 64)

4. Programación
● Intrínsecos. Las funciones de estilo C proporcionan acceso a las instrucciones SIMD
sin necesidad de utilizar código ensamblador (incluya los correspondientes archivos
de cabecera .h). Ejemplos:
○ pcmeqb se convierte en __m64 _mm_cmpeq_pi8 (__m64 a, __m64 b); [#include

<mmintrin.h>]
○ addps pasa a ser __m128 _mm_add_ps (__m128 a, __m128 b) ; [#include
<xmmintrin.h>]
○ vmovaps se convierte en __m256 _mm256_load_ps (float const * mem_addr); [
#include <immintrin.h> ]
○ Ver:
https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=3300,4101,285
para todas las instrucciones y su versión intrínseca.
4. Programación
Compilador intrínseco o macros SIMD
vector_x_matrix_4x4(MMX64 *v, MMX64 *m)

{ MMX64 v0101, v2323, t0, t1, t2, t3;
V0101 = punpckldq(v,v) /* desempaquetar v0 y v1 con ellos mismos */
V2323 = punpckhdq(v,v) /* desempaquetar v2 y v3 con ellos mismos */
t0=pmaddwd(v0101,m[0])/* multiplicar v0 y v1 con las 2 primeras filas*/
t1=pmaddwd(v2323,m[1])/* multiplicar v2 y v3 con las dos primeras filas*/
t2=pmaddwd(v0101,m[2])/* multiplicar v0 y v1 con las dos últimas filas*/
t3=pmaddwd(v2323,m[3])/* multiplicar v2 y v3 con las dos últimas filas*/
t0=paddd(t0,t1)/* sumar la primera mitad de las primeras filas con la segunda mitad*/
t2=paddd(t2,t3)/* sumar la primera mitad de las últimas filas con la segunda mitad*/
v=packssdw(t0,t2)/* empaquetar resultados de 32b a 16b con saturación*/
}/*reordenar la matriz 4x4 por un vector de 4 elementos*/

4. Programación
Compilador intrínseco o macros SIMD
vector_x_matrix_4x4(MMX64 *v, MMX64 *m)
PMADDWD V0 V1 V0 V1 V2 V3 V2 V3
X X X X X X X X
M00 M01 M10 M11 M02 M03 M12 M13
V0xM00+V1xM01 V0xM10+V1xM11 V2xM02+V3xM03 V2xM12+V3xM13

4. Programación
● Clases y bibliotecas
○ Proporcionan una abstracción de programación SIMD

○ Fácil de programar, no se requieren conocimientos de SIMD
○ Ejemplo: Intel Perfomance Libraries (IPP) (Windows y Linux)
http://www.intel.com/software/products/perflib/
■ Funciones de procesamiento de imágenes, procesamiento de señales, vídeo,

reconocimiento, etc.
■ Ejemplo de binarización de imágenes:
iplThreshold(buffer_src, buffer_dst, threshold)

4. Programación
● Autovectorization
○ Fácil de programar, pero requiere un compilador capaz de realizar la auto
vectorización.
○ Ejemplo: Compilador Intel C++ (Windows y Linux). Proporciona también
programación intrínseca y clases para programación SIMD
http://www.intel.com/software/products/compilers/
for (i=0;i<128000;i++)
pointer1[i]=pointer2[i]+50;
for (i=0;i<128000;i+=8)
pointer1[i:i+8]=pointer2[i:i+8]+50;

4. Programación
● Utilizar AVX sin escribir código AVX.Intel Parallel Studio
● Compilar utilizando el interruptor del compilador /QaxAVX.

● Auto Vectorización utilizando el nivel de optimización /O2 o superior.
○ Utilice el informe de vectorización para obtener información sobre lo que se
vectoriza y lo que no se vectorizada vectorizado: /Qvec-report=3.
○ Utilice pragmas para proporcionar información adicional para ayudar con el
proceso de auto vectorización: #pragma simd, #pragma vector aligned, .... (véase
● Guía de referencia y del usuario del compilador Intel C++ XE) Intel Cilk Plus: Es una
extensión de los lenguajes C y C++ para soportar el paralelismo de datos y tareas.
● Bibliotecas Intel IPP y MKL: Miles de funciones altamente optimizadas para
aplicaciones multimedia, de procesamiento de datos, criptográficas y de
comunicaciones. Para AVX, hay aproximadamente 175 funciones optimizadas
optimizadas.
Estructura de computadores

Extensiones Multimedia

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Extensiones Multimedia

Cargado por

Copyright:

Formatos disponibles

Extensiones multimedia

Computer Structure 1 Higher Polytechnic School of Alcoy

Computer Structure 2 Higher Polytechnic School of Alcoy

Computer Structure 3 Higher Polytechnic School of Alcoy

● Tales aplicaciones requieren un fuerte procesamiento matemático y

● Aparecieron las extensiones multimedia, como una versión limitada del

La misma instrucción es ejecutada por "múltiples procesadores" utilizando

Computer Structure 5 Higher Polytechnic School of Alcoy

Computer Structure 6 Higher Polytechnic School of Alcoy

○ También conocido como sub-word parallel instructions.

○ También conocido como short vector instructions.

Computer Structure 7 Higher Polytechnic School of Alcoy

add.vv v3, v1, v2

Computer Structure 8 Higher Polytechnic School of Alcoy

Computer Structure 9 Higher Polytechnic School of Alcoy

Menos volumen Más complejo

Más volumen Menos complejo

Computer Structure 10 Higher Polytechnic School of Alcoy

● Standard benchmark kernels (multiplicación de matrices, FFT, Convolución,

Computer Structure 11 Higher Polytechnic School of Alcoy

Computer Structure 12 Higher Polytechnic School of Alcoy

Assembler code Control del programador

Vector intrinsic (mm_add_ps())

SIMD intrinsic class (F32vec4 add)

Manual CPU dispatch (__declspec(cpu_dispatch...))

User mandated vectorization (SIMD directive)

Compiler: auto vectorization hints (#pragma ivdep…)

Cilk plus array notation

Compiler: Fully automatic vectorization

Use performance libraries (IPP, MKL, etc.) Facilidad de uso

Computer Structure 13 Higher Polytechnic School of Alcoy

○ Análisis coste-beneﬁcio realizado sobre un conjunto de aplicaciones

■ (el 10% del código se lleva el 90% del tiempo de ejecución)

Computer Structure 14 Higher Polytechnic School of Alcoy

● Prioridad 1: Mejorar signiﬁcativamente el rendimiento en aplicaciones

Computer Structure 15 Higher Polytechnic School of Alcoy

2. SIMD en los procesadores Intel

Computer Structure 16 Higher Polytechnic School of Alcoy

2. SIMD en los procesadores Intel.

Computer Structure 17 Higher Polytechnic School of Alcoy

2. SIMD en los procesadores Intel.

Computer Structure 18 Higher Polytechnic School of Alcoy

2. SIMD en los procesadores Intel

Computer Structure 19 Higher Polytechnic School of Alcoy

2. SIMD en los procesadores Intel.

● Introducida por Intel en el año 1997.

Computer Structure 20 Higher Polytechnic School of Alcoy

2. SIMD en los procesadores Intel.

● 8 registros: mm0-mm7. Situados en la unidad FP. Registros superpuestos.

2. SIMD en los procesadores Intel.

● La utilización compartida de los registros de coma ﬂotante y MMX previene la ejecución

Computer Structure 22 Higher Polytechnic School of Alcoy

2. SIMD en los procesadores Intel.

● Una solución eﬁcaz debe abordar los siguientes temas:

Computer Structure 23 Higher Polytechnic School of Alcoy

2. SIMD en los procesadores Intel.

● Packed double word. 2 dword

Computer Structure 24 Higher Polytechnic School of Alcoy

2. SIMD en los procesadores Intel.

Aritmética de saturación y envolvente (Wraparound and saturation arithmetic). En un modelo

Wraparound (aritmética modular) Saturación

Utiliza el valor máximo.

Retira los bits sobrantes

w13 * w23 w12w22 w11w21 w10*w20

mmi w13w23[0..15] w12w22[0..15] w11w21[0..15] w10w20[0..15]