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
 
#ifndef SEASTAR_MODULE
#include <chrono>
#include <functional>
#include <typeindex>
#endif
#include <seastar/core/sstring.hh>
#include <seastar/core/function_traits.hh>
#include <seastar/util/concepts.hh>
#include <seastar/util/modules.hh>
 
 
namespace seastar {
 
SEASTAR_MODULE_EXPORT_BEGIN
constexpr unsigned max_scheduling_groups() { return SEASTAR_SCHEDULING_GROUPS_COUNT; }
 
template <typename T = void>
class future;
 
class reactor;
 
class scheduling_group;
class scheduling_group_key;
 
using sched_clock = std::chrono::steady_clock;
SEASTAR_MODULE_EXPORT_END
 
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;
 
}
 
SEASTAR_MODULE_EXPORT_BEGIN
 
future<scheduling_group> create_scheduling_group(sstring name, float shares) noexcept;
 
future<scheduling_group> create_scheduling_group(sstring name, sstring shortname, float shares) noexcept;
 
future<> destroy_scheduling_group(scheduling_group sg) noexcept;
 
future<> rename_scheduling_group(scheduling_group sg, sstring new_name) noexcept;
future<> rename_scheduling_group(scheduling_group sg, sstring new_name, sstring new_shortname) 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*)> rename;
    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;
};
 
SEASTAR_MODULE_EXPORT_END
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...>) {
    new (pre_alocated_mem) ConstructorType(std::get<Idx>(args)...);
}
}
SEASTAR_MODULE_EXPORT_BEGIN
 
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;
    const sstring& short_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; }
    bool is_at_exit() const noexcept { return _id == 1; }
    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;
 
    float get_shares() const noexcept;
 
#if SEASTAR_API_LEVEL >= 7
    future<> update_io_bandwidth(uint64_t bandwidth) const;
#endif
 
    friend future<scheduling_group> create_scheduling_group(sstring name, sstring shortname, float shares) noexcept;
    friend future<> destroy_scheduling_group(scheduling_group sg) noexcept;
    friend future<> rename_scheduling_group(scheduling_group sg, sstring new_name, sstring new_shortname) 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);
 
 
};
 
SEASTAR_MODULE_EXPORT_END
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);
}
 
#ifdef SEASTAR_BUILD_SHARED_LIBS
scheduling_group*
current_scheduling_group_ptr() noexcept;
#else
inline
scheduling_group*
current_scheduling_group_ptr() noexcept {
    // Slow unless constructor is constexpr
    static thread_local scheduling_group sg;
    return &sg;
}
#endif
}
 
SEASTAR_MODULE_EXPORT_BEGIN
inline
scheduling_group
current_scheduling_group() noexcept {
    return *internal::current_scheduling_group_ptr();
}
 
inline
scheduling_group
default_scheduling_group() noexcept {
    return scheduling_group();
}
 
SEASTAR_MODULE_EXPORT_END
 
inline
bool
scheduling_group::active() const noexcept {
    return *this == current_scheduling_group();
}
 
}
 
namespace std {
 
SEASTAR_MODULE_EXPORT
template <>
struct hash<seastar::scheduling_group> {
    size_t operator()(seastar::scheduling_group sg) const noexcept {
        return seastar::internal::scheduling_group_index(sg);
    }
};
 
}