Comment Calculer le Vecteur Produit scalaire à l'Aide de l'ESS Intrinsèque des Fonctions en C

Je suis en train de multiplier deux vecteurs ensemble où chaque élément d'un vecteur est multiplié par l'élément dans le même index à l'autre vecteur. Je veux la somme de tous les éléments du vecteur résultant pour obtenir un numéro. Par exemple, le calcul devrait ressembler à ceci pour les vecteurs {1,2,3,4} et {5,6,7,8}:

1*5+2*6+3*7+4*8

Essentiellement, je suis prenant le produit scalaire de deux vecteurs. Je sais qu'il y est une ESS commande pour le faire, mais la commande n'a pas une fonction intrinsèque associée. À ce stade, je ne veux pas écrire assembly en ligne dans mon code en C, donc je veux utiliser uniquement les fonctions intrinsèques. Cela semble être une commune de calcul, donc je suis surpris par moi-même que je ne pouvais pas trouver la réponse sur Google.

Remarque: je suis d'optimisation pour une micro-architecture qui prend en charge jusqu'à SSE 4.2.

Merci pour votre aide.

OriginalL'auteur Sam | 2010-11-08

  1. 18

    Si vous êtes en train de faire un produit scalaire de plus les vecteurs, l'utilisation de multiplier et régulière _mm_add_ps (ou FMA) à l'intérieur de la boucle interne. Enregistrer la somme horizontale jusqu'à la fin.

    Mais si vous faites un produit scalaire de juste une paire de SIMD vecteurs:

    GCC (au moins la version 4.3) comprend <smmintrin.h> avec SSE4.1 niveau intrinsèques, y compris le simple et double précision point des produits:

    _mm_dp_ps (__m128 __X, __m128 __Y, const int __M);
_mm_dp_pd (__m128d __X, __m128d __Y, const int __M);

    Sur Intel intégrer des Processeurs (pas Atom/Silvermont) elles sont un peu plus rapide que de le faire manuellement avec de multiples instructions.

    Mais sur AMD (y compris Ryzen), dpps est sensiblement plus lent. (Voir Agner le Brouillard de l'instruction tables)

    Comme un secours pour les processeurs plus anciens, vous pouvez utiliser cet algorithme pour créer le produit scalaire des vecteurs a et b:

    __m128 r1 = _mm_mul_ps(a, b);

    et puis horizontal somme r1 à l'aide de Moyen le plus rapide pour faire horizontale float somme vectorielle sur x86 (y voir une version commentée de cela, et pourquoi c'est plus rapide.)

    __m128 shuf   = _mm_shuffle_ps(r1, r1, _MM_SHUFFLE(2, 3, 0, 1));
__m128 sums   = _mm_add_ps(r1, shuf);
shuf          = _mm_movehl_ps(shuf, sums);
sums          = _mm_add_ss(sums, shuf);
float result =  _mm_cvtss_f32(sums);

    Une lente coûts alternatifs 2 shuffles par hadd, qui sera facilement goulot d'étranglement sur shuffle débit, en particulier sur les Processeurs Intel.

    r2 = _mm_hadd_ps(r1, r1);
r3 = _mm_hadd_ps(r2, r2);
_mm_store_ss(&result, r3);
    Comme une note, je tiens à souligner que le calcul du produit scalaire à l'aide de la dp intrinsèque est plus lent que de le faire la deuxième.
    cela dépend de votre matériel, il n'existe aucun cas qu'il est plus lent.
    Je pense qu'il y a de meilleurs moyens pour horizontal somme que l'utilisation de _mm_hadd_ps. Voir stackoverflow.com/a/35270026/195787.

    OriginalL'auteur caf

  2. 4

    Je dirais que le plus rapide de l'ESS de la méthode:

    static inline float CalcDotProductSse(__m128 x, __m128 y) {
    __m128 mulRes, shufReg, sumsReg;
    mulRes = _mm_mul_ps(x, y);

    //Calculates the sum of SSE Register - https://stackoverflow.com/a/35270026/195787
    shufReg = _mm_movehdup_ps(mulRes);        //Broadcast elements 3,1 to 2,0
    sumsReg = _mm_add_ps(mulRes, shufReg);
    shufReg = _mm_movehl_ps(shufReg, sumsReg); //High Half -> Low Half
    sumsReg = _mm_add_ss(sumsReg, shufReg);
    return  _mm_cvtss_f32(sumsReg); //Result in the lower part of the SSE Register
}

    J'ai suivi - Moyen le plus rapide pour Faire Horizontale Float Somme Vectorielle Sur x86.

    Superbe trouvaille, la ddp de l'habitat instructions étendre à plusieurs uop.

    OriginalL'auteur Royi

  3. 3

    J'ai écrit ce et compilé avec gcc -O3 -S -ftree-vectorize -ftree-vectorizer-verbose=2 sse.c

    void f(int * __restrict__ a, int * __restrict__ b, int * __restrict__ c, int * __restrict__ d,
       int * __restrict__ e, int * __restrict__ f, int * __restrict__ g, int * __restrict__ h,
       int * __restrict__ o)
{
    int i;

    for (i = 0; i < 8; ++i)
        o[i] = a[i]*e[i] + b[i]*f[i] + c[i]*g[i] + d[i]*h[i];
}

    Et GCC 4.3.0 auto-vectorisé:

    sse.c:5: note: LOOP VECTORIZED.
sse.c:2: note: vectorized 1 loops in function.

    Cependant, c'est seulement que si j'ai utilisé une boucle avec un nombre suffisant d'itérations, sinon la sortie détaillée permettrait de préciser que la vectorisation n'était pas rentable ou la boucle était trop petite. Sans le __restrict__ mots-clés, il doit générer séparé, non-vectorisé versions pour traiter les cas où la sortie o peut point sur l'une des entrées.

    Je collez les instructions comme un exemple, mais comme une partie de la vectorisation déroulé la boucle c'est pas très lisible.

    Je pense qu'il voulait dire autre chose. Comme 2 tables de 4 éléments chacune. Ce que vous faites ici, c'est autre chose. Quelque chose comme le produit scalaire de la matrice de vecteurs.

    OriginalL'auteur Ben Jackson

  4. 3

    Il y a un article par Intel ici qui touche à point-implémentations de produit.

    OriginalL'auteur DennyRolling