ScanPack.h

Go to the documentation of this file.

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

#ifndef __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_AVX_SCANPACK_H__
#define __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_AVX_SCANPACK_H__

#include <IPSDKUtil/IPSDKUtilExports.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/ScanPack.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/ScanReg.h>
#include <IPSDKUtil/Tools/ForceInline.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_Avx, ipReal32>
{
    static IPSDK_FORCEINLINE
    BasePack<ePackType::ePT_Avx, ipReal32>
    act(const BasePack<ePackType::ePT_Avx, ipReal32>& in)
    {
        BasePack<ePackType::ePT_Avx, ipReal32> out;
        act(in, out);
        return out;
    }

    static IPSDK_FORCEINLINE
    void
    act(const BasePack<ePackType::ePT_Avx, ipReal32>& in,
        BasePack<ePackType::ePT_Avx, ipReal32>& out)
    {
        out._val[0] = ScanReg<eInstructionSet::eIS_Avx, ipReal32>::act(in._val[0]);
        __m256 t0 = _mm256_permute2f128_ps(out._val[0], out._val[0], 0x11);
        __m256 offset = _mm256_permute_ps(t0, 0xff);

        out._val[1] = ScanReg<eInstructionSet::eIS_Avx, ipReal32>::act(in._val[1]);
        out._val[1] = _mm256_add_ps(out._val[1], offset);
        t0 = _mm256_permute2f128_ps(out._val[1], out._val[1], 0x11);
        offset = _mm256_permute_ps(t0, 0xff);

        out._val[2] = ScanReg<eInstructionSet::eIS_Avx, ipReal32>::act(in._val[2]);
        out._val[2] = _mm256_add_ps(out._val[2], offset);
        t0 = _mm256_permute2f128_ps(out._val[2], out._val[2], 0x11);
        offset = _mm256_permute_ps(t0, 0xff);

        out._val[3] = ScanReg<eInstructionSet::eIS_Avx, ipReal32>::act(in._val[2]);
        out._val[3] = _mm256_add_ps(out._val[2], offset);
    }
};

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

        for(; i < nbAlignedElts; i+=simd::NbEltsPerReg<ePackType::ePT_Avx, ipReal32>::Value) {
            
            simd::detail::LoadReg<eInstructionSet::eIS_Avx, ipReal32>::act(regIn, in+i);
            simd::detail::ScanReg<eInstructionSet::eIS_Avx, ipReal32>::act(regIn, regOut);
            
            regOut = _mm256_add_ps(regOut, regOffset);
            simd::detail::UnloadReg<eInstructionSet::eIS_Avx, ipReal32>::act(regOut, out+i);
            __m256 t0 = _mm256_permute2f128_ps(regOut, regOut, 0x11);
            regOffset = _mm256_permute_ps(t0, 0xff);
        }
        for (; i < nbElts; ++i) {

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

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

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

        ipUInt64 i = 0;

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

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

            simd::detail::LoadReg<eInstructionSet::eIS_Avx, ipReal64>::act(regIn, in + i);
            simd::detail::ScanReg<eInstructionSet::eIS_Avx, ipReal64>::act(regIn, regOut);

            regOut = _mm256_add_pd(regOut, regOffset);
            simd::detail::UnloadReg<eInstructionSet::eIS_Avx, ipReal64>::act(regOut, out + i);
                
            const simd::BaseReg<ePackType::ePT_Avx, ipReal64>::Type regOut2 =
                _mm256_permute2f128_pd(regOut, regOut, 0x11);
            regOffset = _mm256_shuffle_pd(regOut2, regOut2, 0xF);
        }
        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_AVX_SCANPACK_H__