ThreadControlBlock.hpp

Go to the documentation of this file.

#ifndef INCLUDE_DISTORTOS_INTERNAL_SCHEDULER_THREADCONTROLBLOCK_HPP_
#define INCLUDE_DISTORTOS_INTERNAL_SCHEDULER_THREADCONTROLBLOCK_HPP_

#include "distortos/internal/scheduler/RoundRobinQuantum.hpp"
#include "distortos/internal/scheduler/Stack.hpp"
#include "distortos/internal/scheduler/ThreadListNode.hpp"
#include "distortos/internal/scheduler/UnblockFunctor.hpp"

#include "distortos/internal/synchronization/MutexList.hpp"

#include "distortos/SchedulingPolicy.hpp"
#include "distortos/ThreadState.hpp"

namespace distortos
{

class SignalsReceiver;

namespace internal
{

class RunnableThread;
class SignalsReceiverControlBlock;
class ThreadList;
class ThreadGroupControlBlock;

class ThreadControlBlock : public ThreadListNode
{
public:

    ThreadControlBlock(Stack&& stack, uint8_t priority, SchedulingPolicy schedulingPolicy,
            ThreadGroupControlBlock* threadGroupControlBlock, SignalsReceiver* signalsReceiver, RunnableThread& owner);

    ~ThreadControlBlock();

    int addHook();

    void blockHook(const UnblockFunctor* const unblockFunctor)
    {
        unblockFunctor_ = unblockFunctor;
    }

    ThreadList* getList() const
    {
        return list_;
    }

    MutexList& getOwnedProtocolMutexList()
    {
        return ownedProtocolMutexList_;
    }

    RunnableThread& getOwner() const
    {
        return owner_;
    }

    RoundRobinQuantum& getRoundRobinQuantum()
    {
        return roundRobinQuantum_;
    }

    SchedulingPolicy getSchedulingPolicy() const
    {
        return schedulingPolicy_;
    }

    uintptr_t getSequenceNumber() const
    {
        return sequenceNumber_;
    }

#if DISTORTOS_SIGNALS_ENABLE == 1

    SignalsReceiverControlBlock* getSignalsReceiverControlBlock() const
    {
        return signalsReceiverControlBlock_;
    }

#endif  // DISTORTOS_SIGNALS_ENABLE == 1

    Stack& getStack()
    {
        return stack_;
    }

    const Stack& getStack() const
    {
        return stack_;
    }

    ThreadState getState() const
    {
        return state_;
    }

    void setList(ThreadList* const list)
    {
        list_ = list;
    }

    void setPriority(uint8_t priority, bool alwaysBehind = {});

    void setPriorityInheritanceMutexControlBlock(const MutexControlBlock* const priorityInheritanceMutexControlBlock)
    {
        priorityInheritanceMutexControlBlock_ = priorityInheritanceMutexControlBlock;
    }

    void setSchedulingPolicy(SchedulingPolicy schedulingPolicy);

    void setState(const ThreadState state)
    {
        state_ = state;
    }

    void switchedToHook()
    {
        _impure_ptr = &reent_;
    }

    void unblockHook(UnblockReason unblockReason);

    void updateBoostedPriority(uint8_t boostedPriority = {});

    ThreadControlBlock(const ThreadControlBlock&) = delete;
    ThreadControlBlock(ThreadControlBlock&&) = default;
    const ThreadControlBlock& operator=(const ThreadControlBlock&) = delete;
    ThreadControlBlock& operator=(ThreadControlBlock&&) = delete;

private:

    void reposition(bool loweringBefore);

    MutexList ownedProtocolMutexList_;

    _reent reent_;

    Stack stack_;

    ThreadList* list_;

    RunnableThread& owner_;

    const MutexControlBlock* priorityInheritanceMutexControlBlock_;

    uintptr_t sequenceNumber_;

#if DISTORTOS_SIGNALS_ENABLE == 1

    SignalsReceiverControlBlock* signalsReceiverControlBlock_;

#endif  // DISTORTOS_SIGNALS_ENABLE == 1

    ThreadGroupControlBlock* threadGroupControlBlock_;

    const UnblockFunctor* unblockFunctor_;

    RoundRobinQuantum roundRobinQuantum_;

    SchedulingPolicy schedulingPolicy_;

    ThreadState state_;
};

}   // namespace internal

}   // namespace distortos

#endif  // INCLUDE_DISTORTOS_INTERNAL_SCHEDULER_THREADCONTROLBLOCK_HPP_