model.h

Go to the documentation of this file.

#ifndef FPMAS_MODEL_H
#define FPMAS_MODEL_H
 
#include "fpmas/api/graph/graph_builder.h"
#include "guards.h"
#include "detail/model.h"
#include "fpmas/random/random.h"
#include "fpmas/io/breakpoint.h"
#include "fpmas/utils/format.h"
#include "fpmas/graph/graph_builder.h"
#include "fpmas/graph/random_load_balancing.h"
#include "fpmas/synchro/synchro.h"
#include <fstream>
 
 
namespace fpmas { namespace model {
 
    bool is_agent_in_group(api::model::Agent* agent, api::model::GroupId group_id);
 
    bool is_agent_in_group(api::model::Agent* agent, api::model::AgentGroup& group);
 
    template<typename AgentType>
        class Neighbor  {
            private:
                AgentPtr* _agent;
                AgentEdge* _edge;
 
            public:
                Neighbor() : Neighbor(nullptr, nullptr) {}
 
                HEDLEY_DEPRECATED_FOR(1.1, Neighbor(AgentPtr*, AgentEdge*))
                Neighbor(AgentPtr* agent)
                    : Neighbor(agent, nullptr) {}
 
                Neighbor(AgentPtr* agent, AgentEdge* edge)
                    : _agent(agent), _edge(edge) {}
 
                operator AgentType*() const {
                    return static_cast<AgentType*>(_agent->get());
                }
 
                AgentType* operator->() const {
                    return static_cast<AgentType*>(_agent->get());
                }
 
                AgentType& operator*() const {
                    return *static_cast<AgentType*>(_agent->get()); }
 
                AgentEdge* edge() const {
                    return _edge;
                }
 
                AgentType* agent() const {
                    if(_agent == nullptr)
                        return nullptr;
                    return static_cast<AgentType*>(_agent->get());
                }
        };
 
    template<typename AgentType, typename Compare = std::less<AgentType>>
        class CompareNeighbors {
            private:
                Compare compare;
            public:
                CompareNeighbors() = default;
 
                CompareNeighbors(const Compare& compare) : compare(compare) {
                }
 
                bool operator()(
                        const Neighbor<AgentType>& n1,
                        const Neighbor<AgentType>& n2) const {
                    return compare(*n1.agent(), *n2.agent());
                }
        };
 
    template<typename AgentType>
        bool operator<(const Neighbor<AgentType>& n1, const Neighbor<AgentType>& n2) {
            return *n1.agent() < *n2.agent();
        }
 
    struct RandomNeighbors {
        static random::DistributedGenerator<> rd;
 
        static void seed(random::DistributedGenerator<>::result_type seed);
    };
 
    template<typename AgentType>
        class Neighbors {
            private:
                typedef typename std::vector<Neighbor<AgentType>>::iterator iterator;
                typedef typename std::vector<Neighbor<AgentType>>::const_iterator const_iterator;
                std::vector<Neighbor<AgentType>> neighbors;
 
            public:
                Neighbors() = default;
 
                Neighbors(const std::vector<Neighbor<AgentType>>& neighbors)
                    : neighbors(neighbors) {}
 
                iterator begin() {
                    return neighbors.begin();
                }
                const_iterator begin() const {
                    return neighbors.begin();
                }
 
                iterator end() {
                    return neighbors.end();
                }
 
                const_iterator end() const {
                    return neighbors.end();
                }
 
                std::size_t count() const {
                    return neighbors.size();
                }
 
                bool empty() const {
                    return neighbors.empty();
                }
 
                Neighbor<AgentType>& at(std::size_t i) {
                    try {
                        return neighbors.at(i);
                    } catch(const std::out_of_range&) {
                        throw;
                    }
                }
 
                const Neighbor<AgentType>& at(std::size_t i) const {
                    try {
                        return neighbors.at(i);
                    } catch(const std::out_of_range&) {
                        throw;
                    }
                }
 
                Neighbor<AgentType>& operator[](std::size_t i) {
                    return neighbors[i];
                }
 
                const Neighbor<AgentType>& operator[](std::size_t i) const {
                    return neighbors[i];
                }
 
                template<typename Gen>
                    Neighbors& shuffle(Gen& gen) {
                        std::shuffle(neighbors.begin(), neighbors.end(), gen);
                        return *this;
                    }
 
                Neighbors& shuffle() {
                    return shuffle(RandomNeighbors::rd);
                }
 
                template<typename Compare = std::less<AgentType>>
                    Neighbors& sort(Compare comp = Compare()) {
                        std::sort(
                                neighbors.begin(), neighbors.end(),
                                CompareNeighbors<AgentType, Compare>(comp)
                                );
                        return *this;
                    }
 
                template<typename Filter>
                Neighbors& filter(Filter _filter) {
                    neighbors.erase(
                            std::remove_if(
                                neighbors.begin(), neighbors.end(),
                                [&_filter] (const Neighbor<AgentType>& agent) {return !_filter(agent);}),
                            neighbors.end()
                            );
                    return *this;
                }
 
                template<typename Gen>
                    Neighbor<AgentType> random(Gen& gen) {
                        random::UniformIntDistribution<std::size_t> index(
                                0, this->count()-1);
                        return neighbors.at(index(gen));
                    }
 
                Neighbor<AgentType> random() {
                    return random(RandomNeighbors::rd);
                }
        };
 
    template<typename AgentType>
        class Behavior : public api::model::Behavior {
            private:
                std::vector<void(AgentType::*)()> _behaviors;
 
                template<typename T, typename Enable=void>
                    struct AutoAgentCast {
                        static T* cast(api::model::Agent* agent) {
                            return dynamic_cast<T*>(agent);
                        }
                    };
 
                template<typename T>
                    struct AutoAgentCast<T, typename std::enable_if<
                    std::is_base_of<api::model::Agent, T>::value
                    >::type> {
                        static T* cast(api::model::Agent* agent) {
                            return static_cast<T*>(agent);
                        }
                    };
 
            public:
                template<typename ...T>
                    Behavior(T... behaviors)
                    : _behaviors({behaviors...}){
                    }
 
                void execute(api::model::Agent* agent) const {
                    for(auto behavior : this->_behaviors)
                        (AutoAgentCast<AgentType>::cast(agent)->*behavior)();
                }
        };
 
    template<typename AgentType, typename ... Args>
        class BehaviorWithArgs : public api::model::Behavior {
            private:
                void (AgentType::* behavior)(Args...);
                std::tuple<Args...> args;
 
                // helpers for tuple unrolling
                // From: https://riptutorial.com/cplusplus/example/24746/storing-function-arguments-in-std--tuple
                template<int ...> struct seq {};
                template<int N, int ...S> struct gens {
                    public:
                        typedef typename gens<N-1, N-1, S...>::type type;
                };
                template<int ...S> struct gens<0, S...>{ typedef seq<S...> type; };
 
                // invocation helper 
                template<int ...S>
                    void call_fn_internal(api::model::Agent* agent, const seq<S...>) const
                    {
                        (dynamic_cast<AgentType*>(agent)->*behavior)(std::get<S>(args) ...);
                    }
 
            public:
                BehaviorWithArgs(
                        void (AgentType::* behavior)(Args...),
                        Args... args)
                    : behavior(behavior), args(args...) {}
 
                void execute(api::model::Agent* agent) const override {
                    return call_fn_internal(agent, typename gens<sizeof...(Args)>::type());
                }
        };
 
    class IdleBehavior : public api::model::Behavior {
        void execute(api::model::Agent*) const override {
        }
    };
 
    namespace detail {
    template<typename AgentInterface, typename AgentType, typename TypeIdBase = AgentType>
    class AgentBase : public AgentInterface {
        public:
            static const api::model::TypeId TYPE_ID;
            typedef AgentType FinalAgentType;
            
        private:
            std::vector<api::model::GroupId> group_ids;
            std::vector<api::model::AgentGroup*> _groups;
            std::unordered_map<
                api::model::GroupId, std::list<api::model::Agent*>::iterator
                > group_pos;
            std::unordered_map<api::model::GroupId, api::model::AgentTask*> _tasks;
            api::model::AgentNode* _node;
            api::model::Model* _model;
 
        public:
            AgentBase() = default;
 
            AgentBase(const AgentBase& agent) = default;
            
            AgentBase& operator=(const AgentBase& agent) = default;
 
            // Move constructor and assignment preserve groupIds(), groups(),
            // group_pos, tasks(), node() and model()
 
            AgentBase(AgentBase&&) = default;
 
            AgentBase& operator=(AgentBase&&) {
                return *this;
            }
 
            GroupId groupId() const override {
                if(group_ids.size() > 0)
                    return group_ids.back();
                return {};
            }
            std::vector<GroupId> groupIds() const override {return group_ids;}
            void setGroupId(api::model::GroupId id) override {
                group_ids.push_back(id);}
            void addGroupId(api::model::GroupId id) override {
                group_ids.push_back(id);
            }
 
            void removeGroupId(api::model::GroupId id) override {
                group_ids.erase(std::remove(group_ids.begin(), group_ids.end(), id));
            }
 
            api::model::AgentGroup* group() override {
                if(_groups.size() > 0)
                    return _groups.back();
                return nullptr;
            }
            std::vector<const api::model::AgentGroup*> groups() const override {
                return {_groups.begin(), _groups.end()};
            }
 
            const api::model::AgentGroup* group() const override {return _groups.back();}
            std::vector<api::model::AgentGroup*> groups() override {return _groups;}
 
            void setGroup(api::model::AgentGroup* group) override {
                _groups.push_back(group);
            }
            void addGroup(api::model::AgentGroup* group) override {
                _groups.push_back(group);
            }
 
            void removeGroup(api::model::AgentGroup* group) override {
                _groups.erase(std::remove(_groups.begin(), _groups.end(), group));
                _tasks.erase(group->groupId());
            }
 
            void setGroupPos(
                    api::model::GroupId gid,
                    std::list<api::model::Agent*>::iterator pos
                    ) override {
                group_pos[gid] = pos;
            }
 
            std::list<api::model::Agent*>::iterator getGroupPos(api::model::GroupId gid) const override {
                return group_pos.find(gid)->second;
            }
 
            api::model::TypeId typeId() const override {return TYPE_ID;}
            api::model::Agent* copy() const override {
                return new AgentType(*static_cast<const AgentType*>(this));
            }
 
            void copyAssign(api::model::Agent* agent) override {
                // Uses AgentType copy assignment operator
                *static_cast<AgentType*>(this) = *static_cast<const AgentType*>(agent);
            }
 
            void moveAssign(api::model::Agent* agent) override {
                
                // Uses AgentType move assignment operator
                //
                // groupIds(), groups(), tasks(), node() and model() are
                // notably moved from agent to this, but this as no effect
                // considering the move assignment operator defined above. In
                // consequence, those fields are properly preserved, as
                // required by the method.
                // If AgentType only explicitly defines a move assignment
                // operator, it should not call the AgentBase move assignment
                // so there should not be any problem.
                *static_cast<AgentType*>(this) = std::move(*static_cast<AgentType*>(agent));
            }
 
            api::model::AgentNode* node() override {return _node;}
            const api::model::AgentNode* node() const override {return _node;}
            void setNode(api::model::AgentNode* node) override {_node = node;}
 
            api::model::Model* model() override {return _model;}
            const api::model::Model* model() const override {return _model;}
            void setModel(api::model::Model* model) override {_model = model;}
 
            api::model::AgentTask* task() override {
                return _tasks.at(this->groupId());
            }
            const api::model::AgentTask* task() const override {
                return _tasks.at(this->groupId());
            }
            void setTask(api::model::AgentTask* task) override {
                _tasks[this->groupId()] = task;
            }
 
            api::model::AgentTask* task(api::model::GroupId id) override {
                assert(_tasks.count(id) > 0);
                return _tasks.at(id);
            }
            const api::model::AgentTask* task(api::model::GroupId id) const override {
                return _tasks.at(id);}
 
            void setTask(api::model::GroupId id, api::model::AgentTask* task) override {
                _tasks[id] = task;
            }
 
            const std::unordered_map<api::model::GroupId, api::model::AgentTask*>&
                tasks() override { return _tasks;}
 
            
            virtual void act() override {}
 
            template<typename NeighborAgentType> Neighbors<NeighborAgentType> outNeighbors() const {
                std::vector<Neighbor<NeighborAgentType>> out;
                for(api::model::AgentEdge* _edge : node()->getOutgoingEdges()) {
                    api::model::AgentNode* _node = _edge->getTargetNode();
                    if(NeighborAgentType* neighbor = dynamic_cast<NeighborAgentType*>(_node->data().get())) {
                        out.push_back({&_node->data(), _edge});
                    }
                }
                return out;
            }
 
            template<typename NeighborAgentType> Neighbors<NeighborAgentType> outNeighbors(api::graph::LayerId layer) const {
                std::vector<Neighbor<NeighborAgentType>> out;
                for(api::model::AgentEdge* _edge : node()->getOutgoingEdges(layer)) {
                    api::model::AgentNode* _node = _edge->getTargetNode();
                    if(NeighborAgentType* neighbor = dynamic_cast<NeighborAgentType*>(_node->data().get())) {
                        out.push_back({&_node->data(), _edge});
                    }
                }
                return out;
            }
 
 
            template<typename NeighborAgentType> Neighbors<NeighborAgentType> inNeighbors() const {
                std::vector<Neighbor<NeighborAgentType>> in;
                for(api::model::AgentEdge* _edge : node()->getIncomingEdges()) {
                    api::model::AgentNode* _node = _edge->getSourceNode();
                    if(NeighborAgentType* neighbor = dynamic_cast<NeighborAgentType*>(_node->data().get())) {
                        in.push_back({&_node->data(), _edge});
                    }
                }
                return in;
            }
 
            template<typename NeighborAgentType> Neighbors<NeighborAgentType> inNeighbors(api::graph::LayerId layer) const {
                std::vector<Neighbor<NeighborAgentType>> in;
                for(api::model::AgentEdge* _edge : node()->getIncomingEdges(layer)) {
                    api::model::AgentNode* _node = _edge->getSourceNode();
                    if(NeighborAgentType* neighbor = dynamic_cast<NeighborAgentType*>(_node->data().get())) {
                        in.push_back({&_node->data(), _edge});
                    }
                }
                return in;
            }
 
            virtual ~AgentBase() {}
    };
    template<typename AgentInterface, typename AgentType, typename TypeIdBase>
        const api::model::TypeId AgentBase<AgentInterface, AgentType, TypeIdBase>::TYPE_ID = typeid(TypeIdBase);
    }
 
    template<typename AgentType, typename TypeIdBase = AgentType>
        using AgentBase = detail::AgentBase<api::model::Agent, AgentType, TypeIdBase>;
 
    typedef api::utils::Callback<AgentNode*> AgentNodeCallback;
    
    class AgentNodeBuilder : public api::graph::NodeBuilder<AgentPtr> {
        private:
            api::model::AgentGroup& group;
            std::vector<api::model::Agent*> agents;
 
        public:
            AgentNodeBuilder(api::model::AgentGroup& group)
                : group(group) {}
 
            void push(api::model::Agent* agent) {
                agents.push_back(agent);
            }
 
            api::model::AgentNode*
                buildNode(api::graph::DistributedGraph<AgentPtr>&) override;
 
            std::size_t nodeCount() override {
                return agents.size();
            }
    };
    class DistributedAgentNodeBuilder : public graph::DistributedNodeBuilder<AgentPtr> {
        private:
            std::function<api::model::Agent*()> allocator;
            std::function<api::model::Agent*()> distant_allocator;
            api::model::AgentGroup& group;
 
        public:
            DistributedAgentNodeBuilder(
                    api::model::AgentGroup& group,
                    std::size_t agent_count,
                    std::function<api::model::Agent*()> allocator,
                    api::communication::MpiCommunicator& comm);
 
            DistributedAgentNodeBuilder(
                    api::model::AgentGroup& group,
                    std::size_t agent_count,
                    std::function<api::model::Agent*()> allocator,
                    std::function<api::model::Agent*()> distant_allocator,
                    api::communication::MpiCommunicator& comm);
 
 
            api::model::AgentNode*
                buildNode(api::graph::DistributedGraph<AgentPtr>& graph) override;
 
            api::model::AgentNode*
                buildDistantNode(
                        api::graph::DistributedId id,
                        int location,
                        api::graph::DistributedGraph<AgentPtr>& graph) override;
    };
 
    template<template<typename> class SyncMode>
        using Model = detail::DefaultModel<SyncMode>;
 
    using api::model::AgentGroup;
 
    using DistributedUniformGraphBuilder
        = graph::DistributedUniformGraphBuilder<AgentPtr>;
    using DistributedClusteredGraphBuilder
        = graph::DistributedClusteredGraphBuilder<AgentPtr>;
 
    using RingGraphBuilder
        = graph::RingGraphBuilder<AgentPtr>;
 
    using ZoltanLoadBalancing
        = graph::ZoltanLoadBalancing<AgentPtr>;
    using ScheduledLoadBalancing
        = graph::ScheduledLoadBalancing<AgentPtr>;
 
    using RandomLoadBalancing
        = graph::RandomLoadBalancing<AgentPtr>;
 
    typedef io::Breakpoint<api::model::Model> Breakpoint;
 
    class AutoBreakpoint {
        private:
            std::string file_format;
            std::fstream stream;
            fpmas::api::io::Breakpoint<api::model::Model>& breakpoint;
            api::model::Model& model;
            scheduler::detail::LambdaTask task {[this] () {
                stream.open(utils::format(
                            file_format,
                            model.getMpiCommunicator().getRank(),
                            model.runtime().currentDate()
                            ), std::ios_base::out);
                breakpoint.dump(stream, model);
                stream.close();
            }};
            scheduler::Job _job {{task}};
 
        public:
            AutoBreakpoint(
                    std::string file_format,
                    api::io::Breakpoint<api::model::Model>& breakpoint,
                    api::model::Model& model)
                : file_format(file_format), breakpoint(breakpoint), model(model) {
                }
 
            const api::scheduler::Job& job() const {return _job;}
    };
}}
 
namespace fpmas { namespace io { namespace json {
 
    template<>
        struct light_serializer<fpmas::api::model::AgentPtr> {
            static void to_json(light_json& j, const
                    fpmas::api::model::AgentPtr& pointer);
 
            static fpmas::api::model::AgentPtr from_json(const light_json& j);
        };
 
    template<>
        struct light_serializer<fpmas::api::model::WeakAgentPtr> {
            static void to_json(light_json& j, const
                    fpmas::api::model::WeakAgentPtr& pointer);
 
            
            static fpmas::api::model::WeakAgentPtr from_json(const light_json& j);
        };
}}}
 
namespace fpmas { namespace io { namespace datapack {
    using api::model::AgentPtr;
    using api::model::WeakAgentPtr;
 
    template<>
        struct Serializer<AgentPtr> {
            static std::size_t size(const ObjectPack& p, const AgentPtr& ptr);
 
            static void to_datapack(ObjectPack& pack, const AgentPtr& pointer);
 
            static AgentPtr from_datapack(const ObjectPack& pack);
        };
 
    template<>
        struct Serializer<WeakAgentPtr> {
            static std::size_t size(const ObjectPack& pack, const WeakAgentPtr& ptr);
 
            static void to_datapack(ObjectPack& pack, const WeakAgentPtr& ptr);
 
            static WeakAgentPtr from_datapack(const ObjectPack& pack);
        };
 
    template<>
        struct LightSerializer<AgentPtr> {
            static std::size_t size(const LightObjectPack& pack, const AgentPtr& ptr);
 
            static void to_datapack(LightObjectPack& pack, const AgentPtr& pointer);
 
            static AgentPtr from_datapack(const LightObjectPack& pack);
        };
 
    template<>
        struct LightSerializer<WeakAgentPtr> {
            static std::size_t size(const LightObjectPack& pack, const WeakAgentPtr& ptr);
 
            static void to_datapack(LightObjectPack& pack, const WeakAgentPtr& ptr);
 
            static WeakAgentPtr from_datapack(const LightObjectPack& pack);
        };
}}}
 
namespace fpmas { namespace synchro {
    template<>
        struct DataUpdate<api::model::AgentPtr> {
            static void update(
                    api::model::AgentPtr& local_agent,
                    api::model::AgentPtr&& updated_agent) {
                // TODO: this should probably be improved in 2.0
                // The purpose of "moveAssign" is clearly inconsistent with its
                // current behavior, that does much more that just "moving" the
                // agent.
 
                // Sets and overrides the fields that must be preserved
                std::set<api::model::GroupId> local_ids;
                for(auto id : local_agent->groupIds())
                    local_ids.insert(id);
                std::set<api::model::GroupId> updated_ids;
                for(auto id : updated_agent->groupIds())
                    updated_ids.insert(id);
 
                std::vector<api::model::GroupId> new_groups;
                for(auto id : updated_ids)
                    if(local_ids.count(id) == 0)
                        new_groups.push_back(id);
 
                std::vector<api::model::GroupId> obsolete_groups;
                for(auto id : local_ids)
                    if(updated_ids.count(id) == 0)
                        obsolete_groups.push_back(id);
 
                local_agent = std::move(updated_agent);
 
                // Dynamically updates groups lists
                // If `agent` was added to / removed from group on a distant
                // process for example (assuming that this agent is DISTANT),
                // this agent representation groups are updated.
                for(auto id : new_groups)
                    local_agent->model()->getGroup(id).add(local_agent.get());
                for(auto id : obsolete_groups)
                    local_agent->model()->getGroup(id).remove(local_agent.get());
 
            }
        };
}}
 
namespace nlohmann {
    template<>
        struct adl_serializer<fpmas::api::model::AgentPtr> {
            static void to_json(json& j, const fpmas::api::model::AgentPtr& pointer);
 
            static fpmas::api::model::AgentPtr from_json(const json& j);
        };
 
    template<>
        struct adl_serializer<fpmas::api::model::WeakAgentPtr> {
            
            static void to_json(json& j, const fpmas::api::model::WeakAgentPtr& pointer);
 
            static fpmas::api::model::WeakAgentPtr from_json(const json& j);
        };
 
    template<>
        struct adl_serializer<fpmas::api::model::Model> {
            static void to_json(json& j, const fpmas::api::model::Model& model);
 
            static void from_json(const json& j, fpmas::api::model::Model& model);
        };
}
#endif