MutexControlBlock.hpp

Go to the documentation of this file.

#ifndef INCLUDE_DISTORTOS_INTERNAL_SYNCHRONIZATION_MUTEXCONTROLBLOCK_HPP_
#define INCLUDE_DISTORTOS_INTERNAL_SYNCHRONIZATION_MUTEXCONTROLBLOCK_HPP_

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

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

#include "distortos/MutexProtocol.hpp"
#include "distortos/MutexType.hpp"
#include "distortos/TickClock.hpp"

#include <climits>

namespace distortos
{

namespace internal
{

class MutexControlBlock : public MutexListNode
{
public:

    using Protocol = MutexProtocol;

    using RecursiveLocksCount = uint16_t;

    using Type = MutexType;

    uint8_t getBoostedPriority() const;

    ThreadControlBlock* getOwner() const
    {
        return owner_;
    }

    constexpr static uint8_t typeShift {0};

    constexpr static uint8_t typeWidth {CHAR_BIT / 2};

    constexpr static uint8_t protocolShift {typeShift + typeWidth};

    constexpr static uint8_t protocolWidth {CHAR_BIT / 2};

protected:

    constexpr MutexControlBlock(const Type type, const Protocol protocol, const uint8_t priorityCeiling) :
            MutexListNode{},
            blockedList_{},
            owner_{},
            recursiveLocksCount_{},
            priorityCeiling_{priorityCeiling},
            typeProtocol_{static_cast<uint8_t>(static_cast<uint8_t>(type) << typeShift |
                    static_cast<uint8_t>(protocol) << protocolShift)}
    {

    }

    int doBlock();

    int doBlockUntil(TickClock::time_point timePoint);

    void doLock();

    void doUnlockOrTransferLock();

    uint8_t getPriorityCeiling() const
    {
        return priorityCeiling_;
    }

    Protocol getProtocol() const
    {
        return static_cast<Protocol>((typeProtocol_ >> protocolShift) & ((1 << protocolWidth) - 1));
    }

    RecursiveLocksCount& getRecursiveLocksCount()
    {
        return recursiveLocksCount_;
    }

    Type getType() const
    {
        return static_cast<Type>((typeProtocol_ >> typeShift) & ((1 << typeWidth) - 1));
    }

private:

    void beforeBlock() const;

    void doTransferLock();

    void doUnlock();

    ThreadList blockedList_;

    ThreadControlBlock* owner_;

    RecursiveLocksCount recursiveLocksCount_;

    uint8_t priorityCeiling_;

    uint8_t typeProtocol_;
};

}   // namespace internal

}   // namespace distortos

#endif  // INCLUDE_DISTORTOS_INTERNAL_SYNCHRONIZATION_MUTEXCONTROLBLOCK_HPP_