thread.h

Go to the documentation of this file.

/*===========================================================================
     _____        _____        _____        _____
 ___|    _|__  __|_    |__  __|__   |__  __| __  |__  ______
|    \  /  | ||    \      ||     |     ||  |/ /     ||___   |
|     \/   | ||     \     ||     \     ||     \     ||___   |
|__/\__/|__|_||__|\__\  __||__|\__\  __||__|\__\  __||______|
    |_____|      |_____|      |_____|      |_____|

--[Mark3 Realtime Platform]--------------------------------------------------

Copyright (c) 2012 - 2019 m0slevin, all rights reserved.
See license.txt for more information
=========================================================================== */
#pragma once

#include "kerneltypes.h"
#include "mark3cfg.h"

#include "ll.h"
#include "threadlist.h"
#include "scheduler.h"
#include "ithreadport.h"
#include "quantum.h"
#include "autoalloc.h"
#include "priomap.h"

namespace Mark3
{
class Thread;

//---------------------------------------------------------------------------
using ThreadCreateCallout  = void (*)(Thread* pclThread_);
using ThreadExitCallout    = void (*)(Thread* pclThread_);
using ThreadContextCallout = void (*)(Thread* pclThread_);

//---------------------------------------------------------------------------
class Thread : public TypedLinkListNode<Thread>
{
public:
    void* operator new(size_t sz, void* pv) { return reinterpret_cast<Thread*>(pv); };
    ~Thread();

    Thread() { m_eState = ThreadState::Invalid; }

    bool IsInitialized() { return (m_eState != ThreadState::Invalid); }

    void Init(K_WORD*         pwStack_,
              uint16_t        u16StackSize_,
              PORT_PRIO_TYPE  uXPriority_,
              ThreadEntryFunc pfEntryPoint_,
              void*           pvArg_);

    static Thread*
    Init(uint16_t u16StackSize_, PORT_PRIO_TYPE uXPriority_, ThreadEntryFunc pfEntryPoint_, void* pvArg_);

    void Start();

    void Stop();

#if KERNEL_NAMED_THREADS

    void SetName(const char* szName_) { m_szName = szName_; }
    const char* GetName() { return m_szName; }
#endif // #if KERNEL_NAMED_THREADS

    ThreadList* GetOwner(void) { return m_pclOwner; }
    inline ThreadList* GetCurrent(void) { return m_pclCurrent; }
    PORT_PRIO_TYPE GetPriority(void) { return m_uXPriority; }
    PORT_PRIO_TYPE GetCurPriority(void) { return m_uXCurPriority; }

#if KERNEL_ROUND_ROBIN

    void SetQuantum(uint16_t u16Quantum_) { m_u16Quantum = u16Quantum_; }
    uint16_t GetQuantum(void) { return m_u16Quantum; }
#endif // #if KERNEL_ROUND_ROBIN

    void SetCurrent(ThreadList* pclNewList_) { m_pclCurrent = pclNewList_; }
    void SetOwner(ThreadList* pclNewList_) { m_pclOwner = pclNewList_; }
    void SetPriority(PORT_PRIO_TYPE uXPriority_);

    void InheritPriority(PORT_PRIO_TYPE uXPriority_);

    void Exit();

    static void Sleep(uint32_t u32TimeMs_);

    static void Yield(void);

    static void CoopYield(void);

    void SetID(uint8_t u8ID_) { m_u8ThreadID = u8ID_; }
    uint8_t GetID() { return m_u8ThreadID; }

#if KERNEL_STACK_CHECK

    uint16_t GetStackSlack();
#endif // #if KERNEL_STACK_CHECK

#if KERNEL_EVENT_FLAGS

    uint16_t GetEventFlagMask() { return m_u16FlagMask; }

    void SetEventFlagMask(uint16_t u16Mask_) { m_u16FlagMask = u16Mask_; }

    void SetEventFlagMode(EventFlagOperation eMode_) { m_eFlagMode = eMode_; }

    EventFlagOperation GetEventFlagMode() { return m_eFlagMode; }
#endif // #if KERNEL_EVENT_FLAGS

    Timer* GetTimer();

    void SetExpired(bool bExpired_);

    bool GetExpired();

#if KERNEL_EXTENDED_CONTEXT

    void* GetExtendedContext() { return m_pvExtendedContext; }

    void SetExtendedContext(void* pvData_) { m_pvExtendedContext = pvData_; }
#endif // #if KERNEL_EXTENDED_CONTEXT

    ThreadState GetState() { return m_eState; }
    void SetState(ThreadState eState_) { m_eState = eState_; }

    K_WORD* GetStack() { return m_pwStack; }

    K_WORD* GetStackTop() { return m_pwStackTop; }

    uint16_t GetStackSize() { return m_u16StackSize; }

    int* ErrnoStorage() { return &m_iErrno; }

    friend class ThreadPort;

private:
    static void ContextSwitchSWI(void);

    void SetPriorityBase(PORT_PRIO_TYPE uXPriority_);


    K_WORD* m_pwStackTop;

    K_WORD* m_pwStack;

    uint8_t m_u8ThreadID;

    PORT_PRIO_TYPE m_uXPriority;

    PORT_PRIO_TYPE m_uXCurPriority;

    ThreadState m_eState;

#if KERNEL_EXTENDED_CONTEXT
    void* m_pvExtendedContext;
#endif // #if KERNEL_EXTENDED_CONTEXT

#if KERNEL_NAMED_THREADS
    const char* m_szName;
#endif // #if KERNEL_NAMED_THREADS

    uint16_t m_u16StackSize;

    ThreadList* m_pclCurrent;

    ThreadList* m_pclOwner;

    ThreadEntryFunc m_pfEntryPoint;

    void* m_pvArg;

#if KERNEL_ROUND_ROBIN
    uint16_t m_u16Quantum;
#endif // #if KERNEL_ROUND_ROBIN

#if KERNEL_EVENT_FLAGS
    uint16_t m_u16FlagMask;

    EventFlagOperation m_eFlagMode;
#endif // #if KERNEL_EVENT_FLAGS

    bool m_bExpired;

    int m_iErrno;

    Timer m_clTimer;
};

} // namespace Mark3