Caricamento dati per estensioni vettoriali GCC

Question

GCC vector extensions offre un modo piacevole e abbastanza portatile per accedere ad alcune istruzioni SIMD su diverse architetture hardware senza ricorrere a hardware specific intrinsics (o auto-vettorizzazione).

Un caso di utilizzo reale, sta calcolando un semplice checksum additivo. L'unica cosa che non è chiara è come caricare in sicurezza i dati in un vettore.

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; 
} 

Casting un puntatore al tipo di vettore sembra funzionare, ma io sono preoccupato che questo potrebbe esplodere in modo orribile se SIMD hardware si aspetta che i tipi di vettore da allineare correttamente.

L'unica altra opzione che ho pensato è usare un vettore temporaneo e caricare esplicitamente i valori (tramite una memcpy o un assegnamento element-wise), ma nel test questo contrasta la maggior parte dell'uso accelerato delle istruzioni SIMD. Idealmente immagino che si tratti di una generica funzione __builtin_load(), ma nessuna sembra esistere.

Qual è un modo più sicuro di caricare i dati in un vettore che mette in pericolo i problemi di allineamento?

Answer 1

Si potrebbe utilizzare un inizializzatore per caricare i valori, vale a dire fare

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

e spero che GCC trasforma questo in un'istruzione di carico SSE. Lo verificherei con un dissomemblatore, però ;-). Inoltre, per prestazioni migliori, si tenta di rendere allineato 16-byte buf e informare il compilatore tramite un attributo aligned. Se è possibile garantire che il buffer di input sia allineato, elaborarlo a byte finché non si raggiunge un limite di 16 byte.

Answer 2

Modifica (grazie Peter Cordes) Si può lanciare puntatori:

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

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

Questo compila per vmovdqa per caricare e vmovups da memorizzare. Se i dati non sono allineati, impostare aligned (1) per generare vmovdqu. (godbolt)

noti che ci sono anche diversi builtins scopi speciali per il carico e scarico di questi registri (Edit 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 

Sembra essere necessario utilizzare -flax-vector-conversions andare da char s a v16qi con questa funzione.

Consulta anche: C - How to access elements of vector using GCC SSE vector extension
Consulta anche: SSE loading ints into __m128

(Suggerimento:. La frase migliore per google è qualcosa come "gcc carico __m128i")