Assignment.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
 *
 */


#ifdef _MSC_VER
#   pragma once
#   pragma warning( push )
#   pragma warning( disable : 4512 4714 4786 )
#endif  // _MSC_VER

#ifndef _EXMAT_ASSIGNMENT_H
#define _EXMAT_ASSIGNMENT_H

#include "Metaprogramming.h"
#include "Expression.h"         // Include expression for some static analysis
#include "Container/Container.h"

#include "ExpTmp.h"
#include "AliasAnalyser.h"


namespace exmat {

template<class Rep, class ErrChecker_> class Mat;

namespace PNS {

    /************************************************/
    //{@
    template<class MAT1, class MAT2>
    struct Assign_UnRollRowCol_ENV {
        EXMAT_INLINE2 Assign_UnRollRowCol_ENV(MAT1& A, const MAT2& B) : A_(A), B_(B) {}
        MAT1& A_;
        const MAT2& B_;
    };
    template<class MAT1, class MAT2>
    struct Assign_UnRoll_ENV {
        EXMAT_INLINE2 Assign_UnRoll_ENV(MAT1& A, const MAT2& B) : A_(A), B_(B) {}
        MAT1& A_;
        const MAT2& B_;
        typename MAT1::index_type i;
    };

    template<class MAT1, class MAT2, int row_=0, int col_=0>
    struct Assign_UnRollRowCol_STAT {
        typedef LinearBinExpSize<MAT1, MAT2> BINEXPSize;
        enum {
            ROWS = BINEXPSize::ROWS,
            COLS = BINEXPSize::COLS,
            r = col_ == COLS ? row_+1 : row_,
            c = col_ < COLS ? col_ : 0
        };
        EXMAT_INLINE2 static void
        exec(Assign_UnRollRowCol_ENV<MAT1, MAT2>& env) {
            typedef typename MAT1::value_type value_type;
            env.A_.setAt(r, c) = (value_type)(env.B_.getAt(r, c));
        }
        typedef Assign_UnRollRowCol_STAT<MAT1, MAT2, r, c+1> Next;
        enum { Condition = (r < ROWS && c < COLS) };
    };

    template<class MAT1, class MAT2, int r=0>
    struct Assign_UnRollRow_STAT {
        typedef LinearBinExpSize<MAT1, MAT2> BINEXPSize;
        enum {
            ROWS = BINEXPSize::ROWS
        };
        EXMAT_INLINE2 static void
        exec(Assign_UnRoll_ENV<MAT1, MAT2>& env) {
            env.A_.setAt(r, env.i) = env.B_.getAt(r, env.i);
        }
        typedef Assign_UnRollRow_STAT<MAT1, MAT2, r+1> Next;
        enum { Condition = (r < ROWS) };
    };

    template<class MAT1, class MAT2, int c=0>
    struct Assign_UnRollCol_STAT {
        typedef LinearBinExpSize<MAT1, MAT2> BINEXPSize;
        enum {      // BINEXP::LinearStaticColMat should not be NullTag
            COLS = BINEXPSize::COLS
        };
        EXMAT_INLINE2 static void
        exec(Assign_UnRoll_ENV<MAT1, MAT2>& env) {
            env.A_.setAt(env.i, c) = env.B_.getAt(env.i, c);
        }
        typedef Assign_UnRollCol_STAT<MAT1, MAT2, c+1> Next;
        enum { Condition = (c < COLS) };
    };

    template<class MAT1, class MAT2> EXMAT_INLINE2
    static void Assign_FullUnRoll(MAT1& A, const MAT2& B) {
        Assign_UnRollRowCol_ENV<MAT1, MAT2> env(A, B);
        EWHILE1<Assign_UnRollRowCol_STAT<MAT1, MAT2> >::exec(env);
    }
    template<class MAT1, class MAT2> EXMAT_INLINE2
    static void Assign_FullUnRollRow(MAT1& A, const MAT2& B) {
        Assign_UnRoll_ENV<MAT1, MAT2> env(A, B);
        typename MAT1::index_type cols_ = A.cols();
        for(env.i=0; env.i<cols_; ++env.i )
            EWHILE1<Assign_UnRollRow_STAT<MAT1, MAT2> >::exec(env);
    }
    template<class MAT1, class MAT2> EXMAT_INLINE2
    static void Assign_FullUnRollCol(MAT1& A, const MAT2& B) {
        Assign_UnRoll_ENV<MAT1, MAT2> env(A, B);
        typename MAT1::index_type rows_ = A.rows();
        for(env.i=0; env.i<rows_; ++env.i )
            EWHILE1<Assign_UnRollCol_STAT<MAT1, MAT2> >::exec(env);
    }
    template<class MAT1, class MAT2> EXMAT_INLINE1
    static void Assign_PartialUnRoll(MAT1& A, const MAT2& B) {
        typedef typename MAT1::index_type index_type;
        index_type rows_ = A.rows();
        index_type cols_ = A.cols();
        for(index_type i=0; i<rows_; ++i ) {
            register int n=(cols_+7)/8;
            int j = -1;
            switch(cols_%8) {
                case 0: do{ A.setAt(i, j) = B.getAt(i, ++j);
                case 7:     A.setAt(i, j) = B.getAt(i, ++j);
                case 6:     A.setAt(i, j) = B.getAt(i, ++j);
                case 5:     A.setAt(i, j) = B.getAt(i, ++j);
                case 4:     A.setAt(i, j) = B.getAt(i, ++j);
                case 3:     A.setAt(i, j) = B.getAt(i, ++j);
                case 2:     A.setAt(i, j) = B.getAt(i, ++j);
                case 1:     A.setAt(i, j) = B.getAt(i, ++j);
                } while(--n>0);
            }
        }
    }
    template<class MAT1, class MAT2> EXMAT_INLINE1
    static void Assign_NoUnRoll(MAT1& A, const MAT2& B) {
        typedef typename MAT1::index_type index_type;
        typedef typename MAT1::value_type value_type;
        index_type rows_ = A.rows();
        index_type cols_ = A.cols();
        for(index_type i=0; i<rows_; ++i ) {
            for(index_type j=0; j<cols_; ++j )
                A.setAt(i, j) = value_type(B.getAt(i, j));
        }
    }
    template<class MAT1, class MAT2, int i=0>
    struct Assign_UnRollSIMDSTAT {
        enum {
            nUnits = MAT1::nUnit,
        };
        EXMAT_INLINE2 static void
        exec(Assign_UnRollRowCol_ENV<MAT1, MAT2>& env) {
            env.A_.setUnitAt(i) = env.B_.getUnitAt(i);
        }
        typedef Assign_UnRollSIMDSTAT<MAT1, MAT2, i+1> Next;
        enum { Condition = (i < nUnits) };
    };
    template<class MAT1, class MAT2> EXMAT_INLINE2
    static void Assign_FullUnRollSIMD(MAT1& A, const MAT2& B) {
        Assign_UnRollRowCol_ENV<MAT1, MAT2> env(A, B);
        EWHILE1<Assign_UnRollSIMDSTAT<MAT1, MAT2> >::exec(env);
    }

    struct ASSIGN_TYPE {
        enum  {
            Ass_NoUnRoll = 0,
            Ass_FullUnRollRow = 1,
            Ass_FullUnRollCol = 2,
            Ass_FullUnRoll = 3,
            Ass_SIMD = 4
        };
    };

    /************************************************/
    template<class MAT1, class MAT2> EXMAT_INLINE2 static
    void Assign(MAT1& A, const MAT2& B, Int2Type<ASSIGN_TYPE::Ass_FullUnRoll>) {
#if ENABLE_UNROLLING
        Assign_FullUnRoll(A, B);
#else
        Assign_NoUnRoll(A, B);
#endif
    }
    template<class MAT1, class MAT2> EXMAT_INLINE2 static
    void Assign(MAT1& A, const MAT2& B, Int2Type<ASSIGN_TYPE::Ass_FullUnRollRow>) {
#if ENABLE_UNROLLING
        Assign_FullUnRollRow(A, B);
#else
        Assign_NoUnRoll(A, B);
#endif
    }
    template<class MAT1, class MAT2> EXMAT_INLINE2 static
    void Assign(MAT1& A, const MAT2& B, Int2Type<ASSIGN_TYPE::Ass_FullUnRollCol>) {
#if ENABLE_UNROLLING
        Assign_FullUnRollCol(A, B);
#else
        Assign_NoUnRoll(A, B);
#endif
    }
    template<class MAT1, class MAT2> EXMAT_INLINE2 static
    void Assign(MAT1& A, const MAT2& B, Int2Type<ASSIGN_TYPE::Ass_NoUnRoll>) {
        Assign_NoUnRoll(A, B);
        // PartialUnRoll seems didn't help much
//      Assign_PartialUnRoll(A, B);
    }
    template<class MAT1, class MAT2> EXMAT_INLINE2 static
    void Assign(MAT1& A, const MAT2& B, Int2Type<ASSIGN_TYPE::Ass_SIMD>) {
        enum {
            WholeAssign =
                IsDerivedFrom<MAT2, MulExpTag>::RET &&
                !MAT2::IsLinearRecursive &&
                MAT2::EXPLevel == 2,
        };
        Assign_SIMD_inner(A, B, Int2Type<WholeAssign>());
    }
    template<class MAT1, class MAT2> EXMAT_INLINE2 static
    void Assign_SIMD_inner(MAT1& A, const MAT2& B, Int2Type<true> WholeAssign) {
#if EXMAT_ENABLE_SIMD
        typedef typename MAT1::value_type value_type;
        exmat::SIMD::SIMDMatMul(A, B.leftOp, B.rightOp, Type2Type<value_type>());
//      std::cout << "SIMDMatMul is called.\n";
#else
        Assign_NoUnRoll(A, B);
#endif  // EXMAT_ENABLE_SIMD
    }
    template<class MAT1, class MAT2> EXMAT_INLINE2 static
    void Assign_SIMD_inner(MAT1& A, const MAT2& B, Int2Type<false> WholeAssign) {
        Assign_FullUnRollSIMD(A, B);
        //for(size_t i=0; i<MAT1::nUnit; ++i)
        //  A.setUnitAt(i) = B.getUnitAt(i);
    }

};


struct ASSIGN_ANALYSIS {
    enum {
        NONE        = 1 << 0,
        ALIAS       = 1 << 1,
        TEMPORARY   = 1 << 2
    };
};

template<class Mat1, class Mat2> EXMAT_INLINE2 static
void CopyDimension_inner(Mat1& dest, const Mat2& src, Int2Type<false>, Int2Type<false>) {
}
template<class Mat1, class Mat2> EXMAT_INLINE0 static
void CopyDimension_inner(Mat1& dest, const Mat2& src, Int2Type<true>, Int2Type<false>) {
    dest.resize(src.rows());
}
template<class Mat1, class Mat2> EXMAT_INLINE0 static
void CopyDimension_inner(Mat1& dest, const Mat2& src, Int2Type<false>, Int2Type<true>) {
    dest.resize(src.cols());
}
template<class Mat1, class Mat2> EXMAT_INLINE0 static
void CopyDimension_inner(Mat1& dest, const Mat2& src, Int2Type<true>, Int2Type<true>) {
    dest.resize(src.rows(), src.cols());
}
// Resize dest to the same dimension as src, if any dimension of dest is dynamic
template<class Mat1, class Mat2> EXMAT_INLINE0 static
void CopyDimension(Mat1& dest, const Mat2& src) {
    CopyDimension_inner(dest, src, Int2Type<Mat1::ROWS==0>(), Int2Type<Mat1::COLS==0>());
}

template<class Rep1, class Rep2, class EC1, class EC2> EXMAT_INLINE2 static
void assign(Mat<Rep1,EC1>& dest, const Mat<Rep2,EC2>& exp, int assign_type=EXMAT_DEFAULT_ANALYSIS)
{
    using namespace exmat::PNS;
#if ENABLE_ALIAS_ANALYSIS
    if((assign_type & ASSIGN_ANALYSIS::ALIAS) != 0) {
        if(IsAliased(dest, exp)) {
            typename GetAliasTmpType<Mat<Rep1,EC1> >::RET tmp;
            // Resize tmp if it's dynamic sized
            CopyDimension(tmp, dest);
            // Assign exp to tmp first.
// The compilation won't stop for VC release build when using recursive inline.
// Recursive inlining unimplemented for GNUC
#   if EXMAT_VC6 || EXMAT_VC7 || EXMAT_VC2003 || EXMAT_VC2005 || EXMAT_GNUC
#       if ENABLE_TMP_ANALYSIS
            if((assign_type & ASSIGN_ANALYSIS::TEMPORARY) != 0)
                parseExp(tmp, exp);
            else
#       endif   // ENABLE_TMP_ANALYSIS
                GetAliasTmpType<Mat<Rep1,EC1> >::RET::AssignDispatcher(tmp, exp);
#   else
            // Assign exp to tmp, without alias analysis by calling assign recursively
            assign(tmp, exp, (assign_type & ~ASSIGN_ANALYSIS::ALIAS));
#   endif
            // Copy tmp back to dest
            Mat<Rep1,EC1>::AssignDispatcher(dest, tmp);
            return;
        }
    }
#endif  // ENABLE_ALIAS_ANALYSIS

#if ENABLE_TMP_ANALYSIS
    if((assign_type & ASSIGN_ANALYSIS::TEMPORARY) != 0) {
        parseExp(dest, exp);
        return;
    }
#endif  // ENABLE_TMP_ANALYSIS
    
    Mat<Rep1,EC1>::AssignDispatcher(dest, exp);
}


}   // namespace exmat

#if _MSC_VER
#   pragma warning( pop )
#endif  // EXMAT_VC

#endif  // _EXMAT_ASSIGNMENT_H

---