Operaciones SIMD

Presenter Notes

Resumen:

  • Motivación.
  • Historia.
  • Set de instrucciones.
  • Como escribir código SIMD.
  • Clase que viene.

Nicolás Wolovick, $Date: 2012-04-12 19:49:47 -0300 (Thu, 12 Apr 2012) $, $Revision: 3396 $

Presenter Notes

Taxonomía de Flynn

Flynn's taxonomy

Presenter Notes

Motivación

Multiplicación punto a punto: cs = map (uncurry (*)) (zip as bs)

1 int main(void) {
2     unsigned int i=0;
3     for (i=0; i<N; ++i) {
4         a[i] = b[i]*c[i];
5     }
6     return 0;
7 }

Medición gcc -O2

1 Performance counter stats for './multmap' (4 runs):
2 
3    100,830,044 instructions:u            #    1.18  insns per cycle          ( +-  0.00% )
4     85,465,952 cycles:u                  #    0.000 GHz                      ( +-  0.01% )
5     110.614890 cpu-clock:u                ( +-  1.93% )
6 
7    0.111786299 seconds time elapsed                                          ( +-  2.30% )

gcc -O2 -S

1 .L2:
2     movss   b(%rax), %xmm0
3     mulss   c(%rax), %xmm0
4     movss   %xmm0, a(%rax)
5     addq    $4, %rax
6     cmpq    $67108864, %rax
7     jne .L2

Presenter Notes

Máximo grado de optimización

1 int main(void) {
2     unsigned int i=0;
3     for (i=0; i<N; ++i) {
4         a[i] = b[i]*c[i];
5     }
6     return 0;
7 }

Medición gcc -O3

1 Performance counter stats for './multmap' (4 runs):
2 
3     25,332,566 instructions:u            #    0.45  insns per cycle          ( +-  0.00% )
4     56,890,583 cycles:u                  #    0.000 GHz                      ( +-  0.03% )
5      95.927188 cpu-clock:u                ( +-  0.58% )
6 
7    0.096696426 seconds time elapsed                                          ( +-  0.74% )

gcc -O3 -S

1 .L2:
2     movaps  b(%rax), %xmm0
3     mulps   c(%rax), %xmm0
4     movaps  %xmm0, a(%rax)
5     addq    $16, %rax
6     cmpq    $67108864, %rax
7     jne .L2

Presenter Notes

Looking for 4x speedups?™

SSE to rescue!

  • Procesa 4 f32 a la vez.
  • movaps, mulps es la clave.
  • Notar el addq $16, %rax.

Sin embargo

  • No reporta tantas mejoras en CPU-time 110/95: 15% más rápido.
  • En ciclos 56/85: 45% menos ciclos.
  • Conclusión: es memory bound. Ya veremos ejemplos mejores.

Presenter Notes

Nacimiento

These extensions were originally called subword parallelism or vector. Since Intel marketing used SIMD to describe the MMX extension of the 80x86 announced in 1996, that became the popular name, due in part to a successful television advertising campaign involving disco dancers wearing clothing mod- eled after the cleansuits worn in semiconductor fabrication lines.

Publicidad de 1997 para Pentium II con extensiones MMX.

(Hennessy, Patterson, CAAQA5, L-48)

Presenter Notes

Historia

SIMD en x86, línea de tiempo

CS263-2300 ETH

Presenter Notes

Línea de tiempo de SSE

Evolución de SSE

(©2007, Intel)

Presenter Notes

Otros sets de instrucciones SIMD

Otras ISAs SIMD

(CS263-2300 ETH)

Presenter Notes

Set de instrucciones

Presenter Notes

SSE{2,3,4}, tipos de datos

SSE2 datatypes

(©2007, Intel)

Presenter Notes

SSE ISA

Memory-to-register/register-to-memory/register-to-register data movement Scalar– MOVSS Packed – MOVAPS, MOVUPS, MOVLPS, MOVHPS, MOVLHPS, MOVHLPS

Arithmetic Scalar – ADDSS, SUBSS, MULSS, DIVSS, RCPSS, SQRTSS, MAXSS, MINSS, RSQRTSS Packed – ADDPS, SUBPS, MULPS, DIVPS, RCPPS, SQRTPS, MAXPS, MINPS, RSQRTPS

Compare Scalar – CMPSS, COMISS, UCOMISS Packed – CMPPS

Data shuffle and unpacking Packed – SHUFPS, UNPCKHPS, UNPCKLPS

Data-type conversion Scalar – CVTSI2SS, CVTSS2SI, CVTTSS2SI Packed – CVTPI2PS, CVTPS2PI, CVTTPS2PI

Bitwise logical operations Packed – ANDPS, ORPS, XORPS, ANDNPS

...

Cache and Memory management ... MOVNTQ, MOVNTPS, MASKMOVQ, PREFETCH0, PREFETCH1, PREFETCH2, PREFETCHNTA, SFENCE

(Wikipedia, Streaming SIMD Extensions)

Presenter Notes

Convención de nombres

Movimientos

MOV <alineamiento> <alcance> <precisión>

MOVAPS

  • Alineamiento: aligned.
  • Alcance: packed.
  • Precisión: single.

Aritméticas y booleanas

<operación> <alcance> <precisión>

RSQRTPS

  • Operación: rsqrt, 1/√x.
  • Alcance: packed.
  • Precisión: single.

ADDPD solo a partir de SSE2.

Presenter Notes

SSE, movimientos

SSE movimientos

Memory-to-register/register-to-memory/register-to-register data movement

Scalar– MOVSS

Packed – MOVAPS, MOVUPS, MOVLPS, MOVHPS, MOVLHPS, MOVHLPS

(Song Ho Ahn, SSE)

Presenter Notes

SSE, aritméticas

Diferencia entre scalar y packed.

SSE aritméticas

Acá está el 4x publicitado por Intel.

Presenter Notes

SSE, aritméticas, tabla

SSE tabla aritméticas

No hay trascendentales! sin, cos, etc.

(Song Ho Ahn, SSE)

Presenter Notes

SSE, mezclas

shufps: Shuffle Parallel Scalars

shufps op1, op2, op3

op1: 4x f32.

op2: 4x f32.

op3: contains an 8-bit map dd:cc:bb:aa (MSB to LSB).

1 op1[0] = op1[aa]
2 op1[1] = op1[bb]
3 op1[2] = op2[cc]
4 op1[3] = op2[dd]

Presenter Notes

SSE, mezclas, ejemplos

Broadcast Difusión

Swap Intercambio

(Song Ho Ahn, SSE)

Presenter Notes

SSE, mas mezclas

unpcklps, unpckhps

unpcklps, unpckhps

(Song Ho Ahn, SSE)

Presenter Notes

¿Para qué tanto shuffle?

Ejemplo. Meter 4 f32 desperdigados por la memoria.

carga de 4 f32

(CS263-2300 ETH)

Presenter Notes

SSE, Conversión de tipos

  • Scalar: CVTSI2SS, CVTSS2SI, CVTTSS2SI
  • Packed: CVTPI2PS, CVTPS2PI, CVTTPS2PI

Conversiones de tipo

Versiones de f32 -> int que redondean o truncan.

(Song Ho Ahn, SSE)

Presenter Notes

SSE, aun más

  • Comparación.
  • Operadores bitwise.
  • Aritmética entera.
  • Manejo de caché.
    • Prefetching a L1 y/o L2.

Presenter Notes

SSE2

Pentium 4 (2000)

  • Versiones f64, usando d como sufijo: addpd.
  • Extensión de todas las operaciones de enteros a los registros XMM.
    • En SSE, los enteros trabajaban sobre los primeros 64 bits.

Single vs. double precision

(CS263-2300 ETH)

Presenter Notes

SSE3

Pentium 4 Prescott (2004)

Operaciones horizontales

haddps (Horizontal-Add-Packed-Single)

Input: { A0, A1, A2, A3 }, { B0, B1, B2, B3 }

Output: { A0 + A1, A2 + A3, B0 + B1, B2 + B3 }

hsubps ...

Números complejos

addsubps — (Add-Subtract-Packed-Single)

Input: { A0, A1, A2, A3 }, { B0, B1, B2, B3 }

Output: { A0 − B0, A1 + B1, A2 − B2, A3 + B3 }

movddup, movshdup, movsldu

Presenter Notes

SSE3, Ejemplo