inos_1ms.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#if !defined( __INOS_1MS_H )
#define __INOS_1MS_H
 
//--------------------------------------------------------------------------
//--- includes -----------------------------------------------------------------
//------------------------------------------------------------------------------
#include <functional>
 
//------------------------------------------------------------------------------
//--- class definitions --------------------------------------------------------
//------------------------------------------------------------------------------
 
// --- CINOSxmsHandler ---------------------------------------------------------
 
class CINOS1ms;
 
#include <cinosbushooks.h>
class CINOSxmsHandlerBase : public CINOSBusHookEx
{
    //--- user interface ---------------------------------------------------
 
    public:
        // constructor
        CINOSxmsHandlerBase(int32 aInterval, bool aActive=true, bool aSingle=false);
        virtual ~CINOSxmsHandlerBase() {}
        // activate handler
        void Activate()
            { Enable(); };
        // deactivate handler
        void Deactivate()
            { Disable(); };
        // set new interval and return old interval
        long SetInterval(long aiInterval)
            {
                int32 iInterval = GetIntervalCmd();
                SetIntervalCmd((uint32)aiInterval);
                return iInterval;
            };
        long GetTimer() const
            { return GetIntervalAct(); };
 
    //--- internals --------------------------------------------------------
 
    // private members
    private :
 
 
        // allow dynamic object handling (new/delete)
        DECLARE_DYNAMIC(CINOSxmsHandlerBase);
};
 
class CINOSxmsHandler : public CINOSxmsHandlerBase
{
    //--- user interface ---------------------------------------------------
 
    public:
        // constructor
        CINOSxmsHandler(void* aHandler, void* aObject, int32 aInterval, bool aActive=true, bool aSingle=false)
            :   CINOSxmsHandlerBase(aInterval, aActive, aSingle)
        {
            // init members
            pHandler = (void(*)(void)) aHandler;
            pObject = aObject;
        }
        virtual ~CINOSxmsHandler() {}
        virtual void Call() override { INOSCallClassMember_0(pObject, (void *) pHandler); }
 
    //--- internals --------------------------------------------------------
 
    // private members
    private :
        void*   pObject;        // pointer to object (if member function)
        void    (*pHandler)();  // pointer to handler
 
    // allow dynamic object handling (new/delete)
    DECLARE_DYNAMIC(CINOSxmsHandler);
};
 
class CINOSxmsHandlerFunction : public CINOSxmsHandlerBase
{
    //--- user interface ---------------------------------------------------
 
    public:
        typedef std::function<void()> tFunction;
        // constructor
        CINOSxmsHandlerFunction(tFunction aFunction, int32 aInterval, bool aActive=true, bool aSingle=false)
            :   CINOSxmsHandlerBase(aInterval, aActive, aSingle),
                m_Function(aFunction)
        {
        }
        virtual ~CINOSxmsHandlerFunction() {}
        virtual void Call() override { m_Function(); }
 
    //--- internals --------------------------------------------------------
 
    // private members
    private :
        const tFunction m_Function;
 
    // allow dynamic object handling (new/delete)
    DECLARE_DYNAMIC(CINOSxmsHandlerFunction);
    DECLARE_DYNAMIC_PLACEMENT(CINOSxmsHandlerFunction);
};
 
// --- CINOS1ms handler --------------------------------------------------------
 
class CINOS1ms : public CINOSTask
{
    //--- user interface ---------------------------------------------------
 
    public:
        CINOSxmsHandler* AddHandler(void* aHandler, void* aObject, int32 aMS, bool aActive=true, bool aSingle=false);
        CINOSxmsHandlerFunction* AddHandler(
                uintptr_t& aTimeoutId, const CINOSxmsHandlerFunction::tFunction& aFunction, int32 aMS,
                bool aActive=true, bool aSingle=false);
        void AddHandler(CINOSxmsHandlerBase* aHandler);
        void RemoveHandler(CINOSxmsHandlerBase* aHandler, bool aDelete = true);
 
        void eAddTimer(uint32 aTimerPtr);
        void AddTimer(int32* aTimer);
        int32 GetTickCount()
            { return g_pTarget->GetTickCount();};
        int32 GetTickDelta(int32 aiTickCount)
            { return aiTickCount-g_pTarget->GetTickCount();};
        int32* GetTickAddress()
            { return g_pTarget->GetTickAddress();};
        void SetTickAddress(int32* apAddress)
            { m_pTickAddress = apAddress; *m_pTickAddress = 0; };
        uint32 GetSystemTicksAtLast1msTick()
            { return GetResumeTicks();};
 
        typedef uintptr_t tIntervalId;
        template<typename TFct>
        void SetInterval(TFct aFct, uint32 aIntervalMs, tIntervalId& aIntervalId) {
            AddHandler(aIntervalId, aFct, aIntervalMs);
        }
        void ClearInterval(tIntervalId& aIntervalId) {
            if (aIntervalId) {
                auto p = reinterpret_cast<CINOSxmsHandlerBase*>(aIntervalId);
                RemoveHandler(p, true);
                aIntervalId = tIntervalId();
            }
        }
 
        typedef uintptr_t tTimeoutId;
        template<typename TFct>
        void SetTimeout(TFct aFct, uint32 aTimeoutMs, tTimeoutId& aTimeoutId) {
            AddHandler(aTimeoutId, aFct, aTimeoutMs, true/*active*/, true/*single*/);
        }
        void ClearTimeout(tTimeoutId& aTimeoutId) {
            if (aTimeoutId) {
                auto p = reinterpret_cast<CINOSxmsHandlerBase*>(aTimeoutId);
                RemoveHandler(p, true);
                aTimeoutId = tTimeoutId();
            }
        }
 
        bool HasHandlers(uint32 auNumber)
            { return m_Hooks.HasHooks(auNumber); }
 
    //--- internals --------------------------------------------------------
 
    // private members
    private :
        CINOSBusHooks m_Hooks;
        /* list of timers */
        TINOSDoubleLinkedList<int32>* p1msTimers;
 
        int32* m_pTickAddress = 0;
        CINOSTask* m_pExactSource = nullptr;
        uint32 m_uTicksFor1ms = 0;
        enum {
            eThresholdMultiplier = 10   
        };
        uint32 m_uTicksThresholdToSwitchSelected = 0;
        uint32 m_uCountOfReselection = 0;
        volatile uint32 m_uMostRecentlyResumedTicks = 0;
        uint32 m_uOverrun = 0;
        uint32 m_uWakeUpCount = 0;
 
        CINOSxmsHandlerBase* m_pHandlerErr{};
 
    // constructor
    public:
        CINOS1ms();
        ~CINOS1ms();
        bool KickExactly(CINOSTask* apSource = 0) INOS_COMPILE_OPTIMIZED;
        bool KickSporadically() INOS_COMPILE_OPTIMIZED;
 
    // protected members
    protected:
        // main task loop
        virtual void Action() override;
 
    private:
        void iIdleKicker();
 
    public:
        static CINOSMutex m_Mutex;
        static uint32 m_uCoreMask;
        static CINOS1ms& Instance();
        static CINOS1ms* pInstance();
};
 
//--------------------------------------------------------------------------
// 1ms handler
//--------------------------------------------------------------------------
 
#define pINOS1ms CINOS1ms::pInstance()
 
#define g_pINOS1ms CINOS1ms::pInstance()
 
#endif  // __INOS_1MS_H