Come trovare il massimo orizzontale in un vettore AVX a 256 bit

Question

Ho un vettore __m256d pieno di quattro valori a virgola mobile a 64 bit.
Ho bisogno di trovare il massimo orizzontale degli elementi del vettore e di memorizzare il risultato in un valore scalare a doppia precisione;

I miei tentativi hanno finito per utilizzare molto il rimescolamento degli elementi vettoriali, rendendo il codice non molto elegante né efficiente. Inoltre, ho trovato impossibile rimanere solo nel dominio AVX. A un certo punto ho dovuto usare le istruzioni SSE a 128 bit per estrarre il valore finale a 64 bit. Tuttavia, mi piacerebbe essere smentito in quest'ultima affermazione.

Quindi la soluzione ideale sarà:
1) utilizzare solo le istruzioni AVX.
2) ridurre al minimo il numero di istruzioni. (Spero di non più di 3-4 istruzioni)

Detto questo, qualsiasi soluzione elegante/efficiente sarà accettata, anche se non aderisce alle linee guida di cui sopra.

Grazie per qualsiasi aiuto.

-Luigi

Answer 1

Non penso che tu possa fare molto meglio di 4 istruzioni: 2 shuffles e 2 confronti.

__m256d x = ...; // input 

__m128d y = _mm256_extractf128_pd(x, 1); // extract x[2], and x[3] 
__m128d m1 = _mm_max_pd(x, y); // m1[0] = max(x[0], x[2]), m1[1] = max(x[1], x[3]) 
__m128d m2 = _mm_permute_pd(m1, 1); // set m2[0] = m1[1], m2[1] = m1[0] 
__m128d m = _mm_max_pd(m1, m2); // both m[0] and m[1] contain the horizontal max(x[0], x[1], x[2], x[3]) 

modifica banale per funzionare solo con vettori a 256 bit:

__m256d x = ...; // input 

__m256d y = _mm256_permute2f128_pd(x, x, 1); // permute 128-bit values 
__m256d m1 = _mm256_max_pd(x, y); // m1[0] = max(x[0], x[2]), m1[1] = max(x[1], x[3]), etc. 
__m256d m2 = _mm256_permute_pd(m1, 5); // set m2[0] = m1[1], m2[1] = m1[0], etc. 
__m256d m = _mm256_max_pd(m1, m2); // all m[0] ... m[3] contain the horizontal max(x[0], x[1], x[2], x[3]) 

(non testato)

Answer 2

Il modo generale di fare questo per un vettore v1 = [A, B, C, D] è

1. Permute v1-v2 = [C, D, A, B] (0a swap e 2 ° elementi, e il 1 ° e 3 ° quelli)
2. Prendere il max ; Ad esempio v3 = max(v1,v2). Ora hai [max(A,C), max(B,D), max(A,C), max(B,D)]
3. Permuta v3 a v4, scambiando gli elementi 0 ° e 1 ° e 2 ° e 3 °.
4. Riprendere il massimo, ovvero v5 = max(v3,v4). Ora v5 contiene il massimo orizzontale in tutti i suoi componenti.

particolare per AVX, le permutazioni può essere fatto con _mm256_permute_pd ei massimi può essere fatto con _mm256_max_pd. Non ho le maschere di permutazione esatte a portata di mano, ma dovrebbero essere abbastanza semplici da capire.

Spero che questo aiuti.

Answer 3

//Use the code to find the horizontal maximum 
__m256 v1 = initial_vector;//example v1=[1 2 3 4 5 6 7 8] 
__m256 v2 = _mm256_permute_ps(v1,(int)147);//147 is control code for rotate left by upper 4 elements and lower 4 elements separately v2=[2 3 4 1 6 7 8 5] 
__m256 v3 = _mm256_max_ps(v1,v2);//v3=[2 3 4 4 6 7 8 8] 
__m256 v4 = _mm256_permute_ps(v3,(int)147);//v4=[3 4 4 2 7 8 8 6] 
__m256 v5 = _mm256_max_ps(v3,v4);//v5=[3 4 4 4 7 8 8 8] 
__m256 v6 = _mm256_permute_ps(v5,(int)147);//v6=[4 4 4 3 8 8 8 7] 
__m256 v7 = _mm256_max_ps(v5,v6);//contains max of upper four elements and lower 4 elements. v7=[4 4 4 4 8 8 8 8] 

//to get max of this horizontal array. Note that either upper or lower can contain the maximum 
float ALIGN max_array[8]; 
float horizontal_max; 
_mm256_store_ps(max_array, v7); 
if(max_array[0] > max_array[7]) 
{ 
    horizontal_max = max_array[0]; 
} 
else 
{ 
    horizontal_max = max_array[7]; 
}