cinosbushooks.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
#ifndef INC_CINOSBUSHOOKS_H
#define INC_CINOSBUSHOOKS_H
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
#include <inos.h>
//
// C++
#include <map>
//
// project
//
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
 
// --- inos bus hook priorities ------------------------------------------------
//
#define DF_INOS_BUS_HOOK_ORDER_PRE_AXIS     -20 
#define DF_INOS_BUS_HOOK_ORDER_AXIS_PRE_MAP -10 
#define DF_INOS_BUS_HOOK_ORDER_AXIS_MAP     0   
#define DF_INOS_BUS_HOOK_ORDER_CONTROL      0   
#define DF_INOS_BUS_HOOK_ORDER_AXIS_PST_MAP 10  
#define DF_INOS_BUS_HOOK_ORDER_PST_AXIS     20  
#define DF_INOS_BUS_HOOK_ORDER_DEFAULT      20  
 
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
class CINOSBusHook
{
    // public member functions
    public :
        CINOSBusHook (uint8 auCoreId, uint8 auCategory,
            uint8 auCyclenumber, int32 aiOrder, uint32 auCycletime,
            void* apHandler, void* apObject, uint32 auFlags);
 
        virtual ~CINOSBusHook ();
 
        enum EFlags {
            eFlgNone = 0x00000000,
            eFlgEnabled = 0x00000001,
            eFlgSingle = 0x00000002,
            eFlgNoException = 0x00000004,   
            eFlgDeletePending = 0x40000000,
            eFlgDynamic = 0x80000000,
        };
 
        uintid GetId()
            { return m_uId; }
 
        uint32 Enable();
 
        uint32 Disable();
 
        virtual CINOSBusHook* Clone();
 
    //--- internals --------------------------------------------------------
 
    friend class CINOSBusHooks;
    friend class CINCOBusHook;
    friend class CINCOBusHooks;
 
    // protected members
    protected :
        /* hook flags */
        uint32 m_uFlags;
        /* hook id */
        uintid m_uId;
        /* core id */
        uint8 m_uCoreId;
        /* category */
        uint8 m_uCategory;
        /* base cycle number */
        uint8 m_uCyclenumber;
        /* this hook is registered in this number of cycles */
        int8 m_iCycles;
        /* hook order */
        int32 m_iOrder;
        /* hook cycletime */
        uint32 m_uCycletime;
        /* pointer to hook handler */
        void* m_pHandler;
        /* pointer to hook handler object (if any) */
        void* m_pObject;
        /* hook ticks */
        uint32 m_uTicks;
        #if defined(INOS_BUS_HOOK_TIME_MEASUREMENTS)
        /* hook max ticks */
        uint32 m_uTicksMax;
        /* hook time reset */
        uint32 m_uTimeReset;
        #endif
 
    // dynamic object handling
    DECLARE_DYNAMIC(CINOSBusHook);
};
 
//------------------------------------------------------------------------------
//
class CINOSBusHookEx : public CINOSBusHook
{
    // public member functions
    public :
        CINOSBusHookEx (uint8 auCoreId, uint8 auCategory,
            uint8 auCyclenumber, int32 aiOrder, uint32 auCycletime,
            void* apHandler, void* apObject, uint32 auFlags, uint32 auInterval,
            uint32 auCount = 0);
 
        virtual ~CINOSBusHookEx ();
 
        void SetIntervalCmd(uint32 auInterval)
            {
                m_uInterval = auInterval ? auInterval : 1;
                m_uIntervalAct = m_uInterval;
            };
 
        uint32 GetIntervalCmd()
            { return m_uInterval; };
 
        uint32 GetIntervalAct() const
            { return m_uIntervalAct; };
 
        virtual void Action();
 
        virtual void Call();
 
        virtual CINOSBusHook* Clone() override;
 
    //--- internals --------------------------------------------------------
 
    // protected members
    protected :
        /* hook commanded interval */
        uint32 m_uInterval;
        /* hook actual interval */
        uint32 m_uIntervalAct{};
        /* hook count (0 -> endless) */
        uint32 m_uCount{};
        /* pointer to original hook handler */
        void* m_pOrgHandler;
        /* pointer to original hook handler object (if any) */
        void* m_pOrgObject;
 
    // dynamic object handling
    DECLARE_DYNAMIC(CINOSBusHookEx);
};
 
//------------------------------------------------------------------------------
//
struct SINOSBusHookNode
{
    /* pointer to next node in list */
    SINOSBusHookNode* m_pNext;
    /* id of hook this node represents */
    uintid m_uHookId;
    /* order of hook this node represents */
    int32 m_iOrder;
    /*
     * Ensure the size of a cache line to get 'load reserve' and 'store conditional'
     * mechanism running.
     */
    uint32 m_uAlign[
            (DF_INOS_CPU_CACHE_LINE_SIZE-
            sizeof(m_pNext)-
            sizeof(m_uHookId)-
            sizeof(m_iOrder))>>2
        ];
};
 
//------------------------------------------------------------------------------
//
class CINOSBusHookCycle
{
    // public member functions
    public :
 
        CINOSBusHookCycle ();
 
        ~CINOSBusHookCycle ();
 
        uint32 Setup();
 
        uint32 SetupDone(uint16 auHooks);
 
        uint32 Shutdown(class CINOSBusHooks* apParent);
 
    //--- internals --------------------------------------------------------
 
    friend class CINOSBusHooks;
    friend class CINCOBusHooksSequence;
 
    // private members
    private :
        void GetHookIdMap(std::map<uintid,uintid>& aHooks);
 
    // protected members
    protected :
        SINOSBusHookNode* m_pSequence{};
        SINOSBusHookNode* m_pInsert{};
 
        /* cycle ticks */
        uint32 m_uTicks{};
        #if defined(INOS_BUS_HOOK_TIME_MEASUREMENTS)
        /* cycle max ticks */
        uint32 m_uTicksMax{};
        /* hook time reset */
        uint32 m_uTimeReset{};
        #endif
 
        class CINCOBusHooksSequence* m_pInco{};
 
        /*
         * Ensure the size of a cache line to get 'load reserve' and 'store conditional'
         * mechanism running.
         */
        uint32 m_uAlign[
                (DF_INOS_CPU_CACHE_LINE_SIZE-
                sizeof(m_pSequence)-
                sizeof(m_pInsert)-
                sizeof(m_uTicks)-
                sizeof(m_pInco))>>2
            ];
 
    // dynamic object handling
    DECLARE_DYNAMIC(CINOSBusHookCycle);
};
 
//------------------------------------------------------------------------------
//
class CINOSBusHookCategory
{
    // public member functions
    public :
 
        CINOSBusHookCategory ();
 
        ~CINOSBusHookCategory ();
 
        enum EFlags {
            eFlgNone = 0x00000000,
            eFlgEnabled = 0x00000001,
        };
 
        uint32 Setup(uint32 auCycletime, uint32 auFlags);
 
        uint32 SetupDone(uint16 auHooks);
 
        uint32 Shutdown(class CINOSBusHooks* apParent);
 
        uint32 Enable();
 
        uint32 Disable();
 
        bool IsCyclenumberValid(uint8 auCyclenumber);
 
        bool IsCycletimeValid(uint32 auCycletimeNs);
 
    //--- internals --------------------------------------------------------
 
    friend class CINOSBusHooks;
    friend class CINOSBusHookCore;
 
    // protected members
    protected :
        /* category flags */
        uint32 m_uFlags{};
        /* category cycletime [ns] */
        uint32 m_uCycletimeNs{};
        uint32 m_uCycles{};
        CINOSBusHookCycle* m_pCycles{};
 
    // dynamic object handling
    DECLARE_DYNAMIC(CINOSBusHookCategory);
};
 
//------------------------------------------------------------------------------
//
class CINOSBusHookCore
{
    // public member functions
    public :
 
        CINOSBusHookCore ();
 
        ~CINOSBusHookCore ();
 
        uint32 Setup(uint8 auCategories);
 
        uint32 SetupCategory(uint8 auCategory, uint32 auCycletimeNs, uint32 auFlags);
 
        uint32 SetupDone(uint16 auHooks);
 
        uint32 Shutdown(class CINOSBusHooks* apParent);
 
        bool IsCategoryValid(uint8 auCategory);
 
        bool IsCategoryEnabled(uint8 auCategory);
 
    //--- internals --------------------------------------------------------
 
    friend class CINOSBusHooks;
 
    // protected members
    protected :
        uint32 m_uCategories{};
        CINOSBusHookCategory* m_pCategories{};
 
    // dynamic object handling
    DECLARE_DYNAMIC(CINOSBusHookCore);
};
 
//------------------------------------------------------------------------------
//
class CINOSBusHooks
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
 
        /* hook handler states */
        enum EState {
            eStaIdle = 0,
            eStaSetup = 1,
            eStaReady = 2,
            eStaShutdown = 3,
        };
 
        /* hooks constants */
        enum {
            eCnsGroupIdBits = 2,                
        };
 
        /* hooks options */
        enum {
            eOptNone = 0x00000000,
            eOptCategoryDc = 0x000000001,       
            eOptException = 0x000000002,        
            #if defined(INOS_CPP_EXCEPTION_SUPPORT)
            eOptExceptionEx = eOptException,    
            #else
            eOptExceptionEx = eOptNone,         
            #endif
            #if defined(INOS_TESTING) or defined(INOS_TESTING_BASE_SUPPORT)
            eOptDeleteImmediate = 0x80000000,   
            #endif
        };
 
        /* hooks flags */
        enum {
            eFlgNone = 0x00000000,
            eFlgDelete = 0x000000001,
            eFlgNegative = 0x000000002,
            eFlgPositive = 0x000000004,
            eFlgTimeMeasure = 0x00000008,       
        };
 
        /* hook don't care values */
        enum {
            eDcOrder = 20,
            eDcCategory = 0xff,
            eDcCycletime = 0xffffffff,
            eDcCyclenumber = 0xff,
            eDcCoreId = 0x3f,
        };
 
        CINOSBusHooks (uint8 auGroupId = 0);
 
        ~CINOSBusHooks ();
 
        EState GetState()
            { return m_eState; };
 
        uint32 Setup(uint8 auCores = 1, uint8 auCoreId = 0, uint32 auOptions = eOptNone);
 
        uint32 SetupCore(uint8 auCoreId, uint8 auCategories);
 
        uint32 SetupCategory(uint8 auCoreId, uint8 auCategory, uint32 auCycletimeNs, uint32 auFlags = CINOSBusHookCategory::eFlgEnabled);
 
        uint32 SetupDone(uint16 auHooks);
 
        uint32 Shutdown();
 
        uint32 EnableCategory(uint8 auCategory);
 
        uint32 EnableCategory(uint8 auCoreId, uint8 auCategory);
 
        uint32 DisableCategory(uint8 auCategory);
 
        uint32 DisableCategory(uint8 auCoreId, uint8 auCategory);
 
        uint32 RegisterHook(uintid& aoHookId, void* apHandler, CINOSBusHook::EFlags auFlags = CINOSBusHook::eFlgEnabled);
 
        uint32 RegisterHook(uintid& aoHookId, void* apHandler, void* apObject, CINOSBusHook::EFlags auFlags = CINOSBusHook::eFlgEnabled);
 
        uint32 RegisterHook(uintid& aoHookId, void* apHandler, void* apObject, int32 aiOrder, CINOSBusHook::EFlags auFlags = CINOSBusHook::eFlgEnabled);
 
        uint32 RegisterHook(uintid& aoHookId, void* apHandler, void* apObject, int32 aiOrder, uint8 auCategory, CINOSBusHook::EFlags auFlags = CINOSBusHook::eFlgEnabled);
 
        uint32 RegisterHook(uintid& aoHookId, void* apHandler, void* apObject, int32 aiOrder, uint8 auCategory, uint32 auCycletime, CINOSBusHook::EFlags auFlags = CINOSBusHook::eFlgEnabled);
 
        uint32 RegisterHook(uintid& aoHookId, void* apHandler, void* apObject, int32 aiOrder, uint8 auCategory, uint32 auCycletime, uint8 auCyclenumber, CINOSBusHook::EFlags auFlags = CINOSBusHook::eFlgEnabled);
 
        uint32 RegisterHook(uintid& aoHookId, void* apHandler, void* apObject, int32 aiOrder, uint8 auCategory, uint32 auCycletime, uint8 auCyclenumber, uint8 auCoreId, CINOSBusHook::EFlags auFlags = CINOSBusHook::eFlgEnabled);
 
        uint32 RegisterHook(CINOSBusHook* apHook);
 
        uint32 UnregisterHook(uintid auHookId);
 
        uint32 UnregisterHook(CINOSBusHook* apHook, uint32 auFlags = eFlgNone);
 
        uint32 EnableHook(uintid auHookId);
 
        uint32 DisableHook(uintid auHookId);
 
        void* GetHookHandler(uintid auHookId);
 
        uint32 SetHookHandler(uintid auHookId, void* apHandler);
 
        uint8 GetHookCyclenumber(uintid auHookId);
 
        uint32 GetHookCycleTime(uintid auHookId);
 
        uint32 GetHookCycleTime(uintid auHookId, uint32& auCycletime);
 
        uint32 GetHookCategory(uintid auHookId, uint8& auCategory);
 
        uint32 MoveHooks(uint8 auCoreId, uint8 auSrc, uint8 auDst);
 
        uint32 HandleHooks(uint8 auCategory = 0, uint8 auCycle = 0, uint32 auFlags = eFlgNone);
 
        static uint32 GetGroupId(uintid auHookId)
            {
                // mask it out
                return ((uint32) auHookId)>>(32-eCnsGroupIdBits);
            }
 
        #if defined(INOS_BUS_HOOK_TIME_MEASUREMENTS)
        uint32 TimeReset();
 
        uint32 TimeFreeze(uint32 auTicks = 0);
 
        uint32 TimeMeasure();
 
        uint32 TimeFreezeTrigger(uint32 auNs);
        #endif
 
    //--- internals --------------------------------------------------------
 
    friend class CINOS1ms;
    friend class CINOSBus;
    friend class CINOSBusHookCycle;
    friend class CINOSBusHookExTest;
    friend class CINCOBusHooksMain;
    friend class CINCOBusHooks;
    friend class CINOSHwTarget;
 
    // protected methods
    protected :
 
        uint32 RequestId(uintid& aoHookId);
 
        uint32 ReleaseId(uintid auHookId);
 
        uint32 GetIndex(uintid auHookId)
        {
            return auHookId & m_uHookIndexMask;
        }
 
        bool HasHooks(uint32 auNumber)
            { return (m_uHooksAct + auNumber) <= m_uHooksMax; };
 
        uint32 iHookCheck(void* apHandler, void* apObject, int32& aiOrder, uint8& auCategory, uint32& auCycletime, uint8& auCyclenumber, uint8& auCoreId);
 
        uint32 iHookIdCheck(uintid auHookId, CINOSBusHook*& apHook);
 
        uint32 iHookRegister(CINOSBusHook* apHook);
 
        SINOSBusHookNode* AllocNode()
        {
            #if defined(INOS_DESKTOP)
                // locals
                SINOSBusHookNode* node;
                // enter critical section
                uint32 uMsr = INOSDisableInterrupts();
                // parts back to pool
                node = m_pNodes;
                m_pNodes = (SINOSBusHookNode*) *((uintptr*) node);
                // exit critical section
                INOSEnableInterrupts(uMsr);
            #else
                // locals
                SINOSBusHookNode* next;
                SINOSBusHookNode* node;
                uintptr p = (uintptr) &m_pNodes;
                #if defined(INOS_CPU_CORTEXA9)
                    // locals
                    uint32 res;
                    // try to alloc node
                    asm volatile (
                        "   dsb"                "\n\t"
                        "0: ldrex   %0,[%2]"    "\n\t"
                        "   cmp     %0,#0"      "\n\t"
                        "   beq     1f"         "\n\t"
                        "   ldr     %1,[%0]"    "\n\t"
                        "   strex   %3,%1,[%2]" "\n\t"
                        "   cmp     %3,#0"      "\n\t"
                        "   bne     0b"         "\n\t"
                        "1: isb"                "\n\t"
                        : "=r" (node), "=r" (next), "=r" (p), "=&r" (res)
                        : "2" (p));
                #elif defined(INOS_CPU_CORTEXA72)
                    // locals
                    uint32 res;
                    // try to alloc node
                    asm volatile (
                        "0: ldaxr   %0,[%2]"    "\n\t"
                        "   cmp     %0,#0"      "\n\t"
                        "   beq     1f"         "\n\t"
                        "   ldr     %1,[%0]"    "\n\t"
                        "   stlxr   %w3,%1,[%2]" "\n\t"
                        "   cmp     %w3,#0"     "\n\t"
                        "   bne     0b"         "\n\t"
                        "1: isb"                "\n\t"
                        : "=r" (node), "=r" (next), "=r" (p), "=&r" (res)
                        : "2" (p));
                #else
                    // try to alloc node
                    asm volatile (
                        "   sync"               "\n\t"
                        "0: lwarx   %0, 0, %2"  "\n\t"
                        "   cmpwi   %0, 0"      "\n\t"
                        "   beq     1f"         "\n\t"
                        "   lwz     %1, 0(%0)"  "\n\t"
                        "   stwcx.  %1, 0, %2"  "\n\t"
                        "   bne-    0b"         "\n\t"
                        "1: isync"              "\n\t"
                        : "=r" (node), "=r" (next), "=r" (p)
                        : "2" (p));
                #endif
            #endif
 
            // inc number of allocated nodes
            if (node) m_iNodesAct++;
            // return result
            return node;
        }
 
        void FreeNode(SINOSBusHookNode* apNode)
        {
            #if defined(INOS_DESKTOP)
                // enter critical section
                uint32 uMsr = INOSDisableInterrupts();
                // parts back to pool
                apNode->m_pNext = m_pNodes;
                m_pNodes = apNode;
                // exit critical section
                INOSEnableInterrupts(uMsr);
            #else
                // locals
                SINOSBusHookNode* node = nullptr;
                uintptr p = (uintptr) &m_pNodes;
                #if defined(INOS_CPU_CORTEXA9)
                    // locals
                    uint32 res;
                    // try to alloc part
                    asm volatile (
                        "   dsb"                "\n\t"
                        "0: ldrex   %0,[%2]"    "\n\t"
                        "   str     %4,[%3]"    "\n\t"
                        "   strex   %1,%3,[%2]" "\n\t"
                        "   cmp     %1,#0"      "\n\t"
                        "   bne     0b"         "\n\t"
                        "   isb"                "\n\t"
                        : "=r" (node), "=&r" (res)
                        : "r" (p), "r" (apNode), "0" (node));
                #elif defined(INOS_CPU_CORTEXA72)
                    // locals
                    uint32 res;
                    // try to alloc part
                    asm volatile (
                        "0: ldaxr   %0,[%2]"    "\n\t"
                        "   str     %4,[%3,#0]" "\n\t"
                        "   stlxr   %w1,%3,[%2]" "\n\t"
                        "   cmp     %w1,#0"     "\n\t"
                        "   bne     0b"         "\n\t"
                        "   isb"                "\n\t"
                        : "=r" (node), "=&r" (res)
                        : "r" (p), "r" (apNode), "0" (node));
                #else
                    // try to alloc part
                    asm volatile (
                        "   sync"               "\n\t"
                        "0: lwarx   %0, 0, %1"  "\n\t"
                        "   stw     %4, 0(%3)"  "\n\t"
                        "   stwcx.  %2, 0, %1"  "\n\t"
                        "   bne-    0b"         "\n\t"
                        "   isync"              "\n\t"
                        : "=r" (node)
                        : "r" (p), "r" (apNode), "r" (apNode), "0" (node));
                #endif
            #endif
 
            // dec number of allocated nodes
            m_iNodesAct--;
        }
 
        void FreeNodes(SINOSBusHookNode* apNode)
        {
            // something to free ?
            if (nullptr == apNode) {
                // no
                return;
            }
 
            // locals
            int32 iCount = 1;
            SINOSBusHookNode* lst = apNode;
            // count number of nodes
            while (lst->m_pNext){
                lst = lst->m_pNext;
                iCount++;
            }
 
            #if defined(INOS_DESKTOP)
                // enter critical section
                uint32 uMsr = INOSDisableInterrupts();
                // parts back to pool
                lst->m_pNext = m_pNodes;
                m_pNodes = apNode;
                // exit critical section
                INOSEnableInterrupts(uMsr);
            #else
                // locals
                SINOSBusHookNode* node = nullptr;
                uintptr p = (uintptr) &m_pNodes;
                #if defined(INOS_CPU_CORTEXA9)
                    // locals
                    uint32 res;
                    // try to alloc part
                    asm volatile (
                        "   dsb"                "\n\t"
                        "0: ldrex   %0,[%2]"    "\n\t"
                        "   str     %5,[%4]"    "\n\t"
                        "   strex   %1,%3,[%2]" "\n\t"
                        "   cmp     %1,#0"      "\n\t"
                        "   bne     0b"         "\n\t"
                        "   isb"                "\n\t"
                        : "=r" (node), "=&r" (res)
                        : "r" (p), "r" (apNode), "r" (lst), "0" (node));
                #elif defined(INOS_CPU_CORTEXA72)
                    // locals
                    uint32 res;
                    // try to alloc part
                    asm volatile (
                        "0: ldaxr   %0,[%2]"    "\n\t"
                        "   str     %5,[%4]"    "\n\t"
                        "   stlxr   %w1,%3,[%2]" "\n\t"
                        "   cmp     %w1,#0"     "\n\t"
                        "   bne     0b"         "\n\t"
                        "   isb"                "\n\t"
                        : "=r" (node), "=&r" (res)
                        : "r" (p), "r" (apNode), "r" (lst), "0" (node));
                #else
                    // try to alloc part
                    asm volatile (
                        "   sync"               "\n\t"
                        "0: lwarx   %0, 0, %1"  "\n\t"
                        "   stw     %4, 0(%3)"  "\n\t"
                        "   stwcx.  %2, 0, %1"  "\n\t"
                        "   bne-    0b"         "\n\t"
                        "   isync"              "\n\t"
                        : "=r" (node)
                        : "r" (p), "r" (apNode), "r" (lst), "0" (node));
                #endif
            #endif
 
            // dec number of allocated nodes
            m_iNodesAct -= iCount;
        }
 
        SINOSBusHookNode* ListGet(SINOSBusHookNode** apHead);
 
        bool ListSet(SINOSBusHookNode** apHead, SINOSBusHookNode* apList);
 
        void ListInsert(SINOSBusHookNode*& apHead, SINOSBusHookNode* apNode);
 
        void ListDestroy(SINOSBusHookNode** apHead);
 
    //--- testing ---------------------------------------------------------
 
    // private members
    private :
 
        uint32 GetNodes()
            { return m_uNodesMax; }
 
        int32 GetNodesAllocated()
            { return m_iNodesAct; }
 
        SINOSBusHookNode* GetHookListInsert(uint8 auCoreId, uint8 auCategory, uint8 auCycle)
            { return m_pCores[auCoreId].m_pCategories[auCategory].m_pCycles[auCycle].m_pInsert; }
 
        SINOSBusHookNode* GetHookListSequence(uint8 auCoreId, uint8 auCategory, uint8 auCycle)
            { return m_pCores[auCoreId].m_pCategories[auCategory].m_pCycles[auCycle].m_pSequence; }
 
        CINCOObject* GetRegister(const char* apName);
 
        void GetHookIdMap(std::map<uintid,uintid>& aHooks);
 
        static void Create();
 
        #if defined(INOS_TESTING) or defined(INOS_TESTING_BASE_SUPPORT)
        friend class CINOSTestManager;
        static void WaitIdle();
        #endif
 
    // protected members
    protected :
        /* hook handler state */
        EState m_eState = eStaIdle;
        /* hook handler options */
        uint32 m_uOptions = eOptNone;
        /* hook flags */
        uint32 m_uFlags = eFlgTimeMeasure;
        #if defined(INOS_BUS_HOOK_TIME_MEASUREMENTS)
        /* hook time reset counter*/
        std::atomic<uint32> m_uTimeReset{};
        /* hook freeze trigger ticks */
        uint32 m_uTimeFreezeTriggerTicks{};
        /* external time freeze */
        uint32 eTimeFreeze(uint32 auNs);
        uint32 m_ueFreezeTrigger{};
        uint32 m_ueReturn{};
        #endif
 
        uint8 m_uGroupId{};
        uint32 m_uHookIndexMask{};
        uint32 m_uHookIdShift{};
        std::atomic<uint32> m_uHookIdCnt = {1};
        uint32 m_uHooksActive{};
        uint32* m_pHooksActive{};
        uint32 m_uHooksMax{};
        std::atomic<int32> m_uHooksAct = {0};
        CINOSBusHook** m_pHooks{};
 
        uint8 m_uCoreIdBase{};
        uint8 m_uCores{};
        CINOSBusHookCore* m_pCores{};
        uint32 m_uCycletimeSlowest{1000000};
 
        std::atomic<uint32> m_uNodesMax = {0};
        std::atomic<int32> m_iNodesAct = {0};
        SINOSBusHookNode* m_pNodes{};
 
        #if defined(INOS_CPU_CORTEXA9)  
        uint8 m_uActCore{};
        uint8 m_uActCategory{};
        uint8 m_uActCycle{};
        #endif
 
        CINCOObject* m_pRegister{};
        class CINCOBusHooksMain* m_pInco{};
 
        static class CINOSBusHooksHelper* m_pInstance[DF_INOS_MAX_CORES];
 
    // dynamic object handling
    DECLARE_DYNAMIC(CINOSBusHooks);
};
 
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSBUSHOOKS_H