Cargando datos para las extensiones vectoriales de GCC

Question

El vector extensions de GCC ofrece una forma agradable y razonablemente portátil de acceder a algunas instrucciones SIMD en diferentes arquitecturas de hardware sin recurrir a hardware specific intrinsics (o auto-vectorización).

Un caso de uso real, es el cálculo de una suma de comprobación aditiva simple. Lo único que no está claro es cómo cargar datos de forma segura en un vector.

typedef char v16qi __attribute__ ((vector_size(16))); 

static uint8_t checksum(uint8_t *buf, size_t size) 
{ 
    assert(size%16 == 0); 
    uint8_t sum = 0; 

    vec16qi vec = {0}; 
    for (size_t i=0; i<(size/16); i++) 
    { 
     // XXX: Yuck! Is there a better way? 
     vec += *((v16qi*) buf+i*16); 
    } 

    // Sum up the vector 
    sum = vec[0] + vec[1] + vec[2] + vec[3] + vec[4] + vec[5] + vec[6] + vec[7] + vec[8] + vec[9] + vec[10] + vec[11] + vec[12] + vec[13] + vec[14] + vec[15]; 

    return sum; 
} 

Al lanzar un puntero al tipo de vector parece funcionar, pero me preocupa que esto podría explotar de una manera horrible si el hardware SIMD espera que los tipos de vectores para estar alineados correctamente.

La única otra opción que he pensado es utilizar un vector temporal y cargar explícitamente los valores (mediante una asignación memcpy o element-wise), pero al probar esto se contrarrestan la mayor parte de la aceleración del uso de las instrucciones SIMD. Idealmente, me imagino que esto sería algo así como una función genérica __builtin_load(), pero ninguna parece existir.

¿Cuál es una forma más segura de cargar datos en un vector arriesgando problemas de alineación?

Answer 1

Se podría utilizar un inicializador para cargar los valores, es decir, hacer

const vec16qi e = { buf[0], buf[1], ... , buf[15] } 

y esperar que GCC convierte esto en una instrucción de carga ESS. Sin embargo, lo verificaría con un dissassembler ;-). Además, para un mejor rendimiento, intente alinear buf de 16 bytes e informe a ese compilador a través de un atributo aligned. Si puede garantizar que el búfer de entrada estará alineado, trátelo de forma continua hasta que haya alcanzado un límite de 16 bytes.

Answer 2

Editar (gracias Peter Cordes) Usted puede lanzar punteros:

typedef char v16qi __attribute__ ((vector_size (16), aligned (16))); 

v16qi vec = *(v16qi*)&buf[i]; // load 
*(v16qi*)(buf + i) = vec; // store whole vector 

Esto compila a vmovdqa para cargar y vmovups de almacenar. Si no se sabe que los datos están alineados, configure aligned (1) para generar vmovdqu. (godbolt)

Tenga en cuenta que también hay varios órdenes internas de propósito especial para la carga y descarga de estos registros (Editar 2):

v16qi vec = _mm_loadu_si128((__m128i*)&buf[i]); // _mm_load_si128 for aligned 
_mm_storeu_si128((__m128i*)&buf[i]), vec); // _mm_store_si128 for aligned 

Parece ser necesario el uso de -flax-vector-conversions pasar de char s a v16qi con esta función.

Consulte también: C - How to access elements of vector using GCC SSE vector extension
Consulte también: SSE loading ints into __m128

(Consejo:. La mejor frase para Google es algo así como "__m128i gcc carga")