distributed_graph.h

Go to the documentation of this file.

#ifndef FPMAS_DISTRIBUTED_GRAPH_API_H
#define FPMAS_DISTRIBUTED_GRAPH_API_H
 
#include "fpmas/api/communication/communication.h"
#include "fpmas/api/graph/location_manager.h"
#include "fpmas/api/graph/load_balancing.h"
#include "fpmas/api/synchro/sync_mode.h"
 
namespace fpmas {namespace api {namespace graph {
 
    template<typename T>
        struct NodeEvent {
            DistributedNode<T>* node;
 
            NodeEvent(DistributedNode<T>* node) : node(node) {
            }
        };
 
    template<typename T>
        struct SetLocalNodeEvent : public NodeEvent<T> {
            enum Context {
                BUILD_LOCAL,
                IMPORT_NEW_LOCAL,
                IMPORT_EXISTING_LOCAL,
                UNSPECIFIED
            };
 
            Context context;
 
            SetLocalNodeEvent<T>(
                    DistributedNode<T>* node,
                    Context context
                    ) : NodeEvent<T>(node), context(context) {
            }
        };
 
    template<typename T>
        struct SetDistantNodeEvent : public NodeEvent<T> {
            enum Context {
                IMPORT_NEW_DISTANT,
                EXPORT_DISTANT,
                UNSPECIFIED
 
            };
 
            Context context;
 
            SetDistantNodeEvent<T>(
                    DistributedNode<T>* node,
                    Context context
                    ) : NodeEvent<T>(node), context(context) {
            }
        };
 
    template<typename T>
    class DistributedGraph 
        : public virtual fpmas::api::graph::Graph<DistributedNode<T>, DistributedEdge<T>> {
        public:
            using typename fpmas::api::graph::Graph<DistributedNode<T>, DistributedEdge<T>>::NodeMap;
            using typename fpmas::api::graph::Graph<DistributedNode<T>, DistributedEdge<T>>::EdgeMap;
 
            typedef api::utils::EventCallback<SetLocalNodeEvent<T>> SetLocalNodeCallback;
            typedef api::utils::EventCallback<SetDistantNodeEvent<T>> SetDistantNodeCallback;
 
        public:
            virtual api::communication::MpiCommunicator& getMpiCommunicator() = 0;
 
            virtual const api::communication::MpiCommunicator& getMpiCommunicator() const = 0;
 
            virtual LocationManager<T>& getLocationManager() = 0;
 
            virtual const LocationManager<T>& getLocationManager() const = 0;
 
            virtual DistributedNode<T>* importNode(DistributedNode<T>* node) = 0;
 
            virtual DistributedEdge<T>* importEdge(DistributedEdge<T>* edge) = 0;
 
            virtual std::unordered_set<DistributedNode<T>*> getUnsyncNodes() const = 0;
 
            virtual DistributedId currentNodeId() const = 0;
 
            virtual void setCurrentNodeId(DistributedId id) = 0;
 
            virtual DistributedId currentEdgeId() const = 0;
 
            virtual void setCurrentEdgeId(DistributedId id) = 0;
 
            virtual DistributedNode<T>* buildNode(T&& data) = 0;
 
            virtual DistributedNode<T>* buildNode(const T& data) = 0;
 
            virtual DistributedNode<T>* insertDistant(DistributedNode<T>* node) = 0;
 
            virtual void removeNode(DistributedNode<T>* node) = 0;
            virtual void removeNode(DistributedId id) = 0;
 
            virtual void unlink(DistributedEdge<T>* edge) = 0;
            virtual void unlink(DistributedId id) = 0;
 
            virtual DistributedEdge<T>* link(
                    DistributedNode<T>* source, DistributedNode<T>* target,
                    LayerId layer_id) = 0;
 
            virtual void switchLayer(DistributedEdge<T>* edge, LayerId layer_id) = 0;
 
            virtual void addCallOnSetLocal(SetLocalNodeCallback* callback) = 0;
 
            virtual std::vector<SetLocalNodeCallback*> onSetLocalCallbacks() const = 0;
 
            virtual void addCallOnSetDistant(SetDistantNodeCallback* callback) = 0;
 
            virtual std::vector<SetDistantNodeCallback*> onSetDistantCallbacks() const = 0;
 
            
            HEDLEY_DEPRECATED_FOR(1.2, balance(LoadBalancing<T>&, PartitionMode))
            virtual void balance(LoadBalancing<T>& lb) = 0;
 
            virtual void balance(LoadBalancing<T>& lb, PartitionMode partition_mode) = 0;
 
            
            HEDLEY_DEPRECATED_FOR(1.2, balance(FixedVerticesLoadBalancing<T>&, PartitionMap, PartitionMode))
            virtual void balance(
                    FixedVerticesLoadBalancing<T>& lb,
                    PartitionMap fixed_vertices) = 0;
 
            virtual void balance(
                    FixedVerticesLoadBalancing<T>& lb,
                    PartitionMap fixed_vertices,
                    PartitionMode partition_mode) = 0;
 
            virtual void distribute(PartitionMap partition) = 0;
 
            virtual void synchronize() = 0;
 
            virtual void synchronize(
                    std::unordered_set<DistributedNode<T>*> nodes,
                    bool synchronize_links = true
                    ) = 0;
 
 
            virtual synchro::SyncMode<T>& synchronizationMode() = 0;
        };
}}}
#endif