distributed_edge.h

Go to the documentation of this file.

#ifndef FPMAS_DISTRIBUTED_EDGE_H
#define FPMAS_DISTRIBUTED_EDGE_H
 
#include "fpmas/graph/edge.h"
#include "fpmas/graph/distributed_node.h"
#include "fpmas/communication/communication.h"
 
namespace fpmas { namespace graph {
 
    using api::graph::LayerId;
 
    template<typename T>
        class DistributedEdge :
            public graph::Edge<DistributedId, api::graph::DistributedNode<T>>,
            public api::graph::DistributedEdge<T> {
                typedef graph::Edge<DistributedId, api::graph::DistributedNode<T>>
                    EdgeBase;
 
                private:
                    LocationState _state = LocationState::LOCAL;
                    std::unique_ptr<api::graph::TemporaryNode<T>> temp_src;
                    std::unique_ptr<api::graph::TemporaryNode<T>> temp_tgt;
 
                public:
                    using typename graph::Edge<DistributedId, api::graph::DistributedNode<T>>::IdType;
 
                    DistributedEdge(DistributedId id, LayerId layer)
                        : EdgeBase(id, layer) {}
 
                    api::graph::LocationState state() const override {return _state;}
                    void setState(api::graph::LocationState state) override {this->_state = state;}
 
                    void setTempSourceNode(
                            std::unique_ptr<api::graph::TemporaryNode<T>> temp_src
                            ) override {
                        this->temp_src = std::move(temp_src);
                    }
 
                    std::unique_ptr<api::graph::TemporaryNode<T>>
                        getTempSourceNode() override {
                        return std::move(temp_src);
                    }
 
                    void setTempTargetNode(
                            std::unique_ptr<api::graph::TemporaryNode<T>> temp_tgt
                            ) override {
                        this->temp_tgt = std::move(temp_tgt);
                    }
 
                    std::unique_ptr<api::graph::TemporaryNode<T>>
                        getTempTargetNode() override {
                        return std::move(temp_tgt);
                    }
 
            };
 
 
    template<typename T, typename PackType>
        class TemporaryNode : public api::graph::TemporaryNode<T> {
            private:
                PackType pack;
                DistributedId id;
                int location;
 
            public:
                template<typename _PackType>
                    TemporaryNode(DistributedId id, int location, _PackType&& p) :
                        pack(std::forward<_PackType>(p)), id(id), location(location) {
                        }
 
                DistributedId getId() const override {
                    return id;
                }
 
                int getLocation() const override {
                    return location;
                }
 
                api::graph::DistributedNode<T>* build() override {
                    NodePtrWrapper<T> node = pack.template get<NodePtrWrapper<T>>();
                    node->setLocation(location);
                    return node;
                }
        };
 
    template<typename T>
    using EdgePtrWrapper = api::utils::PtrWrapper<api::graph::DistributedEdge<T>>;
}}
 
namespace nlohmann {
    using fpmas::graph::EdgePtrWrapper;
 
    template<typename T>
        struct adl_serializer<EdgePtrWrapper<T>> {
            template<typename JsonType>
            static void to_json(JsonType& j, const EdgePtrWrapper<T>& edge) {
                j["id"] = edge->getId();
                j["layer"] = edge->getLayer();
                j["weight"] = edge->getWeight();
                j["src"] = {{}, edge->getSourceNode()->location()};
                NodePtrWrapper<T> src(edge->getSourceNode());
                j["src"][0] = src;
                j["tgt"] = {{}, edge->getTargetNode()->location()};
                NodePtrWrapper<T> tgt(edge->getTargetNode());
                j["tgt"][0] = tgt;
            }
 
            template<typename JsonType>
            static void from_json(const JsonType& j, EdgePtrWrapper<T>& edge_ptr) {
                fpmas::api::graph::DistributedEdge<T>* edge
                    = new fpmas::graph::DistributedEdge<T> {
                    j.at("id").template get<DistributedId>(),
                    j.at("layer").template get<typename fpmas::graph::LayerId>()
                };
                edge->setWeight(j.at("weight").template get<float>());
 
                edge->setTempSourceNode(std::unique_ptr<fpmas::api::graph::TemporaryNode<T>>(
                        new fpmas::graph::TemporaryNode<T, JsonType>(
                            j.at("src")[0].at("id").template get<DistributedId>(),
                            j.at("src")[1].template get<int>(),
                            std::move(j.at("src")[0])
                            )
                        ));
 
                edge->setTempTargetNode(std::unique_ptr<fpmas::api::graph::TemporaryNode<T>>(
                        new fpmas::graph::TemporaryNode<T, JsonType>(
                            j.at("tgt")[0].at("id").template get<DistributedId>(),
                            j.at("tgt")[1].template get<int>(),
                            std::move(j.at("tgt")[0])
                            )
                        ));
 
                edge_ptr = {edge};
            }
        };
}
 
namespace fpmas { namespace io { namespace datapack {
    using fpmas::graph::EdgePtrWrapper;
 
    template<typename T>
        struct Serializer<EdgePtrWrapper<T>> {
            template<typename PackType>
                static std::size_t size(const PackType& p, const EdgePtrWrapper<T>& edge) {
                    return p.template size<DistributedId>() + // edge id
                        p.template size<int>() + // layer
                        p.template size<float>() + // edge weight
                        p.template size<DistributedId>() + // src id
                        p.template size<int>() + // src location
                        p.template size<std::size_t>() + // src pack size
                        p.template size(NodePtrWrapper<T>(edge->getSourceNode())) + // src pack
                        p.template size<DistributedId>() + // tgt id
                        p.template size<int>() + // tgt location
                        p.template size<std::size_t>() + // tgt pack size
                        p.template size(NodePtrWrapper<T>(edge->getTargetNode())); // tgt pack
                }
 
            template<typename PackType>
                static void to_datapack(PackType& pack, const EdgePtrWrapper<T>& edge) {
                    pack.put(edge->getId());
                    pack.put(edge->getLayer());
                    pack.put(edge->getWeight());
 
                    pack.put(edge->getSourceNode()->getId());
                    pack.put(edge->getSourceNode()->location());
                    {
                        // Skip src pack size
                        std::size_t src_size_offset = pack.writeOffset();
                        pack.seekWrite(src_size_offset + pack.template size<std::size_t>());
 
                        // Serializes src into pack
                        std::size_t w_cursor = pack.writeOffset();
                        pack.put(NodePtrWrapper<T>(edge->getSourceNode()));
 
                        // Computes src pack size
                        std::size_t src_size = pack.writeOffset() - w_cursor;
                        pack.seekWrite(src_size_offset);
                        // Writes src pack size
                        pack.put(src_size);
 
                        // Go back at the end of src pack
                        pack.seekWrite(w_cursor+src_size);
                    }
 
                    pack.put(edge->getTargetNode()->getId());
                    pack.put(edge->getTargetNode()->location());
                    {
                        // Skip tgt pack size
                        std::size_t tgt_size_offset = pack.writeOffset();
                        pack.seekWrite(tgt_size_offset + pack.template size<std::size_t>());
 
                        // Serializes tgt into pack
                        std::size_t w_cursor = pack.writeOffset();
                        pack.put(NodePtrWrapper<T>(edge->getTargetNode()));
 
                        // Computes tgt pack size
                        std::size_t tgt_size = pack.writeOffset() - w_cursor;
                        pack.seekWrite(tgt_size_offset);
                        // Writes tgt pack size
                        pack.put(tgt_size);
 
                        // Go back at the end of tgt pack
                        pack.seekWrite(w_cursor+tgt_size);
                    }
                }
 
            template<typename PackType>
                static EdgePtrWrapper<T> from_datapack(const PackType& pack) {
                    // Call order guaranteed, DO NOT CALL gets FROM THE CONSTRUCTORS
                    DistributedId id = pack.template get<DistributedId>();
                    int i = pack.template get<int>();
                    fpmas::api::graph::DistributedEdge<T>* edge
                        = new fpmas::graph::DistributedEdge<T>(id, i);
                    edge->setWeight(pack.template get<float>());
 
                    id = pack.template get<DistributedId>();
                    i = pack.template get<int>();
                    edge->setTempSourceNode(std::unique_ptr<fpmas::api::graph::TemporaryNode<T>>(
                                new fpmas::graph::TemporaryNode<T, PackType>(
                                    id, i,
                                    pack.extract(pack.template get<std::size_t>())
                                    )
                                ));
 
                    id = pack.template get<DistributedId>();
                    i = pack.template get<int>();
                    edge->setTempTargetNode(std::unique_ptr<fpmas::api::graph::TemporaryNode<T>>(
                                new fpmas::graph::TemporaryNode<T, PackType>(
                                    id, i,
                                    pack.extract(pack.template get<std::size_t>())
                                    )
                                ));
 
                    return {edge};
                }
        };
}}}
 
namespace fpmas { namespace communication {
 
    template<typename T>
        struct TypedMpi<fpmas::graph::EdgePtrWrapper<T>> :
        public detail::TypedMpi<fpmas::graph::EdgePtrWrapper<T>, io::datapack::LightObjectPack> {
            using detail::TypedMpi<fpmas::graph::EdgePtrWrapper<T>, io::datapack::LightObjectPack>::TypedMpi;
        };
}}
#endif