cinostask.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
#ifndef INC_INOSTASK_H
#define INC_INOSTASK_H
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
//
// C++
#if defined(INOS_DESKTOP)
#include <thread>
#include <condition_variable>
#endif
//
// project
//
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
// 
class CINOSTask
{
    // public members
    public:
        CINOSTask(char* apName=nullptr, uint32 auStackSize=defDefaultStackSize,
            uint32 auPriority=DF_INOS_TASK_PRIO_LOWEST, bool abFloatingPoint=true,
            uint32 auTimeSlice=defDefaultTimeSlice, bool abInterruptsDisabled=false,
            void* apHandler=0, void* apObject=0);
 
        CINOSTask(std::function<void(void*)> aFunction, void* apParam = nullptr,
            uint8 auPriority=DF_INOS_TASK_PRIO_LOWEST);
 
        CINOSTask(const char* apName, std::function<void(void*)> aFunction,
            void* apParam = nullptr, uint8 auPriority=DF_INOS_TASK_PRIO_LOWEST);
 
        virtual ~CINOSTask();
 
        virtual uint32 Shutdown(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Join();
 
        virtual void Detach();
 
        virtual void Exit();
 
        virtual void Exit(uint32 auExitCode);
 
        virtual void SetExitCode(uint32 auExitCode)
            { m_uExitCode = auExitCode; };
 
        virtual uint32 GetExitCode()
            { return m_uExitCode; };
 
        virtual bool CheckShutdown()
            { return (m_uTskFlags & eTskFlgShutdownRequest); };
 
        virtual void SetSuspendHook(void* apSuspendHook)
            {
                #if defined(INOS_DESKTOP)
                m_pSuspendHook = apSuspendHook;
                #else
                if (apSuspendHook)
                    m_pSuspendHook = (void*) ((uintnbr)apSuspendHook | 3);
                else
                    m_pSuspendHook = nullptr;
                #endif
            };
 
        virtual void ClrSuspendHook()
            {
                m_pSuspendHook = nullptr;
            };
 
        virtual void* GetSuspendHook()
            {
                return m_pSuspendHook;
            };
 
        enum ETskType {
            eTskTypeBoot = 0,
            eTskTypeResource = 1,
            eTskTypeSystem = 2,
            eTskTypeApplication = 3,
            eTskTypeCommunication = 4,
            eTskTypeRealtime = 5,
            eTskTypeInterrupt = 6,
            eTskTypeBackground = 7,
            eTskTypeLua = 8,
            eTskTypeTest = 9,
            eTskTypeReserved0 = 10,
            eTskTypeReserved1 = 11,
            eTskTypeUser0 = 12,
            eTskTypeUser1 = 13,
            eTskTypeUser2 = 14,
            eTskTypeUser3 = 15,
        };
 
        INOS_INLINE ETskType GetTskType()
            {
                return ETskType(m_eTskType&0xf);
            };
 
        INOS_INLINE ETskType SetTskType(ETskType aeType)
            {
                ETskType old = m_eTskType;
                m_eTskType = ETskType(aeType&0xf);
                return old;
            };
 
    // protected members
    protected:
 
        virtual void Action();
 
#if defined(INOS_TIMINIG_CHECKS_SUSPEND)
        virtual void OnResume(uint32 auLastState, uint32 auElapsedUs, void* apSync);
#endif
 
 
    // private members
    private :
 
    // friend classes
    friend class CINOSMutex;
    friend class CINOSSync;
    friend class CINOSMultiSync;
    friend class CINOSExceptionContext;
    friend class CINOSExceptionCleanup;
    friend class CINOSRegisterLoadDevice;
    friend class CINOSWatchPoint;
    friend class CINCODataLogger;
    friend class CINCODataLoggerReader;
    friend class CINFOLink;
    friend class CINOSTaskQueue;
    friend class CINOSTaskEx;
    friend class CINOSTaskExMsg;
    friend class CINCOTaskExProcedure;
    friend class CINOSMcLua;
    friend class CINOSMcMessage;
    friend class CINOSMcCoord;
    friend class CINOSConcurrencyCheck;
    friend class CINOSOpcUaIncoItemProcedureAdapter;
    friend class CINCOEvtLoggerGet;
    friend class CINCOObject;
    friend class CINCOProcedure;
    friend class CINOSSioTftExpProc;
    friend class CINOSTestpoint;
    friend class CINCOVThreadImpl;
    friend class CINCOVParseProcedure;
    friend class CINOSConditionVariable;
    friend class CINOSMcTargetINCOFrameHandler;
    // hardware
    friend class CINOSHwTarget;
    friend class CINOSHwDevice;
    friend class CINOSHwEthernet;
 
 
 
    friend class CINOSHwDbg_P50XX;
    friend class CINOSHwDbg_P2020;
    friend class CINOSHwDbg_ppc750;
    friend class CINOSHwDbg_CortexA9;
    friend class CINOSHwDbg_ARMv8;
 
    friend class CINOSHwIrq_P50XX;
    friend class CINOSHwIrq_p2020;
    friend class CINOSHwIrq_ppc750;
    friend class CINOSHwIrq_CortexA9;
    friend class CINOSHwIrq_GIC;
    friend class CINOSHwIrq_GICv2;
    friend class CINOSHwIrq_GICv3;
 
    friend class CINOSHwCpu_p50XX;
    friend class CINOSHwCpu_p2020;
    friend class CINOSHwCpu_ppc750;
    friend class CINOSHwCpu_CortexA9;
    friend class CINOSHwCpu_ARMv8;
 
    friend class CINOSHwTrp_P50XX;
    friend class CINOSHwTrp_P2020;
    friend class CINOSHwTrp_ppc750;
    friend class CINOSHwTrp_CortexA9;
    friend class CINOSHwTrp_ARMv8;
    // kernel
    friend class CINOSKernel;
    friend class CINOSKernel_ARM;
    friend class CINOSKernel_P50XX;
    friend class CINOSKernel_P2020;
    friend class CINOSKernel_PPC750;
    friend class CINOSKernel_CortexA9;
    friend class CINOSKernel_ARMv8;
 
    friend void Ready(CINOSTask* apTask, uint32 auFlags);
    friend void* _SetupTask(CINOSTask*);
    #if defined (INOS_DESKTOP)
    #if defined (INOS_WINDOWS)
    friend long _Sleep(long aTime);
    #else
    friend long Sleep(long aTime);
    #endif
    #endif
    friend void _suspend(uint32 auState);
    friend void _suspend(uint32 auState, uint32 auFlags);
    friend void _resume(CINOSTask* apTask);
    friend void _resume(CINOSTask* apTask, uint32 auFlags);
    friend void _preemption();
    friend void _schedule();
    friend void _changepriority(uint32 auPriority);
    friend void _relinquish();
    // friend functions
    friend uint32 INOSDisableExceptions();
    friend void INOSEnableExceptions(uint32 auState);
    friend bool _CINOSExceptionContext__Save();
    friend void SlaveVariable(class CINCOFrame* aFrame);
 
    // Tests
    friend class CTaskExTestImpl;
    friend class CINOSTaskExMsgTest;
    friend class CINOSStackCorruptionTest;
 
 
    // private members
    #if defined(INOS_TESTING)
    public:
    #else
    private:
    #endif
        // task stack (has ro be the first local data)
        void*   pStack;             // pointer to top of stack
        void*   pStackBegin;        // pointer to start of stack
        void*   pStackEnd;          // pointer to end of stack
 
        void* m_pSuspendHook = nullptr;
 
        // linked list pointers
        CINOSTask* pNext;           // pointer to next task in list
        CINOSTask* pPrevious;       // pointer to previous task in list
 
        uint16  mState;             // task state
        uint16  mTrapNumber;        // trap number if task on trap
        uint32  mCycleTicks;        // number of cpu ticks of one task cycle
        uint8   mPriority;          // task priority
        uint8   mSavedPriority;     // saved task priority
        uint16  mUsecTimeSlice;     // task timeslice (in usec)
        uint16  mPreemptionCnt;     // preemption counter
        uint32  mBclkTimeSlice;     // task timeslice (in bus clocks)
        uintnbr mDecSave;           // decrementer save
        uintnbr mSavedMSR;          // temporarly saved mrs over singelstep
    public:
        enum {
        eTskFlgFloatingpoint = 0x00000001,
        eTskFlgIrqDisabled = 0x00000002,
        eTskFlgTimeslice = 0x00000004,
        eTskFlgTimingFailureHaltTask = 0x00000008,  
        eTskFlgDebugTimingDisableIrq = 0x00000010,  
        eTskFlgStartupDone = 0x00000020,
        eTskFlgShutdownRequest = 0x00000040,
        eTskFlgFunctionValid = 0x00000080,
        eTskFlgShutdownPending = 0x00000100,
        eTskFlgStackProtection = 0x00000200,
        eTskFlgPriorityCheck   = 0x00000400,
        eTskFlgSuspendTimingCheck = 0x00000800,
        eTskFlgSuspendHookRunning = 0x00001000,
        eTskFlgIncoTouch = 0x00002000,
        };
        uint32 m_uTskFlags;
        uint32 m_uTskId = 0;
        uint32 m_uTskNxtId = 0;
        uint32 m_uTskPrvId = 0;
        uint32 m_uTskParentId = 0;
        volatile uint32 m_uTskLastChildId = 0;
 
    // sync handling
    private:
        CINOSMutex* pActualMutex;   // pointer to actual mutex
 
    // IMPORTANT: Do not use this member in new projects, as it will not be available
    //            anymore in the future. But some projects of key customers rely on
    //            an 'only' protected' member.
    protected:
        CINOSSync*  pActualSync;    // pointer to actual sync object
 
    private:
        tTaskId     m_idNxtWaiting; // id of next task waiting for a sync object
 
    // exception handling members
    private:
        uint32 mExceptionState;                     // exception state
        class CINOSException* pExceptionPending;            // pointer to pending exception
        class CINOSExceptionContext* pExceptionContext; // pointer to task exception context
 
    // task data
    private:
        char*   pName;              // task name
        char*   pNameSave = nullptr;// task name used at shutdown
        uint32  mTaskIdentification;// task id pattern (0x05640172)
        _reent* m_pReentrancy;      // pointer to _reent structure (libc reentrancy)
        uint32  mTimer_1ms;         // 1ms timer (for Sleep)
 
        // timing data (all data in ticks (4 bus cycles (603) / 1 cpu cycle (403))
        uint64 m_uTbRestore;        // timebase at restore
        uint64 m_uTbTask;           // task timebase
        uint32 m_uTbEntry;          // timebase at method entry
        uint32 m_uTbOld;            // task timebase at last suspend
        uint32 m_uTbAct;            // actual used cpu time
        uint32 m_uTbMin;            // min. used cpu time
        uint32 m_uTbMax;            // max. used cpu time
        uint32  mResumeTime;        // timebase at task resume
        uint64  mResumeTimeNs;      // timebase at task resume [ns]
        uint32  mMinResponseTime;   // min. response time (resume until active)
        uint32  mMaxResponseTime;   // max. response time (resume until active)
        uint32  mActResponseTime;   // actual response time (resume until active)
        uint32  mSinglestepInstruction; // The instruction which we singlestep. we need to store it because it can't always be calculated in the interrupt handler, becuase after a 'branch instruction', the stepped over instruction can't be calculated anymore.
        uint32 m_uActivity;
 
        uint16  mError;             // task error (used for callprocedure etc.)
        uint16  mClassSize;         // size of class (used for delete operator)
        static uint32 m_uDebugUpdateId; // update id that changes whenever a "debug setting" changes, such as breakpoint/watchpoint added, removed, etc.
        void* m_pHandler;
        void* m_pObject;
        uint64 m_uBusTickAtIrq;
 
    // private member functions
    private :
        // prepare stack context
        void PrepareStack(bool aInterruptsDisabled, void* apHandler, void* apObject);
        // main loop (called at startup)
        void MainLoop();
 
    // public debug functions
    public :
        enum ETaskErrorFlags {
            // note: the lower Byte is currently used to send inco errors,
            // such as 'wrong param count' (defRpcNumberParam) to the caller,
            // therfore do not use the lower Byte
 
            eFlagCalledByINCO           = 0x100, 
            eFlagUseINCO4AsyncResultMgr = 0x200, 
#if defined(INCO_RETRY_AWARE_GETVARIABLE)
            eFlagINCODenyRetries        = 0x400 
#endif
        };
        virtual void MsgReply(
            CINOSTaskExMsg* apMsg, uint32 auReply, uint32 aAppError)
            {}
        uint32 GetError()
            {return mError;}
    # if defined(INCO_DEPRECATED_CALLPROCEDURE_ERRORS)
    // Some projects of key customers return CallProcedure errors via this SetError method
    public:
    #else
    // SetError is private to avoid code that accidentally sets the error of the task with
    // an unsupported error.
    private:
    #endif
        void SetError(uint32 aError)
            { mError=(uint16)aError;}
    public:
        uint32 GetId()
            {return mTaskIdentification;}
        void SetId(uint32 aId)
            { mTaskIdentification=aId;}
        uint32 GetTaskId()
            { return m_uTskId; }
        uint32 GetParentId()
            { return m_uTskParentId; }
        uint32 GetState () const
            { return mState;}
        void SetState(uint16 aState)
            { mState=aState;}
        uint32 GetPriority()
            { return mPriority;}
        void SetPriority(uint32 auPriority);
 
        uint32 GetTrapNumber()
            { return mTrapNumber;}
        void SetTrapNumber(uint32 aNumber)
            { mTrapNumber = (uint16)aNumber;}
        uint32 GetCycleTicks()
            { return mCycleTicks&0x00ffffff;}
        uint32 SetCycleTicks(uint32 auCycleTicks)
            { return mCycleTicks = auCycleTicks;}
        uint8 GetOversampling()
            { return (uint8) ((mCycleTicks>>24)&0xff);}
        void SetOversampling(uint8 auOversampling)
            { mCycleTicks = (mCycleTicks&0x00ffffff)|(auOversampling<<24);}
        uint32 GetResumeTicks()
            { return mResumeTime;}
        uint64 GetResumeTimeNs()
            { return mResumeTimeNs;}
        void SetResumeTimeNs(uint64 auResumeTimeNs)
            { mResumeTimeNs = auResumeTimeNs;}
        uint32 GetTbEntry()
            { return m_uActivity;}
        uint64 GetTbTask() const
        {
            uint32 uMsr = INOSDisableInterrupts();
            uint64 uValue = m_uTbTask;
            INOSEnableInterrupts(uMsr);
            return uValue;
        }
        uint64 GetTbTaskReal() const
        {
            uint64 uCurrentTicks = GetSystemTicks();
            const CINOSTask* pTask = ActualTask();
            uint32 uMsr = INOSDisableInterrupts();
            uint64 uTskTicks = pTask->m_uTbTask;
            uint64 uTskRestore = pTask->m_uTbRestore;
            INOSEnableInterrupts(uMsr);
            if (uCurrentTicks > uTskRestore) uTskTicks += (uCurrentTicks-uTskRestore);
            return uTskTicks;
        }
        uint64 GetTbRestore() const
        {
            uint32 uMsr = INOSDisableInterrupts();
            uint64 uValue = m_uTbRestore;
            INOSEnableInterrupts(uMsr);
            return uValue;
        }
        uint16 GetClassSize()
            { return mClassSize;}
        _reent* GetReentrancy()
            {
                m_uReentrancyTouched++;
                return m_pReentrancy;
            };
        uint32 GetReentrancyTouched()
            {
                return m_uReentrancyTouched;
            };
 
        char* GetName() const
            { return pName;}
        CINCOObject* iGetRegister();
 
        uint32 SingleStep();
        uint32 RangeStep(uint32 auFrom, uint32 auTo);
        uint32 Halt();
        uint32 Run();
 
        uint32 GetPC(uintnbr* aValue);
        uint32 PutPC(uintnbr aValue);
        uint32 GetLR(uintnbr* aValue);
        uint32 GetSPR(uint32 aNumber, uint32* aValue);
        uint32 PutSPR(uint32 aNumber, uint32 aValue);
        uint32 GetSPRs(uint32* aResult);
        uint32 GetSPRsGdb(uint32* aResult);
 
        uint32 GetGPR(uint32 aNumber, uint32* aValue);
        uint32 PutGPR(uint32 aNumber, uint32 aValue);
        uint32 GetGPRs(uint32* aResult, bool abNative=false);
 
        uint32 GetGdbRegsSize(uint32& auSize);
 
        uint32 GetGdbRegs(void* apData);
 
        uint32 PutGdbReg(const uint32 auRegister, const void* apData, uint32 auDataLength);
 
        uint32 GetFPR(uint32 aNumber, double* aValue);
        uint32 PutFPR(uint32 aNumber, double aValue);
        uint32 GetFPRs(double* aResult);
        #ifdef E500V2
        uint32 GetEVHs(uint32* aResult);
        uint32 GetSPE(uint32* aResult);
        #endif
 
        uint32 GetTaskData(uint32 aDataDef, uintnbr* aResult, uint32& aLength);
        uint32 PutTaskData(uint32 aDataDef, uint32* aData, uint32 aLength);
 
        bool DisableFloatingPoint();
        bool EnableFloatingPoint();
 
        uint16 EnableExceptions();
 
        void RestoreExceptions(uint16 auLevel);
 
        bool AreExceptionsEnabled();
 
        // checks the passed address against the stack of this task and returns true
        // if the address belongs to the tasks stack or false otherwise.
        bool IsAddressOnStack(uintptr auAddress) const;
        // return stack size [bytes]
        uint32 GetStackSize() const;
 
        // returns size of the stack that has never been allocated yet [bytes]
        // this is used to determine the maximum stack usage so far in percent,
        // and if this is zero, most likely a stack overflow happened at some time
        uint32 GetStackSizeFree() const;
 
        #if !defined(INOS_DESKTOP)
        // return stack still left [bytes]
        uintnbr GetStackLeft() const
        {
            uintnbr uSp;
            #if defined(INOS_CPU_CORTEXA9)
            asm volatile ("mov %0,sp" : "=r" (uSp));
            #elif defined(INOS_CPU_ARMV8)
            asm volatile ("mov %0,sp" : "=r" (uSp));
            #else
            asm volatile ("mr %0,1" : "=r" (uSp));
            #endif
            return uSp - (uintnbr)pStackEnd;
        }
        #endif
 
        static uint32 GetDebugUpdateId();
        static void ChangeDebugUpdateId();
 
#ifdef INOS_STACKPROTECTION
        void ProtectStack();
        void UnprotectStack();
        void StackProtectionEnable() {
            m_uTskFlags |= eTskFlgStackProtection;
        }
        void StackProtectionDisable() {
            m_uTskFlags &= ~eTskFlgStackProtection;
        }
        bool StackProtectionEnabled() const {
            return m_uTskFlags & eTskFlgStackProtection;
        }
#endif
 
    // protected member functions
    protected :
        // sleep 'aTime' ms and return 0 if the requested time was slept or the
        // number of remaining ms if the task was resumed by someone else before
        // aTime ms
        #ifndef INOS_DESKTOP
        friend long Sleep(long aTime);
        #endif
 
    // exception handling member functions
    public:
        // throw exception to myself
        void ThrowException(CINOSException* aException);
        // throw exception to myself (running in a context of a different task)
        void ThrowExceptionToTask(CINOSException* aException);
        // accept exception
        void AcceptException();
        // ignore exception
        void IgnoreException();
        #ifdef INOS_EXCEPTION_MUTEX
        CINOSMutex* pExceptionMutex;
        #endif
        inline void SetBusTicksAtIrq(uint64 auBusTicks) {
            #ifdef INOS_ARCH_ARM
            m_uBusTickAtIrq = auBusTicks;
            #else
            // avoid double instructions, because FP instructions are usually
            // not allowed in the context of calling this function (e.g.
            // GINLink interrupt context), because on PPC, the FP-unit is
            // disabled and on ARM, the IRQ tasks do not save the FP-registers.
            // That's why we need to ensure that the compiler doesn't generate
            // FP-instructions.
            const uint32* pSrc = reinterpret_cast<const uint32*>(&auBusTicks);
            uint32* pDst = reinterpret_cast<uint32*>(&m_uBusTickAtIrq);
            pDst[0] = pSrc[0];
            pDst[1] = pSrc[1];
            #endif
        }
        inline uint64 GetBusTicksAtIrq() const {
            return m_uBusTickAtIrq;
        }
 
        // allow dynamic object handling (new/delete)
        void* operator new(size_t aSize);
        void operator delete(void* aPtr);
 
    // private member functions
    protected :
        // create task
        void Create(char* apName = nullptr, uint32 auStackSize=defDefaultStackSize,
            uint32 auPriority=DF_INOS_TASK_PRIO_LOWEST, bool abFloatingPoint=true,
            uint32 auTimeSlice=defDefaultTimeSlice, bool abInterruptsDisabled=false,
            void* apHandler=0, void* apObject=0);
        // allocate task stack
        void* AllocStack(uint32 auSize);
        // reallocate task stack
        void ReAllocStack(uint32 auSize);
        // free task stack
        void FreeStack();
 
        virtual CINOSSync* GetSync();
        virtual void SetCallResult(CMcResult aResult);
        virtual CMcResult GetCallResult();
 
    public:
        struct STLSKeyData* TLSFindData(STLSKeyData* apKeyData) const;
        void TLSAddData(struct STLSKeyData* apKeyData);
        void TLSRemoveData(struct STLSKeyData* apKeyData);
 
        #ifdef INOS_MULTICORE_KERNEL
        void SetCoreSync(struct SINOSCoreSync* apCoreSync) { m_pCoreSync = apCoreSync; };
        struct SINOSCoreSync* GetCoreSync() { return m_pCoreSync; };
        uint8 GetTaskCoreId() const { return m_uTaskCoreId; }
        //** Set Id of CPU core this task has to run on.
        void SetTaskCoreId(uint8 auCoreId)
            { m_uTaskCoreId = auCoreId; m_uTaskCoreIdRequested = auCoreId; };
        void SetTaskCoreIdRequested(uint8 auCoreIdRequested)
            { m_uTaskCoreIdRequested = auCoreIdRequested; };
        uint8 GetTaskCoreIdRequested()
            { return m_uTaskCoreIdRequested; };
        #else
        struct SINOSCoreSync* GetCoreSync() { return nullptr; };
        uint8 GetTaskCoreId() const { return 0; }
        #endif
        //** Set fieldbus category this task belongs to.
        void SetTaskCategory(uint8 auCategory)
            { m_uTaskCategory = auCategory; };
        //** Get fieldbus category this task belongs to.
        uint8 GetTaskCategory()
            { return m_uTaskCategory; };
        void EnableTimingFailureHaltTask() {
            m_uTskFlags |= eTskFlgTimingFailureHaltTask;
        }
        void DisableTimingFailureHaltTask() {
            m_uTskFlags &= (~eTskFlgTimingFailureHaltTask);
        }
        bool IsTimingFailureHaltTaskEnabled() {
            return (m_uTskFlags & eTskFlgTimingFailureHaltTask);
        }
 
        inline void EnableIrqDisableTiming() {
            m_uTskFlags |= eTskFlgDebugTimingDisableIrq;
        }
        inline void DisableIrqDisableTiming() {
            m_uTskFlags &= (~eTskFlgDebugTimingDisableIrq);
        }
        inline bool IsIrqDisableTimingEnabled() {
            return (m_uTskFlags & eTskFlgDebugTimingDisableIrq);
        }
        inline void EnablePriorityChecking() {
            m_uTskFlags |= eTskFlgPriorityCheck;
        }
        inline void DisablePriorityChecking() {
            m_uTskFlags &= (~eTskFlgPriorityCheck);
        }
        inline bool IsPriorityCheckingEnabled() {
            return (m_uTskFlags & eTskFlgPriorityCheck);
        }
        inline void EnableSuspendTimingCheck() {
            m_uTskFlags |= eTskFlgSuspendTimingCheck;
        }
        inline void DisableSuspendTimingCheck() {
            m_uTskFlags &= (~eTskFlgSuspendTimingCheck);
        }
        inline bool IsSuspendTimingCheckEnabled() {
            return (m_uTskFlags & eTskFlgSuspendTimingCheck);
        }
        inline bool IsStartupDone() {
            return (m_uTskFlags & eTskFlgStartupDone);
        }
        inline void EnableIncoTouch() {
            m_uTskFlags |= eTskFlgIncoTouch;
        }
        inline void DisableIncoTouch() {
            m_uTskFlags &= (~eTskFlgIncoTouch);
        }
        inline bool IsIncoTouchEnabled() {
            return (m_uTskFlags & eTskFlgIncoTouch);
        }
        inline void EnableFloatingpoint() {
            m_uTskFlags |= eTskFlgFloatingpoint;
        }
        inline void DisableFloatingpoint() {
            m_uTskFlags &= (~eTskFlgFloatingpoint);
        }
        inline bool IsFloatingpointEnabled() {
            return (m_uTskFlags & eTskFlgFloatingpoint);
        }
        void SetTskFlag(uint32 auFlag) {
            m_uTskFlags |= auFlag;
        }
        /* \return Reference to the time stamp (in system ticks) when the
         INOSDisableInterrupts() function has been called. The value is 0
         if the function has not been called or if the INOSEnableInterrupts
         has already been called again. */
        inline uint32& GetIrqDisableTicks() {
            return m_uIrqDisableTicks;
        }
        inline bool IsRealtime() {
            return (m_eTskType == eTskTypeInterrupt) || ((m_eTskType == eTskTypeRealtime));
        }
 
    private:
        TINOSBalancedBinaryTree<STLSKeyData> m_TLS;
        mutable CINOSMutex m_TLSLock;
        // call sync
        CINOSSync* m_pCallSync{};
        // call result
        CMcResult* m_pCallResult{};
        // multi core sync
        #ifdef INOS_MULTICORE_KERNEL
        struct SINOSCoreSync* m_pCoreSync;
        uint8 m_uTaskCoreId = GetCoreId();
        uint8 m_uTaskCoreIdRequested = DF_INOS_CORE_DEFAULT;
        #endif
        uint8 m_uTaskCategory = 0xff;
        // thread handle
        #if defined(INOS_DESKTOP)
        friend class CINOSKernel_desktop;
        friend void _Suspend(uint32 auState, uint32 auFlags, CINOSTask* apTask);
        friend void Resume(CINOSTask* apTask, uint32 auFlags);
        friend void Relinquish();
        friend void ChangePriority(uint32 auPriority);
        std::thread* m_pThread = nullptr;
        std::condition_variable_any m_Startup;
        std::condition_variable_any m_Resume;
        #endif
        uint32 m_uIrqDisableTicks = 0;
 
        uint32 m_uExitCode = 0;
        CINOSSync* m_pShutdownDone = nullptr;
        CINOSMutex m_ShutdownMutex = CINOSMutex(CINOSMutex::eFlgReclaimLock);
        alignas(4) inosName128 m_cName = {0};
        void* m_pFunctionParam = nullptr;
        std::function<void(void*)> m_Function;
        ETskType m_eTskType = eTskTypeSystem;
        uint32 m_uReentrancyTouched{};
 
        #if !defined(INOS_DESKTOP) && defined(INOS_THREADLOCAL)
        uint8* m_pThreadLocal{};
        uint8* m_pThreadLocalBase{};
        #endif
 
};
 
//------------------------------------------------------------------------------
//--- class CINOSTaskType ------------------------------------------------------
//------------------------------------------------------------------------------
 
class CINOSTaskType
{
    //--- user interface ---------------------------------------------------
 
    // public members
    public :
        explicit CINOSTaskType(CINOSTask::ETskType aeType)
            { m_eType = ActualTask()->SetTskType(aeType);};
 
        ~CINOSTaskType()
            { ActualTask()->SetTskType(m_eType); };
 
    //--- internals --------------------------------------------------------
 
    // protected members
    protected :
        CINOSTask::ETskType m_eType;
};
 
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_INOSTASK_H