hard_sync_mode.h

Go to the documentation of this file.

#ifndef FPMAS_HARD_SYNC_MODE_H
#define FPMAS_HARD_SYNC_MODE_H
 
#include "fpmas/communication/communication.h"
#include "hard_data_sync.h"
#include "hard_sync_mutex.h"
#include "hard_sync_linker.h"
 
namespace fpmas { namespace synchro {
    namespace hard {
        template<typename T>
            class HardSyncModeBase : public fpmas::api::synchro::SyncMode<T> {
                private:
                    communication::TypedMpi<Color> color_mpi;
                    communication::TypedMpi<DistributedId> id_mpi;
                    communication::TypedMpi<T> data_mpi;
                    communication::TypedMpi<DataUpdatePack<T>> data_update_mpi;
 
                protected:
                    TerminationAlgorithm termination;
 
                    MutexServer<T> mutex_server;
 
                private:
                    MutexClient<T> mutex_client;
                    HardDataSync<T> data_sync;
 
                public:
 
                    HardSyncModeBase(
                            fpmas::api::graph::DistributedGraph<T>& graph,
                            fpmas::api::communication::MpiCommunicator& comm,
                            ServerPackBase& server_pack
                            ) :
                        color_mpi(comm), id_mpi(comm),
                        data_mpi(comm), data_update_mpi(comm),
                        termination(comm, color_mpi),
                        mutex_server(comm, id_mpi, data_mpi, data_update_mpi, server_pack),
                        mutex_client(comm, id_mpi, data_mpi, data_update_mpi, server_pack),
                        data_sync(comm, server_pack, graph) {
                        }
 
                    HardSyncMutex<T>* buildMutex(fpmas::api::graph::DistributedNode<T>* node) override {
                        HardSyncMutex<T>* mutex = new HardSyncMutex<T>(node, mutex_client, mutex_server);
                        mutex_server.manage(node->getId(), mutex);
                        return mutex;
                    };
 
                    HardDataSync<T>& getDataSync() override {return data_sync;};
 
            };
 
        namespace hard_link {
            template<typename T>
                class HardSyncMode : public HardSyncModeBase<T> {
                    private:
                        communication::TypedMpi<DistributedId> id_mpi;
                        communication::TypedMpi<graph::EdgePtrWrapper<T>> edge_mpi;
 
                        LinkServer<T> link_server;
                        LinkClient<T> link_client;
 
                        ServerPack<api::MutexServer<T>, api::LinkServer> server_pack;
                        HardSyncLinker<T> sync_linker;
 
                    public:
                        HardSyncMode(
                                fpmas::api::graph::DistributedGraph<T>& graph,
                                fpmas::api::communication::MpiCommunicator& comm) :
                            HardSyncModeBase<T>(graph, comm, server_pack),
                            id_mpi(comm), edge_mpi(comm),
                            link_server(comm, graph, id_mpi, edge_mpi),
                            link_client(comm, id_mpi, edge_mpi, server_pack),
                            server_pack(
                                    comm, this->termination,
                                    this->mutex_server, link_server),
                            sync_linker(graph, link_client, server_pack) {
                            }
                        HardSyncLinker<T>& getSyncLinker() override {
                            return sync_linker;
                        };
                };
        }
 
        namespace ghost_link {
            template<typename T>
                class HardSyncMode : public HardSyncModeBase<T> {
                    private:
                        communication::TypedMpi<DistributedId> id_mpi;
                        communication::TypedMpi<graph::EdgePtrWrapper<T>> edge_mpi;
 
                        // Unused link_server
                        VoidServer link_server;
                        // This server is terminated by HardGhostSyncLinker and
                        // HardDataSync
                        ServerPack<api::MutexServer<T>, VoidServer> server_pack;
 
                        HardSyncLinker<T> sync_linker;
 
 
                    public:
                        HardSyncMode(
                                fpmas::api::graph::DistributedGraph<T>& graph,
                                fpmas::api::communication::MpiCommunicator& comm) :
                            HardSyncModeBase<T>(graph, comm, server_pack),
                            id_mpi(comm), edge_mpi(comm),
                            server_pack(comm, this->termination, this->mutex_server, link_server),
                            sync_linker(edge_mpi, id_mpi, graph, server_pack) {
                            }
 
                        HardSyncLinker<T>& getSyncLinker() override {return sync_linker;};
                };
        }
 
    }
    template<typename T>
        using HardSyncMode = hard::hard_link::HardSyncMode<T>;
 
    template<typename T>
        using HardSyncModeWithGhostLink = hard::ghost_link::HardSyncMode<T>;
}}
#endif