distributed_id.h

Go to the documentation of this file.

#ifndef FPMAS_DISTRIBUTED_ID_H
#define FPMAS_DISTRIBUTED_ID_H
 
#include "hedley/hedley.h"
 
#ifndef FPMAS_ID_TYPE
    #define FPMAS_ID_TYPE std::uint_fast32_t
#endif
 
#include <functional>
#include <nlohmann/json.hpp>
#include <mpi.h>
#include <climits>
#include <type_traits>
 
static_assert(
        std::is_integral<FPMAS_ID_TYPE>::value,
        "FPMAS_ID_TYPE must be an unsigned integer."
        );
static_assert(
        std::is_unsigned<FPMAS_ID_TYPE>::value,
        "FPMAS_ID_TYPE must be unsigned."
        );
 
 
namespace fpmas { namespace api { namespace graph {
    class DistributedId;
}}}
 
namespace fpmas { namespace api { namespace communication {
    struct MpiDistributedId {
        int rank;
        FPMAS_ID_TYPE id;
    };
}}}
 
namespace fpmas { namespace api { namespace graph {
    class DistributedId;
}}}
 
using fpmas::api::communication::MpiDistributedId;
 
namespace fpmas { namespace api { namespace graph {
 
    class DistributedId {
        friend nlohmann::adl_serializer<DistributedId>;
 
        private:
            int _rank;
            FPMAS_ID_TYPE _id;
 
        public:
            static int max_rank;
            static FPMAS_ID_TYPE max_id;
 
            static MPI_Datatype mpiDistributedIdType;
 
            explicit DistributedId(const MpiDistributedId& mpi_id)
                : _rank(mpi_id.rank), _id(mpi_id.id) {}
 
            DistributedId() : DistributedId(0, 0) {}
 
            explicit DistributedId(int rank) : DistributedId(rank, 0) {}
 
            DistributedId(int rank, FPMAS_ID_TYPE id) : _rank(rank), _id(id) {}
 
            int rank() const {
                return _rank;
            }
 
            FPMAS_ID_TYPE id() const {
                return _id;
            }
 
            DistributedId operator++(int) {
                DistributedId old(*this);
                _id++;
                return old;
            };
 
            bool operator<(const DistributedId& other) const {
                if(this->_rank==other._rank)
                    return this->_id < other._id;
                if(this->_rank < other._rank)
                    return true;
                return false;
            }
 
            bool operator<=(const DistributedId& other) const {
                if(*this == other)
                    return true;
                return *this < other;
            }
 
            bool operator==(const DistributedId& other) const {
                return (other._rank == this->_rank) && (other._id == this->_id);
            }
 
            bool operator!=(const DistributedId& other) const {
                return (other._rank != this->_rank) || (other._id != this->_id);
            }
 
            HEDLEY_DEPRECATED(1.1)
            //TODO: Removes this in 2.0 (conflicts with nlohmann::json, when
            //declaring std::map<DistributedId, _>)
            operator std::string() const {
                return "[" + std::to_string(_rank) + ":" + std::to_string(_id) + "]";
            }
 
            std::size_t hash() const {
                return std::hash<FPMAS_ID_TYPE>()(_id);
            }
    };
 
    std::ostream& operator<<(std::ostream& os, const DistributedId& id);
}}}
 
using fpmas::api::graph::DistributedId;
 
namespace fpmas {
    std::string to_string(const api::graph::DistributedId& id);
}
 
namespace fpmas { namespace api { namespace communication {
    inline static void createMpiTypes() {
        MPI_Datatype types[2] = {MPI_INT, MPI_UNSIGNED_LONG_LONG};
        int block[2] = {1, 1};
        MPI_Aint disp[2] = {
            offsetof(MpiDistributedId, rank),
            offsetof(MpiDistributedId, id)
        };
        MPI_Type_create_struct(2, block, disp, types, &DistributedId::mpiDistributedIdType);
        MPI_Type_commit(&DistributedId::mpiDistributedIdType);
    }
 
    inline static void freeMpiTypes() {
        MPI_Type_free(&DistributedId::mpiDistributedIdType);
    }
}}}
 
namespace std {
    template<> struct hash<DistributedId> {
        std::size_t operator()(DistributedId const& id) const noexcept
        {
            return id.hash();
        }
 
    };
}
 
 
namespace nlohmann {
    using fpmas::api::graph::DistributedId;
 
    template<>
        struct adl_serializer<DistributedId> {
            template<typename JsonType>
            static void to_json(JsonType& j, const DistributedId& value) {
                j[0] = value.rank();
                j[1] = value.id();
            }
 
            template<typename JsonType>
            static void from_json(const JsonType& j, DistributedId& id) {
                id._rank = j[0].template get<int>();
                id._id = j[1].template get<FPMAS_ID_TYPE>();
            }
        };
 
    /*
     * Temporary hack to solve the DistributedId std::string conversion issue
     *
     * Will be removed in a next release, when DistributedId automatic
     * std::string conversion will be disabled.
     */
    template<typename Value, typename Hash, typename Equal, typename Alloc>
        struct adl_serializer<std::unordered_map<DistributedId, Value, Hash, Equal, Alloc>> {
            typedef std::unordered_map<DistributedId, Value, Hash, Equal, Alloc> Map;
            static void to_json(json& j, const Map& map) {
                for(auto item : map)
                    j[json(item.first).dump()] = json(item.second);
            }
            static void from_json(const json& j, Map& map) {
                for(auto item : j.items()) {
                    map.insert({
                            json::parse(item.key()).get<DistributedId>(),
                            item.value().get<Value>()});
                }
            }
        };
}
#endif