Registro AVX2 compacto para que los enteros seleccionados sean contiguos según la máscara [duplicado]

Question

Esta pregunta ya tiene respuestas aquí.:

AVX2 ¿Cuál es la forma más eficiente de empacar a la izquierda basándose en una máscara? (4 respuestas)

Cerrado hace 3 años.

en la pregunta Optimización de la compactación de la matriz, la respuesta principal dice:

Los registros SSE/AVX con los últimos conjuntos de instrucciones permiten un mejor enfoque.Podemos usar el resultado de PMOVMSKB directamente, transformándolo en el registro de control de algo como PSHUFB.

¿Es esto posible con Haswell (AVX2)?¿O requiere uno de los sabores de AVX512?

Tengo un vector AVX2 que contiene int32s y un vector correspondiente del resultado de una comparación.Quiero mezclarlo de alguna manera para que los elementos con el msb correspondiente establecido en la máscara (comparar verdadero) sean contiguos en el extremo inferior del vector.

Lo mejor que puedo ver es obtener una máscara de bits con _mm256_movemask_ps/vmovmskps (¿no hay variante *d?) y luego usarla en una tabla de búsqueda de vectores 256 AVX2 para obtener una máscara aleatoria para el carril cruzado _mm256_permutevar8x32_epi32/vpermd

Answer 1

Lo primero que debe hacer es encontrar una función escalar rápida.Aquí hay una versión que no utiliza una rama.

inline int compact(int *x, int *y, const int n) {
    int cnt = 0;
    for(int i=0; i<n; i++) {
        int cut = x[i]!=0;
        y[cnt] = cut*x[i];
        cnt += cut;
    }
    return cnt;
}

El mejor resultado con SIMD probablemente dependa de la distribución de ceros.Si es escaso o denso.El siguiente código debería funcionar bien para distribuciones escasas o densas.Por ejemplo, tiradas largas de ceros y distintos de ceros.Si la distribución es más pareja no sé si este código tendrá algún beneficio.Pero de todos modos dará el resultado correcto.

Aquí hay una versión de AVX2 que probé.

int compact_AVX2(int *x, int *y, int n) {
    int i =0, cnt = 0;
    for(i=0; i<n-8; i+=8) {
        __m256i x4 = _mm256_loadu_si256((__m256i*)&x[i]);
        __m256i cmp = _mm256_cmpeq_epi32(x4, _mm256_setzero_si256());
        int mask = _mm256_movemask_epi8(cmp);
        if(mask == -1) continue; //all zeros
        if(mask) {
            cnt += compact(&x[i],&y[cnt], 8);
        }
        else {
            _mm256_storeu_si256((__m256i*)&y[cnt], x4);
            cnt +=8;
        }       
    }
    cnt += compact(&x[i], &y[cnt], n-i); // cleanup for n not a multiple of 8
    return cnt;
}

Aquí está la versión SSE2 que probé.

int compact_SSE2(int *x, int *y, int n) {
    int i =0, cnt = 0;
    for(i=0; i<n-4; i+=4) {
        __m128i x4 = _mm_loadu_si128((__m128i*)&x[i]);
        __m128i cmp = _mm_cmpeq_epi32(x4, _mm_setzero_si128());
        int mask = _mm_movemask_epi8(cmp);
        if(mask == 0xffff) continue; //all zeroes
        if(mask) {
            cnt += compact(&x[i],&y[cnt], 4);
        }
        else {
            _mm_storeu_si128((__m128i*)&y[cnt], x4);
            cnt +=4;
        }       
    }
    cnt += compact(&x[i], &y[cnt], n-i); // cleanup for n not a multiple of 4
    return cnt;
}

Aquí tienes una prueba completa.

#include <stdio.h>
#include <stdlib.h>
#if defined (__GNUC__) && ! defined (__INTEL_COMPILER)
#include <x86intrin.h>                
#else
#include <immintrin.h>                
#endif

#define N 50

inline int compact(int *x, int *y, const int n) {
    int cnt = 0;
    for(int i=0; i<n; i++) {
        int cut = x[i]!=0;
        y[cnt] = cut*x[i];
        cnt += cut;
    }
    return cnt;
}

int compact_SSE2(int *x, int *y, int n) {
        int i =0, cnt = 0;
        for(i=0; i<n-4; i+=4) {
            __m128i x4 = _mm_loadu_si128((__m128i*)&x[i]);
            __m128i cmp = _mm_cmpeq_epi32(x4, _mm_setzero_si128());
            int mask = _mm_movemask_epi8(cmp);
            if(mask == 0xffff) continue; //all zeroes
            if(mask) {
                cnt += compact(&x[i],&y[cnt], 4);
            }
            else {
                _mm_storeu_si128((__m128i*)&y[cnt], x4);
                cnt +=4;
            }       
        }
        cnt += compact(&x[i], &y[cnt], n-i); // cleanup for n not a multiple of 4
        return cnt;
    }

int compact_AVX2(int *x, int *y, int n) {
    int i =0, cnt = 0;
    for(i=0; i<n-8; i+=8) {
        __m256i x4 = _mm256_loadu_si256((__m256i*)&x[i]);
        __m256i cmp = _mm256_cmpeq_epi32(x4, _mm256_setzero_si256());
        int mask = _mm256_movemask_epi8(cmp);
        if(mask == -1) continue; //all zeros
        if(mask) {
            cnt += compact(&x[i],&y[cnt], 8);
        }
        else {
            _mm256_storeu_si256((__m256i*)&y[cnt], x4);
            cnt +=8;
        }       
    }
    cnt += compact(&x[i], &y[cnt], n-i); // cleanup for n not a multiple of 8
    return cnt;
}

int main() {
    int x[N], y[N];
    for(int i=0; i<N; i++) x[i] = rand()%10;
    //int cnt = compact_SSE2(x,y,N);
    int cnt = compact_AVX2(x,y,N);
    for(int i=0; i<N; i++) printf("%d ", x[i]); printf("\n");
    for(int i=0; i<cnt; i++) printf("%d ", y[i]); printf("\n");
}