Am schnellsten horizontale Vektor-Summe mit AVX-Instruktionen

Habe ich eine gepackte Vektor von vier 64-bit-floating-point-Werte.
Ich möchte die Summe der Vektor-Elemente.

Mit SSE (und mit 32-bit floats) konnte ich nur Folgendes tun:

v_sum = _mm_hadd_ps(v_sum, v_sum);
v_sum = _mm_hadd_ps(v_sum, v_sum);

Leider, obwohl AVX verfügt über eine _mm256_hadd_pd Anweisung, es unterscheidet sich im Ergebnis von der SSE-version. Ich glaube, dies ist aufgrund der Tatsache, dass die meisten AVX-Instruktionen arbeiten, als SSE-Anweisungen für jede low-und high-128-bits separat, ohne Sie je überschreiten der 128-bit-Grenze.

Idealerweise die Lösung, die ich Suche, sollten Sie diese Richtlinien befolgen:
1) nur verwenden, AVX/AVX2-Instruktionen. (kein SSE)
2) tun Sie es in nicht mehr als 2-3 Anweisungen.

Jedoch, eine effiziente und elegante Art und Weise, es zu tun (auch ohne die oben genannten Richtlinien) ist immer gut angenommen.

Vielen Dank für jede Hilfe.

-Luigi Castelli

InformationsquelleAutor der Frage Luigi Castelli | 2012-03-19

  1. 19

    Wenn Sie zwei __m256d Vektoren x1 und x2 enthalten vier doubles, die Sie möchten, um horizontal Summe, die man tun könnte:

    __m256d x1, x2;
//calculate 4 two-element horizontal sums:
//lower 64 bits contain x1[0] + x1[1]
//next 64 bits contain x2[0] + x2[1]
//next 64 bits contain x1[2] + x1[3]
//next 64 bits contain x2[2] + x2[3]
__m256d sum = _mm256_hadd_pd(x1, x2);
//extract upper 128 bits of result
__m128d sum_high = _mm256_extractf128_pd(sum1, 1);
//add upper 128 bits of sum to its lower 128 bits
__m128d result = _mm_add_pd(sum_high, _mm256_castpd256_pd128(sum));
//lower 64 bits of result contain the sum of x1[0], x1[1], x1[2], x1[3]
//upper 64 bits of result contain the sum of x2[0], x2[1], x2[2], x2[3]

    So wie es aussieht 3 Anweisungen müssen 2 von der horizontalen Summen, die Sie brauchen. Das oben ist ungetestet, aber sollte man das Konzept.

    InformationsquelleAutor der Antwort Jason R

  2. 5

    Wenn Sie möchten, dass nur die Summe, und ein bisschen scalar code wird akzeptiert:

    __m256d x;
__m256d s = _mm256_hadd_pd(x,x);
return ((double*)&s)[0] + ((double*)&s)[2];

    InformationsquelleAutor der Antwort RJVB

  3. 3

    Vorausgesetzt, die folgenden, Sie haben eine __m256d Vektor mit 4 verpackt verdoppelt, und Sie möchten berechnen die Summe seiner Bestandteile, dh a0, a1, a2, a3 ist jedes Doppel-Komponente, die Sie möchten a0 + a1 + a2 + a3 dann heres eine andere AVX Lösung:

    //goal to calculate a0 + a1 + a2 + a3
__m256d values = _mm256_set_pd(23211.24, -123.421, 1224.123, 413.231);

//assuming _mm256_hadd_pd(a, b) == a0 + a1, b0 + b1, a2 + a3, b2 + b3 (5 cycles) ...
values = _mm256_hadd_pd(values, _mm256_permute2f128_pd(values, values, 1));
//^^^^^^^^^^^^^^^^^^^^ a0 + a1, a2 + a3, a2 + a3, a0 + a1

values = _mm256_hadd_pd(values, values);
//^^^^^^^^^^^^^^^^^^^^ (a0 + a1 + a2 + a3), (a0 + a1 + a2 + a3), (a2 + a3 + a0 + a1), (a2 + a3 + a0 + a1)

//Being that addition is associative then each component of values contains the sum of all its initial components (11 cycles) to calculate, (1-2 cycles) to extract, total (12-13 cycles)
double got = _mm_cvtsd_f64(_mm256_castpd256_pd128(values)), exp = (23211.24 + -123.421 + 1224.123 + 413.231);

if (got != exp || _mm256_movemask_pd(_mm256_cmp_pd(values, _mm256_set1_pd(exp), _CMP_EQ_OS)) != 0b1111)
    printf("Failed to sum double components, exp: %f, got %f\n", exp, got);
else
    printf("ok\n");

    Diese Lösung hat die Summe ausgestrahlt, die vielleicht nützlich ...

    Wenn ich falsch interpretiert-das problem, das ich zu entschuldigen.

    $ uname -a
Darwin Samys-MacBook-Pro.local 13.3.0 Darwin Kernel Version 13.3.0: Tue Jun  3 21:27:35 PDT 2014; root:xnu-2422.110.17~1/RELEASE_X86_64 x86_64

$ gcc --version
Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1
Apple LLVM version 5.1 (clang-503.0.40) (based on LLVM 3.4svn)
Target: x86_64-apple-darwin13.3.0
Thread model: posix

    InformationsquelleAutor der Antwort Samy Vilar

Schreibe einen Kommentar