ScanPack.h

Go to the documentation of this file.

// ScanPack.h:
// -------------------
//

#ifndef __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_SSE2_SCANPACK_H__
#define __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_SSE2_SCANPACK_H__

#include <IPSDKUtil/IPSDKUtilExports.h>
#include <IPSDKUtil/Tools/ForceInline.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/ScanReg.h>
#include <IPSDKUtil/InstructionSet/NbEltsPerReg.h>
#include <IPSDKUtil/InstructionSet/detail/BaseReg.h>
#include <IPSDKUtil/InstructionSet/detail/LoadReg.h>
#include <IPSDKUtil/InstructionSet/detail/UnloadReg.h>

namespace ipsdk {
namespace simd {
namespace detail {


template <>
struct ScanPack<eInstructionSet::eIS_Sse2, ipReal32>
{
    static IPSDK_FORCEINLINE
    BasePack<ePackType::ePT_Sse, ipReal32>
    act(const BasePack<ePackType::ePT_Sse, ipReal32>& in)
    {
        BasePack<ePackType::ePT_Sse, ipReal32> out;
        out._val[0] = ScanReg<eInstructionSet::eIS_Sse2, ipReal32>::act(in._val[0]);
        
        __m128 offset = _mm_shuffle_ps(out._val[0], out._val[0], _MM_SHUFFLE(3, 3, 3, 3));
        
        out._val[1] = ScanReg<eInstructionSet::eIS_Sse2, ipReal32>::act(in._val[1]);
        out._val[1] = _mm_add_ps(out._val[1], offset);
        offset = _mm_shuffle_ps(out._val[1], out._val[1], _MM_SHUFFLE(3, 3, 3, 3));
        
        out._val[2] = ScanReg<eInstructionSet::eIS_Sse2, ipReal32>::act(in._val[2]);
        out._val[2] = _mm_add_ps(out._val[2], offset);
        offset = _mm_shuffle_ps(out._val[2], out._val[1], _MM_SHUFFLE(3, 3, 3, 3));
        
        out._val[3] = ScanReg<eInstructionSet::eIS_Sse2, ipReal32>::act(in._val[2]);
        out._val[3] = _mm_add_ps(out._val[2], offset);
        offset = _mm_shuffle_ps(out._val[3], out._val[3], _MM_SHUFFLE(3, 3, 3, 3));
        
        return out;
    }

    static IPSDK_FORCEINLINE
    void
    act(const BasePack<ePackType::ePT_Sse, ipReal32>& in,
        BasePack<ePackType::ePT_Sse, ipReal32>& out)
    {
        ScanReg<eInstructionSet::eIS_Sse2, ipReal32>::act(in._val[0], out._val[0]);
        
        __m128 offset = _mm_shuffle_ps(out._val[0], out._val[0], _MM_SHUFFLE(3, 3, 3, 3));
        
        ScanReg<eInstructionSet::eIS_Sse2, ipReal32>::act(in._val[1], out._val[1]);
        out._val[1] = _mm_add_ps(out._val[1], offset);
        offset = _mm_shuffle_ps(out._val[1], out._val[1], _MM_SHUFFLE(3, 3, 3, 3));
        
        ScanReg<eInstructionSet::eIS_Sse2, ipReal32>::act(in._val[2], out._val[2]);
        out._val[2] = _mm_add_ps(out._val[2], offset);
        offset = _mm_shuffle_ps(out._val[2], out._val[1], _MM_SHUFFLE(3, 3, 3, 3));
        
        ScanReg<eInstructionSet::eIS_Sse2, ipReal32>::act(in._val[2], out._val[3]);
        out._val[3] = _mm_add_ps(out._val[2], offset);
        offset = _mm_shuffle_ps(out._val[3], out._val[3], _MM_SHUFFLE(3, 3, 3, 3));
    }
};

template <>
struct ScanFunc<eInstructionSet::eIS_Sse2, ipReal32>
{
    static IPSDK_FORCEINLINE
    void act(const ipReal32* in, ipReal32* out, ipUInt64 nbElts)
    {        
        __m128 regOffset = _mm_setzero_ps();
        
        const ipUInt64 nbAlignedElts = nbElts - (nbElts%simd::NbEltsPerReg<ePackType::ePT_Sse, ipReal32>::Value);
     
        ipUInt64 i=0;
        
        simd::BaseReg<ePackType::ePT_Sse, ipReal32>::Type regIn, regOut;

        for(; i < nbAlignedElts; i+=simd::NbEltsPerReg<ePackType::ePT_Sse, ipReal32>::Value) {
            
            simd::detail::LoadReg<eInstructionSet::eIS_Sse2, ipReal32>::act(regIn, in+i);
            simd::detail::ScanReg<eInstructionSet::eIS_Sse2, ipReal32>::act(regIn, regOut);
            regOut = _mm_add_ps(regOut, regOffset);
            simd::detail::UnloadReg<eInstructionSet::eIS_Sse2, ipReal32>::act(regOut, out+i);
            regOffset = _mm_shuffle_ps(regOut, regOut, _MM_SHUFFLE(3, 3, 3, 3));
        }
        for (; i < nbElts; ++i) {

            // update of mean
            out[i] = out[i - 1] + in[i];
        }
    }
};

template <>
struct ScanFunc<eInstructionSet::eIS_Sse2, ipReal64>
{
    static IPSDK_FORCEINLINE
        void act(const ipReal64* in, ipReal64* out, ipUInt64 nbElts)
    {
        __m128d regOffset = _mm_setzero_pd();

        const ipUInt64 nbAlignedElts = nbElts - (nbElts%simd::NbEltsPerReg<ePackType::ePT_Sse, ipReal64>::Value);

        ipUInt64 i = 0;

        simd::BaseReg<ePackType::ePT_Sse, ipReal64>::Type regIn, regOut;

        for (; i < nbAlignedElts; i += simd::NbEltsPerReg<ePackType::ePT_Sse, ipReal64>::Value) {

            simd::detail::LoadReg<eInstructionSet::eIS_Sse2, ipReal64>::act(regIn, in + i);
            simd::detail::ScanReg<eInstructionSet::eIS_Sse2, ipReal64>::act(regIn, regOut);
            regOut = _mm_add_pd(regOut, regOffset);
            simd::detail::UnloadReg<eInstructionSet::eIS_Sse2, ipReal64>::act(regOut, out + i);
            regOffset = _mm_shuffle_pd(regOut, regOut, _MM_SHUFFLE2(1, 1));
        }
        for (; i < nbElts; ++i) {

            // update of mean
            out[i] = out[i - 1] + in[i];
        }
    }
};


} // end of namespace detail
} // end of namespace simd
} // end of namespace ipsdk

#endif // __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_SSE2_SCANPACK_H__