Wie findet man die maximale horizontale in eine 256-bit-AVX-Vektor

Ich habe ein __m256d Vektor verpackt mit vier 64-bit-floating-point-Werte.

Ich muss die horizontale maximale von der vector-Elemente und speichert das Ergebnis in einer double-precision-skalaren Wert;

Meine versuche wurden alle mit einer Menge von schlurfenden der vector-Elemente, so dass der code nicht sonderlich elegant noch effizient. Auch fand ich es unmöglich, bleiben nur die AVX-Domäne. Irgendwann hatte ich die Verwendung der SSE-128-bit-Anweisungen zum extrahieren der endgültigen 64-bit-Wert. Ich möchte jedoch zu sein, erwies sich als falsch, auf diese Letzte Aussage.

Also die ideale Lösung:

1) nur verwenden, nur AVX-Anweisungen.

2) minimieren der Anzahl der Anweisungen. (Ich hoffe auf nicht mehr als 3-4 Anweisungen)

Having said that, jede elegante/effiziente Lösung akzeptiert werden, auch wenn Sie nicht Einhaltung der oben genannten Richtlinien.

Vielen Dank für jede Hilfe.

-Luigi

  • Das ist eine schwierige Frage... machst du das mit nur 1 Vektor? Oder haben Sie viele Vektoren, für die Sie brauchen, um zu finden, die max? Können Sie (relativ) effizient tun, 4 von diesen parallel mit einem 4 x 4-Vektor transponieren...
  • Naja... ich beschäftige mich mit vielen Vektoren. Jedoch ist die Einfachheit der Verarbeitung rechtfertigen nicht zwei 4x4-Transposition Operationen für jede iteration. Also ich bin von der Verarbeitung alles, was "horizontal" ohne transposition. Ich bin immer ein großer speed-up, der Art, der Nähe von 4x, denn ich bin die Vermeidung der Aufwand für die Umsetzung. Alles wird in einer engen Schleife manuell abgerollt 4 mal. Allerdings, wenn die Schleife ist vorbei, ich bin Links mit einem letzten AVX Vektor. Ich habe zu finden, die größte der vier Elemente, um zu speichern das Ergebnis zurück in mein doppelter Genauigkeit skalarer Wert. Daher meine Frage...
  • Wenn es nicht in der "enge Schleife", ist es auch performance kritisch?
  • Dieses mal nicht wirklich... 🙂 aber ich weiß, ich werde laufen in eine situation, wo es performance-kritisch. Das ist, warum ich formulierte die Frage, wie ich es Tat...
  • Ah 🙂 In diesem Fall ist der beste Weg, dies zu tun wäre wahrscheinlich sehr spezifische, wie es verwendet wird. In anderen Worten, es ist nicht vectorizable auf dieser Ebene, aber können Sie schieben Sie es auf eine höhere Ebene...
  • Was meinst du mit "schieben Sie es auf eine höhere Ebene" ?
  • lassen Sie uns weiter, diese Diskussion im chat
  • Beachten Sie, dass Sie bleiben können, in die AVX-Domäne, während mit einer 128-bit-Anweisungen. Es gibt eigentlich 3 Arten von Befehlen: AVX256, AVX128 und legacy SSE128. Ein Schalter zwischen den ersten beiden und letztere zu vermeiden ist, seine teuer auf Intel (also nicht auf AMD), aber die ersten beiden können vermischt werden, fast frei (Sie können zum einfügen vzeroupper manchmal)

InformationsquelleAutor Luigi Castelli | 2012-03-20
  1. 17

    Ich glaube nicht, dass Sie tun können, viel besser als 4 Anleitung: 2 mischt und 2 Vergleiche.

    __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])

    Triviale änderung, nur mit 256-bit-Vektoren: 

    __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])

    (ungetestet)

    • Ja, das stimmte... Gute Lösung. Danke.
    • Die all-256-version ist gut auf Intel CPUs, wenn die Folge ausgestrahlt, aber es ist viel langsamer auf Ryzen. Siehe Get Summe der gespeicherten Werte in __m256d mit SSE/AVX. (Und BTW, _mm_unpackhi_pd 2 bytes kürzer als _mm_permute_pd zu verwenden, so dass, wenn Sie nur wollen, ein Skalares Ergebnis. Keinen unmittelbaren Bedarf, eine 2-byte-VEX-Präfix.)
    InformationsquelleAutor Norbert P.
  2. 6

    Den Allgemeinen Weg, dies zu tun für einen Vektor v1 = [A, B, C, D] ist

    1. Permutiert v1 zu v2 = [C, D, A, B] (swap 0. und 2. Elemente und 1. und 3. sind)
    2. Nehmen die max; d.h. v3 = max(v1,v2). Sie haben jetzt [max(A,C), max(B,D), max(A,C), max(B,D)]
    3. Permutiert v3 zu v4 Tausch die 0. und 1. Elemente, und die 2. und 3. diejenigen.
    4. Nehmen die max wieder, d.h. v5 = max(v3,v4). Jetzt v5 enthält die horizontale max in all seinen Komponenten.

    Speziell für AVX, die Permutationen kann man mit _mm256_permute_pd und die Höchstwerte getan werden kann, mit _mm256_max_pd. Ich habe nicht die genauen permutiert Masken praktisch, aber Sie sollte ziemlich einfach sein, um herauszufinden.

    Hoffe, das hilft.

    • Besonders gut gefällt mir deine Lösung, denn bisher ist es die einzige ist, die verwendet AVX-Anweisungen ausschließlich, ohne jemals die 256-bit-Domäne. Danke.
    • sorry, ich Sprach zu früh... Man kann das nicht mit AVX. Die meisten AVX-Operationen nicht über die 128-bit-Grenze. So in diesem Fall können Sie die swap-die 0. und 2. Elemente und der 1. und 3. Platz. Die AVX permutiert Betrieb können Sie nur tauschen Sie die 0. und 1. Elemente oder die 2. und 3.Platz.
    • meine Lösung geschrieben werden kann, so lassen Sie nie die 256-bit-domain, wenn Sie wollen. Ersetzen _mm256_extractf128_pd durch _mm256_permute2f128_pd(x, x, 1), __m128d durch __m256d, und _mm_... durch _mm256_..., _mm_permute_pd(m1, 1) durch _mm256_permute_pd(m1, 5).
    InformationsquelleAutor celion
  3. -2
    //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 the highest end of 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[3] > max_array[7])
{
    horizontal_max = max_array[3];
}
else
{
    horizontal_max = max_array[7];
}
    • Es wird eine zusätzliche Schritt für float-Vektoren, sondern die Speicherung in ein array und ein Skalar Vergleich ist nicht einer der Schritte. Sie wollen immer noch, um mit zu beginnen eine extractf128 / 128bit maxps. In der Tat lane stuff erste ist nicht besser auf Intel-CPUs, und auf jeden Fall schlechter auf AMD-CPUs, wo 256b AVX-ops sind doppelt so teuer wie 128b AVX-ops. So oder so, eine 256b speichern und dann zwei Lasten -> ein Skalar zu vergleichen ist einfach nur albern, und langsamer als eine extractf128.
    InformationsquelleAutor joyx
Schreibe einen Kommentar