Home Research Papers Posters Manuals Talks Download People Help Internal

util/treeStrategy_nodeAware_minGens.h

Go to the documentation of this file.

#include "charm++.h"
#include <algorithm>

#ifndef TREE_STRATEGY_NODE_AWARE_MIN_GENS
#define TREE_STRATEGY_NODE_AWARE_MIN_GENS
namespace topo {

namespace impl {
    template <typename Iterator>
    SpanningTreeVertex* buildNextGen_nodeAware_minGens(const vtxType parentPE, const Iterator firstVtx, const Iterator beyondLastVtx, const int maxBranches=2);
}

template <typename Iterator,typename ValueType = typename std::iterator_traits<Iterator>::value_type>
class SpanningTreeStrategy_nodeAware_minGens: public SpanningTreeStrategy<Iterator>
{
    public:
        inline virtual SpanningTreeVertex* buildNextGen(const Iterator firstVtx, const Iterator beyondLastVtx, const int maxBranches=2)
        { return impl::buildNextGen_nodeAware_minGens(*firstVtx, firstVtx,beyondLastVtx,maxBranches); }
};



template <typename Iterator>
class SpanningTreeStrategy_nodeAware_minGens<Iterator,SpanningTreeVertex>: public SpanningTreeStrategy<Iterator>
{
    public:
        inline virtual SpanningTreeVertex* buildNextGen(const Iterator firstVtx, const Iterator beyondLastVtx, const int maxBranches=2)
        {
            (*firstVtx).childIndex.clear();
            SpanningTreeVertex *parent = impl::buildNextGen_nodeAware_minGens((*firstVtx).id,firstVtx,beyondLastVtx,maxBranches);
            *firstVtx = *parent;
            return parent;
        }
};


namespace impl {

    #if CMK_FIND_FIRST_OF_PREDICATE

    class vtxEqual
    {
        public:
            inline bool operator() (const SpanningTreeVertex &vtx, const int num) { return vtx.id == num; }
            inline bool operator() (const int num, const SpanningTreeVertex &vtx) { return vtx.id == num; }
            inline bool operator() (const int a, const int b) { return a == b; }
    };
    #endif

    template <typename Iterator>
    SpanningTreeVertex* buildNextGen_nodeAware_minGens(const vtxType parentPE, const Iterator firstVtx, const Iterator beyondLastVtx, const int maxBranches)
    {
        SpanningTreeVertex *parent = impl::buildNextGen_topoUnaware(firstVtx,beyondLastVtx,maxBranches);

        CkAssert(parentPE < CkNumPes() );
        int numOnNode, *pesOnNode;
        CmiGetPesOnPhysicalNode(CmiPhysicalNodeID(parentPE),&pesOnNode,&numOnNode);

        if (numOnNode > 0 && parent->childIndex.size() > 0)
        {
            Iterator itr = firstVtx;
            int brNum = 0, numBranches = parent->childIndex.size();

            while ( brNum < numBranches && itr != beyondLastVtx)
            {
                std::vector<int>::iterator isChild;
                do {
            itr = std::find_first_of(++itr,beyondLastVtx,pesOnNode,pesOnNode + numOnNode
#if CMK_FIND_FIRST_OF_PREDICATE
                         , vtxEqual()
#endif
            );
                    int dist = std::distance(firstVtx,itr);
                    isChild = std::find(parent->childIndex.begin(),parent->childIndex.end(),dist);
                } while (itr != beyondLastVtx && isChild != parent->childIndex.end());

                Iterator childLoc;
                int *pos;
                do {
                    childLoc = firstVtx;
                    std::advance(childLoc,parent->childIndex[brNum]);
                    pos = std::find(pesOnNode,pesOnNode+numOnNode,*childLoc);
                } while( pos < (numOnNode+pesOnNode) && ++brNum < numBranches );

                if (itr != beyondLastVtx && brNum < numBranches)
                {
                    std::iter_swap(itr,childLoc);
                    brNum++;
                }
            }
        }

        return parent;
    }
} // end namespace impl

} // end namespace topo
#endif // TREE_STRATEGY_NODE_AWARE_MIN_GENS

---