kernel.hpp

#ifndef QOS_CPP_KERNEL
#define QOS_CPP_KERNEL
 
#include "config/config.h"
#include "include/list.hpp"
#include "include/clock.hpp"
#include "include/types.hpp"
#include "include/task.hpp"
#include "include/prioqueue.hpp"
#include "include/input.hpp"
 
#if ( Q_FSM == 1 )
    #include "include/fsm.hpp"
#endif
#if ( Q_CLI == 1 )
    #include "include/cli.hpp"
#endif
 
namespace qOS {
 
    using coreFlags_t = uint32_t ;
    enum class notifyMode : uint8_t {
        SIMPLE = 0U,    
        QUEUED = 1U,    
        NOTIFY_NONE = 3U,    
    };
 
    struct notificationSpreader_t {
        notifyMode mode;
        void *eventData;
    };
    constexpr taskFlag_t EVENT_FLAG( index_t i )
    {
        return ( ( i >= 1U ) && ( i <= 20U ) ) ?  0x00001000UL << ( i - 1U ) : 0x00001000UL;
    }
 
    class core final : protected taskEvent {
        private:
            task idle;
            taskFcn_t releaseSchedCallback{ nullptr };
            task *yieldTask{ nullptr };
            pq::queueStack_t pq_stack[ Q_PRIO_QUEUE_SIZE ]; // skipcq: CXX-W2066
            prioQueue priorityQueue{ pq_stack, sizeof(pq_stack)/sizeof(pq::queueStack_t) }; // skipcq: CXX-C1000
            volatile coreFlags_t flag{ 0UL };
            notificationSpreader_t nSpreader{ notifyMode::NOTIFY_NONE, nullptr };
            size_t taskEntries{ 0UL };
            list coreLists[ Q_PRIORITY_LEVELS + 2 ]; // skipcq: CXX-W2066
            list& waitingList;  // skipcq: CXX-W2012, CXX-W2010
            list& suspendedList;  // skipcq: CXX-W2012, CXX-W2010
            list inputWatchers;
            static const priority_t MAX_PRIORITY_VALUE;
            static const uint32_t BIT_INIT;
            static const uint32_t BIT_FCALL_IDLE;
            static const uint32_t BIT_RELEASE_SCHED;
            static const uint32_t BIT_FCALL_RELEASED;
            void triggerReleaseSchedEvent( void ) noexcept;
            bool checkIfReady( void ) noexcept;
            void dispatchTaskFillEventInfo( task *Task ) noexcept;
            void dispatch( list * const xList ) noexcept;
            void dispatchIdle( void ) noexcept;
            void handleInputWatchers( void ) noexcept;
            core() : waitingList( coreLists[ Q_PRIORITY_LEVELS ] ), suspendedList( coreLists[ Q_PRIORITY_LEVELS + 1 ] ) {}
            core( core &other ) = delete;
            void operator=( const core & ) = delete;
        public:
            static const priority_t LOWEST_PRIORITY;
            static const priority_t MEDIUM_PRIORITY;
            static const priority_t HIGHEST_PRIORITY;
            static core& getInstance( void ) noexcept;
            bool init( const getTickFcn_t tFcn = nullptr, taskFcn_t callbackIdle = nullptr ) noexcept;
            bool add( task &Task, taskFcn_t callback, const priority_t p, const duration_t t, const iteration_t n, const taskState s = taskState::ENABLED_STATE, void *arg = nullptr ) noexcept;
            inline bool add( task &Task, taskFcn_t callback, const priority_t p, void *arg = nullptr ) noexcept
            {
                return add( Task, callback, p, clock::IMMEDIATE, task::SINGLE_SHOT, taskState::DISABLED_STATE, arg );
            }
            #if ( Q_FSM == 1 )
            bool add( task &Task, stateMachine &m, const priority_t p, const duration_t t, const taskState s = taskState::ENABLED_STATE, void *arg = nullptr ) noexcept;
            #endif
            #if ( Q_CLI == 1 )
            bool add( task &Task, commandLineInterface &cli, const priority_t p, void *arg = nullptr ) noexcept;
            #endif
            bool setIdleTask( taskFcn_t callback ) noexcept;
            bool setNameIdleTask( const char *tName ) noexcept;
            bool schedulerRelease( void ) noexcept;
            bool setSchedulerReleaseCallback( taskFcn_t callback ) noexcept;
            bool remove( task &Task ) noexcept;
            bool run( void ) noexcept;
 
            bool notify( notifyMode mode, task &Task, void* eventData = nullptr ) noexcept;
            bool notify( notifyMode mode, void* eventData = nullptr ) noexcept;
            bool hasPendingNotifications( const task &Task ) const noexcept;
 
            bool eventFlagsModify( task &Task, const taskFlag_t tFlags, const bool action ) noexcept;
            taskFlag_t eventFlagsRead( task &Task ) const noexcept;
            bool eventFlagsCheck( task &Task, taskFlag_t flagsToCheck, const bool clearOnExit = true, const bool checkForAll = false ) noexcept;
            task* getTaskByName( const char *name ) noexcept;
            task* getTaskByID( size_t id ) noexcept;
            bool yieldToTask( task &Task ) noexcept;
            globalState getGlobalState( task &Task ) const noexcept;
            bool add( input::watcher &w ) noexcept;
            bool remove( input::watcher &w ) noexcept;
    };
    extern core& os; // skipcq: CXX-W2011, CXX-W2009
 
}
 
 
#endif /*QOS_CPP_KERNEL*/