Vettorizzazione del calcolo del prodotto a punti utilizzando SSE4

Vettorizzazione del calcolo del prodotto a punti utilizzando SSE4


Sto cercando di migliorare questo codice con il prodotto SSE4 dot ma ho difficoltà a trovare una soluzione. Questa funzione ottiene i parametri qi e tj che contengono array float con 80 celle ciascuno e quindi calcola il prodotto scalare. Il valore restituito è un vettore con quattro prodotti scalari. Quindi quello che sto cercando di fare è calcolare quattro prodotti scalari di venti valori in parallelo.


Hai qualche idea su come migliorare questo codice?


inline __m128 ScalarProd20Vec(__m128* qi, __m128* tj)
{
__m128 res=_mm_add_ps(_mm_mul_ps(tj[0],qi[0]),_mm_mul_ps(tj[1],qi[1]));
res=_mm_add_ps(res,_mm_add_ps(_mm_mul_ps(tj[2],qi[2]),_mm_mul_ps(tj[3],qi[3])));
res=_mm_add_ps(res,_mm_add_ps(_mm_mul_ps(tj[4],qi[4]),_mm_mul_ps(tj[5],qi[5])));
res=_mm_add_ps(res,_mm_add_ps(_mm_mul_ps(tj[6],qi[6]),_mm_mul_ps(tj[7],qi[7])));
res=_mm_add_ps(res,_mm_add_ps(_mm_mul_ps(tj[8],qi[8]),_mm_mul_ps(tj[9],qi[9])));
res=_mm_add_ps(res,_mm_add_ps(_mm_mul_ps(tj[10],qi[10]),_mm_mul_ps(tj[11],qi[11])));
res=_mm_add_ps(res,_mm_add_ps(_mm_mul_ps(tj[12],qi[12]),_mm_mul_ps(tj[13],qi[13])));
res=_mm_add_ps(res,_mm_add_ps(_mm_mul_ps(tj[14],qi[14]),_mm_mul_ps(tj[15],qi[15])));
res=_mm_add_ps(res,_mm_add_ps(_mm_mul_ps(tj[16],qi[16]),_mm_mul_ps(tj[17],qi[17])));
res=_mm_add_ps(res,_mm_add_ps(_mm_mul_ps(tj[18],qi[18]),_mm_mul_ps(tj[19],qi[19])));
return res;
}

Risposte:


Delle centinaia di esempi SSE che ho visto su SO, il tuo codice è uno dei pochi che è già in buone condizioni dall'inizio. Non hai bisogno dell'istruzione SSE4 dot-product. (Puoi fare di meglio!)


Tuttavia, c'è una cosa che puoi provare: (Dico di provare perché non ho ancora cronometrato.)


Attualmente hai una catena di dipendenza dai dati su res . L'aggiunta del vettore è di 3-4 cicli sulla maggior parte delle macchine oggi. Quindi il tuo codice richiederà un minimo di 30 cicli per essere eseguito poiché hai:


(10 additions on critical path) * (3 cycles addps latency) = 30 cycles

Quello che puoi fare è dividere il nodo res variabile come segue:


__m128 res0 = _mm_add_ps(_mm_mul_ps(tj[ 0],qi[ 0]),_mm_mul_ps(tj[ 1],qi[ 1]));
__m128 res1 = _mm_add_ps(_mm_mul_ps(tj[ 2],qi[ 2]),_mm_mul_ps(tj[ 3],qi[ 3]));
res0 = _mm_add_ps(res0,_mm_add_ps(_mm_mul_ps(tj[ 4],qi[ 4]),_mm_mul_ps(tj[ 5],qi[ 5])));
res1 = _mm_add_ps(res1,_mm_add_ps(_mm_mul_ps(tj[ 6],qi[ 6]),_mm_mul_ps(tj[ 7],qi[ 7])));
res0 = _mm_add_ps(res0,_mm_add_ps(_mm_mul_ps(tj[ 8],qi[ 8]),_mm_mul_ps(tj[ 9],qi[ 9])));
res1 = _mm_add_ps(res1,_mm_add_ps(_mm_mul_ps(tj[10],qi[10]),_mm_mul_ps(tj[11],qi[11])));
res0 = _mm_add_ps(res0,_mm_add_ps(_mm_mul_ps(tj[12],qi[12]),_mm_mul_ps(tj[13],qi[13])));
res1 = _mm_add_ps(res1,_mm_add_ps(_mm_mul_ps(tj[14],qi[14]),_mm_mul_ps(tj[15],qi[15])));
res0 = _mm_add_ps(res0,_mm_add_ps(_mm_mul_ps(tj[16],qi[16]),_mm_mul_ps(tj[17],qi[17])));
res1 = _mm_add_ps(res1,_mm_add_ps(_mm_mul_ps(tj[18],qi[18]),_mm_mul_ps(tj[19],qi[19])));
return _mm_add_ps(res0,res1);

Questo quasi taglia a metà il tuo percorso critico. Si noti che a causa della non associatività in virgola mobile, questa ottimizzazione è illegale per i compilatori.



Ecco una versione alternativa che utilizza la divisione dei nodi a 4 vie e le istruzioni AMD FMA4. Se non riesci a utilizzare le addizioni di moltiplicazione fusa, sentiti libero di dividerle. Potrebbe essere comunque migliore della prima versione precedente.


__m128 res0 = _mm_mul_ps(tj[ 0],qi[ 0]);
__m128 res1 = _mm_mul_ps(tj[ 1],qi[ 1]);
__m128 res2 = _mm_mul_ps(tj[ 2],qi[ 2]);
__m128 res3 = _mm_mul_ps(tj[ 3],qi[ 3]);
res0 = _mm_macc_ps(tj[ 4],qi[ 4],res0);
res1 = _mm_macc_ps(tj[ 5],qi[ 5],res1);
res2 = _mm_macc_ps(tj[ 6],qi[ 6],res2);
res3 = _mm_macc_ps(tj[ 7],qi[ 7],res3);
res0 = _mm_macc_ps(tj[ 8],qi[ 8],res0);
res1 = _mm_macc_ps(tj[ 9],qi[ 9],res1);
res2 = _mm_macc_ps(tj[10],qi[10],res2);
res3 = _mm_macc_ps(tj[11],qi[11],res3);
res0 = _mm_macc_ps(tj[12],qi[12],res0);
res1 = _mm_macc_ps(tj[13],qi[13],res1);
res2 = _mm_macc_ps(tj[14],qi[14],res2);
res3 = _mm_macc_ps(tj[15],qi[15],res3);
res0 = _mm_macc_ps(tj[16],qi[16],res0);
res1 = _mm_macc_ps(tj[17],qi[17],res1);
res2 = _mm_macc_ps(tj[18],qi[18],res2);
res3 = _mm_macc_ps(tj[19],qi[19],res3);
res0 = _mm_add_ps(res0,res1);
res2 = _mm_add_ps(res2,res3);
return _mm_add_ps(res0,res2);