Wie Berechne Vektor-Skalarprodukt SSE Verwenden Intrinsische Funktionen in C

Ich versuche multiplizieren von zwei Vektoren zusammen, wo jedes element des einen Vektors multipliziert mit dem element in der gleichen index auf den anderen Vektor. Dann möchte ich die Summe aller Elemente des resultierenden Vektors zu erhalten, eine Zahl. Zum Beispiel, die Berechnung Aussehen würde, wie dies für die Vektoren {1,2,3,4} und {5,6,7,8}:

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

Im wesentlichen, ich nehme das Skalarprodukt der beiden Vektoren. Ich weiß, es ist eine SSE-Befehl, um dies zu tun, aber der Befehl nicht über eine systeminterne Funktion zugeordnet. An dieser Stelle möchte ich nicht zu schreiben, inline-Montage in meinem C-code, so möchte ich nur systeminterne Funktionen. Dies scheint eine gemeinsame Berechnung, so bin ich überrascht von mir selbst, dass ich konnte nicht finden, die Antwort auf Google.

Hinweis: ich bin die Optimierung für eine spezielle micro-Architektur, die unterstützt bis zu SSE 4.2.

Vielen Dank für Ihre Hilfe.

InformationsquelleAutor Sam | 2010-11-08

18

, Wenn Sie tun eine dot-Produkt von mehr Vektoren verwenden multiplizieren und regelmäßige _mm_add_ps (oder FMA) innerhalb der inneren Schleife. Speichern Sie die horizontale Summe bis zum Ende.

Aber wenn Sie tun, eine dot-Produkt von nur einem einzigen paar von SIMD-Vektoren:

GCC (ab version 4.3) umfasst <smmintrin.h> mit SSE4.1 Ebene-Interna, darunter die single-und double-precision-dot-Produkte:
```
_mm_dp_ps (__m128 __X, __m128 __Y, const int __M);
_mm_dp_pd (__m128d __X, __m128d __Y, const int __M);
```
Auf Intel mainstream CPUs (nicht Atom/Silvermont) diese sind etwas schneller als es manuell zu tun mit mehreren Anweisungen.

Aber auf AMD (einschließlich Ryzen), dpps ist deutlich langsamer. (Siehe Agner Fog-Anweisung Tabellen)

Als fallback für ältere Prozessoren, diesen Algorithmus können Sie verwenden, um erstellen Sie das Skalarprodukt der Vektoren a und b:
```
__m128 r1 = _mm_mul_ps(a, b);
```
und dann horizontale Summe r1 mit Am schnellsten horizontal float Vektorsumme auf x86 (siehe dort für eine kommentierte version dieses, und warum geht es schneller.)
```
__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);
```
Eine langsame alternative Kosten 2 shuffles pro hadd, die leicht Engpass auf shuffle Durchsatz, insbesondere auf Intel-CPUs.
```
r2 = _mm_hadd_ps(r1, r1);
r3 = _mm_hadd_ps(r2, r2);
_mm_store_ss(&result, r3);
```
- Als Anmerkung möchte ich darauf hinweisen, dass die Berechnung des skalarprodukts mithilfe der dp intrinsic ist langsamer als es zu tun die zweite Möglichkeit.
- das hängt ganz davon ab, Ihre hardware, es gibt keine globalen Fall, dass es langsamer ist.
- Ich denke, es gibt bessere Möglichkeiten für die horizontale Summe, als mit _mm_hadd_ps. Siehe stackoverflow.com/a/35270026/195787.
InformationsquelleAutor caf

Ich würde sagen, der Schnellste SSE Methode wäre:

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
}

Folgte ich - Am schnellsten Horizontal Float Vektorsumme Auf x86.

Toll finden, die hadd-Anweisungen erweitern, um mehrere uops.

InformationsquelleAutor Royi

3

Schrieb ich dies und kompiliert es mit 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];
}
```
Und GCC 4.3.0 auto-vektorisiert es:
```
sse.c:5: note: LOOP VECTORIZED.
sse.c:2: note: vectorized 1 loops in function.
```
Allerdings wäre es nur, wenn ich eine Schleife mit genug Iterationen -- sonst wird die ausführliche Ausgabe klarstellen würde, dass die Vektorisierung war unrentabel oder die Schleife zu klein war. Ohne die __restrict__ Schlüsselwörter generieren separate, nicht-vektorisierte Versionen zum Umgang mit Fällen, in denen die Ausgabe o kann in einem der Eingänge.

Ich würde fügen Sie den Anweisungen, als ein Beispiel, aber da ein Teil der Vektorisierung entrollen der loop, es ist nicht sehr gut lesbar ist.
- Ich glaube er meinte etwas anderes. Wie 2 arrays mit 4 Elementen jedes. Was Sie hier tun, ist etwas anderes. So etwas wie dot product array von Vektoren.
InformationsquelleAutor Ben Jackson
3

Dort ist ein Artikel von Intel hier berührt dot-Produkt-Implementierungen.

InformationsquelleAutor DennyRolling

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.