group.hpp

Go to the documentation of this file.

#pragma once

#include <chrono>
#include <cstdint>
#include <ctime>
#include <exception>
#include <iostream>
#include <list>
#include <map>
#include <mutex>
#include <queue>
#include <string>
#include <type_traits>
#include <typeindex>
#include <utility>
#include <vector>

#include <derecho/tcp/tcp.hpp>

#include "derecho_exception.hpp"
#include "detail/derecho_internal.hpp"
#include "detail/persistence_manager.hpp"
#include "detail/rpc_manager.hpp"
#include "detail/view_manager.hpp"
#include "replicated.hpp"
#include "subgroup_info.hpp"

#include <derecho/conf/conf.hpp>
#include <mutils-containers/KindMap.hpp>
#include <mutils-containers/TypeMap2.hpp>

namespace derecho {
template <uint32_t counter, typename TargetType, typename FirstType, typename... RestTypes>
constexpr uint32_t index_of_type_impl() {
    if constexpr(std::is_same<TargetType, FirstType>::value)
        return counter;
    else
        return index_of_type_impl<counter + 1, TargetType, RestTypes...>();
}

template <typename TargetType, typename... TypePack>
constexpr inline uint32_t index_of_type = index_of_type_impl<0, TargetType, TypePack...>();

template <typename TargetType, typename... TypePack>
using contains = std::integral_constant<bool, (std::is_same<TargetType, TypePack>::value || ...)>;

//Type alias for a sparse-vector of Replicated, otherwise KindMap can't understand it's a template
template <typename T>
using replicated_index_map = std::map<uint32_t, Replicated<T>>;

class _Group {
private:
protected:
    virtual uint32_t get_index_of_type(const std::type_info&) = 0;

public:
    virtual ~_Group() = default;

    template <typename SubgroupType>
    auto& get_subgroup(uint32_t subgroup_num = 0);

    template <typename SubgroupType>
    auto& get_nonmember_subgroup(uint32_t subgroup_num = 0);

    template <typename SubgroupType>
    std::size_t get_number_of_shards(uint32_t subgroup_index = 0);

    template <typename SubgroupType>
    std::vector<std::vector<node_id_t>> get_subgroup_members(uint32_t subgroup_index = 0);
};

template <typename ReplicatedType>
class GroupProjection : public virtual _Group {
protected:
    virtual void set_replicated_pointer(std::type_index, uint32_t, void**) = 0;
    virtual void set_external_caller_pointer(std::type_index, uint32_t, void**) = 0;
    virtual ViewManager& get_view_manager() = 0;

public:
    Replicated<ReplicatedType>& get_subgroup(uint32_t subgroup_num = 0);
    ExternalCaller<ReplicatedType>& get_nonmember_subgroup(uint32_t subgroup_index = 0);
    std::vector<std::vector<node_id_t>> get_subgroup_members(uint32_t subgroup_index = 0);
    std::size_t get_number_of_shards(uint32_t subgroup_index = 0);
};

class GroupReference {
public:
    _Group* group;
    uint32_t subgroup_index;
    void set_group_pointers(_Group* group, uint32_t subgroup_index) {
        this->group = group;
        this->subgroup_index = subgroup_index;
    }
};

template <typename... ReplicatedTypes>
class Group : public virtual _Group, public GroupProjection<ReplicatedTypes>... {
public:
    void set_replicated_pointer(std::type_index type, uint32_t subgroup_num, void** ret);
    void set_external_caller_pointer(std::type_index type, uint32_t subgroup_num, void** ret);

protected:
    uint32_t get_index_of_type(const std::type_info&) override;
    ViewManager& get_view_manager() override;

private:
    using pred_handle = sst::Predicates<DerechoSST>::pred_handle;

    //Same thing for a sparse-vector of ExternalCaller
    template <typename T>
    using external_caller_index_map = std::map<uint32_t, ExternalCaller<T>>;

    const node_id_t my_id;
    bool is_starting_leader;
    std::optional<tcp::socket> leader_connection;
    // std::shared_ptr<IDeserializationContext> user_deserialization_context;
    IDeserializationContext* user_deserialization_context;

    PersistenceManager persistence_manager;
    std::shared_ptr<tcp::tcp_connections> tcp_sockets;
    ViewManager view_manager;
    rpc::RPCManager rpc_manager;
    mutils::KindMap<Factory, ReplicatedTypes...> factories;
    mutils::KindMap<replicated_index_map, ReplicatedTypes...> replicated_objects;
    mutils::KindMap<external_caller_index_map, ReplicatedTypes...> external_callers;
    std::map<subgroup_id_t, std::reference_wrapper<ReplicatedObject>> objects_by_subgroup_id;

    void receive_objects(const std::set<std::pair<subgroup_id_t, node_id_t>>& subgroups_and_leaders);

    void set_up_components();

    template <typename... Empty>
    std::enable_if_t<0 == sizeof...(Empty),
                     std::set<std::pair<subgroup_id_t, node_id_t>>>
    construct_objects(const View&, const vector_int64_2d&) {
        return std::set<std::pair<subgroup_id_t, node_id_t>>();
    }

    template <typename FirstType, typename... RestTypes>
    std::set<std::pair<subgroup_id_t, node_id_t>> construct_objects(
            const View& curr_view, const vector_int64_2d& old_shard_leaders);

public:
    Group(const CallbackSet& callbacks,
          const SubgroupInfo& subgroup_info,
          IDeserializationContext* deserialization_context,
          std::vector<view_upcall_t> _view_upcalls = {},
          Factory<ReplicatedTypes>... factories);

    Group(const SubgroupInfo& subgroup_info, Factory<ReplicatedTypes>... factories);

    ~Group();

    template <typename SubgroupType>
    Replicated<SubgroupType>& get_subgroup(uint32_t subgroup_index = 0);

    template <typename SubgroupType>
    ExternalCaller<SubgroupType>& get_nonmember_subgroup(uint32_t subgroup_index = 0);

    template <typename SubgroupType>
    ShardIterator<SubgroupType> get_shard_iterator(uint32_t subgroup_index = 0);

    void leave(bool group_shutdown = true);

    std::vector<node_id_t> get_members();
    template <typename SubgroupType>
    std::vector<std::vector<node_id_t>> get_subgroup_members(uint32_t subgroup_index = 0);
    std::int32_t get_my_rank();
    node_id_t get_my_id();
    template <typename SubgroupType>
    std::int32_t get_my_shard(uint32_t subgroup_index = 0);
    void report_failure(const node_id_t who);
    void barrier_sync();
    void debug_print_status() const;
};

} /* namespace derecho */

#include "detail/group_impl.hpp"