model.h

Go to the documentation of this file.

#ifndef FPMAS_MODEL_DETAIL_H
#define FPMAS_MODEL_DETAIL_H
 
#include "fpmas/api/model/model.h"
#include "fpmas/graph/distributed_graph.h"
#include "fpmas/graph/zoltan_load_balancing.h"
#include "fpmas/graph/scheduled_load_balancing.h"
#include "fpmas/runtime/runtime.h"
 
namespace fpmas {
    namespace model {
        using api::model::AgentNode;
        using api::model::AgentEdge;
        using api::model::AgentPtr;
        using api::model::GroupId;
        using api::scheduler::JID;
 
        class DefaultBehavior : public api::model::Behavior {
            public:
                void execute(api::model::Agent* agent) const override {
                    agent->act();
                }
        };
 
        namespace detail {
            class AgentTaskBase : public scheduler::TaskBase<api::model::AgentTask> {
                protected:
                    api::model::AgentPtr& _agent;
                public:
                    AgentTaskBase(api::model::AgentPtr& agent_ptr)
                        : _agent(agent_ptr) {}
 
                    const api::model::AgentPtr& agent() const override {
                        return _agent;
                    }
 
                    AgentNode* node() override {
                        return _agent->node();
                    }
            };
 
            class AgentTask : public AgentTaskBase {
                public:
                    AgentTask(api::model::AgentPtr& agent_ptr)
                        : AgentTaskBase(agent_ptr) {}
 
 
                    void run() override {
                        _agent->act();
                    }
            };
 
            class AgentBehaviorTask : public AgentTaskBase {
                private:
                    const api::model::Behavior& behavior;
 
                public:
                    AgentBehaviorTask(const api::model::Behavior& behavior, api::model::AgentPtr& agent)
                        : AgentTaskBase(agent), behavior(behavior) {}
 
                    void run() override {
                        behavior.execute(_agent.get());
                    }
            };
 
            class SynchronizeGraphTask : public scheduler::TaskBase<api::scheduler::Task> {
                private:
                    api::model::AgentGraph& agent_graph;
                public:
                    SynchronizeGraphTask(api::model::AgentGraph& agent_graph)
                        : agent_graph(agent_graph) {}
 
                    void run() override {
                        agent_graph.synchronize();
                    }
            };
 
            class EraseAgentCallback;
 
            class InsertAgentNodeCallback 
                : public api::utils::Callback<AgentNode*> {
                    private:
                        api::model::Model& model;
                    public:
                        InsertAgentNodeCallback(api::model::Model& model) : model(model) {}
 
                        void call(api::model::AgentNode* node) override;
                };
 
            class EraseAgentNodeCallback 
                : public api::utils::Callback<AgentNode*> {
                    private:
                        api::model::Model& model;
                    public:
                        EraseAgentNodeCallback(api::model::Model& model) : model(model) {}
 
                        void call(api::model::AgentNode* node) override;
                };
 
            class SetAgentLocalCallback
                : public api::utils::EventCallback<api::graph::SetLocalNodeEvent<AgentPtr>> {
                    private:
                        api::model::Model& model;
                    public:
                        SetAgentLocalCallback(api::model::Model& model) : model(model) {}
 
                        void call(const api::graph::SetLocalNodeEvent<AgentPtr>& event) override;
                };
 
            class SetAgentDistantCallback
                : public api::utils::EventCallback<api::graph::SetDistantNodeEvent<AgentPtr>> {
                    private:
                        api::model::Model& model;
                    public:
                        SetAgentDistantCallback(api::model::Model& model) : model(model) {}
 
                        void call(const api::graph::SetDistantNodeEvent<AgentPtr>& event) override;
                };
 
            template<template<typename> class SyncMode>
                using AgentGraph = graph::DistributedGraph<AgentPtr, SyncMode>;
 
            typedef graph::ZoltanLoadBalancing<AgentPtr> ZoltanLoadBalancing;
            typedef graph::ScheduledLoadBalancing<AgentPtr> ScheduledLoadBalancing;
 
            class LoadBalancingTask : public scheduler::TaskBase<api::scheduler::Task> {
                public:
                    typedef api::graph::NodeMap<AgentPtr> NodeMap;
                    typedef typename api::graph::PartitionMap PartitionMap;
 
                private:
                    api::model::AgentGraph& agent_graph;
                    api::model::LoadBalancing& load_balancing;
                    // Initially PARTITION, and REPARTITION after the first run
                    api::graph::PartitionMode partition_mode;
 
                public:
                    LoadBalancingTask(
                            api::model::AgentGraph& agent_graph,
                            api::model::LoadBalancing& load_balancing
                            )
                        : agent_graph(agent_graph), load_balancing(load_balancing),
                        partition_mode(api::graph::PARTITION) {
                        }
 
                    void run() override;
            };
 
            class AgentGroupBase : public virtual api::model::AgentGroup {
                friend detail::EraseAgentCallback;
                private:
                GroupId id;
                api::model::AgentGraph& agent_graph;
                scheduler::Job job_base;
                detail::SynchronizeGraphTask sync_graph_task;
                std::list<api::model::Agent*> _agents;
 
                static const DefaultBehavior default_behavior;
                const api::model::Behavior& _behavior;
 
                std::unordered_map<
                    Event,
                    std::vector<api::utils::Callback<api::model::Agent*>*>
                        > event_handlers;
 
                void emit(Event event, api::model::Agent* agent);
 
                public:
                AgentGroupBase(GroupId group_id, api::model::AgentGraph& agent_graph);
 
                AgentGroupBase(const AgentGroupBase&) = delete;
                AgentGroupBase& operator=(const AgentGroupBase&) = delete;
 
                AgentGroupBase(
                        GroupId group_id,
                        api::model::AgentGraph& agent_graph,
                        const api::model::Behavior& behavior);
 
                GroupId groupId() const override {return id;}
                const api::model::Behavior& behavior() override {return _behavior;}
 
                void add(api::model::Agent*) override;
                void remove(api::model::Agent*) override;
 
                void insert(api::model::AgentPtr*) override;
                void erase(api::model::AgentPtr*) override;
                void clear() override;
 
                scheduler::Job& job() override {return job_base;}
                const scheduler::Job& job() const override {return job_base;}
                api::scheduler::Job& agentExecutionJob() override {return job_base;}
                const api::scheduler::Job& agentExecutionJob() const override {return job_base;}
 
                std::vector<api::model::Agent*> agents() const override;
                std::vector<api::model::Agent*> localAgents() const override;
                std::vector<api::model::Agent*> distantAgents() const override;
 
                void addEventHandler(
                        Event event,
                        api::utils::Callback<api::model::Agent*>* callback) override;
 
                void removeEventHandler(
                        Event event,
                        api::utils::Callback<api::model::Agent*>* callback) override;
 
                ~AgentGroupBase();
            };
 
            class AgentGroup : public AgentGroupBase {
                public:
                    using AgentGroupBase::AgentGroupBase;
 
                    api::scheduler::JobList jobs() const override {
                        return {this->agentExecutionJob()};
                    }
            };
 
 
            class Model : public virtual api::model::Model {
                protected:
                    void insert(api::model::GroupId id, api::model::AgentGroup* group) override;
 
                private:
                    api::model::AgentGraph& _graph;
                    api::scheduler::Scheduler& _scheduler;
                    api::runtime::Runtime& _runtime;
                    scheduler::Job _loadBalancingJob;
                    LoadBalancingTask load_balancing_task;
                    InsertAgentNodeCallback* insert_node_callback
                        = new InsertAgentNodeCallback(*this);
                    EraseAgentNodeCallback* erase_node_callback
                        = new EraseAgentNodeCallback(*this);
                    SetAgentLocalCallback* set_local_callback
                        = new SetAgentLocalCallback(*this);
                    SetAgentDistantCallback* set_distant_callback
                        = new SetAgentDistantCallback(*this);
 
                    std::unordered_map<GroupId, api::model::AgentGroup*> _groups;
 
                public:
                    Model(
                            api::model::AgentGraph& graph,
                            api::scheduler::Scheduler& scheduler,
                            api::runtime::Runtime& runtime,
                            api::model::LoadBalancing& load_balancing);
                    Model(const Model&) = delete;
                    Model(Model&&) = delete;
                    Model& operator=(const Model&) = delete;
                    Model& operator=(Model&&) = delete;
 
                    api::model::AgentGraph& graph() override {
                        return _graph;
                    }
                    const api::model::AgentGraph& graph() const override {
                        return _graph;
                    }
                    api::scheduler::Scheduler& scheduler() override {
                        return _scheduler;
                    }
                    const api::scheduler::Scheduler& scheduler() const override {
                        return _scheduler;
                    }
                    api::runtime::Runtime& runtime() override {
                        return _runtime;
                    }
                    const api::runtime::Runtime& runtime() const override {
                        return _runtime;
                    }
 
                    const scheduler::Job& loadBalancingJob() const override {
                        return _loadBalancingJob;
                    }
 
                    api::model::AgentGroup& buildGroup(
                            api::model::GroupId id) override;
                    api::model::AgentGroup& buildGroup(
                            api::model::GroupId id,
                            const api::model::Behavior& behavior) override;
 
                    void removeGroup(api::model::AgentGroup& group) override;
 
                    api::model::AgentGroup& getGroup(
                            api::model::GroupId id) const override;
 
                    const std::unordered_map<GroupId, api::model::AgentGroup*>&
                        groups() const override {return _groups;}
 
                    AgentEdge* link(
                            api::model::Agent* src_agent,
                            api::model::Agent* tgt_agent,
                            api::graph::LayerId layer) override;
                    void unlink(api::model::AgentEdge* edge) override;
 
                    api::communication::MpiCommunicator& getMpiCommunicator() override {
                        return this->_graph.getMpiCommunicator();
                    }
 
                    const api::communication::MpiCommunicator& getMpiCommunicator() const override {
                        return this->_graph.getMpiCommunicator();
                    }
 
                    void clear() override {
                        this->_graph.clear();
                        this->runtime().setCurrentDate(0);
                    }
 
                    ~Model();
            };
 
            template<template<typename> class SyncMode>
                class DefaultModelConfig {
                    protected:
                        communication::MpiCommunicator comm;
                        AgentGraph<SyncMode> __graph {comm};
                        scheduler::Scheduler __scheduler;
                        runtime::Runtime __runtime {__scheduler};
                        ZoltanLoadBalancing __zoltan_lb {comm};
                        ScheduledLoadBalancing __load_balancing {
                            __zoltan_lb, __scheduler, __runtime
                        };
                };
 
            template<template<typename> class SyncMode>
                class DefaultModel : private DefaultModelConfig<SyncMode>, public Model {
                    public:
                        DefaultModel() :
                            DefaultModelConfig<SyncMode>(),
                            Model(
                                    this->__graph, this->__scheduler, this->__runtime,
                                    this->__load_balancing
                                    ) {}
                        DefaultModel(
                                api::graph::LoadBalancing<AgentPtr>& load_balancing) :
                            DefaultModelConfig<SyncMode>(),
                            Model(
                                    this->__graph, this->__scheduler, this->__runtime,
                                    load_balancing
                                    ) {}
 
                        DefaultModel(
                                api::scheduler::Scheduler& scheduler,
                                api::runtime::Runtime& runtime,
                                api::graph::LoadBalancing<AgentPtr>& load_balancing) :
                            DefaultModelConfig<SyncMode>(),
                            Model(
                                    this->__graph, scheduler, runtime,
                                    load_balancing
                                    ) {}
                };
 
        }
    }
}
#endif