Verwendung von Fused Multiply-Add (FMA)-Anweisungen mit SSE/AVX

Question 1

Ich habe gelernt, dass einige Intel/AMD-CPUs simultan multiplizieren und mit SSE/AVX addieren können:
FLOPS pro Zyklus für Sandy-Bridge und Haswell SSE2/AVX/AVX2.

Ich möchte wissen, wie man das am besten im Code macht, und ich möchte auch wissen, wie es intern in der CPU gemacht wird. Ich meine mit der superskalaren Architektur. Nehmen wir an, ich möchte eine lange Summe wie die folgende in SSE ausführen:

//sum = a1*b1 + a2*b2 + a3*b3 +... where a is a scalar and b is a SIMD vector (e.g. from matrix multiplication)
sum = _mm_set1_ps(0.0f);
a1  = _mm_set1_ps(a[0]); 
b1  = _mm_load_ps(&b[0]);
sum = _mm_add_ps(sum, _mm_mul_ps(a1, b1));

a2  = _mm_set1_ps(a[1]); 
b2  = _mm_load_ps(&b[4]);
sum = _mm_add_ps(sum, _mm_mul_ps(a2, b2));

a3  = _mm_set1_ps(a[2]); 
b3  = _mm_load_ps(&b[8]);
sum = _mm_add_ps(sum, _mm_mul_ps(a3, b3));
...

Meine Frage ist, wie wird dies in gleichzeitiges Multiplizieren und Addieren umgewandelt? Können die Daten abhängig sein? Ich meine, kann die CPU tun _mm_add_ps(sum, _mm_mul_ps(a1, b1)) gleichzeitig oder müssen die bei der Multiplikation und Addition verwendeten Register unabhängig sein?

Und schließlich, wie gilt dies für die FMA (mit Haswell)? Ist _mm_add_ps(sum, _mm_mul_ps(a1, b1)) automatisch in eine einzelne FMA-Anweisung oder Mikrooperation umgewandelt?

Question 2

Der Compiler darf eine getrennte Addition und Multiplikation fusionieren, obwohl dies das Endergebnis ändert (indem es genauer wird).

Ein FMA hat nur eine Rundung (es behält effektiv eine unendliche Genauigkeit für das interne temporäre Multiplikationsergebnis bei), während ein ADD + MUL zwei hat.

Die IEEE- und C-Standards erlauben dies, wenn #pragma STDC FP_CONTRACT ON ist in Kraft, und Compiler dürfen es haben ON standardmäßig (aber nicht alle). Gcc schließt standardmäßig Verträge mit der FMA ab (mit der Voreinstellung default -std=gnu*aber nicht -std=c*z.B -std=c++14). Für Klanges ist nur mit aktiviert -ffp-contract=fast. (Nur mit der #pragma aktiviert, nur innerhalb eines einzelnen Ausdrucks wie a+b*cnicht über separate C++-Anweisungen.).

Dies unterscheidet sich von strengem vs. entspanntem Gleitkomma (oder in gcc-Begriffen, -ffast-math vs. -fno-fast-math), die andere Arten von Optimierungen ermöglichen würde, die den Rundungsfehler abhängig von den Eingabewerten erhöhen könnten. Das Besondere an diesem ist die unendliche Präzision des FMA-internen Provisoriums; Wenn es im internen Temporär überhaupt eine Rundung gäbe, wäre dies im strikten FP nicht zulässig.

Selbst wenn Sie entspanntes Fließkomma aktivieren, entscheidet sich der Compiler möglicherweise trotzdem dafür, nicht zu fusionieren, da er möglicherweise erwartet, dass Sie wissen, was Sie tun, wenn Sie bereits systeminterne verwenden.

So der beste Weg Um sicherzustellen, dass Sie tatsächlich die gewünschten FMA-Anweisungen erhalten, verwenden Sie tatsächlich die bereitgestellten Intrinsics für sie:

FMA3-Intrinsik: (AVX2 – Intel-Haswell)

_mm_fmadd_pd()_mm256_fmadd_pd()
_mm_fmadd_ps(), _mm256_fmadd_ps()

und ungefähr eine Unmenge anderer Variationen …

FMA4-Intrinsik: (XOP – AMD Bulldozer)

_mm_macc_pd(), _mm256_macc_pd()

_mm_macc_ps(), _mm256_macc_ps()
und ungefähr eine Unmenge anderer Variationen …

Question 3

Ich habe den folgenden Code in GCC 5.3, Clang 3.7, ICC 13.0.1 und MSVC 2015 (Compiler-Version 19.00) getestet.

float mul_add(float a, float b, float c) {
    return a*b + c;
}

__m256 mul_addv(__m256 a, __m256 b, __m256 c) {
    return _mm256_add_ps(_mm256_mul_ps(a, b), c);
}

Mit den richtigen Compiler-Optionen (siehe unten) generiert jeder Compiler eine vfmadd Anleitung (zB vfmadd213ss) aus mul_add. Allerdings kann nur MSVC keinen Vertrag abschließen mul_addv zu einem einzigen vfmadd Anleitung (zB vfmadd213ps).

Die folgenden Compileroptionen reichen zum Generieren aus vfmadd Anleitung (außer mit mul_addv mit MSVC).

GCC:   -O2 -mavx2 -mfma
Clang: -O1 -mavx2 -mfma -ffp-contract=fast
ICC:   -O1 -march=core-avx2
MSVC:  /O1 /arch:AVX2 /fp:fast

GCC 4.9 zieht sich nicht zusammen mul_addv zu einer einzelnen fma-Anweisung, aber seit mindestens GCC 5.1 tut es. Ich weiß nicht, wann die anderen Compiler damit begonnen haben.