Scheduler.hpp

Go to the documentation of this file.

#ifndef INCLUDE_DISTORTOS_INTERNAL_SCHEDULER_SCHEDULER_HPP_
#define INCLUDE_DISTORTOS_INTERNAL_SCHEDULER_SCHEDULER_HPP_

#include "distortos/internal/scheduler/ThreadControlBlock.hpp"
#include "distortos/internal/scheduler/ThreadList.hpp"
#include "distortos/internal/scheduler/SoftwareTimerSupervisor.hpp"

namespace distortos
{

namespace internal
{

class Scheduler
{
public:

    constexpr Scheduler() :
            currentThreadControlBlock_{},
            runnableList_{},
            suspendedList_{},
            softwareTimerSupervisor_{},
            contextSwitchCount_{},
            tickCount_{}
    {

    }

    int add(ThreadControlBlock& threadControlBlock);

    int block(ThreadList& container, ThreadState state, const UnblockFunctor* unblockFunctor = {});

    int block(ThreadList& container, ThreadList::iterator iterator, ThreadState state,
            const UnblockFunctor* unblockFunctor = {});

    int blockUntil(ThreadList& container, ThreadState state, TickClock::time_point timePoint,
            const UnblockFunctor* unblockFunctor = {});

    uint64_t getContextSwitchCount() const;

    ThreadControlBlock& getCurrentThreadControlBlock() const
    {
        return *currentThreadControlBlock_;
    }

    SoftwareTimerSupervisor& getSoftwareTimerSupervisor()
    {
        return softwareTimerSupervisor_;
    }

    const SoftwareTimerSupervisor& getSoftwareTimerSupervisor() const
    {
        return softwareTimerSupervisor_;
    }

    uint64_t getTickCount() const;

    int initialize(ThreadControlBlock& mainThreadControlBlock);

    void maybeRequestContextSwitch() const;

    int remove();

    int resume(ThreadList::iterator iterator);

    int suspend();

    int suspend(ThreadList::iterator iterator);

    void* switchContext(void* stackPointer);

    bool tickInterruptHandler();

    void unblock(ThreadList::iterator iterator, UnblockReason unblockReason = UnblockReason::unblockRequest);

    void yield();

private:

    int addInternal(ThreadControlBlock& threadControlBlock);

    int blockInternal(ThreadList& container, ThreadList::iterator iterator, ThreadState state,
            const UnblockFunctor* unblockFunctor);

    bool isContextSwitchRequired() const;

    void unblockInternal(ThreadList::iterator iterator, UnblockReason unblockReason);

    ThreadList::iterator currentThreadControlBlock_;

    ThreadList runnableList_;

    ThreadList suspendedList_;

    SoftwareTimerSupervisor softwareTimerSupervisor_;

    uint64_t contextSwitchCount_;

    uint64_t tickCount_;
};

}   // namespace internal

}   // namespace distortos

#endif  // INCLUDE_DISTORTOS_INTERNAL_SCHEDULER_SCHEDULER_HPP_