Summenreduzierung von vorzeichenlosen Bytes ohne Überlauf, mit SSE2 auf Intel

Question

Ich versuche, Summenreduktion von 32 Elementen (jeweils 1 Byte Daten) auf einem Intel i3-Prozessor zu finden. Ich tat das:

Allerdings nimmt es mehr Zeit, da meine Anwendung eine Echtzeit-Anwendung viel weniger Zeit benötigt. Bitte beachten Sie, dass die endgültige Summe könnte mehr als 255 sein.

Gibt es eine Möglichkeit, die ich mit Low-Level-SIMD SSE2-Anweisungen implementieren kann? Leider habe ich SSE nie benutzt. Ich habe versucht, zu diesem Zweck nach der Funktion sse2 zu suchen, aber es ist auch nicht verfügbar. Ist es (s) garantiert, die Berechnungszeit für solch kleine Probleme zu reduzieren?

Irgendwelche Vorschläge ??

Hinweis: Ich habe die ähnlichen Algorithmen mit OpenCL und CUDA implementiert und das funktionierte großartig, aber nur, wenn die Problemgröße groß war. Bei kleinen Problemen waren die Kosten für den Overhead höher. Nicht sicher, wie es auf SSE funktioniert

Answer 1

Sie können PSADBW missbrauchen, um kleine horizontale Summen schnell zu berechnen.

Etwas wie folgt aus: (nicht getestet)

pxor xmm0, xmm0 
psadbw xmm0, [a + 0] 
pxor xmm1, xmm1 
psadbw xmm1, [a + 16] 
paddw xmm0, xmm1 
pshufd xmm1, xmm0, 2 
paddw xmm0, xmm1 ; low word in xmm0 is the total sum 

---

Versuchte intrinsics Version:

ich nie intrinsics verwenden sodass dieser Code wahrscheinlich überhaupt keinen Sinn macht. Die Demontage sah allerdings gut aus.

uint16_t sum_32(const uint8_t a[32]) 
{ 
    __m128i zero = _mm_xor_si128(zero, zero); 
    __m128i sum0 = _mm_sad_epu8(
         zero, 
         _mm_load_si128(reinterpret_cast<const __m128i*>(a))); 
    __m128i sum1 = _mm_sad_epu8(
         zero, 
         _mm_load_si128(reinterpret_cast<const __m128i*>(&a[16]))); 
    __m128i sum2 = _mm_add_epi16(sum0, sum1); 
    __m128i totalsum = _mm_add_epi16(sum2, _mm_shuffle_epi32(sum2, 2)); 
    return totalsum.m128i_u16[0]; 
} 

Answer 2

Das ist ein bisschen langatmig, aber es sollte noch mindestens 2x schneller als der Skalar-Code sein:

uint16_t sum_32(const uint8_t a[32]) 
{ 
    const __m128i vk0 = _mm_set1_epi8(0); // constant vector of all 0s for use with _mm_unpacklo_epi8/_mm_unpackhi_epi8 
    __m128i v = _mm_load_si128(a);   // load first vector of 8 bit values 
    __m128i vl = _mm_unpacklo_epi8(v, vk0); // unpack to two vectors of 16 bit values 
    __m128i vh = _mm_unpackhi_epi8(v, vk0); 
    __m128i vsum = _mm_add_epi16(vl, vh); 
    v = _mm_load_si128(&a[16]);    // load second vector of 8 bit values 
    vl = _mm_unpacklo_epi8(v, vk0);   // unpack to two vectors of 16 bit values 
    vh = _mm_unpackhi_epi8(v, vk0); 
    vsum = _mm_add_epi16(vsum, vl); 
    vsum = _mm_add_epi16(vsum, vh); 
    // horizontal sum 
    vsum = _mm_add_epi16(vsum, _mm_srli_si128(vsum, 8)); 
    vsum = _mm_add_epi16(vsum, _mm_srli_si128(vsum, 4)); 
    vsum = _mm_add_epi16(vsum, _mm_srli_si128(vsum, 2)); 
    return _mm_extract_epi16(vsum, 0); 
} 

Beachten Sie, dass a[] Bedürfnisse 16 Byte ausgerichtet sein.

Sie können wahrscheinlich den obigen Code mit _mm_hadd_epi16 verbessern.