subgroup_functions.hpp

Go to the documentation of this file.

#pragma once

#include <memory>
#include <variant>

#include "derecho_modes.hpp"
#include "detail/derecho_internal.hpp"
#include "subgroup_info.hpp"

namespace derecho {

template <typename T>
std::unique_ptr<T> deep_pointer_copy(const std::unique_ptr<T>& to_copy) {
    if(to_copy) {
        return std::make_unique<T>(*to_copy);
    } else {
        return nullptr;
    }
}

/*
 * String constants for the names of configuration profile fields that
 * the default subgroup allocator will look up
 */
constexpr char num_shards_profile_field[] = "num_shards";
constexpr char min_nodes_profile_field[] = "min_nodes";
constexpr char max_nodes_profile_field[] = "max_nodes";
/* It would be really nice if we could group these together in an enumerated class
 * called ProfileFields or something, but there's no way to do that with strings. */

subgroup_allocation_map_t one_subgroup_entire_view(const std::vector<std::type_index>& subgroup_type_order,
                                                   const std::unique_ptr<View>& prev_view, View& curr_view);
subgroup_allocation_map_t one_subgroup_entire_view_raw(const std::vector<std::type_index>& subgroup_type_order,
                                                       const std::unique_ptr<View>& prev_view, View& curr_view);

struct ShardAllocationPolicy {
    int num_shards;
    bool even_shards;
    int min_nodes_per_shard;
    int max_nodes_per_shard;
    Mode shards_mode;
    std::string shards_profile;
    std::vector<int> min_num_nodes_by_shard;
    std::vector<int> max_num_nodes_by_shard;
    std::vector<Mode> modes_by_shard;
    std::vector<std::string> profiles_by_shard;
};

struct SubgroupAllocationPolicy {
    int num_subgroups;
    bool identical_subgroups;
    std::vector<ShardAllocationPolicy> shard_policy_by_subgroup;
};

struct CrossProductPolicy {
    std::pair<std::type_index, uint32_t> source_subgroup;
    std::pair<std::type_index, uint32_t> target_subgroup;
};

/* Helper functions that construct ShardAllocationPolicy values for common cases. */

ShardAllocationPolicy flexible_even_shards(int num_shards, int min_nodes_per_shard,
                                           int max_nodes_per_shard,
                                           const std::string& profile = "default");

ShardAllocationPolicy flexible_even_shards(const std::string& profile);

ShardAllocationPolicy fixed_even_shards(int num_shards, int nodes_per_shard,
                                        const std::string& profile = "default");

ShardAllocationPolicy raw_fixed_even_shards(int num_shards, int nodes_per_shard,
                                            const std::string& profile = "default");
ShardAllocationPolicy custom_shards_policy(const std::vector<int>& min_nodes_by_shard,
                                           const std::vector<int>& max_nodes_by_shard,
                                           const std::vector<Mode>& delivery_modes_by_shard,
                                           const std::vector<std::string>& profiles_by_shard);

ShardAllocationPolicy custom_shard_policy(const std::vector<Mode>& delivery_modes_by_shard,
                                          const std::vector<std::string>& profiles_by_shard);

SubgroupAllocationPolicy one_subgroup_policy(const ShardAllocationPolicy& policy);

SubgroupAllocationPolicy identical_subgroups_policy(int num_subgroups, const ShardAllocationPolicy& subgroup_policy);

class DefaultSubgroupAllocator {
protected:
    const std::map<std::type_index, std::variant<SubgroupAllocationPolicy, CrossProductPolicy>> policies;

    std::map<std::type_index, std::vector<std::vector<uint32_t>>> compute_standard_shard_sizes(
            const std::vector<std::type_index>& subgroup_type_order,
            const std::unique_ptr<View>& prev_view,
            const View& curr_view) const;

    subgroup_shard_layout_t allocate_standard_subgroup_type(
            const std::type_index subgroup_type,
            View& curr_view,
            const std::map<std::type_index, std::vector<std::vector<uint32_t>>>& shard_sizes) const;

    subgroup_shard_layout_t update_standard_subgroup_type(
            const std::type_index subgroup_type,
            const subgroup_type_id_t subgroup_type_id,
            const std::unique_ptr<View>& prev_view,
            View& curr_view,
            const std::map<std::type_index, std::vector<std::vector<uint32_t>>>& shard_sizes) const;

    void compute_standard_memberships(const std::vector<std::type_index>& subgroup_type_order,
                                      const std::unique_ptr<View>& prev_view,
                                      View& curr_view,
                                      subgroup_allocation_map_t& subgroup_layouts) const;

    void compute_cross_product_memberships(const std::vector<std::type_index>& subgroup_type_order,
                                           const std::unique_ptr<View>& prev_view,
                                           View& curr_view,
                                           subgroup_allocation_map_t& subgroup_layouts) const;

public:
    DefaultSubgroupAllocator(const std::map<std::type_index,
                                            std::variant<SubgroupAllocationPolicy, CrossProductPolicy>>&
                                     policies_by_subgroup_type)
            : policies(policies_by_subgroup_type) {}
    DefaultSubgroupAllocator(const DefaultSubgroupAllocator& to_copy)
            : policies(to_copy.policies) {}
    DefaultSubgroupAllocator(DefaultSubgroupAllocator&&) = default;

    subgroup_allocation_map_t operator()(const std::vector<std::type_index>& subgroup_type_order,
                                         const std::unique_ptr<View>& prev_view,
                                         View& curr_view) const;
};

}  // namespace derecho