MulReg.h

Go to the documentation of this file.

// MulReg.h:
// -------------------
//

#ifndef __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_SSE2_MULREG_H__
#define __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_SSE2_MULREG_H__

#include <IPSDKUtil/IPSDKUtilExports.h>
#include <IPSDKUtil/InstructionSet/SSE2/Sse2Types.h>
#include <IPSDKUtil/Tools/ForceInline.h>

namespace ipsdk {
namespace simd {
namespace detail {


static IPSDK_FORCEINLINE
__m128i
_custom_mm_mullo_epi8(__m128i a, __m128i b)
{
    /*
    // There is no 8-bit multiply in SSE2. Split into two 16-bit multiplies
    __m128i aodd    = _mm_srli_epi16(a,8);                 // odd numbered elements of a
    __m128i bodd    = _mm_srli_epi16(b,8);                 // odd numbered elements of b
    __m128i muleven = _mm_mullo_epi16(a,b);                // product of even numbered elements
    __m128i mulodd  = _mm_mullo_epi16(aodd,bodd);          // product of odd  numbered elements
            mulodd  = _mm_slli_epi16(mulodd,8);            // put odd numbered elements back in place
    __m128i mask    = _mm_set1_epi32(0x00FF00FF);          // mask for even positions
    __m128i product = selectb(mask,muleven,mulodd);        // interleave even and odd
    return product;*/
    __m128i mask = _mm_set1_epi16(0xFF);
    return _mm_or_si128 ( _mm_and_si128(mask, _mm_mullo_epi16(a, b))
                          , _mm_slli_epi16
                            ( _mm_and_si128 ( mask
                                            , _mm_mullo_epi16
                                              ( _mm_srli_epi16(a, 8)
                                              , _mm_srli_epi16(b, 8)
                                              )
                                            )
                            , 8
                            )
                          );
}

static IPSDK_FORCEINLINE
void
_custom_mm_mullo_epi8(__m128i a, __m128i b, __m128i& out)
{
    __m128i mask = _mm_set1_epi16(0xFF);
    out = _mm_or_si128 ( _mm_and_si128(mask, _mm_mullo_epi16(a, b))
                          , _mm_slli_epi16
                            ( _mm_and_si128 ( mask
                                            , _mm_mullo_epi16
                                              ( _mm_srli_epi16(a, 8)
                                              , _mm_srli_epi16(b, 8)
                                              )
                                            )
                            , 8
                            )
                          );
}

IPSDK_FORCEINLINE
__m128i
_custom_mm_mullo_epi32(__m128i a, __m128i b)
{
    /*__m128i a13    = _mm_shuffle_epi32(a, 0xF5);          // (-,a3,-,a1)
    __m128i b13    = _mm_shuffle_epi32(b, 0xF5);          // (-,b3,-,b1)
    __m128i prod02 = _mm_mul_epu32(a, b);                 // (-,a2*b2,-,a0*b0)
    __m128i prod13 = _mm_mul_epu32(a13, b13);             // (-,a3*b3,-,a1*b1)
    __m128i prod01 = _mm_unpacklo_epi32(prod02,prod13);   // (-,-,a1*b1,a0*b0)
    __m128i prod23 = _mm_unpackhi_epi32(prod02,prod13);   // (-,-,a3*b3,a2*b2)

    return _mm_unpacklo_epi64(prod01,prod23);   // (ab3,ab2,ab1,ab0)*/

    /*__m128 af = _mm_castsi128_ps(a);
    __m128 bf = _mm_castsi128_ps(b);
    __m128 resf = _mm_mul_ps(af, bf);
    return _mm_castps_si128(_mm_mul_ps(_mm_castsi128_ps(a), _mm_castsi128_ps(b)));*/

    return _mm_or_si128(
                    _mm_and_si128(
                       _mm_mul_epu32(a, b),
                       _mm_setr_epi32(0xffffffff,0,0xffffffff,0)
                    )
                  , _mm_slli_si128(
                        _mm_and_si128(
                            _mm_mul_epu32( _mm_srli_si128(a, 4)
                                         , _mm_srli_si128(b, 4)
                                         )
                          , _mm_setr_epi32(0xffffffff,0,0xffffffff,0)
                        )
                      , 4
                    )
             );
}

IPSDK_FORCEINLINE
void
_custom_mm_mullo_epi32(__m128i a, __m128i b, __m128i& out)
{
    out = _mm_or_si128(
                    _mm_and_si128(
                       _mm_mul_epu32(a, b),
                       _mm_setr_epi32(0xffffffff,0,0xffffffff,0)
                    )
                  , _mm_slli_si128(
                        _mm_and_si128(
                            _mm_mul_epu32( _mm_srli_si128(a, 4)
                                         , _mm_srli_si128(b, 4)
                                         )
                          , _mm_setr_epi32(0xffffffff,0,0xffffffff,0)
                        )
                      , 4
                    )
             );
}

template <typename T>
struct MulReg<eInstructionSet::eIS_Sse2, T, 
    typename boost::enable_if_c<boost::is_integral<T>::value
        && sizeof(T) == 1>::type>
{
    static IPSDK_FORCEINLINE
    typename Sse2Type<T>::Type
    act(const typename Sse2Type<T>::Type& in1,
        const typename Sse2Type<T>::Type& in2)
    {
        return _custom_mm_mullo_epi8(in1, in2);
    }

    static IPSDK_FORCEINLINE
    void
    act(const typename Sse2Type<T>::Type& in1,
        const typename Sse2Type<T>::Type& in2,
        typename Sse2Type<T>::Type& out)
    {
        _custom_mm_mullo_epi8(in1, in2, out);
    }
};

template <typename T>
struct MulReg<eInstructionSet::eIS_Sse2, T, 
    typename boost::enable_if_c<boost::is_integral<T>::value
        && sizeof(T) == 2>::type>
{
    static IPSDK_FORCEINLINE
    typename Sse2Type<T>::Type
    act(const typename Sse2Type<T>::Type& in1,
        const typename Sse2Type<T>::Type& in2)
    {
        return _mm_mullo_epi16(in1, in2);
    }

    static IPSDK_FORCEINLINE
    void
    act(const typename Sse2Type<T>::Type& in1,
        const typename Sse2Type<T>::Type& in2,
        typename Sse2Type<T>::Type& out)
    {
        out = _mm_mullo_epi16(in1, in2);
    }
};

template <typename T>
struct MulReg<eInstructionSet::eIS_Sse2, T, 
    typename boost::enable_if_c<boost::is_integral<T>::value
        && sizeof(T) == 4>::type>
{
    static IPSDK_FORCEINLINE
    typename Sse2Type<T>::Type
    act(const typename Sse2Type<T>::Type& in1,
        const typename Sse2Type<T>::Type& in2)
    {
        return _custom_mm_mullo_epi32(in1, in2);
    }

    static IPSDK_FORCEINLINE
    void
    act(const typename Sse2Type<T>::Type& in1,
        const typename Sse2Type<T>::Type& in2,
        typename Sse2Type<T>::Type& out)
    {
        _custom_mm_mullo_epi32(in1, in2, out);
    }
};

template <>
struct MulReg<eInstructionSet::eIS_Sse2, ipReal32>
{
    static IPSDK_FORCEINLINE
    Sse2Type<ipReal32>::Type
    act(const Sse2Type<ipReal32>::Type& in1,
        const Sse2Type<ipReal32>::Type& in2)
    {
        return _mm_mul_ps(in1, in2);
    }

    static IPSDK_FORCEINLINE
    void
    act(const Sse2Type<ipReal32>::Type& in1,
        const Sse2Type<ipReal32>::Type& in2,
        Sse2Type<ipReal32>::Type& out)
    {
        out = _mm_mul_ps(in1, in2);
    }
};

template <>
struct MulReg<eInstructionSet::eIS_Sse2, ipReal64>
{
    static IPSDK_FORCEINLINE
    Sse2Type<ipReal64>::Type
    act(const Sse2Type<ipReal64>::Type& in1,
        const Sse2Type<ipReal64>::Type& in2)
    {
        return _mm_mul_pd(in1, in2);
    }

    static IPSDK_FORCEINLINE
    void
    act(const Sse2Type<ipReal64>::Type& in1,
        const Sse2Type<ipReal64>::Type& in2,
        Sse2Type<ipReal64>::Type& out)
    {
        out = _mm_mul_pd(in1, in2);
    }
};


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

#endif // __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_SSE2_MULREG_H__