scheduling.hh

Go to the documentation of this file.

/*
 * This file is open source software, licensed to you under the terms
 * of the Apache License, Version 2.0 (the "License").  See the NOTICE file
 * distributed with this work for additional information regarding copyright
 * ownership.  You may not use this file except in compliance with the License.
 *
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
/*
 * Copyright (C) 2016 Scylla DB Ltd
 */
 
#pragma once
 
#include <typeindex>
#include <seastar/core/sstring.hh>
#include <seastar/core/function_traits.hh>
#include <seastar/util/concepts.hh>
 
 
namespace seastar {
 
constexpr unsigned max_scheduling_groups() { return 16; }
 
#if SEASTAR_API_LEVEL < 6
#define SEASTAR_ELLIPSIS ...
template <typename SEASTAR_ELLIPSIS T>
#else
#define SEASTAR_ELLIPSIS
template <typename T = void>
#endif
class future;
 
class reactor;
 
class scheduling_group;
class scheduling_group_key;
 
namespace internal {
 
// Returns an index between 0 and max_scheduling_groups()
unsigned scheduling_group_index(scheduling_group sg) noexcept;
scheduling_group scheduling_group_from_index(unsigned index) noexcept;
 
unsigned long scheduling_group_key_id(scheduling_group_key) noexcept;
 
template<typename T>
T* scheduling_group_get_specific_ptr(scheduling_group sg, scheduling_group_key key) noexcept;
 
}
 
 
future<scheduling_group> create_scheduling_group(sstring name, float shares) noexcept;
 
future<> destroy_scheduling_group(scheduling_group sg) noexcept;
 
future<> rename_scheduling_group(scheduling_group sg, sstring new_name) noexcept;
 
 
struct scheduling_group_key_config {
    scheduling_group_key_config() :
        scheduling_group_key_config(typeid(void)) {}
    scheduling_group_key_config(const std::type_info& type_info) :
            type_index(type_info) {}
    size_t allocation_size;
    size_t alignment;
    std::type_index type_index;
    std::function<void (void*)> constructor;
    std::function<void (void*)> destructor;
 
};
 
 
class scheduling_group_key {
public:
    scheduling_group_key(const scheduling_group_key&) noexcept = default;
    scheduling_group_key(scheduling_group_key&&) noexcept = default;
private:
    scheduling_group_key(unsigned long id) noexcept :
        _id(id) {}
    unsigned long _id;
    unsigned long id() const noexcept {
        return _id;
    }
    friend class reactor;
    friend future<scheduling_group_key> scheduling_group_key_create(scheduling_group_key_config cfg) noexcept;
    template<typename T>
    friend T* internal::scheduling_group_get_specific_ptr(scheduling_group sg, scheduling_group_key key) noexcept;
    template<typename T>
    friend T& scheduling_group_get_specific(scheduling_group_key key) noexcept;
 
    friend unsigned long internal::scheduling_group_key_id(scheduling_group_key key) noexcept;
};
 
namespace internal {
 
inline unsigned long scheduling_group_key_id(scheduling_group_key key) noexcept {
    return key.id();
}
 
template<typename ConstructorType, typename Tuple, size_t...Idx>
void apply_constructor(void* pre_alocated_mem, Tuple args, std::index_sequence<Idx...> idx_seq) {
    new (pre_alocated_mem) ConstructorType(std::get<Idx>(args)...);
}
}
 
template <typename T, typename... ConstructorArgs>
scheduling_group_key_config
make_scheduling_group_key_config(ConstructorArgs... args) {
    scheduling_group_key_config sgkc(typeid(T));
    sgkc.allocation_size = sizeof(T);
    sgkc.alignment = alignof(T);
    sgkc.constructor = [args = std::make_tuple(args...)] (void* p) {
        internal::apply_constructor<T>(p, args, std::make_index_sequence<sizeof...(ConstructorArgs)>());
    };
    sgkc.destructor = [] (void* p) {
        static_cast<T*>(p)->~T();
    };
    return sgkc;
}
 
future<scheduling_group_key> scheduling_group_key_create(scheduling_group_key_config cfg) noexcept;
 
template<typename T>
T& scheduling_group_get_specific(scheduling_group sg, scheduling_group_key key);
 
 
class scheduling_group {
    unsigned _id;
private:
    explicit scheduling_group(unsigned id) noexcept : _id(id) {}
public:
    constexpr scheduling_group() noexcept : _id(0) {} // must be constexpr for current_scheduling_group_holder
    bool active() const noexcept;
    const sstring& name() const noexcept;
    bool operator==(scheduling_group x) const noexcept { return _id == x._id; }
    bool operator!=(scheduling_group x) const noexcept { return _id != x._id; }
    bool is_main() const noexcept { return _id == 0; }
    template<typename T>
    T& get_specific(scheduling_group_key key) noexcept {
        return *internal::scheduling_group_get_specific_ptr<T>(*this, key);
    }
    void set_shares(float shares) noexcept;
    friend future<scheduling_group> create_scheduling_group(sstring name, float shares) noexcept;
    friend future<> destroy_scheduling_group(scheduling_group sg) noexcept;
    friend future<> rename_scheduling_group(scheduling_group sg, sstring new_name) noexcept;
    friend class reactor;
    friend unsigned internal::scheduling_group_index(scheduling_group sg) noexcept;
    friend scheduling_group internal::scheduling_group_from_index(unsigned index) noexcept;
 
    template<typename SpecificValType, typename Mapper, typename Reducer, typename Initial>
    SEASTAR_CONCEPT( requires requires(SpecificValType specific_val, Mapper mapper, Reducer reducer, Initial initial) {
        {reducer(initial, mapper(specific_val))} -> std::convertible_to<Initial>;
    })
    friend future<typename function_traits<Reducer>::return_type>
    map_reduce_scheduling_group_specific(Mapper mapper, Reducer reducer, Initial initial_val, scheduling_group_key key);
 
    template<typename SpecificValType, typename Reducer, typename Initial>
    SEASTAR_CONCEPT( requires requires(SpecificValType specific_val, Reducer reducer, Initial initial) {
        {reducer(initial, specific_val)} -> std::convertible_to<Initial>;
    })
    friend future<typename function_traits<Reducer>::return_type>
        reduce_scheduling_group_specific(Reducer reducer, Initial initial_val, scheduling_group_key key);
 
 
};
 
namespace internal {
 
inline
unsigned
scheduling_group_index(scheduling_group sg) noexcept {
    return sg._id;
}
 
inline
scheduling_group
scheduling_group_from_index(unsigned index) noexcept {
    return scheduling_group(index);
}
 
inline
scheduling_group*
current_scheduling_group_ptr() noexcept {
    // Slow unless constructor is constexpr
    static thread_local scheduling_group sg;
    return &sg;
}
 
}
 
inline
scheduling_group
current_scheduling_group() noexcept {
    return *internal::current_scheduling_group_ptr();
}
 
inline
scheduling_group
default_scheduling_group() noexcept {
    return scheduling_group();
}
 
inline
bool
scheduling_group::active() const noexcept {
    return *this == current_scheduling_group();
}
 
}
 
namespace std {
 
template <>
struct hash<seastar::scheduling_group> {
    size_t operator()(seastar::scheduling_group sg) const noexcept {
        return seastar::internal::scheduling_group_index(sg);
    }
};
 
}