DistributionStrategy.h

Go to the documentation of this file.

#ifndef DistributionStrategy_H_
#define DistributionStrategy_H_

#include "SimEngine.h"
#include "SimpleRandomNumberGenerator.h"
#include "RandomDistribution.h"

#include <mpi.h>

#include <vector>
using std::vector;

#include <list>
using std::list;

#include <functional>
using std::unary_function;

class SimNetwork;
class DistributedNetwork;

class DistributionStrategy
{

public:

class DistributionFunction : public unary_function<SimNetwork*, SimEngine::ID>
    {
    public:
        virtual SimEngine::ID operator()( SimNetwork* dn ) = 0;
        virtual SimEngine::ID operator()( DistributedNetwork* dn ) = 0;
        virtual ~DistributionFunction()
        { /*NOOP*/
        };
    };


class ModuloOverGlobalEngines : public DistributionFunction
    {
    public:
        ModuloOverGlobalEngines(void)
        {
            e = 0;
        };
        virtual ~ModuloOverGlobalEngines()
        { /*NOOP*/
        };
        virtual SimEngine::ID operator()( SimNetwork* net );
        virtual SimEngine::ID operator()( DistributedNetwork* dn );

    private:
        int e;
    };


class ModuloOverLocalEngines : public DistributionFunction
    {
    public:
        ModuloOverLocalEngines()
        {
            e = 0;
        };
        virtual ~ModuloOverLocalEngines()
        { /*NOOP*/
        };
        virtual SimEngine::ID operator()( SimNetwork* net );
        virtual SimEngine::ID operator()( DistributedNetwork* dn );

    private:
        int e;
    };

    typedef ModuloOverGlobalEngines GlobalRoundRobin;
    typedef ModuloOverLocalEngines LocalRoundRobin;

class ModuloOverLocalEnginesOnOneNode : public DistributionFunction
    {
    public:
        ModuloOverLocalEnginesOnOneNode(nodeid_t node)
                : node(node)
        {
            e = 0;
        };
        virtual ~ModuloOverLocalEnginesOnOneNode()
        { /*NOOP*/
        };
        virtual SimEngine::ID operator()( SimNetwork* net );
        virtual SimEngine::ID operator()( DistributedNetwork* dn );

    private:
        int e;
        nodeid_t node;

    };

class RandomOverGlobalEngines : public DistributionFunction
    {
    public:
        RandomOverGlobalEngines( const MPI::Intracomm &mpiCommunicator )
        {
            // uni = new UniformDistribution<  >( 0, 1, mpiCommunicator );
        };


        virtual ~RandomOverGlobalEngines()
        {
            // delete uni;
        };

        virtual SimEngine::ID operator()( SimNetwork* net )
        {
            return SimEngine::ID::Invalid;
        };
        virtual SimEngine::ID operator()( DistributedNetwork* dn );

    private:
        // UniformDistribution< > *uni;
    };


class RandomOverLocalEngines : public DistributionFunction
    {
    public:
        RandomOverLocalEngines(void)
        {
            // uni = new UniformDistribution< >( 0, 1 );
        };


        virtual ~RandomOverLocalEngines()
        {
            // delete uni;
        };

        virtual SimEngine::ID operator()( SimNetwork* net );
        virtual SimEngine::ID operator()( DistributedNetwork* dn );

    private:
        // UniformDistribution< > *uni;
    };

    typedef RandomOverGlobalEngines GlobalRandom;
    typedef RandomOverLocalEngines LocalRandom;



class EngineListStrategy: public DistributionFunction
    {
    public:
        EngineListStrategy(void)
        {
        };

        void setEngineList(const list<int> &the_engine_list)
        {
            engine_list = the_engine_list;
        };

        void addEngineList(const int e)
        {
            engine_list.push_back( e );
        };

        virtual ~EngineListStrategy()
        {
        };

        virtual SimEngine::ID operator()( SimNetwork* net );
        virtual SimEngine::ID operator()( DistributedNetwork* dn );

    protected:
        list<int> engine_list;

    };


class RankListStrategy: public DistributionFunction
    {
    public:
        RankListStrategy(void)
        {
            e = 0;
        };

        void setRankList(const list<int> &the_rank_list)
        {
            rank_list = the_rank_list;
        };

        void addEngineList(const int e)
        {
            rank_list.push_back( e );
        };

        virtual ~RankListStrategy()
        {
        };

        virtual SimEngine::ID operator()( SimNetwork* net );
        virtual SimEngine::ID operator()( DistributedNetwork* dn );

    protected:
        list<int> rank_list;
        int e;

    };

};

#endif /* DistributionStrategy_H_ */

---