SIMDContainer.h

Go to the documentation of this file.

/*
 * Expression Template Matrix Library
 *
 * Copyright (C) 2004 - 2006 Ricky Lung <mtlung@users.sourceforge.net>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */


#ifndef _EXMAT_SIMDCONTAINER_H
#define _EXMAT_SIMDCONTAINER_H


#ifdef _MSC_VER
#   pragma warning( push )
#   pragma warning( disable : 4201 4786 )
#endif  // _MSC_VER

#include <iterator>
#include "../ErrorCheck.h"
#include "../Iterators.h"
#include "../Allocator.h"
#include "SIMDAlignment.h"
// Borrowing the unroller from assignment.h
#include "../Assignment.h"


namespace exmat {


namespace SIMD {


template<typename T>
struct SIMD_UNIT_Chooser {
    typedef NullTag RET;
};

#if EXMAT_SIMD_FLOAT
template<>
struct SIMD_UNIT_Chooser<float> {
    enum {
        ALIGN = EXMAT_SIMD_FLOAT_ALIGN
    };
    typedef EXMAT_SIMD_FLOAT_UNIT RET;
};
#endif  // EXMAT_SIMD_FLOAT

#if EXMAT_SIMD_DOUBLE
template<>
struct SIMD_UNIT_Chooser<double> {
    enum {
        ALIGN = EXMAT_SIMD_DOUBLE_ALIGN
    };
    typedef EXMAT_SIMD_DOUBLE_UNIT RET;
};
#endif  // EXMAT_SIMD_DOUBLE


template<int ROWS_, int COLS_, typename T=float>
struct EXMAT_TYPE_ALIGN_PREFIX(EXMAT_SIMD_DEFAULT_ALIGN)
SCon_RM : public SIMDTag, public RowMajorTag
{
    typedef typename SIMD_UNIT_Chooser<T>::RET UNIT;
    enum {
        ALIGNED = true,
        ROWS = ROWS_,
        COLS = COLS_,
        Align = SIMD_UNIT_Chooser<T>::ALIGN,
        nElePerUnit = sizeof(UNIT)/sizeof(T),
        nUnitPerRow = (COLS+nElePerUnit-1)/nElePerUnit,
        nUnit = nUnitPerRow*ROWS,
        // Padding at the end of each row
        rPadding = (COLS%nElePerUnit == 0) ? 0 : nElePerUnit-COLS%nElePerUnit,
        cPadding = 0,
        rStride = COLS+rPadding,
        cStride = ROWS,
        nTotalEle = ROWS*(COLS+rPadding),

        IsLinear = true,            
        IsLinearRecursive = true,   
        TNOP = 0,                   
        ENOP = 0,                   
        EXPLevel = 0
    };

    union {
        UNIT unitData[nUnit];
        T data[ROWS][COLS+rPadding];
        struct { T x, y, z, w; };
    };

    EXMAT_INLINE2 SCon_RM() {
        ALIGNMENT_CHECK(sizeof(UNIT));
    }

    /************************************************/
    // Index function (for internal use, no error checking applied)
    EXMAT_INLINE2 T& setAt(size_t i)
    {   return *(&data[0][0]+i+i*rPadding/COLS);    }
    EXMAT_INLINE2 const T& getAt(size_t i) const
    {   return *(&data[0][0]+i+i*rPadding/COLS);    }
    EXMAT_INLINE2 T& setAt(size_t i, size_t j)
    {   return data[i][j];  }
    EXMAT_INLINE2 const T& getAt(size_t i, size_t j) const
    {   return data[i][j];  }
    EXMAT_INLINE2 UNIT& setUnitAt(size_t i)
    {   return unitData[i]; }
    EXMAT_INLINE2 const UNIT& getUnitAt(size_t i) const
    {   return unitData[i]; }
} EXMAT_TYPE_ALIGN_SUFFIX(EXMAT_SIMD_DEFAULT_ALIGN);


template<int ROWS_, int COLS_, typename T=float>
struct EXMAT_TYPE_ALIGN_PREFIX(EXMAT_SIMD_DEFAULT_ALIGN)
SCon_CM : public SIMDTag, public ColMajorTag
{
    typedef typename SIMD_UNIT_Chooser<T>::RET UNIT;
    enum {
        ALIGNED = true,
        ROWS = ROWS_,
        COLS = COLS_,
        Align = SIMD_UNIT_Chooser<T>::ALIGN,
        nElePerUnit = sizeof(UNIT)/sizeof(T),
        nUnitPerCol = (ROWS+nElePerUnit-1)/nElePerUnit,
        nUnit = nUnitPerCol*COLS,
        rPadding = 0,
        cPadding = (ROWS%nElePerUnit == 0) ? 0 : nElePerUnit-ROWS%nElePerUnit,
        rStride = COLS,
        cStride = ROWS+cPadding,
        nTotalEle = COLS*(ROWS+cPadding),

        IsLinear = true,            
        IsLinearRecursive = true,   
        TNOP = 0,                   
        ENOP = 0,                   
        EXPLevel = 0
    };

    union {
        UNIT unitData[nUnit];
        T data[COLS][ROWS+cPadding];
        struct { T x, y, z, w; };
    };

    EXMAT_INLINE2 SCon_CM() {
        ALIGNMENT_CHECK(sizeof(UNIT));
    }

    /************************************************/
    // Index function (for internal use, no error checking applied)
    EXMAT_INLINE2 T& setAt(size_t i)
    {   return *(&data[0][0]+i+i*cPadding/ROWS);    }
    EXMAT_INLINE2 const T& getAt(size_t i) const
    {   return *(&data[0][0]+i+i*cPadding/ROWS);    }
    EXMAT_INLINE2 T& setAt(size_t i, size_t j)
    {   return data[j][i];  }
    EXMAT_INLINE2 const T& getAt(size_t i, size_t j) const
    {   return data[j][i];  }
    EXMAT_INLINE2 UNIT& setUnitAt(size_t i)
    {   return unitData[i]; }
    EXMAT_INLINE2 const UNIT& getUnitAt(size_t i) const
    {   return unitData[i]; }
} EXMAT_TYPE_ALIGN_SUFFIX(EXMAT_SIMD_DEFAULT_ALIGN);


template<int ROWS_, int COLS_, typename T=float>
struct SConCA_RM : public SIMDTag, public RowMajorTag
{
    typedef typename SIMD_UNIT_Chooser<T>::RET UNIT;
    enum {
        ALIGNED = true,
        ROWS = ROWS_,
        COLS = COLS_,
        Align = SIMD_UNIT_Chooser<T>::ALIGN,
        nElePerUnit = sizeof(UNIT)/sizeof(T),
        nUnitPerRow = (COLS+nElePerUnit-1)/nElePerUnit,
        nUnit = nUnitPerRow*ROWS,
        // Padding at the end of each row
        rPadding = (COLS%nElePerUnit == 0) ? 0 : nElePerUnit-COLS%nElePerUnit,
        cPadding = 0,
        rStride = COLS+rPadding,
        cStride = ROWS,
        nTotalEle = ROWS*(COLS+rPadding),

        IsLinear = true,            
        IsLinearRecursive = true,   
        TNOP = 0,                   
        ENOP = 0,                   
        EXPLevel = 0
    };

    // VC2005 need to init an pointer explicitly first
#if EXMAT_VC2005
    UNIT* refPtr;
#   define INIT_REF \
    refPtr( (UNIT*)aligned_stack_allocate(sizeof(UNIT)*nUnit) ),    \
    unitData( (UNIT (&)[nUnit]) *refPtr),   \
    data((T (&)[ROWS][COLS+rPadding])(unitData[0]))
#else
#   define INIT_REF \
    unitData( (UNIT (&)[nUnit]) *(UNIT*)aligned_stack_allocate(sizeof(UNIT)*nUnit)),    \
    data((T (&)[ROWS][COLS+rPadding])(unitData[0]))
#endif  // EXMAT_VC2005

    // MSVC does not treat multiply union initialization as error
#ifdef  _MSC_VER
    union {
#endif
        // How to add named element here?
        UNIT (&unitData)[nUnit];
        T (&data)[ROWS][COLS+rPadding];
#ifdef  _MSC_VER
    };
#endif

    EXMAT_INLINE2 SConCA_RM() : INIT_REF {
        ALIGNMENT_CHECK(sizeof(UNIT));
    }

#undef INIT_REF

    EXMAT_INLINE2 virtual ~SConCA_RM() {
        aligned_stack_free();
    }

    /************************************************/
    // Index function (for internal use, no error checking applied)
    EXMAT_INLINE2 T& setAt(size_t i)
    {   return *(&data[0][0]+i+i*rPadding/COLS);    }
    EXMAT_INLINE2 const T& getAt(size_t i) const
    {   return *(&data[0][0]+i+i*rPadding/COLS);    }
    EXMAT_INLINE2 T& setAt(size_t i, size_t j)
    {   return data[i][j];  }
    EXMAT_INLINE2 const T& getAt(size_t i, size_t j) const
    {   return data[i][j];  }
    EXMAT_INLINE2 UNIT& setUnitAt(size_t i)
    {   return unitData[i]; }
    EXMAT_INLINE2 const UNIT& getUnitAt(size_t i) const
    {   return unitData[i]; }
};

template<int ROWS_, int COLS_, typename T=float>
struct SConCA_CM : public SIMDTag, public ColMajorTag
{
    typedef typename SIMD_UNIT_Chooser<T>::RET UNIT;
    enum {
        ALIGNED = true,
        ROWS = ROWS_,
        COLS = COLS_,
        Align = SIMD_UNIT_Chooser<T>::ALIGN,
        nElePerUnit = sizeof(UNIT)/sizeof(T),
        nUnitPerCol = (ROWS+nElePerUnit-1)/nElePerUnit,
        nUnit = nUnitPerCol*COLS,
        rPadding = 0,
        cPadding = (ROWS%nElePerUnit == 0) ? 0 : nElePerUnit-ROWS%nElePerUnit,
        rStride = COLS,
        cStride = ROWS+cPadding,
        nTotalEle = COLS*(ROWS+cPadding),

        IsLinear = true,            
        IsLinearRecursive = true,   
        TNOP = 0,                   
        ENOP = 0,                   
        EXPLevel = 0
    };

    // VC2005 need to init an pointer explicitly first
#if EXMAT_VC2005
    UNIT* refPtr;
#   define INIT_REF \
    refPtr( (UNIT*)aligned_stack_allocate(sizeof(UNIT)*nUnit) ),    \
    unitData( (UNIT (&)[nUnit]) *refPtr),   \
    data((T (&)[COLS][ROWS+cPadding])(unitData[0]))
#else
#   define INIT_REF \
    unitData( (UNIT (&)[nUnit]) *(UNIT*)aligned_stack_allocate(sizeof(UNIT)*nUnit)),    \
    data((T (&)[COLS][ROWS+cPadding])(unitData[0]))
#endif  // EXMAT_VC2005

    // MSVC does not treat multiply union initialization as error
#ifdef  _MSC_VER
    union {
#endif
        UNIT (&unitData)[nUnit];
        T (&data)[COLS][ROWS+cPadding];
#ifdef  _MSC_VER
    };
#endif

    EXMAT_INLINE2 SConCA_CM() : INIT_REF {
        ALIGNMENT_CHECK(sizeof(UNIT));
    }

#undef INIT_REF

    EXMAT_INLINE2 virtual ~SConCA_CM() {
        aligned_stack_free();
    }

    /************************************************/
    // Index function (for internal use, no error checking applied)
    EXMAT_INLINE2 T& setAt(size_t i)
    {   return *(&data[0][0]+i+i*cPadding/ROWS);    }
    EXMAT_INLINE2 const T& getAt(size_t i) const
    {   return *(&data[0][0]+i+i*cPadding/ROWS);    }
    EXMAT_INLINE2 T& setAt(size_t i, size_t j)
    {   return data[j][i];  }
    EXMAT_INLINE2 const T& getAt(size_t i, size_t j) const
    {   return data[j][i];  }
    EXMAT_INLINE2 UNIT& setUnitAt(size_t i)
    {   return unitData[i]; }
    EXMAT_INLINE2 const UNIT& getUnitAt(size_t i) const
    {   return unitData[i]; }
};


template<int R, int C, typename T>
struct SConCHooser {
    typedef typename IF<
        C == 1,
        // VC6 fail to do the alignment correctly
#if EXMAT_VC6
        SConCA_CM<R,C,T>,
        SConCA_RM<R,C,T>
#else
        SCon_CM<R,C,T>,
        SCon_RM<R,C,T>
#endif  // EXMAT_VC6
    >::RET RET;
};


template<int ROWS_, int COLS_, typename T=float>
struct EXMAT_TYPE_ALIGN_PREFIX(EXMAT_SIMD_DEFAULT_ALIGN)
SCon : public SConCHooser<ROWS_,COLS_,T>::RET
{
    typedef typename SConCHooser<ROWS_,COLS_,T>::RET    super_type;
    typedef typename super_type::UNIT                   SIMD_unit_type;
    typedef T                   value_type;
    typedef value_type&         reference;
    typedef const value_type&   const_reference;
    typedef value_type*         row_type;
    typedef const value_type*   const_row_type;
    typedef NullTag             col_type;
    typedef size_t              index_type;
    typedef typename Loki::TypeTraits<value_type>::ParameterType param_type;
    typedef typename Loki::TypeTraits<const value_type>::ParameterType const_param_type;
    typedef NullTag             exp_tag;    // It's not an expression, so exp_tag is NullTag

    typedef SCon<ROWS_,COLS_,T>             self_type;
    typedef self_type                       rep_type;
    typedef mat_iterator<self_type>         iterator;
    typedef const_mat_iterator<self_type>   const_iterator;

#if EXMAT_USING_MEMVAR
    using super_type::data;
#endif  // EXMAT_USING_MEMVAR

    enum {
        ROWS = ROWS_,
        COLS = COLS_,
        nTotalEle = super_type::nTotalEle,
        nUnit = super_type::nUnit,
        rPadding = super_type::rPadding,
        cPadding = super_type::cPadding,
        rStride = super_type::rStride,
        cStride = super_type::cStride
    };

    EXMAT_INLINE2 SCon() {
        // Give valid values for data with paddings,
        // otherwise invalid float will cause floating point exceptions
        if(rPadding > 0 || cPadding > 0)
            memset(&(this->data[0][0]), 0, sizeof(value_type)*nTotalEle);
    }

    EXMAT_INLINE2 SCon(const self_type& x) {
        exmat::PNS::Assign_FullUnRollSIMD(*this, x);
    }

    EXMAT_INLINE2 explicit SCon(const value_type s) {
        SIMD_unit_type scalar = Intrinsics::load1_p(&s);
        for(int i=0; i<nUnit; ++i)
            this->unitData[i] = scalar;
    }

    EXMAT_INLINE2 self_type& operator=(const self_type& x) {
        exmat::PNS::Assign_FullUnRollSIMD(*this, x);
        return *this;
    }

    EXMAT_INLINE2 self_type& operator=(const value_type s) {
        SIMD_unit_type scalar = Intrinsics::load1_p(&s);
        for(int i=0; i<nUnit; ++i)
            this->unitData[i] = scalar;
        return *this;
    }

    /************************************************/
    // Begin / End
    EXMAT_INLINE2 iterator begin()
    {   return iterator(*this, 0, 0);   }
    EXMAT_INLINE2 const_iterator begin() const
    {   return const_iterator(*this, 0, 0); }
    EXMAT_INLINE2 iterator end()
    {   return iterator(*this, rows(), 0);  }
    EXMAT_INLINE2 const_iterator end() const
    {   return const_iterator(*this, rows(), 0);    }
    /************************************************/
    // Raw data pointer
    EXMAT_INLINE2 value_type* getRawData()
    {   return &data[0][0]; }
    /************************************************/
    // Index operator
    EXMAT_INLINE2 T* operator[] (size_t i)
    {   return &data[i][0]; }
    EXMAT_INLINE2 const T* operator[] (size_t i) const
    {   return &data[i][0]; }
    /************************************************/
    // Dimension information
    EXMAT_INLINE2 size_t size() const { return ROWS*COLS; }
    EXMAT_INLINE2 size_t rows() const { return ROWS; }
    EXMAT_INLINE2 size_t cols() const { return COLS; }

    EXMAT_INLINE2 size_t rstride() const
    {   return rStride; }
    EXMAT_INLINE2 size_t exstride() const
    {   return rPadding;    }
} EXMAT_TYPE_ALIGN_SUFFIX(EXMAT_SIMD_DEFAULT_ALIGN);

template<class Rep>
struct SSCon : public Rep
{
    typedef SSCon<Rep>  self_type;
    // Must use self_type as rep_type to enable SIMD specialized expression
    typedef self_type   rep_type;
    typedef Rep         super_type;

    enum {
        IsLinear = Rep::IsLinear,
        IsLinearRecursive = Rep::IsLinearRecursive
    };

    EXMAT_INLINE2 SSCon() : Rep() {}


    template<typename T1>
    EXMAT_INLINE2 SSCon(T1& t1) : Rep(t1) {}
    template<typename T1, typename T2>
    EXMAT_INLINE2 SSCon(T1& t1, T2& t2) : Rep(t1, t2) {}
    template<typename T1, typename T2, typename T3>
    EXMAT_INLINE2 SSCon(T1& t1, T2& t2, T3& t3) : Rep(t1, t2, t3) {}
#if !EXMAT_VC6 && !EXMAT_VC7
    template<typename T1, typename T2>
    EXMAT_INLINE2 SSCon(const T1& t1, ScalarCon<T2> t2) : Rep(t1, t2) {}
    template<typename T1, typename T2>
    EXMAT_INLINE2 SSCon(ScalarCon<T1> t1, const T2& t2) : Rep(t1, t2) {}
#endif  // HAVE_PARTIAL_SPECIALIZATION


    template<typename T1> EXMAT_INLINE2
    SSCon& operator=(const T1& t1) {
        (*static_cast<Rep*>(this)) = t1;
        return *this;
    }
};


};  // namespace SIMD

    // end of groupCon


}   // namespace exmat

#ifdef  _MSC_VER
#   pragma warning( pop )
#endif  // _MSC_VER

#endif  // _EXMAT_SIMDCONTAINER_H

---