scheduler.hpp

Go to the documentation of this file.

#pragma once
 
#include <cortex/memory_resource.hpp>
#include <cortex/tiny_fiber/detail/fiber.hpp>
 
#include <deque>
#include <memory>
#include <unordered_map>
 
namespace cortex::tiny_fiber {
 
class Scheduler {
public:
    struct Config {
        std::size_t default_stack_size = cortex::Coroutine::kDefaultStackSizeBytes;
        MemoryResourceSharedPtr memory_resource = GetDefaultMemoryResource();
    };
 
    template <typename F>
    static void Run(F&& entry);
 
    template <typename F>
    static void Run(F&& entry, Config config);
 
    template <typename F>
    static std::unique_ptr<Scheduler> Create(F&& entry);
 
    template <typename F>
    static std::unique_ptr<Scheduler> Create(F&& entry, Config config);
 
    static Scheduler& Current();
 
    Scheduler(const Scheduler&) = delete;
    Scheduler& operator=(const Scheduler&) = delete;
    Scheduler(Scheduler&&) = delete;
    Scheduler& operator=(Scheduler&&) = delete;
    ~Scheduler();
 
    bool Step();
 
    [[nodiscard]] bool IsDone() const noexcept {
        return ready_queue_.empty() && !current_fiber_;
    }
 
    [[nodiscard]] std::size_t GetDefaultStackSize() const noexcept {
        return config_.default_stack_size;
    }
 
    [[nodiscard]] MemoryResourceSharedPtr GetMemoryResource() const noexcept {
        return config_.memory_resource;
    }
 
    [[nodiscard]] bool IsRunning() const noexcept {
        return running_;
    }
 
    [[nodiscard]] bool IsStopping() const noexcept {
        return stopping_;
    }
 
    void Stop();
 
    detail::Fiber::Id SpawnFiberInternal(detail::Fiber::Body func, std::size_t stack_size);
 
private:
    friend class detail::Fiber;
    template <typename T>
    friend class Future;
    friend class Mutex;
    friend class ConditionVariable;
    friend void Yield();
    friend bool YieldIfOthersReady();
 
    explicit Scheduler(Config config);
 
    void RunLoop();
 
    // Get fiber by ID
    detail::Fiber* GetFiber(detail::Fiber::Id id);
 
    // Get currently running fiber
    detail::Fiber* GetCurrentFiber() {
        return current_fiber_;
    }
 
    // Wake a suspended fiber and enqueue it to run
    void Schedule(detail::Fiber* fiber);
 
    // Suspend current fiber
    void SuspendCurrent();
 
    // Yield current fiber (put back in ready queue)
    void YieldCurrent();
 
    // Check if there are other ready fibers
    bool HasOtherReadyFibers() const;
 
    // Process pending fiber cleanup
    void ProcessPendingCleanup();
 
private:
    Config config_;
    bool running_ {false};
    bool stopping_ {false};
    detail::Fiber* current_fiber_ {nullptr};
    std::deque<detail::Fiber*> ready_queue_;
    std::unordered_map<detail::Fiber::Id, std::unique_ptr<detail::Fiber>> fibers_;
    std::vector<detail::Fiber::Id> pending_cleanup_;
};
 
// Template implementations
template <typename F>
void Scheduler::Run(F&& entry) {
    Run(std::forward<F>(entry), Config {});
}
 
template <typename F>
void Scheduler::Run(F&& entry, Config config) {
    Scheduler scheduler(std::move(config));
    scheduler.SpawnFiberInternal(std::forward<F>(entry), scheduler.config_.default_stack_size);
    scheduler.RunLoop();
}
 
template <typename F>
std::unique_ptr<Scheduler> Scheduler::Create(F&& entry) {
    return Create(std::forward<F>(entry), Config {});
}
 
template <typename F>
std::unique_ptr<Scheduler> Scheduler::Create(F&& entry, Config config) {
    std::unique_ptr<Scheduler> scheduler(new Scheduler(std::move(config)));
    scheduler->SpawnFiberInternal(std::forward<F>(entry), scheduler->config_.default_stack_size);
    return scheduler;
}
 
} // namespace cortex::tiny_fiber