|| || || || || ||

---

ReduceSum.h

Go to the documentation of this file.

#ifndef Impala_Core_Vector_ReduceSum_h
#define Impala_Core_Vector_ReduceSum_h

#include "Core/Vector/VectorTem.h"
#ifdef SSE_USED
#include <xmmintrin.h>
#include <stdint.h>
#ifndef POINTER_ALIGNED
#define POINTER_ALIGNED(x) (!((( intptr_t)x) & 0xF))
#endif
#endif // SSE_USED

namespace Impala
{
namespace Core
{
namespace Vector
{


#ifdef SSE_USED

// assumption: A has size IntAlignUp(n,4) and the pointer is 16-byte aligned
float
ReduceSumSSE(const float* A, unsigned int n)
{
    if(!POINTER_ALIGNED(A)) return -1.0f;
    __m128 result = _mm_setzero_ps();
    __m128 *pA = (__m128*) A;
    const int SSELength = IntAlignUp(n, 4) / 4;
    for(unsigned int i = 0; i < SSELength; i++)
    {
        result = _mm_add_ps(result, pA[i]);
    }

    // shuffle = [1 0 3 2]
    // sum     = [3+1 2+0 1+3 0+2]
    // shuffle = [2+0 3+1 0+2 1+3]
    // res     = [3+1+2+0 3+1+2+0 1+3+0+2 0+2+1+3]
    __m128 shuffle, sum;
    shuffle = _mm_shuffle_ps(result, result, _MM_SHUFFLE(1, 0, 3, 2));
    sum     = _mm_add_ps(result, shuffle) ;
    shuffle = _mm_shuffle_ps(sum, sum, _MM_SHUFFLE(2, 3, 0, 1));
    result  = _mm_add_ps(sum, shuffle) ;

    return _mm_cvtss_f32(result);
}


// assumption: A has size IntAlignUp(n,2) and the pointer is 16-byte aligned
double
ReduceSumSSE(const double* A, unsigned int n)
{
    if(!POINTER_ALIGNED(A)) return -1.0;
    __m128d result = _mm_setzero_pd();
    __m128d *pA = (__m128d*) A;
    const int SSELength = IntAlignUp(n, 2) / 2;
    for(unsigned int i = 0; i < SSELength; i++)
    {
        result = _mm_add_pd(result, pA[i]);
    }

    __m128d shuffle, sum;
    shuffle = _mm_shuffle_pd(result, result, _MM_SHUFFLE2(0, 1));
    result  = _mm_add_pd(result, shuffle) ;

    return _mm_cvtsd_f64(result);
}

#endif // SSE_USED


template <class FType>
inline double
ReduceSumStd(const FType* A, unsigned int n)
{
    double result = 0.0;
    for(unsigned int i = 0; i < n; i++)
    {
        result += A[i];
    }
    return result;
}

template <class FType>
inline double
ReduceSum(const FType* A, unsigned int n)
{
#ifdef SSE_USED
    return ReduceSumSSE(A, n);
#endif
    ReduceSum(A, n);
}

} // namespace Vector
} // namespace Core
} // namespace Impala

#endif

---