multiplicación SSE 16 x uint8_t

Question

Quiero multiplicar con SSE4 un objeto __m128i con 16 enteros de 8 bits sin signo, pero solo pude encontrar un valor intrínseco para multiplicar números enteros de 16 bits. ¿No hay nada como _mm_mult_epi8?

Answer 1

No hay multiplicación de 8 bits en MMX/SSE/AVX. Sin embargo, puede emular a 8 bits multiplicación intrínseca mediante la multiplicación de 16 bits de la siguiente manera:

inline __m128i _mm_mullo_epi8(__m128i a, __m128i b) 
{ 
    __m128i zero = _mm_setzero_si128(); 
    __m128i Alo = _mm_cvtepu8_epi16(a); 
    __m128i Ahi = _mm_unpackhi_epi8(a, zero); 
    __m128i Blo = _mm_cvtepu8_epi16(b); 
    __m128i Bhi = _mm_unpackhi_epi8(b, zero); 
    __m128i Clo = _mm_mullo_epi16(Alo, Blo); 
    __m128i Chi = _mm_mullo_epi16(Ahi, Bhi); 
    __m128i maskLo = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0); 
    __m128i maskHi = _mm_set_epi8(14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80); 
    __m128i C = _mm_or_si128(_mm_shuffle_epi8(Clo, maskLo), _mm_shuffle_epi8(Chi, maskHi)); 

    return C; 
} 

Answer 2

La única instrucción de multiplicar SSE de 8 bits es PMADDUBSW (SSSE3 y posterior, C/C++ intrínseca: _mm_maddubs_epi16). Esto multiplica los valores de 16 x 8 bit sin signo por 16 x 8 bit con valores firmados y luego suma pares adyacentes para obtener resultados firmados de 8 x 16 bits. Si no puede usar esta instrucción más bien especializada, necesitará desempaquetar pares de vectores de 16 bits y usar instrucciones regulares de multiplicar de 16 bits. Obviamente, esto implica al menos un golpe de 2x, así que usa la multiplicación de 8 bits si puedes.

Answer 3

Una forma (potencialmente) más rápido que la solución de Marat basado en Agner Fog's solution:

En lugar de dividir alta/baja, dividida impar/par. Esto tiene el beneficio adicional de que funciona con SSE2 puro en lugar de requerir SSE4.1 (sin uso para el OP, pero es una buena bonificación añadida para algunos). También agregué una optimización si tienes AVX2. Técnicamente, la optimización de AVX2 solo funciona con SSE2 intrínsecos, pero es más lenta que la solución de desplazamiento a la izquierda y luego a la derecha.

__m128i mullo_epi8(__m128i a, __m128i b) 
{ 
    // unpack and multiply 
    __m128i dst_even = _mm_mullo_epi16(a, b); 
    __m128i dst_odd = _mm_mullo_epi16(_mm_srli_epi16(a, 8),_mm_srli_epi16(b, 8)); 
    // repack 
#ifdef __AVX2__ 
    // only faster if have access to VPBROADCASTW 
    return _mm_or_si128(_mm_slli_epi16(dst_odd, 8), _mm_and_si128(dst_even, _mm_set1_epi16(0xFF))); 
#else 
    return _mm_or_si128(_mm_slli_epi16(dst_odd, 8), _mm_srli_epi16(_mm_slli_epi16(dst_even,8), 8)); 
#endif 
} 

Agner utiliza el blendv_epi8 intrínseca con el apoyo SSE4.1.

Editar:

Curiosamente, después de hacer un trabajo más desmontaje (con optimizado construye), al menos mis dos implementaciones se compilan a exactamente la misma cosa. Ejemplo de desensamblaje dirigido a "ivy-bridge" (AVX).

vpmullw xmm2,xmm0,xmm1 
vpsrlw xmm0,xmm0,0x8 
vpsrlw xmm1,xmm1,0x8 
vpmullw xmm0,xmm0,xmm1 
vpsllw xmm0,xmm0,0x8 
vpand xmm1,xmm2,XMMWORD PTR [rip+0x281] 
vpor xmm0,xmm0,xmm1 

Utiliza la versión "optimizada para AVX2" con una constante de 128 bits xmm precompilada. Compilar solo con soporte SSE2 produce resultados similares (aunque usando instrucciones SSE2). Sospecho que la solución original de Agner Fog podría optimizarse para lo mismo (sería una locura si no fuera así). No tengo idea de cómo se compara la solución original de Marat en una compilación optimizada, aunque para mí tener un solo método para todas las extensiones x86 simd más nuevas que SSE2 e inclusive es bastante agradable.