grid_load_balancing.h

Go to the documentation of this file.

#ifndef FPMAS_GRID_LB_H
#define FPMAS_GRID_LB_H
 
#include "fpmas/api/graph/load_balancing.h"
#include "fpmas/api/model/spatial/grid.h"
 
#include <list>
 
namespace fpmas { namespace model {
    using api::model::DiscretePoint;
    using api::model::DiscreteCoordinate;
 
    class GridDimensions {
        private:
            DiscretePoint origin;
            DiscretePoint extent;
 
        public:
            GridDimensions(DiscretePoint origin, DiscretePoint extent)
                : origin(origin), extent(extent) {
                }
            GridDimensions() {}
 
            DiscretePoint getOrigin() const {return origin;}
            void setOrigin(const DiscretePoint& point) {this->origin = point;}
 
            DiscretePoint getExtent() const {return extent;}
            void setExtent(const DiscretePoint& point) {this->extent = point;}
 
            DiscreteCoordinate width() const {
                return extent.x - origin.x;
            }
            DiscreteCoordinate height() const {
                return extent.y - origin.y;
            }
    };
 
    class GridProcessMapping {
        public:
            virtual int process(DiscretePoint point) const = 0;
 
            virtual GridDimensions gridDimensions(int process) const = 0;
 
            virtual ~GridProcessMapping() {}
    };
 
    class TreeProcessMapping : public GridProcessMapping {
        private:
            enum NodeType {
                HORIZONTAL_FRONTIER,
                VERTICAL_FRONTIER,
                LEAF
            };
 
            std::vector<GridDimensions> process_grid_dimensions;
 
            struct Node {
                // Coordinates of the bottom left corner of the zone
                // represented by this node
                DiscretePoint origin;
                // Width of the node represented by this node
                DiscreteCoordinate width;
                // Height of the node represented by this node
                DiscreteCoordinate height;
 
                NodeType node_type;
                // When the node is a frontier, the value between the first and
                // second child. Depending on the orientation of the frontier,
                // this is an x or y coordinate.
                DiscreteCoordinate value;
 
                // Children of the node (empty if the node is a LEAF, exactly two
                // children otherwise)
                std::vector<Node*> childs;
 
                // When the node is a LEAF, process that owns the zone
                // represented by this node
                int process = -1;
            };
            Node* root;
 
            /*
             * Splits the first node of the list in two nodes, that become the
             * children of the node.
             *
             * The zone is split vertically if node->height > node->width,
             * horizontally otherwise, in order to minimize the size of
             * frontiers.
             *
             * By construction, the leafs are ordered so that largest zones are
             * at the beginning of the list, so its consistent to split those
             * nodes first. Indeed, split nodes are always pushed back in the
             * list, while the first element of leafs is popped. Moreover, at
             * the beginning of the algorithm, the only element in `leafs` is
             * `root`, that represents the whole grid.
             *
             * Also note that this procedure increases the leafs size by 1: 2
             * children are added at the end of the list, while the split node
             * is removed from the beginning of the list.
             */
            void split_node(std::list<Node*>& leafs);
 
            /*
             * Recursively deletes all nodes of the tree.
             */
            void delete_node(Node* node);
 
            /*
             * Recursively finds the LEAF node that contains `point`, and
             * returns the rank of the process associated to this node.
             */
            int process(DiscretePoint point, Node* node) const;
 
        public:
            TreeProcessMapping(
                DiscreteCoordinate width, DiscreteCoordinate height,
                api::communication::MpiCommunicator& comm
                );
 
            TreeProcessMapping(const TreeProcessMapping&) = delete;
            TreeProcessMapping& operator=(const TreeProcessMapping&) = delete;
 
            int process(DiscretePoint point) const override;
 
            GridDimensions gridDimensions(int process) const override;
 
            ~TreeProcessMapping();
    };
 
    class StripProcessMapping : public GridProcessMapping {
        private:
            enum Mode {
                HORIZONTAL,
                VERTICAL
            };
            Mode mode;
            std::map<DiscreteCoordinate, int> process_bounds;
            std::vector<GridDimensions> process_grid_dimensions;
 
        public:
            StripProcessMapping(
                DiscreteCoordinate width, DiscreteCoordinate height,
                api::communication::MpiCommunicator& comm
                );
 
            int process(DiscretePoint point) const override;
 
            GridDimensions gridDimensions(int process) const override;
    };
 
    class FastProcessMapping : public GridProcessMapping {
        private:
            std::vector<GridDimensions> process_grid_dimensions;
            std::vector<std::vector<int>> process_map;
            int _n;
            int _p;
            int N_x;
            int N_y;
            DiscreteCoordinate width;
            DiscreteCoordinate height;
        public:
            FastProcessMapping(
                    DiscreteCoordinate width, DiscreteCoordinate height,
                    api::communication::MpiCommunicator& comm
                    );
 
            int process(DiscretePoint point) const override;
 
            GridDimensions gridDimensions(int process) const override;
 
            int n() const;
            int p() const;
    };
 
    class GridLoadBalancing : public api::graph::LoadBalancing<api::model::AgentPtr> {
        private:
            FastProcessMapping default_process_mapping;
            const GridProcessMapping& grid_process_mapping;
 
        public:
            GridLoadBalancing(
                DiscreteCoordinate width, DiscreteCoordinate height,
                api::communication::MpiCommunicator& comm
                );
 
            GridLoadBalancing(const GridProcessMapping& grid_process_mapping);
 
            
            api::graph::PartitionMap balance(
                    api::graph::NodeMap<api::model::AgentPtr> nodes
                    ) override;
 
            api::graph::PartitionMap balance(
                    api::graph::NodeMap<api::model::AgentPtr> nodes,
                    api::graph::PartitionMode partition_mode
                    ) override;
    };
 
}}
#endif