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


/*
 *  Todo:
 *  There may be special needs to do conversion between Mat<DenseMatCon> and Mat<XXXVecCon>
 *  So that less temporaries will be needed
 */

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

#ifndef _EXMAT_EXPTMP_H
#define _EXMAT_EXPTMP_H

#include "loki/HierarchyGenerators.h"
#include "Expression.h"
#include "ExpTree.h"
#include "Tag2Exp.h"

#include <iostream>
#include <vector>
#include <deque>

#include "SIMD/SIMDAlignment.h"


namespace exmat {


    template<class Con, unsigned int IsFree_>
    struct TmpListEntry : public Con {
        typedef Con container_type;
        enum {
            IsFree = IsFree_
        };
    };


    template<class TL, class TC, size_t Index_, size_t TarIndex_>
    struct GetTmp {
    private:
        template<unsigned int Index>
        struct DefaultTmp {
            typedef typename ::Loki::TL::TypeAt<TTYPENAME TL::tmp_list, Index>::Result return_type;
            template<class TmpList> static EXMAT_INLINE2
            return_type&
            GetTmpAt(::Loki::Tuple<TmpList>& obj, TC& tCon) {
                return ::Loki::Field<Index>(obj);
            }
        };
        template<unsigned int Index>
        struct TarConTmp {
            typedef TC return_type;
            template<class TmpList> static EXMAT_INLINE2
            return_type&
            GetTmpAt(::Loki::Tuple<TmpList>& obj, TC& tCon) {
                return tCon;
            }
        };
    public:
        typedef typename IF<
            (Index_ == TarIndex_),
            TarConTmp<Index_>,
            DefaultTmp<Index_>
        >::RET RET;
    };


    template<class TmpList, int Index>
    class ReleaseTmpAt {
        struct NullT{
            typedef ::Loki::NullType container_type;
        };
        typedef typename ::Loki::TL::TypeAtNonStrict<TmpList, (unsigned int)Index, NullT>::Result TA;
        typedef typename TA::container_type container_type;
        typedef TmpListEntry<container_type, true> FreeT;
    public:
        typedef typename ::Loki::TL::ReplaceAt<TmpList, Index, FreeT>::Result RET;
    };


    template<class DyTmpCon>
    struct DynamicTmpList {
        EXMAT_INLINE1 DynamicTmpList() {
            // Reserve some space, to prevent excessive memory allocation
            ConList.reserve(10);
            AvlList.reserve(10);
            FreeList.reserve(10);
        }

        EXMAT_INLINE1 DyTmpCon& CastToCon() {
            size_t i;
            if(AccessQue.size() >= 3) {
                i = AccessQue.front();
                AccessQue.pop_front();
                AccessQue.push_back(i);
            }
            i = AccessQue.front();
            AccessQue.pop_front();
            FreeList.push_back(i);
            //std::cout << "free\n";
            //print();
            return ConList[i];
        }
        EXMAT_INLINE2 operator DyTmpCon&() {
            return CastToCon();
        }
        EXMAT_INLINE2 operator const DyTmpCon&() {
            return CastToCon();
        }

        template<class Exp> EXMAT_INLINE2
        DyTmpCon& AssignNoAna(const Exp& A) {
            return (this->assign(A));
        }

        template<class Exp> EXMAT_INLINE1
        DynamicTmpList<DyTmpCon>& operator=(const Exp& A) {
            this->assign(A);
            return *this;
        }

        // Internal function for assignment
        template<class Exp> EXMAT_INLINE2
        DyTmpCon& assign(const Exp& A) {
            int idx = -1;
            size_t i;
            // Find the first available tmp that match the dimension of A
            for(i=0; i<ConList.size(); ++i) {
                if(!AvlList[i] || ConList[i].rows() != A.rows() || ConList[i].cols() != A.cols())
                    continue;
                ConList[i] = A;
                //cout << "Use dyn idx = " << i << " with value:\n" << ConList[i] << endl;
                AvlList[i] = false;
                AccessQue.push_back(i);
                idx = int(i);
                break;
            }
            // If no tmp available, then create one
            if(idx == -1) {
                AccessQue.push_back(ConList.size());
                idx = ConList.size();
                ConList.push_back(DyTmpCon(A));
                AvlList.push_back(false);
                //cout << "Creating dyn idx = " << idx << " with value:\n" << ConList[idx] << endl;
            }

            // Free all pending free list
            for(i=0; i<FreeList.size(); ++i)
                AvlList[FreeList[i]] = true;
            FreeList.clear();

            return ConList[idx];
        }

        void print() {
            int i;
            for(i=0; i<AvlList.size(); ++i)
                std::cout << AvlList[i] << ", ";
            std::cout << std::endl;
            for(i=0; i<AccessQue.size(); ++i)
                std::cout << AccessQue[i] << ", ";
            std::cout << std::endl;
            for(i=0; i<FreeList.size(); ++i)
                std::cout << FreeList[i] << ", ";
            std::cout << std::endl;
            std::cout << std::endl;
        }
        std::vector<DyTmpCon> ConList;  // List of container
        std::vector<bool> AvlList;      // Availability list
        std::deque<size_t> AccessQue;   // Track the accessing sequence
        std::vector<size_t> FreeList;   // Tmps that are pending to free
    };

namespace PNS {

    template<class TList>
    struct ReplaceTmp
    {
    private:
        typedef typename TList::Head Head;
        typedef typename TList::Tail Tail;

        typedef typename Head::container_type container_type;
        enum {
            IsStaticRow = (container_type::ROWS > 0),
            IsStaticCol = (container_type::COLS > 0),
            IsLeftRowVec = (container_type::ROWS == 1),
            IsLeftColVec = (container_type::COLS == 1)
        };
        typedef typename IF<
            !IsStaticRow || !IsStaticCol,
            DynamicTmpList<container_type>,
            container_type
        >::RET replacing_type;
    public:
        typedef Loki::Typelist<replacing_type, typename ReplaceTmp<Tail>::Result> Result;
    };

    template <>
    struct ReplaceTmp<Loki::NullType> {
        typedef Loki::NullType Result;
    };
};



    template<class TmpList>
    struct TmpInstance : public ::Loki::Tuple<TmpList> {
        typedef TmpList tmp_list;
        EXMAT_INLINE2 TmpInstance() {}
    };


    // Forward declarations
    template<class Exp, class TmpList, class TarConType, class ForceUseTmp,
        int IsRootNode=false, bool NeedTmp_=false>
    struct TmpAnalyserUnaNode;
    template<class Exp, class TmpList, class TarConType, class ForceUseTmp,
        int IsRootNode=false, bool NeedTmp_=false>
    struct TmpAnalyserBinNode;



    template<class Exp_, class TmpList, class TarConType, class ForceUseTmp, int IsRootNode, bool NeedTmp_>
    struct TmpAnalyserUnaNode {
        typedef Exp_ Exp;
        enum {
            IsCBin = IsDerivedFrom<typename Exp::super_type,BinExpTag>::RET,
            IsCUna = IsDerivedFrom<typename Exp::super_type,UnaExpTag>::RET,
            IsCLeaf = (!IsCBin && !IsCUna),
            CNeedTmp = false,
            IsDynamicTmp = (Exp::ROWS == 0) || (Exp::COLS == 0),
            IsTarConDynamic = (TarConType::ROWS == 0 || TarConType::COLS == 0)
        };

        typedef typename Exp::exp_tag exp_tag;
        typedef typename IF<
            IsRootNode == int(true),
            TarConType,                 // We sure the temp_type of the root node
            TTYPENAME Exp::temp_type    // must be the target container type
        >::RET temp_type;

        private:
        typedef TmpListEntry<temp_type, true> E1;   // Free entry
        typedef typename IF<                        // Used entry
            IsDynamicTmp,       // Dynamic temp is always available at compile time
            TmpListEntry<temp_type, true>,
            TmpListEntry<temp_type, false>
        >::RET E2;
        public:

        typedef typename IF<
            IsCLeaf,
            LeafeNode<typename Exp::super_type>,
        typename IF<
            IsCUna,
            TmpAnalyserUnaNode<typename Exp::super_type, TmpList, TarConType, ForceUseTmp>,
            TmpAnalyserBinNode<typename Exp::super_type, TmpList, TarConType, ForceUseTmp>
        >::RET>::RET child;

        private:
        typedef typename IF<
            IsCLeaf,
            TmpList,
        typename IF<
            IsCUna,
            TTYPENAME child::tmp_list,
            TTYPENAME child::tmp_list
        >::RET>::RET cTL;
        public:

        typedef typename IF<
            NeedTmp_,
            temp_type,
            Mat<
#if (HAVE_TT_PARAMETER)
                TTYPENAME RefillUnaExp<TTYPENAME Exp::rep_type,
#else
                TTYPENAME Tag2UnaExp<exp_tag,
#endif
                    TTYPENAME child::node_exp::rep_type,
                    TTYPENAME Exp::extra_param_type
                >::RET,
                EmptyErrorChecker
            >
        >::RET node_exp;

        private:
        // Request one temp for itself
        enum {
            PreTmpIndex = ::Loki::TL::IndexOf<cTL, E1>::value
        };
        typedef typename IF<
            PreTmpIndex == -1,      // Not enough temp in the list
            // Append new temp to list
            typename ::Loki::TL::Append<cTL, E2>::Result,
            // Mark the tmp to be unavailable
            typename ::Loki::TL::ReplaceAt<cTL, PreTmpIndex, E2>::Result
        >::RET PreRed_list;
        public:

        enum {
            CTmpIndex = child::TmpIndex,
            TmpIndex =
                IsRootNode && IsTarConDynamic ?
                0 :
                !NeedTmp_ && !IsRootNode?
                -1 : (
                    // New temp been added to Tlist?
                    (PreTmpIndex == -1) ?
                    // If yes then the index is the last
                    ::Loki::TL::Length<PreRed_list>::value-1 :
                    // Otherwise use PreTmpIndex
                    PreTmpIndex
                )
        };

        private:
        // Release the child's temp
        typedef typename ReleaseTmpAt<PreRed_list, CTmpIndex>::RET CRed_list;
        public:

        typedef typename IF<
            NeedTmp_, CRed_list, cTL
        >::RET tmp_list;


        template<class Tag> static void print(Tag) {
            child::print(TTYPENAME child::exp_tag());
            std::cout << Tag::name() << ", to index: " << TmpIndex << std::endl;
        }



        template<class TInst, class TargetCon, class TarConIndex> EXMAT_INLINE2
        static const node_exp& getNodeObj(const Exp& exp, TInst& tmpInst,
            TargetCon& tCon, Int2Type<0+2*1>, TarConIndex)
        {
            enum {
                TIdx = TarConIndex::RET
            };
            typedef Mat<
#if (HAVE_TT_PARAMETER)
                TTYPENAME RefillUnaExp<TTYPENAME Exp::rep_type,
#else
                TTYPENAME Tag2UnaExp<exp_tag,
#endif
                    TTYPENAME child::node_exp::rep_type,
                    TTYPENAME Exp::extra_param_type
                >::RET,
                EmptyErrorChecker
            > expT;
            typedef typename GetTmp<TInst, TargetCon, TmpIndex, TIdx>::RET GT;
            typedef typename GT::return_type RT;
            // Use node_exp::rep_type to prevent the problem of different error checker,
            // at this point the cast operator of DynamicTmpList will be called
            return *((const node_exp*)(&
                GT::GetTmpAt(tmpInst, tCon).AssignNoAna(expT(
                    exp,
                    child::getNodeObj(
                        *((const typename child::Exp*)(&exp.rep)),
                        tmpInst, tCon,
                    Int2Type<IsCLeaf+2*CNeedTmp>(), TarConIndex())
                ))
            ));
        }
        // Create an unary node
        template<class TInst, class TargetCon, class TarConIndex> EXMAT_INLINE2
        static const node_exp getNodeObj(const Exp& exp, TInst& tmpInst,
            TargetCon& tCon, Int2Type<0+2*0>, TarConIndex)
        {
            return node_exp(
                exp,
                child::getNodeObj(
                    *((const typename child::Exp*)(&exp.rep)),
                    tmpInst, tCon,
                    Int2Type<IsCLeaf+2*CNeedTmp>(), TarConIndex())
            );
        }

        template<class TInst, class TargetCon, class TarConIndex> EXMAT_INLINE2
        static void ass_root(const Exp& exp, TInst& tmpInst,
            TargetCon& tCon, TarConIndex)
        {
            tCon.AssignNoAna(
                getNodeObj(exp, tmpInst, tCon, Int2Type<0+2*0>(), TarConIndex())
            );
        }
    };



    template<class Exp_, class TmpList, class TarConType, class ForceUseTmp, int IsRootNode, bool NeedTmp_>
    struct TmpAnalyserBinNode {
        typedef Exp_ Exp;
        enum {
            Forced = ForceUseTmp::RET,
            IsLinearExp = Exp::IsLinear,
            IsLLinear = Exp::left_type::IsLinear,
            IsRLinear = Exp::right_type::IsLinear,
            IsSIMDExp = IsDerivedFrom<Exp,SIMDTag>::RET,
            IsLCon = (Exp::left_type::EXPLevel == 0),
            IsRCon = (Exp::right_type::EXPLevel == 0),
            IsLBin = IsDerivedFrom<typename Exp::left_type,BinExpTag>::RET,
            IsRBin = IsDerivedFrom<typename Exp::right_type,BinExpTag>::RET,
            IsLUna = IsDerivedFrom<typename Exp::left_type,UnaExpTag>::RET,
            IsRUna = IsDerivedFrom<typename Exp::right_type,UnaExpTag>::RET,
            IsLSIMD = IsDerivedFrom<typename Exp::left_type,SIMDTag>::RET,
            IsRSIMD = IsDerivedFrom<typename Exp::right_type,SIMDTag>::RET,
            LNeedTmp =
                Forced ? IsLBin : (
                    (!IsLinearExp && Exp::COLS!=1) ||
                    (IsSIMDExp && !IsLinearExp) || (IsLSIMD && !IsLLinear)
                ) && (!IsLCon), //<- Container always need no temp
            RNeedTmp =
                Forced ? IsRBin : (
                    (!IsLinearExp) ||
                    (IsSIMDExp && !IsLinearExp) || (IsRSIMD && !IsRLinear)
                ) && (!IsRCon), //<- Container always need no temp
            IsLLeaf =
                Forced ? IsLCon :
                (Exp::left_type::IsLinearRecursive && !LNeedTmp) || (!IsLUna && !IsLBin),
            IsRLeaf =
                Forced ? IsRCon :
                (Exp::right_type::IsLinearRecursive && !RNeedTmp) || (!IsRUna && !IsRBin),
            IsDynamicTmp = (Exp::ROWS == 0) || (Exp::COLS == 0),
            IsTarConDynamic = (TarConType::ROWS == 0 || TarConType::COLS == 0)
        };

        typedef typename Exp::exp_tag exp_tag;
        typedef typename IF<
            IsRootNode == int(true),
            TarConType,                 // We sure the temp_type of the root node
            TTYPENAME Exp::temp_type    // must be the target container type
        >::RET temp_type;

        private:
        typedef TmpListEntry<temp_type, true> E1;   // Free entry
        typedef typename IF<                        // Used entry
            IsDynamicTmp,       // Dynamic temp is always available at compile time
            TmpListEntry<temp_type, true>,
            TmpListEntry<temp_type, false>
        >::RET E2;
        public:

        typedef typename IF<
            IsLLeaf,
            LeafeNode<typename Exp::left_type>,
        typename IF<
            IsLUna,
            TmpAnalyserUnaNode<typename Exp::left_type, TmpList, TarConType, ForceUseTmp, false, LNeedTmp>,
            TmpAnalyserBinNode<typename Exp::left_type, TmpList, TarConType, ForceUseTmp, false, LNeedTmp>
        >::RET>::RET left_child;

        private:
        typedef typename IF<
            IsLLeaf,
            TmpList,
        typename IF<
            IsLUna,
            TTYPENAME left_child::tmp_list,
            TTYPENAME left_child::tmp_list
        >::RET>::RET lTL;
        public:

        typedef typename IF<
            IsRLeaf,
            LeafeNode<typename Exp::right_type>,
        typename IF<
            IsRUna,
            TmpAnalyserUnaNode<typename Exp::right_type, lTL, TarConType, ForceUseTmp, false, RNeedTmp>,
            TmpAnalyserBinNode<typename Exp::right_type, lTL, TarConType, ForceUseTmp, false, RNeedTmp>
        >::RET>::RET right_child;

        private:
        typedef typename IF<
            IsRLeaf,
            lTL,
        typename IF<
            IsRUna,
            TTYPENAME right_child::tmp_list,
            TTYPENAME right_child::tmp_list
        >::RET>::RET rTL;
        public:

        typedef typename IF<
            NeedTmp_,
            temp_type,
            Mat<
#if (HAVE_TT_PARAMETER)
            TTYPENAME RefillBinExp<TTYPENAME Exp::rep_type,
#else
            TTYPENAME Tag2BinExp<exp_tag,
#endif
                    TTYPENAME left_child::node_exp::rep_type,
                    TTYPENAME right_child::node_exp::rep_type>::RET,
                EmptyErrorChecker
            >
        >::RET node_exp;

        private:
        // Request one temp for itself
        enum {
            PreTmpIndex = ::Loki::TL::IndexOf<rTL, E1>::value
        };
        typedef typename IF<
            PreTmpIndex == -1,      // Not enough temp in the list
            // Append new temp to list
            typename ::Loki::TL::Append<rTL, E2>::Result,
            // Mark the tmp to be unavailable
            typename ::Loki::TL::ReplaceAt<rTL, PreTmpIndex, E2>::Result
        >::RET PreRed_list;
        public:

        enum {
            LTmpIndex = left_child::TmpIndex,
            RTmpIndex = right_child::TmpIndex,
            TmpIndex =
                IsRootNode && IsTarConDynamic ?
                0 :
                !NeedTmp_ && !IsRootNode ?
                -1 : (
                    // New temp been added to Tlist?
                    (PreTmpIndex == -1) ?
                    // If yes then the index is the last
                    ::Loki::TL::Length<PreRed_list>::value-1 :
                    // Otherwise use PreTmpIndex
                    PreTmpIndex
                )
        };

        private:
        // Release the left child's temp
        typedef typename ReleaseTmpAt<PreRed_list, LTmpIndex>::RET LRed_list;
        // Release the right child's temp
        typedef typename ReleaseTmpAt<LRed_list, RTmpIndex>::RET RRed_list;
        public:

        typedef typename IF<
            NeedTmp_, RRed_list, rTL
        >::RET tmp_list;


        template<class Tag> static void print(Tag) {
            left_child::print(TTYPENAME left_child::exp_tag());
            right_child::print(TTYPENAME right_child::exp_tag());
            std::cout << Tag::name() << ", to index: " << TmpIndex << std::endl;
            std::cout << "LNeedTmp: " << LNeedTmp << "\n";
            std::cout << "RNeedTmp: " << RNeedTmp << "\n";
            std::cout << "IsLLeaf: " << IsLLeaf << "\n";
            std::cout << "IsRLeaf: " << IsRLeaf << "\n";
//          cout << typeid(Exp).name() << " ";
        }



        template<class TInst, class TargetCon, class TarConIndex> EXMAT_INLINE2
        static const node_exp& getNodeObj(const Exp& exp, TInst& tmpInst,
            TargetCon& tCon, Int2Type<0+2*1>, TarConIndex)
        {
            enum {
                TIdx = TarConIndex::RET
            };
            typedef Mat<
#if (HAVE_TT_PARAMETER)
                TTYPENAME RefillBinExp<TTYPENAME Exp::rep_type,
#else
                TTYPENAME Tag2BinExp<exp_tag,
#endif
                    TTYPENAME left_child::node_exp::rep_type,
                    TTYPENAME right_child::node_exp::rep_type>::RET,
                EmptyErrorChecker
            > expT;
            typedef typename GetTmp<TInst, TargetCon, TmpIndex, TIdx>::RET GT;
            // Force the left child node to be evaluated first
            const typename left_child::node_exp& ln =
                left_child::getNodeObj(
                    // Casting must be used, otherwise temporary will be passed
                    // instead of reference. The will happen especially for SIMD exp
                    *((const typename left_child::Exp*)(&exp.leftOp)),
                    tmpInst, tCon,
                    Int2Type<IsLLeaf+2*LNeedTmp>(), TarConIndex());
            // The error checker between TargetCon and node_exp may be different.
            // The container type may also be the same but presented differently.
            // Therefore we cast the pointer explicitly.
            return *((const node_exp*)(&
                GT::GetTmpAt(tmpInst, tCon).AssignNoAna(expT(
                    ln,
                    right_child::getNodeObj(
                        *((const typename right_child::Exp*)(&exp.rightOp)),
                        tmpInst, tCon,
                        Int2Type<IsRLeaf+2*RNeedTmp>(), TarConIndex()
                    )
                ))
            ));
        }
        template<class TInst, class TargetCon, class TarConIndex> EXMAT_INLINE2
        static const node_exp getNodeObj(const Exp& exp, TInst& tmpInst,
            TargetCon& tCon, Int2Type<0+2*0>, TarConIndex)
        {
            // Force the left child node to be evaluated first
            const typename left_child::node_exp& ln =
                left_child::getNodeObj(
                    *((const typename left_child::Exp*)(&exp.leftOp)),
                    tmpInst, tCon,
                    Int2Type<IsLLeaf+2*LNeedTmp>(), TarConIndex());
            return node_exp(
                ln,
                right_child::getNodeObj(
                    *((const typename right_child::Exp*)(&exp.rightOp)),
                    tmpInst, tCon,
                    Int2Type<IsRLeaf+2*RNeedTmp>(), TarConIndex()
                )
            );
        }

        template<class TInst, class TargetCon, class TarConIndex> EXMAT_INLINE2
        static void ass_root(const Exp& exp, TInst& tmpInst,
            TargetCon& tCon, TarConIndex)
        {
            tCon.AssignNoAna(
                getNodeObj(exp, tmpInst, tCon, Int2Type<0+2*0>(), TarConIndex())
            );
        }
    };


    template<class Exp, class Con, class ErrChk1, class ErrChk2, class ForceUseTmp> EXMAT_INLINE2
    static void parseExp_inner(Mat<Con, ErrChk1>& mat,
        const Mat<Exp, ErrChk2>& exp, Int2Type<1+2*0>, ForceUseTmp) {
        typedef Mat<Con, ErrChk1> TarConType;
        enum {
            // This target index only valid for static target con
            TargetIndex = TmpAnalyserUnaNode<Exp, Loki::NullType, TarConType, ForceUseTmp, true>::TmpIndex,
            // is the target container dynamic?
            IsTarConDynamic =
                (Con::ROWS == 0 || Con::COLS == 0)
        };
        // Define the unavailable target container
        typedef TmpListEntry<Mat<Con, EmptyErrorChecker>, false> UnAvailableTarCon;
        // Insert the UnAvailableTarCon into the analyzer,
        // so that the target con will always occupied the list at index 0,
        // if the target con is dynamic
        typedef typename IF<
            IsTarConDynamic,
            LOKI_TYPELIST_1(UnAvailableTarCon),
            Loki::NullType
        >::RET tmplist;
        // Replace the type in tmp list, simplify static tmp, warp dynamic tmp with DynamicTmpList
        typedef typename exmat::PNS::ReplaceTmp<
            TTYPENAME TmpAnalyserUnaNode<Exp, tmplist, TarConType, ForceUseTmp, true>::tmp_list
        >::Result ReplacedTList;
        // Create instance of the tmp list
        TmpInstance<ReplacedTList> tmpInstance;
//      cout << "TargetIndex: " << TargetIndex << endl;
//      TmpAnalyserUnaNode<Exp, tmplist, TarConType, ForceUseTmp, true>::print(TTYPENAME Exp::exp_tag());
        TmpAnalyserUnaNode<Exp, tmplist, TarConType, ForceUseTmp, true>::
			ass_root(exp, tmpInstance, mat, Int2Type<TargetIndex>());
    }

    template<class Exp, class Con, class ErrChk1, class ErrChk2, class ForceUseTmp> EXMAT_INLINE2
    static void parseExp_inner(Mat<Con, ErrChk1>& mat,
        const Mat<Exp, ErrChk2>& exp, Int2Type<0+2*1>, ForceUseTmp)
    {
        typedef Mat<Con, ErrChk1> TarConType;
        enum {
            // This target index only valid for static target con
            TargetIndex = TmpAnalyserBinNode<Exp, Loki::NullType, TarConType, ForceUseTmp, true>::TmpIndex,
            // is the target container dynamic?
            IsTarConDynamic =
                (Con::ROWS == 0 || Con::COLS == 0)
        };
        // Define the unavailable target container
        typedef TmpListEntry<Mat<Con, EmptyErrorChecker>, false> UnAvailableTarCon;
        // Insert the UnAvailableTarCon into the analyzer,
        // so that the target con will always occupied the list at index 0,
        // if the target con is dynamic
        typedef typename IF<
            IsTarConDynamic,
            LOKI_TYPELIST_1(UnAvailableTarCon),
            Loki::NullType
        >::RET tmplist;
        // Replace the type in tmp list, simplify static tmp, warp dynamic tmp with DynamicTmpList
        typedef typename exmat::PNS::ReplaceTmp<
            TTYPENAME TmpAnalyserBinNode<Exp, tmplist, TarConType, ForceUseTmp, true>::tmp_list
        >::Result ReplacedTList;
        // Create instance of the tmp list
        EXMAT_VAR_ALIGN(TmpInstance<ReplacedTList> tmpInstance, EXMAT_SIMD_DEFAULT_ALIGN);
//      cout << "TargetIndex: " << TargetIndex << endl;
//      TmpAnalyserBinNode<Exp, tmplist, TarConType, ForceUseTmp, true>::print(TTYPENAME Exp::exp_tag());
        TmpAnalyserBinNode<Exp, tmplist, TarConType, ForceUseTmp, true>::
			ass_root(exp, tmpInstance, mat, Int2Type<TargetIndex>());
    }

    template<class Exp, class Con, class ErrChk1, class ErrChk2, class ForceUseTmp> EXMAT_INLINE2
    static void parseExp_inner(Mat<Con, ErrChk1>& mat,
        const Mat<Exp, ErrChk2>& exp, Int2Type<0+2*0>, ForceUseTmp)
    {
        mat.AssignNoAna(exp);
    }


    template<class Exp, class Con, class ErrChk1, class ErrChk2> EXMAT_INLINE2
    static void parseExp(Mat<Con, ErrChk1>& mat, const Mat<Exp, ErrChk2>& exp) {
        enum {
            IsUna = IsDerivedFrom<Exp,UnaExpTag>::RET,
            IsBin = IsDerivedFrom<Exp,BinExpTag>::RET,
            // If the rhs is linear recursive, no tmp analysis is needed
            IsLinear = Exp::IsLinearRecursive,
            // Split the expression for SIMD container
//          ForceUseTmp = IsDerivedFrom<Con,SIMDTag>::RET
            ForceUseTmp = false
        };
        parseExp_inner(mat, exp,
            Int2Type<
                (IsLinear && !ForceUseTmp) ? 0 :
                (IsUna+2*IsBin)
            >(),
            Int2Type<ForceUseTmp>()
        );
    }

}   // namespace exmat

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

#endif  // _EXMAT_EXPTMP_H

---