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/gcc6-concepts.hh>


namespace seastar {

constexpr unsigned max_scheduling_groups() { return 16; }

template <typename... T>
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);
scheduling_group scheduling_group_from_index(unsigned index);

unsigned long scheduling_group_key_id(scheduling_group_key);

}


future<scheduling_group> create_scheduling_group(sstring name, float shares);

future<> destroy_scheduling_group(scheduling_group sg);

future<> rename_scheduling_group(scheduling_group sg, sstring new_name);


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&) = default;
private:
    scheduling_group_key(unsigned long id) :
        _id(id) {}
    unsigned long _id;
    unsigned long id() const {
        return _id;
    }
    friend class reactor;
    friend future<scheduling_group_key> scheduling_group_key_create(scheduling_group_key_config cfg);
    template<typename T>
    friend T& scheduling_group_get_specific(scheduling_group sg, scheduling_group_key key);
    template<typename T>
    friend T& scheduling_group_get_specific(scheduling_group_key key);

    friend unsigned long internal::scheduling_group_key_id(scheduling_group_key key) {
        return key.id();
    }
};

namespace internal {
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);

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) : _id(id) {}
public:
    constexpr scheduling_group() noexcept : _id(0) {} // must be constexpr for current_scheduling_group_holder
    bool active() const;
    const sstring& name() const;
    bool operator==(scheduling_group x) const { return _id == x._id; }
    bool operator!=(scheduling_group x) const { return _id != x._id; }
    bool is_main() const { return _id == 0; }
    template<typename T>
    T& get_specific(scheduling_group_key key) {
        return scheduling_group_get_specific<T>(*this, key);
    }
    void set_shares(float shares);
    friend future<scheduling_group> create_scheduling_group(sstring name, float shares);
    friend future<> destroy_scheduling_group(scheduling_group sg);
    friend future<> rename_scheduling_group(scheduling_group sg, sstring new_name);
    friend class reactor;
    friend unsigned internal::scheduling_group_index(scheduling_group sg);
    friend scheduling_group internal::scheduling_group_from_index(unsigned index);

    template<typename SpecificValType, typename Mapper, typename Reducer, typename Initial>
    GCC6_CONCEPT( requires requires(SpecificValType specific_val, Mapper mapper, Reducer reducer, Initial initial) {
        {reducer(initial, mapper(specific_val))} -> 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>
    GCC6_CONCEPT( requires requires(SpecificValType specific_val, Reducer reducer, Initial initial) {
        {reducer(initial, specific_val)} -> 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) {
    return sg._id;
}

inline
scheduling_group
scheduling_group_from_index(unsigned index) {
    return scheduling_group(index);
}

inline
scheduling_group*
current_scheduling_group_ptr() {
    // Slow unless constructor is constexpr
    static thread_local scheduling_group sg;
    return &sg;
}

}

inline
scheduling_group
current_scheduling_group() {
    return *internal::current_scheduling_group_ptr();
}

inline
scheduling_group
default_scheduling_group() {
    return scheduling_group();
}

inline
bool
scheduling_group::active() const {
    return *this == current_scheduling_group();
}

}

namespace std {

template <>
struct hash<seastar::scheduling_group> {
    size_t operator()(seastar::scheduling_group sg) const {
        return seastar::internal::scheduling_group_index(sg);
    }
};

}