Concrete implementation of IKernel. More...

#include <stk.h>

Inheritance diagram for stk::Kernel< TMode, TSize, TStrategy, TPlatform >:

Collaboration diagram for stk::Kernel< TMode, TSize, TStrategy, TPlatform >:

Classes
class	KernelTask
	Internal per-slot kernel descriptor that wraps a user ITask instance. More...
class	KernelService
	Concrete implementation of IKernelService exposed to running tasks. More...
class	SleepTrapStack
	Storage bundle for the sleep trap: a Stack descriptor paired with its backing memory. More...
class	ExitTrapStack
	Storage bundle for the exit trap: a Stack descriptor paired with its backing memory. More...

Public Types
enum	EConsts { TASKS_MAX = TSize }
	Constants. More...
enum	EState : uint8_t { STATE_INACTIVE = 0 , STATE_READY , STATE_RUNNING }
	Kernel state. More...

Public Member Functions
	Kernel ()
	Construct the kernel with all storage zero-initialised and the request flag set to ~0 (indicating uninitialized state; cleared to REQUEST_NONE by Initialize()).
	~Kernel ()
	Destructor.
void	Initialize (uint32_t resolution_us=PERIODICITY_DEFAULT)
	Prepare kernel for use: reset state, configure the platform, and register the service singleton.
void	AddTask (ITask *user_task)
	Register task for a soft real-time (SRT) scheduling.
void	AddTask (ITask *user_task, Timeout periodicity_tc, Timeout deadline_tc, Timeout start_delay_tc)
	Register a task for hard real-time (HRT) scheduling.
void	RemoveTask (ITask *user_task)
	Remove a previously added task from the kernel before Start().
void	Start ()
	Start the scheduler. This call does not return until all tasks have exited (KERNEL_DYNAMIC mode) or indefinitely (KERNEL_STATIC mode).
bool	IsStarted () const
	Check whether scheduler is currently running.
IPlatform *	GetPlatform ()
	Get platform driver instance owned by this kernel.
ITaskSwitchStrategy *	GetSwitchStrategy ()
	Get task-switching strategy instance owned by this kernel.
EState	GetState () const
	Get kernel state.

Protected Types
enum	ERequest : uint8_t { REQUEST_NONE = 0 , REQUEST_ADD_TASK = (1 << 0) }
	Bitmask flags for pending inter-task requests that must be processed by the kernel on the next tick (in UpdateTaskRequest()). More...
enum	EFsmState : int8_t { FSM_STATE_NONE = -1 , FSM_STATE_SWITCHING , FSM_STATE_SLEEPING , FSM_STATE_WAKING , FSM_STATE_EXITING , FSM_STATE_MAX }
	Finite-state machine (FSM) state. Encodes what the kernel is currently doing between two consecutive tick events. More...
enum	EFsmEvent : int8_t { FSM_EVENT_SWITCH = 0 , FSM_EVENT_SLEEP , FSM_EVENT_WAKE , FSM_EVENT_EXIT , FSM_EVENT_MAX }
	Finite-state machine (FSM) event. Computed by FetchNextEvent() each tick based on strategy output and current kernel state. More...
typedef StackMemoryWrapper<(32)>	SleepTrapStackMemory
	Stack memory wrapper type for the sleep trap.
typedef StackMemoryWrapper< STACK_SIZE_MIN >	ExitTrapStackMemory
	Stack memory wrapper type for the exit trap.
typedef KernelTask	TaskStorageType[TASKS_MAX]
	KernelTask array type used as a storage for the KernelTask instances.
typedef ISyncObject::ListHeadType	SyncObjectList
	Intrusive list of active ISyncObject instances registered with this kernel. Each sync object in this list receives a Tick() call every kernel tick for timeout tracking. Allocated only when KERNEL_SYNC is set (zero-size otherwise).

Protected Member Functions
void	InitTraps ()
	Initialize stack of the traps.
KernelTask *	AllocateNewTask (ITask *user_task)
	Allocate new instance of KernelTask.
void	AddKernelTask (KernelTask *task)
	Add kernel task to the scheduling strategy.
void	AllocateAndAddNewTask (ITask *user_task)
	Allocate new instance of KernelTask and add it into the scheduling process.
void	HrtAllocateAndAddNewTask (ITask *user_task, Timeout periodicity_tc, Timeout deadline_tc, Timeout start_delay_tc)
	Allocate new instance of KernelTask and add it into the HRT scheduling process.
void	RequestAddTask (ITask *user_task)
	Request to add new task.
KernelTask *	FindTaskByUserTask (const ITask *user_task)
	Find kernel task by the bound ITask instance.
KernelTask *	FindTaskByStack (const Stack *stack)
	Find kernel task by the bound Stack instance.
KernelTask *	FindTaskBySP (Word SP)
	Find kernel task for a Stack Pointer (SP).
void	RemoveTask (KernelTask *task)
	Remove kernel task.
void	OnStart (Stack *&active)
	Called by platform driver immediately after a scheduler start (first tick).
void	OnStop ()
	Called by the platform driver after a scheduler stop (all tasks have exited).
bool	OnTick (Stack &idle, Stack &active)
	Process one scheduler tick. Called from the platform timer/tick ISR.
void	OnTaskSwitch (Word caller_SP)
	Called by Thread process (via IKernelService::SwitchToNext) to switch to a next task.
void	OnTaskSleep (Word caller_SP, Timeout ticks)
	Called by Thread process (via IKernelService::Sleep) for exclusion of the calling process from scheduling (sleeping).
void	OnTaskSleepUntil (Word caller_SP, Ticks timestamp)
	Called by Thread process (via IKernelService::SleepUntil) for exclusion of the calling process from scheduling (sleeping).
void	OnTaskExit (Stack *stack)
	Called from the Thread process when task finished (its Run function exited by return).
IWaitObject *	OnTaskWait (Word caller_SP, ISyncObject sync_obj, IMutex mutex, Timeout timeout)
	Called from the Thread process when task needs to wait.
TId	OnGetTid (Word caller_SP)
	Called from the Thread process when for getting task/thread id of the process.
Timeout	UpdateTasks (const Timeout elapsed_ticks)
	Update tasks (sleep, requests).
Timeout	UpdateTaskState (const Timeout elapsed_ticks)
	Update task state: process removals, advance sleep timers, and track HRT durations.
void	UpdateSyncObjects (const Timeout elapsed_ticks)
	Update synchronization objects.
void	UpdateTaskRequest ()
	Update pending task requests.
EFsmEvent	FetchNextEvent (KernelTask *&next)
	Fetch next event for the FSM.
EFsmState	GetNewFsmState (KernelTask *&next)
	Get new FSM state.
bool	UpdateFsmState (Stack &idle, Stack &active)
	Update FSM state.
bool	StateSwitch (KernelTask now, KernelTask next, Stack &idle, Stack &active)
	Switches contexts.
bool	StateWake (KernelTask now, KernelTask next, Stack &idle, Stack &active)
	Wakes up after sleeping.
bool	StateSleep (KernelTask now, KernelTask next, Stack &idle, Stack &active)
	Enters into a sleeping mode.
bool	StateExit (KernelTask now, KernelTask next, Stack &idle, Stack &active)
	Exits from scheduling.
bool	IsInitialized () const
	Check whether Initialize() has been called and completed successfully.
void	ScheduleAddTask ()
	Signal the kernel to process a pending AddTask request on the next tick.

Static Protected Member Functions
static bool	IsValidFsmState (EFsmState state)
	Check if FSM state is valid.
static bool	IsStaticMode ()
static bool	IsDynamicMode ()
static bool	IsHrtMode ()
static bool	IsSyncMode ()
static bool	IsTicklessMode ()

Protected Attributes
KernelService	m_service
	Kernel service singleton exposed to running tasks via IKernelService::GetInstance().
TPlatform	m_platform
	Platform driver (SysTick, PendSV, context switch implementation).
TStrategy	m_strategy
	Task-switching strategy (determines which task runs next).
KernelTask *	m_task_now
	Currently executing task, or `nullptr` before Start() or after all tasks exit.
TaskStorageType	m_task_storage
	Static pool of TSize KernelTask slots (free slots have m_user == nullptr).
SleepTrapStack	m_sleep_trap [1]
	Sleep trap (always present): executed when all tasks are sleeping.
ExitTrapStack	m_exit_trap [((((TMode) &(KERNEL_DYNAMIC)) !=0U) ?(1) :(0))]
	Exit trap: zero-size in KERNEL_STATIC mode; one entry in KERNEL_DYNAMIC mode.
EFsmState	m_fsm_state
	Current FSM state. Drives context-switch decision on every tick.
volatile uint8_t	m_request
	Bitmask of pending ERequest flags from running tasks. Written by tasks, read/cleared by UpdateTaskRequest() in tick context.
volatile EState	m_state
	Current kernel state.
SyncObjectList	m_sync_list [((((TMode) &(KERNEL_SYNC)) !=0U) ?(1) :(0))]
	List of active sync objects. Zero-size (no memory) if KERNEL_SYNC is not set.
const EFsmState	m_fsm [FSM_STATE_MAX][FSM_EVENT_MAX]

Detailed Description

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>
class stk::Kernel< TMode, TSize, TStrategy, TPlatform >

Concrete implementation of IKernel.

All configuration is expressed as template parameters. No virtual dispatch, no heap allocation - the entire kernel, tasks, and traps live in statically reserved storage.

Template Parameters

TMode	Bitmask of EKernelMode flags that configures kernel features: KERNEL_STATIC — fixed task list, no add/remove after Start(). KERNEL_DYNAMIC — tasks may be added or removed at runtime. KERNEL_HRT — Hard Real-Time mode (must combine with STATIC or DYNAMIC). KERNEL_SYNC — enables synchronization primitives (Mutex, Event, etc.). KERNEL_TICKLESS — enables tickless low-power operation. Requires STK_TICKLESS_IDLE=1 in stk_config.h. Incompatible with KERNEL_HRT (tickless suppresses the timer, which destroys the precise periodicity HRT depends on — enforced by the compile-time assertion TICKLESS_HRT_CONFLICT). KERNEL_STATIC and KERNEL_DYNAMIC are mutually exclusive.
TSize	Maximum number of concurrent tasks. Must be > 0.
TStrategy	Task-switching strategy type (e.g. SwitchStrategyRoundRobin). Must inherit ITaskSwitchStrategy.
TPlatform	Platform driver type (e.g. PlatformArmCortexM, or PlatformDefault). Must inherit IPlatform.

Note: At least 1 task is required: TSize must be > 0 (enforced by compile-time assertion).; KERNEL_HRT is incompatible with weighted scheduling strategies (WEIGHT_API == true), also enforced by a compile-time assertion.; KERNEL_TICKLESS is incompatible with KERNEL_HRT, also enforced by a compile-time assertion (TICKLESS_HRT_CONFLICT).

Usage example:

static stk::Kernel<KERNEL_STATIC, 3,
                   SwitchStrategyRoundRobin,
                   PlatformDefault> kernel;
 
static MyTask1<256, ACCESS_PRIVILEGED> task1;
static MyTask2<512, ACCESS_USER>       task2;
static MyTask3<512, ACCESS_USER>       task3;
 
kernel.Initialize();
kernel.AddTask(&task1);
kernel.AddTask(&task2);
kernel.AddTask(&task3);
kernel.Start();

Definition at line 82 of file stk.h.

Member Typedef Documentation

◆ ExitTrapStackMemory

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

typedef StackMemoryWrapper<STACK_SIZE_MIN> stk::Kernel< TMode, TSize, TStrategy, TPlatform >::ExitTrapStackMemory

protected

Stack memory wrapper type for the exit trap.

See also: ExitTrapStack, STACK_SIZE_MIN

Definition at line 95 of file stk.h.

◆ SleepTrapStackMemory

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

typedef StackMemoryWrapper< ( 32 )> stk::Kernel< TMode, TSize, TStrategy, TPlatform >::SleepTrapStackMemory

protected

Stack memory wrapper type for the sleep trap.

See also: SleepTrapStack, STK_SLEEP_TRAP_STACK_SIZE

Definition at line 89 of file stk.h.

◆ SyncObjectList

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

typedef ISyncObject::ListHeadType stk::Kernel< TMode, TSize, TStrategy, TPlatform >::SyncObjectList

protected

Intrusive list of active ISyncObject instances registered with this kernel. Each sync object in this list receives a Tick() call every kernel tick for timeout tracking. Allocated only when KERNEL_SYNC is set (zero-size otherwise).

Definition at line 1988 of file stk.h.

◆ TaskStorageType

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

typedef KernelTask stk::Kernel< TMode, TSize, TStrategy, TPlatform >::TaskStorageType[TASKS_MAX]

protected

KernelTask array type used as a storage for the KernelTask instances.

Definition at line 1950 of file stk.h.

Member Enumeration Documentation

◆ EConsts

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

enum stk::Kernel::EConsts

Constants.

Enumerator
TASKS_MAX	Maximum number of concurrently registered tasks. Fixed at compile time. Exceeding this limit in AddTask() triggers a compile-time assert (TASKS_MAX > 0) and a runtime STK_ASSERT.

Definition at line 762 of file stk.h.

    {
        TASKS_MAX = TSize 
    };

◆ EFsmEvent

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

enum stk::Kernel::EFsmEvent : int8_t

protected

Finite-state machine (FSM) event. Computed by FetchNextEvent() each tick based on strategy output and current kernel state.

Enumerator
FSM_EVENT_SWITCH	Strategy returned a runnable task, perform a context switch.
FSM_EVENT_SLEEP	No runnable tasks, enter sleep trap.
FSM_EVENT_WAKE	A task became runnable while the kernel was sleeping, wake from sleep trap.
FSM_EVENT_EXIT	No tasks remain (KERNEL_DYNAMIC), exit scheduling and return from Start().
FSM_EVENT_MAX	Sentinel: number of valid events (used to size the FSM table).

Definition at line 984 of file stk.h.

    {
        FSM_EVENT_SWITCH = 0, 
        FSM_EVENT_SLEEP,      
        FSM_EVENT_WAKE,       
        FSM_EVENT_EXIT,       
        FSM_EVENT_MAX         
    };

◆ EFsmState

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

enum stk::Kernel::EFsmState : int8_t

protected

Finite-state machine (FSM) state. Encodes what the kernel is currently doing between two consecutive tick events.

Enumerator
FSM_STATE_NONE	Sentinel / uninitialized value. Set by the constructor, replaced by FSM_STATE_SWITCHING on the first tick.
FSM_STATE_SWITCHING	Normal operation: switching between runnable tasks each tick.
FSM_STATE_SLEEPING	All tasks are sleeping, the sleep trap is executing (CPU in low-power state).
FSM_STATE_WAKING	At least one task woke up, transitioning from sleep trap back to a user task.
FSM_STATE_EXITING	All tasks exited (KERNEL_DYNAMIC only), executing the exit trap to return from Start().
FSM_STATE_MAX	Sentinel: number of valid states (used to size the FSM table), denotes uninitialized state.

Definition at line 970 of file stk.h.

    {
        FSM_STATE_NONE      = -1, 
        FSM_STATE_SWITCHING,      
        FSM_STATE_SLEEPING,       
        FSM_STATE_WAKING,         
        FSM_STATE_EXITING,        
        FSM_STATE_MAX             
    };

◆ ERequest

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

enum stk::Kernel::ERequest : uint8_t

protected

Bitmask flags for pending inter-task requests that must be processed by the kernel on the next tick (in UpdateTaskRequest()).

Enumerator
REQUEST_NONE	No pending requests.
REQUEST_ADD_TASK	An AddTask() request is pending from a running task (KERNEL_DYNAMIC only).

Definition at line 101 of file stk.h.

    {
        REQUEST_NONE     = 0,       
        REQUEST_ADD_TASK = (1 << 0) 
    };

◆ EState

enum stk::IKernel::EState : uint8_t

inherited

Kernel state.

Enumerator
STATE_INACTIVE	not ready, IKernel::Initialize() must be called
STATE_READY	ready to start, IKernel::Start() must be called
STATE_RUNNING	initialized and running, IKernel::Start() was called successfully

Definition at line 859 of file stk_common.h.

    {
        STATE_INACTIVE = 0, 
        STATE_READY,        
        STATE_RUNNING       
    };

Constructor & Destructor Documentation

◆ Kernel()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Kernel ( )

inlineexplicit

Construct the kernel with all storage zero-initialised and the request flag set to ~0 (indicating uninitialized state; cleared to REQUEST_NONE by Initialize()).

Note: In debug builds also verifies that TPlatform derives from IPlatform and TStrategy from ITaskSwitchStrategy.; If TMode includes KERNEL_TICKLESS, a compile-time assertion fires unless STK_TICKLESS_IDLE is defined to 1 in stk_config.h.

Definition at line 774 of file stk.h.

                      : m_platform(), m_strategy(), m_task_now(nullptr), m_task_storage(), m_sleep_trap(),
        m_exit_trap(), m_fsm_state(FSM_STATE_NONE), m_request(REQUEST_NONE), m_state(STATE_INACTIVE)
    {
    #ifdef _DEBUG
        // TPlatform must inherit IPlatform
        IPlatform *platform = &m_platform;
        (void)platform;
 
        // TStrategy must inherit ITaskSwitchStrategy
        ITaskSwitchStrategy *strategy = &m_strategy;
        (void)strategy;
    #endif
 
    #if !STK_TICKLESS_IDLE
        STK_STATIC_ASSERT_DESC(((TMode & KERNEL_TICKLESS) == 0U),
            "STK_TICKLESS_IDLE must be defined to 1 for KERNEL_TICKLESS");
    #endif
    }

References FSM_STATE_NONE, stk::KERNEL_TICKLESS, m_exit_trap, m_fsm_state, m_platform, m_request, m_sleep_trap, m_state, m_strategy, m_task_now, m_task_storage, REQUEST_NONE, stk::IKernel::STATE_INACTIVE, and STK_STATIC_ASSERT_DESC.

◆ ~Kernel()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

stk::Kernel< TMode, TSize, TStrategy, TPlatform >::~Kernel ( )

inline

Destructor.

Note: MISRA deviation: [STK-DEV-005] Rule 10-3-2.

Definition at line 796 of file stk.h.

797 {}

Member Function Documentation

◆ AddKernelTask()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddKernelTask ( KernelTask * task )

inlineprotected

Add kernel task to the scheduling strategy.

Parameters

[in] task Pointer to the kernel task.

Definition at line 1073 of file stk.h.

    {
    #if STK_SEGGER_SYSVIEW
        // start tracing new task
        SEGGER_SYSVIEW_OnTaskCreate(task->GetUserStack()->tid);
        if (IsStarted())
            SendTaskTraceInfo(task);
    #endif
 
        m_strategy.AddTask(task);
    }

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetUserStack(), IsStarted(), and m_strategy.

Referenced by AllocateAndAddNewTask(), and HrtAllocateAndAddNewTask().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddTask() [1/2]

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask ( ITask * user_task )

inlinevirtual

Register task for a soft real-time (SRT) scheduling.

Parameters

[in] user_task User task to add. Must not already be registered. Must not be nullptr.

Note: Before Start(): allocates a free KernelTask slot and adds it to the strategy immediately.; After Start() (KERNEL_DYNAMIC only): serialises the request via RequestAddTask() — the calling task yields and the kernel processes the request on the next tick.

Warning: Asserts if called in KERNEL_HRT mode (use the HRT overload instead), if called after Start() without KERNEL_DYNAMIC, or if TASKS_MAX is exceeded.

Implements stk::IKernel.

Definition at line 832 of file stk.h.

    {
        if (!IsHrtMode())
        {
            STK_ASSERT(user_task != nullptr);
            STK_ASSERT(IsInitialized());
 
            // when started the operation must be serialized by switching out from processing until
            // kernel processes this request
            if (IsStarted())
            {
                if (IsDynamicMode())
                {
                    RequestAddTask(user_task);
                }
                else
                {
                    STK_ASSERT(false);
                }
            }
            else
            {
                AllocateAndAddNewTask(user_task);
            }
        }
        else
        {
            STK_ASSERT(false);
        }
    }

References __stk_attr_noinline, AllocateAndAddNewTask(), IsDynamicMode(), IsHrtMode(), IsInitialized(), IsStarted(), RequestAddTask(), and STK_ASSERT.

Here is the call graph for this function:

◆ AddTask() [2/2]

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask	(	ITask *	user_task,
		Timeout	periodicity_tc,
		Timeout	deadline_tc,
		Timeout	start_delay_tc )

inlinevirtual

Register a task for hard real-time (HRT) scheduling.

Parameters

[in]	user_task	User task to add. Must not already be registered. Must not be `nullptr`.
[in]	periodicity_tc	Activation period in ticks. Must be > 0 and < INT32_MAX.
[in]	deadline_tc	Maximum allowed active duration in ticks. Must be > 0 and < INT32_MAX.
[in]	start_delay_tc	Initial sleep delay in ticks before the first activation. 0 means activate immediately.

Note: Must be called before Start(). Dynamic (post-Start) HRT task addition is not supported.

Warning: Asserts if called outside KERNEL_HRT mode (use the SRT overload instead) or after Start().

Implements stk::IKernel.

Definition at line 871 of file stk.h.

    {
        if (IsHrtMode())
        {
            STK_ASSERT(user_task != nullptr);
            STK_ASSERT(IsInitialized());
            STK_ASSERT(!IsStarted());
 
            HrtAllocateAndAddNewTask(user_task, periodicity_tc, deadline_tc, start_delay_tc);
        }
        else
        {
            STK_ASSERT(false);
        }
    }

References __stk_attr_noinline, HrtAllocateAndAddNewTask(), IsHrtMode(), IsInitialized(), IsStarted(), and STK_ASSERT.

Here is the call graph for this function:

◆ AllocateAndAddNewTask()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AllocateAndAddNewTask ( ITask * user_task )

inlineprotected

Allocate new instance of KernelTask and add it into the scheduling process.

Parameters

[in] user_task User task for which kernel task object is allocated.

Returns: Kernel task.

Definition at line 1089 of file stk.h.

    {
        KernelTask *task = AllocateNewTask(user_task);
        STK_ASSERT(task != nullptr);
 
        AddKernelTask(task);
    }

References AddKernelTask(), AllocateNewTask(), and STK_ASSERT.

Referenced by AddTask(), and UpdateTaskRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AllocateNewTask()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

KernelTask * stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AllocateNewTask ( ITask * user_task )

inlineprotected

Allocate new instance of KernelTask.

Parameters

[in] user_task User task for which kernel task object is allocated.

Returns: Kernel task.

Definition at line 1037 of file stk.h.

    {
        // look for a free kernel task
        KernelTask *new_task = nullptr;
        for (uint32_t i = 0; i < TASKS_MAX; ++i)
        {
            KernelTask *task = &m_task_storage[i];
            if (task->IsBusy())
            {
                // avoid task collision
                STK_ASSERT(task->m_user != user_task);
 
                // avoid stack collision
                STK_ASSERT(task->m_user->GetStack() != user_task->GetStack());
            }
            else
            if (new_task == nullptr)
            {
                new_task = task;
            #if defined(NDEBUG) && !defined(_STK_ASSERT_REDIRECT)
                break; // break if assertions are inactive and do not try to validate collision with existing tasks
            #endif
            }
        }
 
        // if nullptr - exceeded max supported kernel task count, application design failure
        STK_ASSERT(new_task != nullptr);
 
        new_task->Bind(&m_platform, user_task);
 
        return new_task;
    }

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::Bind(), stk::IStackMemory::GetStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::IsBusy(), m_platform, m_task_storage, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_user, STK_ASSERT, and TASKS_MAX.

Referenced by AllocateAndAddNewTask(), and HrtAllocateAndAddNewTask().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FetchNextEvent()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

EFsmEvent stk::Kernel< TMode, TSize, TStrategy, TPlatform >::FetchNextEvent ( KernelTask *& next )

inlineprotected

Fetch next event for the FSM.

Parameters

[out] next Next kernel task to which Kernel can switch.

Returns: FSM event.

Definition at line 1656 of file stk.h.

    {
        EFsmEvent type = FSM_EVENT_EXIT;
        KernelTask *itr = nullptr;
 
        // check if no tasks left in KERNEL_DYNAMIC mode and exit, if KERNEL_DYNAMIC is not
        // set then 'is_empty' will always be false
        bool is_empty = IsDynamicMode() && (m_strategy.GetSize() == 0U);
 
        if (!is_empty)
        {
            // MISRA 5-2-3 deviation: GetNext/GetFirst returns IKernelTask*, all objects in
            // the strategy pool are KernelTask instances - downcast is guaranteed safe.
            itr = static_cast<KernelTask *>(m_strategy.GetNext());
 
            // sleep-aware strategy returns nullptr if no active tasks available, start sleeping
            if (itr == nullptr)
            {
                type = FSM_EVENT_SLEEP;
            }
            else
            {
                // strategy must provide active-only task
                STK_ASSERT(!itr->IsSleeping());
 
                // if was sleeping, process wake event first
                type = (m_fsm_state == FSM_STATE_SLEEPING ? FSM_EVENT_WAKE : FSM_EVENT_SWITCH);
            }
        }
 
        next = itr;
        return type;
    }

References FSM_EVENT_EXIT, FSM_EVENT_SLEEP, FSM_EVENT_SWITCH, FSM_EVENT_WAKE, FSM_STATE_SLEEPING, IsDynamicMode(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::IsSleeping(), m_fsm_state, m_strategy, and STK_ASSERT.

Referenced by GetNewFsmState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindTaskBySP()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

KernelTask * stk::Kernel< TMode, TSize, TStrategy, TPlatform >::FindTaskBySP ( Word SP )

inlineprotected

Find kernel task for a Stack Pointer (SP).

Parameters

[in] SP Stack pointer.

Returns: Kernel task.

Definition at line 1175 of file stk.h.

    {
        STK_ASSERT(m_task_now != nullptr);
 
        if (m_task_now->IsMemoryOfSP(SP))
            return m_task_now;
 
        for (uint32_t i = 0; i < TASKS_MAX; ++i)
        {
            KernelTask *task = &m_task_storage[i];
 
            // skip finished tasks (applicable only for KERNEL_DYNAMIC mode)
            if (IsDynamicMode() && !task->IsBusy())
                continue;
 
            if (task->IsMemoryOfSP(SP))
                return task;
        }
 
        return nullptr;
    }

References __stk_attr_noinline, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::IsBusy(), IsDynamicMode(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::IsMemoryOfSP(), m_task_now, m_task_storage, STK_ASSERT, and TASKS_MAX.

Referenced by OnGetTid(), OnTaskSleep(), OnTaskSleepUntil(), OnTaskWait(), and RequestAddTask().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindTaskByStack()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

KernelTask * stk::Kernel< TMode, TSize, TStrategy, TPlatform >::FindTaskByStack ( const Stack * stack )

inlineprotected

Find kernel task by the bound Stack instance.

Parameters

[in] stack Stack.

Returns: Kernel task.

Definition at line 1159 of file stk.h.

    {
        for (uint32_t i = 0; i < TASKS_MAX; ++i)
        {
            KernelTask *task = &m_task_storage[i];
            if (task->GetUserStack() == stack)
                return task;
        }
 
        return nullptr;
    }

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetUserStack(), m_task_storage, and TASKS_MAX.

Referenced by OnTaskExit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindTaskByUserTask()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

KernelTask * stk::Kernel< TMode, TSize, TStrategy, TPlatform >::FindTaskByUserTask ( const ITask * user_task )

inlineprotected

Find kernel task by the bound ITask instance.

Parameters

[in] user_task User task.

Returns: Kernel task.

Definition at line 1143 of file stk.h.

    {
        for (uint32_t i = 0; i < TASKS_MAX; ++i)
        {
            KernelTask *task = &m_task_storage[i];
            if (task->GetUserTask() == user_task)
                return task;
        }
 
        return nullptr;
    }

References __stk_attr_noinline, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetUserTask(), m_task_storage, and TASKS_MAX.

Referenced by RemoveTask().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetNewFsmState()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

EFsmState stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetNewFsmState ( KernelTask *& next )

inlineprotected

Get new FSM state.

Parameters

[out] next Next kernel task to which Kernel can switch.

Returns: FSM state.

Definition at line 1697 of file stk.h.

    {
        STK_ASSERT(IsValidFsmState(m_fsm_state));
        return m_fsm[m_fsm_state][FetchNextEvent(next)];
    }

References FetchNextEvent(), IsValidFsmState(), m_fsm, m_fsm_state, and STK_ASSERT.

Referenced by stk::test::KernelMock< TMode, TSize, TStrategy, TPlatform >::GetNewFsmState(), OnStart(), and UpdateFsmState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPlatform()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

IPlatform * stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform ( )

inlinevirtual

Get platform driver instance owned by this kernel.

Returns: Pointer to the internal TPlatform cast to IPlatform*.

Implements stk::IKernel.

Definition at line 954 of file stk.h.

954{ return &m_platform; }

References m_platform.

Here is the caller graph for this function:

◆ GetState()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

EState stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetState ( ) const

inlinevirtual

Get kernel state.

Implements stk::IKernel.

Definition at line 963 of file stk.h.

963{ return m_state; }

References m_state.

Referenced by stk::test::TEST(), stk::test::TEST(), and stk::test::TEST().

Here is the caller graph for this function:

◆ GetSwitchStrategy()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

ITaskSwitchStrategy * stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy ( )

inlinevirtual

Get task-switching strategy instance owned by this kernel.

Returns: Pointer to the internal TStrategy cast to ITaskSwitchStrategy*.

Implements stk::IKernel.

Definition at line 959 of file stk.h.

959{ return &m_strategy; }

References m_strategy.

Here is the caller graph for this function:

◆ HrtAllocateAndAddNewTask()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::HrtAllocateAndAddNewTask	(	ITask *	user_task,
		Timeout	periodicity_tc,
		Timeout	deadline_tc,
		Timeout	start_delay_tc )

inlineprotected

Allocate new instance of KernelTask and add it into the HRT scheduling process.

Note: Related to stk::KERNEL_HRT mode only.

Parameters

[in]	user_task	User task for which kernel task object is allocated.
[in]	periodicity_tc	Periodicity time at which task is scheduled (ticks).
[in]	deadline_tc	Deadline time within which a task must complete its work (ticks).
[in]	start_delay_tc	Initial start delay for the task (ticks).

Returns: Kernel task.

Definition at line 1105 of file stk.h.

    {
        KernelTask *task = AllocateNewTask(user_task);
        STK_ASSERT(task != nullptr);
 
        task->HrtInit(periodicity_tc, deadline_tc, start_delay_tc);
 
        AddKernelTask(task);
    }

References AddKernelTask(), AllocateNewTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::HrtInit(), and STK_ASSERT.

Referenced by AddTask().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Initialize()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize ( uint32_t resolution_us = PERIODICITY_DEFAULT )

inlinevirtual

Prepare kernel for use: reset state, configure the platform, and register the service singleton.

Parameters

[in] resolution_us System tick resolution in microseconds per tick (default: PERIODICITY_DEFAULT). Valid range: 1 .. PERIODICITY_MAX. Asserts if 0 or out of range.

Note: Must be called before AddTask() or Start(). Calling twice without an intervening Stop() asserts (IsInitialized() is false until this call completes).

Implements stk::IKernel.

Definition at line 805 of file stk.h.

    {
        STK_ASSERT(resolution_us != 0);
        STK_ASSERT(resolution_us <= PERIODICITY_MAX);
        STK_ASSERT(!IsInitialized());
 
        // reinitialize key state variables
        m_task_now  = nullptr;
        m_fsm_state = FSM_STATE_NONE;
        m_request   = REQUEST_NONE;
 
        m_service.Initialize(&m_platform);
 
        m_platform.Initialize(this, &m_service, resolution_us, (IsDynamicMode() ? &m_exit_trap[0].stack : nullptr));
 
        // now ready to Start()
        m_state = STATE_READY;
    }

References __stk_attr_noinline, FSM_STATE_NONE, IsDynamicMode(), IsInitialized(), m_exit_trap, m_fsm_state, m_platform, m_request, m_service, m_state, m_task_now, stk::PERIODICITY_DEFAULT, stk::PERIODICITY_MAX, REQUEST_NONE, stk::IKernel::STATE_READY, and STK_ASSERT.

Here is the call graph for this function:

◆ InitTraps()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::InitTraps ( )

inlineprotected

Initialize stack of the traps.

Definition at line 1003 of file stk.h.

    {
        // init stack for a Sleep trap
        {
            SleepTrapStack &sleep = m_sleep_trap[0];
 
            SleepTrapStackMemory wrapper(&sleep.memory);
            sleep.stack.mode = ACCESS_PRIVILEGED;
        #if STK_NEED_TASK_ID
            sleep.stack.tid  = SYS_TASK_ID_SLEEP;
        #endif
 
            m_platform.InitStack(STACK_SLEEP_TRAP, &sleep.stack, &wrapper, nullptr);
        }
 
        // init stack for an Exit trap
        if (IsDynamicMode())
        {
            ExitTrapStack &exit = m_exit_trap[0];
 
            ExitTrapStackMemory wrapper(&exit.memory);
            exit.stack.mode = ACCESS_PRIVILEGED;
        #if STK_NEED_TASK_ID
            exit.stack.tid  = SYS_TASK_ID_EXIT;
        #endif
 
            m_platform.InitStack(STACK_EXIT_TRAP, &exit.stack, &wrapper, nullptr);
        }
    }

References __stk_attr_noinline, stk::ACCESS_PRIVILEGED, IsDynamicMode(), m_exit_trap, m_platform, m_sleep_trap, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::ExitTrapStack::memory, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::SleepTrapStack::memory, stk::Stack::mode, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::ExitTrapStack::stack, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::SleepTrapStack::stack, stk::STACK_EXIT_TRAP, stk::STACK_SLEEP_TRAP, stk::SYS_TASK_ID_EXIT, and stk::SYS_TASK_ID_SLEEP.

Referenced by Start().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsDynamicMode()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsDynamicMode ( )

inlinestaticprotected

Definition at line 1923 of file stk.h.

1923{ return ((TMode & KERNEL_DYNAMIC) != 0U); }

References __stk_forceinline, and stk::KERNEL_DYNAMIC.

Referenced by AddTask(), FetchNextEvent(), FindTaskBySP(), Initialize(), InitTraps(), OnStop(), OnTaskExit(), RemoveTask(), RequestAddTask(), StateExit(), UpdateTaskRequest(), and UpdateTaskState().

Here is the caller graph for this function:

◆ IsHrtMode()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsHrtMode ( )

inlinestaticprotected

Definition at line 1924 of file stk.h.

1924{ return ((TMode & KERNEL_HRT) != 0U); }

References __stk_forceinline, and stk::KERNEL_HRT.

Referenced by AddTask(), AddTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetHrtDeadline(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetHrtPeriodicity(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetHrtRelativeDeadline(), OnStart(), OnTaskSleep(), OnTaskSleepUntil(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::ScheduleRemoval(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelService::Sleep(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelService::SleepUntil(), StateSleep(), StateSwitch(), StateWake(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::Unbind(), UpdateTaskRequest(), and UpdateTaskState().

Here is the caller graph for this function:

◆ IsInitialized()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsInitialized ( ) const

inlineprotected

Check whether Initialize() has been called and completed successfully.

Returns: true if Initialize() was called, false otherwise.

Definition at line 1888 of file stk.h.

1888{ return (m_state != STATE_INACTIVE); }

References m_state, and stk::IKernel::STATE_INACTIVE.

Referenced by AddTask(), AddTask(), Initialize(), and Start().

Here is the caller graph for this function:

◆ IsStarted()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsStarted ( ) const

inline

Check whether scheduler is currently running.

Returns: true if Start() has been called and the first task switch has occurred (m_task_now != nullptr), false before Start() or after all tasks exit.

Definition at line 946 of file stk.h.

    {
        return (m_task_now != nullptr);
    }

References m_task_now.

Referenced by AddKernelTask(), AddTask(), AddTask(), and RemoveTask().

Here is the caller graph for this function:

◆ IsStaticMode()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsStaticMode ( )

inlinestaticprotected

Definition at line 1922 of file stk.h.

1922{ return ((TMode & KERNEL_STATIC) != 0U); }

References __stk_forceinline, and stk::KERNEL_STATIC.

◆ IsSyncMode()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsSyncMode ( )

inlinestaticprotected

Definition at line 1925 of file stk.h.

1925{ return ((TMode & KERNEL_SYNC) != 0U); }

References __stk_forceinline, and stk::KERNEL_SYNC.

Referenced by stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::KernelTask(), OnTaskWait(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::Unbind(), UpdateSyncObjects(), UpdateTasks(), UpdateTaskState(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelService::Wait().

Here is the caller graph for this function:

◆ IsTicklessMode()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsTicklessMode ( )

inlinestaticprotected

Definition at line 1926 of file stk.h.

1926{ return ((TMode & KERNEL_TICKLESS) != 0U); }

References __stk_forceinline, and stk::KERNEL_TICKLESS.

Referenced by UpdateTaskState().

Here is the caller graph for this function:

◆ IsValidFsmState()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsValidFsmState ( EFsmState state )

inlinestaticprotected

Check if FSM state is valid.

Definition at line 995 of file stk.h.

    {
        return (state > FSM_STATE_NONE) &&
               (state < FSM_STATE_MAX);
    }

References __stk_forceinline, FSM_STATE_MAX, and FSM_STATE_NONE.

Referenced by GetNewFsmState().

Here is the caller graph for this function:

◆ OnGetTid()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

TId stk::Kernel< TMode, TSize, TStrategy, TPlatform >::OnGetTid ( Word caller_SP )

inlineprotectedvirtual

Called from the Thread process when for getting task/thread id of the process.

Parameters

[in] caller_SP Value of Stack Pointer (SP) register (for locating the calling process inside the kernel).

Returns: Task/thread id of the process.

Implements stk::IPlatform::IEventHandler.

Definition at line 1460 of file stk.h.

    {
        KernelTask *task = FindTaskBySP(caller_SP);
        STK_ASSERT(task != nullptr);
 
        return task->GetTid();
    }

References FindTaskBySP(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetTid(), and STK_ASSERT.

Here is the call graph for this function:

◆ OnStart()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::OnStart ( Stack *& active )

inlineprotectedvirtual

Called by platform driver immediately after a scheduler start (first tick).

Parameters

[out] active Set to the stack of the first task to run, or to the sleep-trap stack if all tasks are initially sleeping.

Note: Delivers initial OnTaskSleep notifications to sleep-aware strategies for any tasks that were added in a sleeping state before Start() was called.; Selects the first runnable task via GetNewFsmState() and transitions the kernel to STATE_RUNNING.; If STK_SEGGER_SYSVIEW is enabled, emits a task-start trace event for the first task.

Warning: At least one task must have been added via AddTask(); asserts if the strategy pool is empty.

Implements stk::IPlatform::IEventHandler.

Definition at line 1223 of file stk.h.

    {
        STK_ASSERT(m_strategy.GetSize() != 0);
 
        // iterate tasks and generate OnTaskSleep for a strategy for all initially sleeping tasks
        if (TStrategy::SLEEP_EVENT_API)
        {
            for (uint32_t i = 0; i < TASKS_MAX; ++i)
            {
                KernelTask *task = &m_task_storage[i];
 
                if (task->IsSleeping())
                {
                    if ((task->m_state & KernelTask::STATE_SLEEP_PENDING) != 0U)
                    {
                        task->m_state &= ~KernelTask::STATE_SLEEP_PENDING;
 
                        // notify strategy that task is sleeping
                        m_strategy.OnTaskSleep(task);
                    }
                }
            }
        }
 
        // get initial state and first task
        {
            m_fsm_state = FSM_STATE_SWITCHING;
 
            KernelTask *next = nullptr;
            m_fsm_state = GetNewFsmState(next);
 
            // expecting only SLEEPING or SWITCHING states
            STK_ASSERT((m_fsm_state == FSM_STATE_SLEEPING) || (m_fsm_state == FSM_STATE_SWITCHING));
 
            if (m_fsm_state == FSM_STATE_SWITCHING)
            {
                m_task_now = next;
 
                active = next->GetUserStack();
 
                if (IsHrtMode())
                    next->HrtOnSwitchedIn();
            }
            else
            if (m_fsm_state == FSM_STATE_SLEEPING)
            {
                // MISRA 5-2-3 deviation: GetNext/GetFirst returns IKernelTask*, all objects in
                // the strategy pool are KernelTask instances - downcast is guaranteed safe.
                m_task_now = static_cast<KernelTask *>(m_strategy.GetFirst());
 
                active = &m_sleep_trap[0].stack;
            }
        }
 
        // is in running state
        m_state = STATE_RUNNING;
 
    #if STK_SEGGER_SYSVIEW
        SEGGER_SYSVIEW_OnTaskStartExec(m_task_now->tid);
    #endif
    }

References __stk_attr_noinline, FSM_STATE_SLEEPING, FSM_STATE_SWITCHING, GetNewFsmState(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetUserStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::HrtOnSwitchedIn(), IsHrtMode(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::IsSleeping(), m_fsm_state, m_sleep_trap, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_state, m_state, m_strategy, m_task_now, m_task_storage, stk::IKernel::STATE_RUNNING, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::STATE_SLEEP_PENDING, STK_ASSERT, and TASKS_MAX.

Here is the call graph for this function:

◆ OnStop()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::OnStop ( )

inlineprotectedvirtual

Called by the platform driver after a scheduler stop (all tasks have exited).

Note: KERNEL_DYNAMIC mode only: resets FSM to FSM_STATE_NONE and transitions kernel back to STATE_READY so Start() may be called again.; Has no effect in KERNEL_STATIC mode (static kernels never stop).

Implements stk::IPlatform::IEventHandler.

Definition at line 1290 of file stk.h.

    {
        if (IsDynamicMode())
        {
            m_fsm_state = FSM_STATE_NONE;
 
            // is in stopped state, i.e. is ready to Start() again
            m_state = STATE_READY;
        }
    }

References __stk_attr_noinline, FSM_STATE_NONE, IsDynamicMode(), m_fsm_state, m_state, and stk::IKernel::STATE_READY.

Here is the call graph for this function:

◆ OnTaskExit()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::OnTaskExit ( Stack * stack )

inlineprotectedvirtual

Called from the Thread process when task finished (its Run function exited by return).

Parameters

[out] stack Stack of the exited task.

Implements stk::IPlatform::IEventHandler.

Definition at line 1401 of file stk.h.

    {
        if (IsDynamicMode())
        {
            KernelTask *task = FindTaskByStack(stack);
            STK_ASSERT(task != nullptr);
 
            task->ScheduleRemoval();
        }
        else
        {
            // kernel operating mode must be KERNEL_DYNAMIC for tasks to be able to exit
            STK_KERNEL_PANIC(KERNEL_PANIC_BAD_MODE);
        }
    }

References FindTaskByStack(), IsDynamicMode(), stk::KERNEL_PANIC_BAD_MODE, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::ScheduleRemoval(), STK_ASSERT, and STK_KERNEL_PANIC.

Here is the call graph for this function:

◆ OnTaskSleep()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::OnTaskSleep	(	Word	caller_SP,
		Timeout	ticks )

inlineprotectedvirtual

Called by Thread process (via IKernelService::Sleep) for exclusion of the calling process from scheduling (sleeping).

Parameters

[in]	caller_SP	Value of Stack Pointer (SP) register (for locating the calling process inside the kernel).
[in]	ticks	Time to sleep (ticks).

Implements stk::IPlatform::IEventHandler.

Definition at line 1352 of file stk.h.

    {
        KernelTask *task = FindTaskBySP(caller_SP);
        STK_ASSERT(task != nullptr);
 
        // make change to HRT state and sleep time atomic
        {
            hw::CriticalSection::ScopedLock cs_;
 
            if (IsHrtMode())
                task->HrtOnWorkCompleted();
 
            task->ScheduleSleep(ticks);
        }
 
        // note: we do not spin long here, kernel will switch this task out from scheduling on the next tick
        while (task->IsSleeping())
        {
            __stk_relax_cpu();
        }
    }

References __stk_relax_cpu, FindTaskBySP(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::HrtOnWorkCompleted(), IsHrtMode(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::IsSleeping(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::ScheduleSleep(), and STK_ASSERT.

Referenced by OnTaskSwitch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OnTaskSleepUntil()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::OnTaskSleepUntil	(	Word	caller_SP,
		Ticks	timestamp )

inlineprotectedvirtual

Called by Thread process (via IKernelService::SleepUntil) for exclusion of the calling process from scheduling (sleeping).

Parameters

[in]	caller_SP	Value of Stack Pointer (SP) register (for locating the calling process inside the kernel).
[in]	timestamp	Absolute timestamp (ticks).

Implements stk::IPlatform::IEventHandler.

Definition at line 1374 of file stk.h.

    {
        STK_ASSERT(!IsHrtMode());
 
        KernelTask *task = FindTaskBySP(caller_SP);
        STK_ASSERT(task != nullptr);
 
        // make change to HRT state and sleep time atomic
        {
            hw::CriticalSection::ScopedLock cs_;
 
            Ticks ticks = timestamp - m_service.m_ticks;
 
            // if provided timestamp expired, just ignore any sleep for this task
            if (ticks <= 0)
                return;
 
            task->ScheduleSleep(ticks);
        }
 
        // note: we do not spin long here, kernel will switch this task out from scheduling on the next tick
        while (task->IsSleeping())
        {
            __stk_relax_cpu();
        }
    }

References __stk_relax_cpu, FindTaskBySP(), IsHrtMode(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::IsSleeping(), m_service, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::ScheduleSleep(), and STK_ASSERT.

Here is the call graph for this function:

◆ OnTaskSwitch()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::OnTaskSwitch ( Word caller_SP )

inlineprotectedvirtual

Called by Thread process (via IKernelService::SwitchToNext) to switch to a next task.

Parameters

[in] caller_SP Value of Stack Pointer (SP) register (for locating the calling process inside the kernel).

Implements stk::IPlatform::IEventHandler.

Definition at line 1344 of file stk.h.

    {
        // yield with 2 ticks: 1 will be incremented on the next OnTick call by UpdateTasks
        // and remaining 1 will cause a context switch by UpdateFsmState when strategy detects
        // it as a sleeping test
        OnTaskSleep(caller_SP, 2);
    }

References OnTaskSleep().

Here is the call graph for this function:

◆ OnTaskWait()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

IWaitObject * stk::Kernel< TMode, TSize, TStrategy, TPlatform >::OnTaskWait	(	Word	caller_SP,
		ISyncObject *	sync_obj,
		IMutex *	mutex,
		Timeout	timeout )

inlineprotectedvirtual

Called from the Thread process when task needs to wait.

Parameters

[in]	caller_SP	Value of Stack Pointer (SP) register (for locating the calling process inside the kernel).
[in]	sync_obj	ISyncObject instance (passed by Wait).
[in]	mutex	IMutex instance (passed by Wait).
[in]	timeout	Time to sleep (ticks).

Implements stk::IPlatform::IEventHandler.

Definition at line 1417 of file stk.h.

    {
        if (IsSyncMode())
        {
            STK_ASSERT(timeout != 0);        // API contract: caller must not be in ISR
            STK_ASSERT(sync_obj != nullptr); // API contract: ISyncObject instance must be provided
            STK_ASSERT(mutex != nullptr);    // API contract: IMutex instance must be provided
            STK_ASSERT((sync_obj->GetHead() == nullptr) || (sync_obj->GetHead() == &m_sync_list[0]));
 
            KernelTask *task = FindTaskBySP(caller_SP);
            STK_ASSERT(task != nullptr);
 
            // configure waiting
            task->m_wait_obj->SetupWait(sync_obj, timeout);
 
            // register ISyncObject if not yet
            if (sync_obj->GetHead() == nullptr)
                m_sync_list->LinkBack(sync_obj);
 
            // start sleeping infinitely, we rely on a Wake call via WaitObject
            task->ScheduleSleep(WAIT_INFINITE);
 
            // unlock mutex locked externally, so that we could wait in a busy-waiting loop
            mutex->Unlock();
 
            // note: we do not spin long here, kernel will switch this task out from scheduling on the next tick
            while (task->IsSleeping())
            {
                __stk_relax_cpu();
            }
 
            // re-lock mutex when returning to the task's execution space
            mutex->Lock();
 
            return task->m_wait_obj;
        }
        else
        {
            STK_ASSERT(false);
            return nullptr;
        }
    }

References __stk_relax_cpu, FindTaskBySP(), stk::util::DListEntry< T, _ClosedLoop >::GetHead(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::IsSleeping(), IsSyncMode(), stk::IMutex::Lock(), m_sync_list, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_wait_obj, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::ScheduleSleep(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::WaitObject::SetupWait(), STK_ASSERT, stk::IMutex::Unlock(), and stk::WAIT_INFINITE.

Here is the call graph for this function:

◆ OnTick()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::OnTick	(	Stack *&	idle,
		Stack *&	active )

inlineprotectedvirtual

Process one scheduler tick. Called from the platform timer/tick ISR.

Parameters

[out]	idle	Stack descriptor to context-switch out (`nullptr` if no switch needed).
[out]	active	Stack descriptor to context-switch in (`nullptr` if no switch needed).
[in,out]	ticks	(KERNEL_TICKLESS builds only) On entry: actual number of ticks elapsed since the last call, as measured by the platform driver. On return: the number of ticks the hardware timer may suppress before the next required wakeup, computed as the minimum remaining sleep across all active tasks, clamped to [1, STK_TICKLESS_TICKS_MAX]. The platform driver programs this value into the timer to avoid unnecessary wakeups. This parameter is absent in non-tickless builds.

Returns: true if a context switch is required (idle and active are valid); false if the current task continues running.

Note: In non-tickless mode the internal tick counter always advances by exactly 1 per call.; In tickless mode (KERNEL_TICKLESS) the counter advances by the ticks value supplied by the platform driver, which may be greater than 1 after a suppressed interval.

Implements stk::IPlatform::IEventHandler.

Definition at line 1317 of file stk.h.

    {
    #if !STK_TICKLESS_IDLE
        // in non-tickless mode kernel is advancing strictly by 1 tick on every OnTick call
        enum { ticks = 1 };
    #endif
 
        // advance internal timestamp
        m_service.IncrementTicks(ticks);
 
        // consume elapsed and update to ticks to sleep
    #if STK_TICKLESS_IDLE
        ticks = (
    #else
        // notify compiler that we ignore a return value of UpdateTasks
        static_cast<void>(
    #endif
        UpdateTasks(ticks));
 
        // decide on a context switch
        return UpdateFsmState(idle, active);
    }

References m_service, STK_TICKLESS_IDLE, UpdateFsmState(), and UpdateTasks().

Here is the call graph for this function:

◆ RemoveTask() [1/2]

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask ( ITask * user_task )

inlinevirtual

Remove a previously added task from the kernel before Start().

Parameters

[in] user_task User task to remove. Must not be nullptr.

Note: Only valid before Start() (i.e. while the kernel is not running). To remove tasks after Start() the task should return from its Run function (in KERNEL_DYNAMIC mode the slot is freed automatically on the next tick).

Warning: KERNEL_DYNAMIC mode only. Asserts if called in KERNEL_STATIC or KERNEL_HRT mode, or if called after Start().

Implements stk::IKernel.

Definition at line 895 of file stk.h.

    {
        if (IsDynamicMode())
        {
            STK_ASSERT(user_task != nullptr);
            STK_ASSERT(!IsStarted());
 
            KernelTask *task = FindTaskByUserTask(user_task);
            if (task != nullptr)
                RemoveTask(task);
        }
        else
        {
            // kernel operating mode must be KERNEL_DYNAMIC for tasks to be able to be removed
            STK_ASSERT(false);
        }
    }

References __stk_attr_noinline, FindTaskByUserTask(), IsDynamicMode(), IsStarted(), RemoveTask(), and STK_ASSERT.

Referenced by RemoveTask(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TestAlgorithm(), stk::test::TestPriorityNext(), and UpdateTaskState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveTask() [2/2]

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask ( KernelTask * task )

inlineprotected

Remove kernel task.

Note: Removal of the kernel task means releasing it from the user task details.

Parameters

[in] task Kernel task.

Definition at line 1201 of file stk.h.

    {
        STK_ASSERT(task != nullptr);
 
    #if STK_SEGGER_SYSVIEW
        SEGGER_SYSVIEW_OnTaskTerminate(task->GetUserStack()->tid);
    #endif
 
        m_strategy.RemoveTask(task);
        task->Unbind();
    }

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetUserStack(), m_strategy, STK_ASSERT, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::Unbind().

Here is the call graph for this function:

◆ RequestAddTask()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RequestAddTask ( ITask * user_task )

inlineprotected

Request to add new task.

Note: Must be called by the task process only!

Parameters

[in] user_task User task to add.

Definition at line 1119 of file stk.h.

    {
        STK_ASSERT(IsDynamicMode());
 
        KernelTask *caller = FindTaskBySP(m_platform.GetCallerSP());
        STK_ASSERT(caller != nullptr);
 
        typename KernelTask::AddTaskRequest req = { .user_task = user_task };
        caller->m_srt[0].add_task_req = &req;
 
        // notify kernel
        ScheduleAddTask();
 
        // switch out and wait for completion (due to context switch request could be processed here)
        if (caller->m_srt[0].add_task_req != nullptr)
            m_service.SwitchToNext();
 
        STK_ASSERT(caller->m_srt[0].add_task_req == nullptr);
    }

References __stk_attr_noinline, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::SrtInfo::add_task_req, FindTaskBySP(), IsDynamicMode(), m_platform, m_service, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_srt, ScheduleAddTask(), and STK_ASSERT.

Referenced by AddTask().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ScheduleAddTask()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::ScheduleAddTask ( )

inlineprotected

Signal the kernel to process a pending AddTask request on the next tick.

Note: Sets the REQUEST_ADD_TASK bit in m_request and emits a full memory fence so the ISR-side tick handler observes the flag without delay.

Definition at line 1894 of file stk.h.

    {
        hw::CriticalSection::ScopedLock cs_;
        m_request |= REQUEST_ADD_TASK;
    }

References m_request, and REQUEST_ADD_TASK.

Referenced by RequestAddTask().

Here is the caller graph for this function:

◆ Start()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start ( )

inlinevirtual

Start the scheduler. This call does not return until all tasks have exited (KERNEL_DYNAMIC mode) or indefinitely (KERNEL_STATIC mode).

Note: Re-initialises trap stacks on every call so Start() can be called again after a previous scheduling session ended.; If STK_SEGGER_SYSVIEW is enabled, starts tracing and registers all pre-added tasks.

Warning: At least one task must have been added via AddTask() before calling Start(). Asserts if called before Initialize().

Implements stk::IKernel.

Definition at line 921 of file stk.h.

    {
        STK_ASSERT(IsInitialized());
 
         // stacks of the traps must be re-initilized on every subsequent Start
        InitTraps();
 
        // start tracing
    #if STK_SEGGER_SYSVIEW
        SEGGER_SYSVIEW_Start();
        for (int32_t i = 0; i < TASKS_MAX; ++i)
        {
            KernelTask *task = &m_task_storage[i];
            if (task->IsBusy())
                SendTaskTraceInfo(task);
        }
    #endif
 
        m_platform.Start();
    }

References __stk_attr_noinline, InitTraps(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::IsBusy(), IsInitialized(), m_platform, m_task_storage, STK_ASSERT, and TASKS_MAX.

Here is the call graph for this function:

◆ StateExit()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::StateExit	(	KernelTask *	now,
		KernelTask *	next,
		Stack *&	idle,
		Stack *&	active )

inlineprotected

Exits from scheduling.

Note: FSM state: stk::FSM_STATE_EXITING.; Exits only if stk::KERNEL_DYNAMIC mode is specified, otherwise ignored.

Parameters

[in]	now	Currently active kernel task (ignored).
[in]	next	Next kernel task (ignored).
[out]	idle	Stack of the task which must enter Idle state.
[out]	active	Stack of the task which must enter Active state (to which context will switch).

Definition at line 1859 of file stk.h.

    {
        (void)now;
        (void)next;
 
        if (IsDynamicMode())
        {
            // dynamic tasks are not supported if main processes's stack memory is not provided in Start()
            STK_ASSERT(m_exit_trap[0].stack.SP != 0);
 
            idle   = nullptr;
            active = &m_exit_trap[0].stack;
 
            m_task_now = nullptr;
 
            m_platform.Stop();
        }
        else
        {
            (void)idle;
            (void)active;
        }
 
        return false;
    }

References IsDynamicMode(), m_exit_trap, m_platform, m_task_now, and STK_ASSERT.

Referenced by UpdateFsmState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StateSleep()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::StateSleep	(	KernelTask *	now,
		KernelTask *	next,
		Stack *&	idle,
		Stack *&	active )

inlineprotected

Enters into a sleeping mode.

Note: FSM state: stk::FSM_STATE_SLEEPING.

Parameters

[in]	now	Currently active kernel task.
[in]	next	Next kernel task (ignored).
[out]	idle	Stack of the task which must enter Idle state.
[out]	active	Stack of the task which must enter Active state (to which context will switch).

Definition at line 1826 of file stk.h.

    {
        (void)next;
 
        STK_ASSERT(now != nullptr);
        STK_ASSERT(m_sleep_trap[0].stack.SP != 0);
 
        idle   = now->GetUserStack();
        active = &m_sleep_trap[0].stack;
 
        m_task_now = static_cast<KernelTask *>(m_strategy.GetFirst());
 
    #if STK_SEGGER_SYSVIEW
        SEGGER_SYSVIEW_OnTaskStopReady(now->GetUserStack()->tid, TRACE_EVENT_SLEEP);
    #endif
 
        if (IsHrtMode())
        {
            if (!now->IsPendingRemoval())
                now->HrtOnSwitchedOut(&m_platform);
        }
 
        return true; // switch context
    }

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetUserStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::HrtOnSwitchedOut(), IsHrtMode(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::IsPendingRemoval(), m_platform, m_sleep_trap, m_strategy, m_task_now, STK_ASSERT, and stk::TRACE_EVENT_SLEEP.

Referenced by UpdateFsmState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StateSwitch()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::StateSwitch	(	KernelTask *	now,
		KernelTask *	next,
		Stack *&	idle,
		Stack *&	active )

inlineprotected

Switches contexts.

Note: FSM state: stk::FSM_STATE_SWITCHING.

Parameters

[in]	now	Currently active kernel task.
[in]	next	Next kernel task.
[out]	idle	Stack of the task which must enter Idle state.
[out]	active	Stack of the task which must enter Active state (to which context will switch).

Definition at line 1748 of file stk.h.

    {
        STK_ASSERT(now != nullptr);
        STK_ASSERT(next != nullptr);
 
        // do not switch context because task did not change
        if (next == now)
            return false;
 
        idle   = now->GetUserStack();
        active = next->GetUserStack();
 
        // if stack memory is exceeded these assertions will be hit
        if (now->IsBusy())
        {
            // current task could exit, thus we check it with IsBusy to avoid referencing nullptr returned by GetUserTask()
            STK_ASSERT(now->GetUserTask()->GetStack()[0] == STK_STACK_MEMORY_FILLER);
        }
        STK_ASSERT(next->GetUserTask()->GetStack()[0] == STK_STACK_MEMORY_FILLER);
 
        m_task_now = next;
 
        if ((IsHrtMode()))
        {
            if (now->m_hrt[0].done)
            {
                now->HrtOnSwitchedOut(&m_platform);
                next->HrtOnSwitchedIn();
            }
        }
 
    #if STK_SEGGER_SYSVIEW
        SEGGER_SYSVIEW_OnTaskStopReady(now->GetUserStack()->tid, TRACE_EVENT_SWITCH);
        SEGGER_SYSVIEW_OnTaskStartReady(next->GetUserStack()->tid);
    #endif
 
        return true; // switch context
    }

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::HrtInfo::done, stk::IStackMemory::GetStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetUserStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetUserTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::HrtOnSwitchedIn(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::HrtOnSwitchedOut(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::IsBusy(), IsHrtMode(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_hrt, m_platform, m_task_now, STK_ASSERT, STK_STACK_MEMORY_FILLER, and stk::TRACE_EVENT_SWITCH.

Referenced by UpdateFsmState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StateWake()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::StateWake	(	KernelTask *	now,
		KernelTask *	next,
		Stack *&	idle,
		Stack *&	active )

inlineprotected

Wakes up after sleeping.

Note: FSM state: stk::FSM_STATE_WAKING.

Parameters

[in]	now	Currently active kernel task (ignored).
[in]	next	Next kernel task.
[out]	idle	Stack of the task which must enter Idle state.
[out]	active	Stack of the task which must enter Active state (to which context will switch).

Definition at line 1794 of file stk.h.

    {
        (void)now;
 
        STK_ASSERT(next != nullptr);
 
        idle   = &m_sleep_trap[0].stack;
        active = next->GetUserStack();
 
        // if stack memory is exceeded these assertions will be hit
        STK_ASSERT(m_sleep_trap[0].memory[0] == STK_STACK_MEMORY_FILLER);
        STK_ASSERT(next->GetUserTask()->GetStack()[0] == STK_STACK_MEMORY_FILLER);
 
        m_task_now = next;
 
    #if STK_SEGGER_SYSVIEW
        SEGGER_SYSVIEW_OnTaskStartReady(next->GetUserStack()->tid);
    #endif
 
        if ((IsHrtMode()))
            next->HrtOnSwitchedIn();
 
        return true; // switch context
    }

References stk::IStackMemory::GetStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetUserStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetUserTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::HrtOnSwitchedIn(), IsHrtMode(), m_sleep_trap, m_task_now, STK_ASSERT, and STK_STACK_MEMORY_FILLER.

Referenced by UpdateFsmState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateFsmState()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::UpdateFsmState	(	Stack *&	idle,
		Stack *&	active )

inlineprotected

Update FSM state.

Parameters

[out]	idle	Stack of the task which must enter Idle state.
[out]	active	Stack of the task which must enter Active state (to which context will switch).

Returns: FSM state.

Definition at line 1708 of file stk.h.

    {
        KernelTask *now = m_task_now, *next = nullptr;
        bool switch_context = false;
 
        EFsmState new_state = GetNewFsmState(next);
 
        switch (new_state)
        {
        case FSM_STATE_SWITCHING:
            switch_context = StateSwitch(now, next, idle, active);
            break;
        case FSM_STATE_SLEEPING:
            switch_context = StateSleep(now, next, idle, active);
            break;
        case FSM_STATE_WAKING:
            switch_context = StateWake(now, next, idle, active);
            break;
        case FSM_STATE_EXITING:
            switch_context = StateExit(now, next, idle, active);
            break;
        case FSM_STATE_NONE:
            return switch_context; // valid intermittent non-persisting state: no-transition
        case FSM_STATE_MAX:
        default:                   // invalid state value
            STK_KERNEL_PANIC(KERNEL_PANIC_BAD_STATE);
            break;
        }
 
        m_fsm_state = new_state;
        return switch_context;
    }

References FSM_STATE_EXITING, FSM_STATE_MAX, FSM_STATE_NONE, FSM_STATE_SLEEPING, FSM_STATE_SWITCHING, FSM_STATE_WAKING, GetNewFsmState(), stk::KERNEL_PANIC_BAD_STATE, m_fsm_state, m_task_now, StateExit(), StateSleep(), StateSwitch(), StateWake(), and STK_KERNEL_PANIC.

Referenced by stk::test::KernelMock< TMode, TSize, TStrategy, TPlatform >::ForceUpdateInvalidFsmState(), and OnTick().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateSyncObjects()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::UpdateSyncObjects ( const Timeout elapsed_ticks )

inlineprotected

Update synchronization objects.

Definition at line 1600 of file stk.h.

    {
        STK_ASSERT(IsSyncMode());
 
        ISyncObject::ListEntryType *itr = m_sync_list->GetFirst();
 
        while (itr != nullptr)
        {
            ISyncObject::ListEntryType *next = itr->GetNext();
 
            // MISRA 5-2-3 deviation: GetNext/GetFirst returns ISyncObject*, all objects in
            // m_sync_list are ISyncObject instances - downcast is guaranteed safe.
            if (!static_cast<ISyncObject *>(itr)->Tick(elapsed_ticks))
                m_sync_list->Unlink(itr);
 
            itr = next;
        }
    }

References stk::util::DListEntry< T, _ClosedLoop >::GetNext(), IsSyncMode(), m_sync_list, and STK_ASSERT.

Referenced by UpdateTasks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateTaskRequest()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::UpdateTaskRequest ( )

inlineprotected

Update pending task requests.

Definition at line 1621 of file stk.h.

    {
        if (m_request == REQUEST_NONE)
            return;
 
        // process AddTask requests coming from tasks (KERNEL_DYNAMIC mode only, KERNEL_HRT is
        // excluded as we assume that HRT tasks must be known to the kernel before a Start())
        if (IsDynamicMode() && !IsHrtMode())
        {
            // process serialized AddTask request made from another active task, requesting process
            // is currently waiting due to SwitchToNext()
            if ((m_request & REQUEST_ADD_TASK) != 0U)
            {
                m_request &= ~REQUEST_ADD_TASK;
 
                for (uint32_t i = 0; i < TASKS_MAX; ++i)
                {
                    KernelTask *task = &m_task_storage[i];
 
                    if (task->m_srt[0].add_task_req != nullptr)
                    {
                        AllocateAndAddNewTask(task->m_srt[0].add_task_req->user_task);
 
                        task->m_srt[0].add_task_req = nullptr;
                        __stk_full_memfence();
                    }
                }
            }
        }
    }

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::SrtInfo::add_task_req, AllocateAndAddNewTask(), IsDynamicMode(), IsHrtMode(), m_request, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_srt, m_task_storage, REQUEST_ADD_TASK, REQUEST_NONE, TASKS_MAX, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::AddTaskRequest::user_task.

Referenced by UpdateTasks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateTasks()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

Timeout stk::Kernel< TMode, TSize, TStrategy, TPlatform >::UpdateTasks ( const Timeout elapsed_ticks )

inlineprotected

Update tasks (sleep, requests).

Definition at line 1470 of file stk.h.

    {
        // sync objects are updated before UpdateTaskRequest which may add a new object (newly added object must become 1 tick older)
        if (IsSyncMode())
            UpdateSyncObjects(elapsed_ticks);
 
        UpdateTaskRequest();
 
        return UpdateTaskState(elapsed_ticks);
    }

References IsSyncMode(), UpdateSyncObjects(), UpdateTaskRequest(), and UpdateTaskState().

Referenced by OnTick().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateTaskState()

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

Timeout stk::Kernel< TMode, TSize, TStrategy, TPlatform >::UpdateTaskState ( const Timeout elapsed_ticks )

inlineprotected

Update task state: process removals, advance sleep timers, and track HRT durations.

Parameters

[in] elapsed_ticks Number of ticks elapsed since the previous call. Always 1 in non-tickless mode, may be >1 in tickless mode.

Returns: In non-tickless mode: always 1. In tickless mode (KERNEL_TICKLESS): the minimum remaining sleep ticks across all active tasks, clamped to [1, STK_TICKLESS_TICKS_MAX]. The platform driver uses this value to program the next timer wakeup interval, suppressing timer/tick ISR for that many ticks when the system would otherwise be idle.

Definition at line 1490 of file stk.h.

    {
        Timeout sleep_ticks = (IsTicklessMode() ? STK_TICKLESS_TICKS_MAX : 1);
 
        for (uint32_t i = 0; i < TASKS_MAX; ++i)
        {
            KernelTask *task = &m_task_storage[i];
 
            if (task->IsSleeping())
            {
                if (IsDynamicMode())
                {
                    // task is pending removal, wait until it is switched out
                    if (task->IsPendingRemoval())
                    {
                        if ((task != m_task_now) ||
                            ((m_strategy.GetSize() == 1) && (m_fsm_state == FSM_STATE_SLEEPING)))
                        {
                            RemoveTask(task);
                            continue;
                        }
                    }
                }
 
                // deliver sleep event to strategy
                // note: only currently scheduled task can be pending to sleep
                if (TStrategy::SLEEP_EVENT_API)
                {
                    if ((task->m_state & KernelTask::STATE_SLEEP_PENDING) != 0U)
                    {
                        task->m_state &= ~KernelTask::STATE_SLEEP_PENDING;
 
                        // notify strategy that task is sleeping
                        m_strategy.OnTaskSleep(task);
                    }
                }
 
                // advance sleep time by a tick
                task->m_time_sleep += elapsed_ticks;
 
                // deliver sleep event to strategy
                if (TStrategy::SLEEP_EVENT_API)
                {
                    // notify strategy that task woke up
                    if (task->m_time_sleep >= 0)
                        m_strategy.OnTaskWake(task);
                }
            }
            else
            if (IsHrtMode())
            {
                // in HRT mode we trace how long task spent in active state (doing some work)
                if (task->IsBusy())
                {
                    task->m_hrt[0].duration += elapsed_ticks;
 
                    // check if deadline is missed (HRT failure)
                    if (task->HrtIsDeadlineMissed(task->m_hrt[0].duration))
                    {
                        bool can_recover = false;
 
                        // report deadline overrun to a strategy which supports overrun recovery
                        if (TStrategy::DEADLINE_MISSED_API)
                            can_recover = m_strategy.OnTaskDeadlineMissed(task);
 
                        // report failure if it could not be recovered by a scheduling strategy
                        if (!can_recover)
                            task->HrtHardFailDeadline(&m_platform);
                    }
                }
            }
 
            // get the number ticks the driver has to keep CPU in Idle
            if (IsTicklessMode() && (sleep_ticks > 1) && task->IsBusy())
            {
                // note: task sleep time is negative
                Timeout task_sleep = stk::Max<Timeout>(0, -task->m_time_sleep);
 
                if (IsSyncMode())
                {
                    // likely task is sleeping during sync operation (see Wait)
                    if (task->m_wait_obj->IsWaiting())
                    {
                        // note: sync wait time is positive
                        task_sleep = task->m_wait_obj->m_time_wait;
 
                        // we shall account for only valid time (when task is waiting during sync operation)
                        if (task_sleep > 0)
                            sleep_ticks = stk::Min(sleep_ticks, task_sleep);
                    }
                    else
                    {
                        sleep_ticks = stk::Min(sleep_ticks, task_sleep);
                    }
                }
                else
                {
                    sleep_ticks = stk::Min(sleep_ticks, task_sleep);
                }
 
                // clamp to [1, STK_TICKLESS_TICKS_MAX] range
                sleep_ticks = stk::Max<Timeout>(sleep_ticks, 1);
            }
        }
 
        return sleep_ticks;
    }

Referenced by UpdateTasks().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ m_exit_trap

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

ExitTrapStack stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_exit_trap[((((TMode) &(KERNEL_DYNAMIC)) !=0U) ?(1) :(0))]

protected

Exit trap: zero-size in KERNEL_STATIC mode; one entry in KERNEL_DYNAMIC mode.

Definition at line 1996 of file stk.h.

Referenced by Initialize(), InitTraps(), Kernel(), and StateExit().

◆ m_fsm

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

const EFsmState stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_fsm[FSM_STATE_MAX][FSM_EVENT_MAX]

protected

Initial value:

= {
    
        { FSM_STATE_SWITCHING, FSM_STATE_SLEEPING, FSM_STATE_NONE,   FSM_STATE_EXITING }, 
        { FSM_STATE_NONE,      FSM_STATE_NONE,     FSM_STATE_WAKING, FSM_STATE_EXITING }, 
        { FSM_STATE_SWITCHING, FSM_STATE_SLEEPING, FSM_STATE_NONE,   FSM_STATE_EXITING }, 
        { FSM_STATE_NONE,      FSM_STATE_NONE,     FSM_STATE_NONE,   FSM_STATE_NONE    }  
    }

Compile-time FSM transition table. Indexed as m_fsm[current_state][event] -> next_state. FSM_STATE_NONE as a next-state means "no transition": the FSM stays in the current state. Updated by UpdateFsmState() each tick via GetNewFsmState() -> FetchNextEvent().

Definition at line 2002 of file stk.h.

                                                           {
    //    FSM_EVENT_SWITCH     FSM_EVENT_SLEEP     FSM_EVENT_WAKE    FSM_EVENT_EXIT
        { FSM_STATE_SWITCHING, FSM_STATE_SLEEPING, FSM_STATE_NONE,   FSM_STATE_EXITING }, // FSM_STATE_SWITCHING
        { FSM_STATE_NONE,      FSM_STATE_NONE,     FSM_STATE_WAKING, FSM_STATE_EXITING }, // FSM_STATE_SLEEPING
        { FSM_STATE_SWITCHING, FSM_STATE_SLEEPING, FSM_STATE_NONE,   FSM_STATE_EXITING }, // FSM_STATE_WAKING
        { FSM_STATE_NONE,      FSM_STATE_NONE,     FSM_STATE_NONE,   FSM_STATE_NONE    }  // FSM_STATE_EXITING
    }; 

Referenced by GetNewFsmState().

◆ m_fsm_state

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

EFsmState stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_fsm_state

protected

Current FSM state. Drives context-switch decision on every tick.

Definition at line 1997 of file stk.h.

Referenced by FetchNextEvent(), GetNewFsmState(), Initialize(), Kernel(), OnStart(), OnStop(), UpdateFsmState(), and UpdateTaskState().

◆ m_platform

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

TPlatform stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_platform

protected

Platform driver (SysTick, PendSV, context switch implementation).

Definition at line 1991 of file stk.h.

Referenced by AllocateNewTask(), GetPlatform(), Initialize(), InitTraps(), Kernel(), RequestAddTask(), Start(), StateExit(), StateSleep(), StateSwitch(), and UpdateTaskState().

◆ m_request

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

volatile uint8_t stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_request

protected

Bitmask of pending ERequest flags from running tasks. Written by tasks, read/cleared by UpdateTaskRequest() in tick context.

Definition at line 1998 of file stk.h.

Referenced by Initialize(), Kernel(), ScheduleAddTask(), and UpdateTaskRequest().

◆ m_service

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

KernelService stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_service

protected

Kernel service singleton exposed to running tasks via IKernelService::GetInstance().

Definition at line 1990 of file stk.h.

Referenced by Initialize(), OnTaskSleepUntil(), OnTick(), and RequestAddTask().

◆ m_sleep_trap

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

SleepTrapStack stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_sleep_trap[1]

protected

Sleep trap (always present): executed when all tasks are sleeping.

Definition at line 1995 of file stk.h.

Referenced by InitTraps(), Kernel(), OnStart(), StateSleep(), and StateWake().

◆ m_state

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

volatile EState stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_state

protected

Current kernel state.

Definition at line 1999 of file stk.h.

Referenced by GetState(), Initialize(), IsInitialized(), Kernel(), OnStart(), and OnStop().

◆ m_strategy

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

TStrategy stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_strategy

protected

Task-switching strategy (determines which task runs next).

Definition at line 1992 of file stk.h.

Referenced by AddKernelTask(), FetchNextEvent(), GetSwitchStrategy(), Kernel(), OnStart(), RemoveTask(), StateSleep(), and UpdateTaskState().

◆ m_sync_list

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

SyncObjectList stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_sync_list[((((TMode) &(KERNEL_SYNC)) !=0U) ?(1) :(0))]

protected

List of active sync objects. Zero-size (no memory) if KERNEL_SYNC is not set.

Definition at line 2000 of file stk.h.

Referenced by OnTaskWait(), and UpdateSyncObjects().

◆ m_task_now

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

KernelTask* stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_task_now

protected

Currently executing task, or nullptr before Start() or after all tasks exit.

Definition at line 1993 of file stk.h.

Referenced by FindTaskBySP(), stk::test::KernelMock< TMode, TSize, TStrategy, TPlatform >::ForceUpdateInvalidFsmState(), Initialize(), IsStarted(), Kernel(), OnStart(), StateExit(), StateSleep(), StateSwitch(), StateWake(), UpdateFsmState(), and UpdateTaskState().

◆ m_task_storage

template<uint8_t TMode, uint32_t TSize, class TStrategy, class TPlatform>

TaskStorageType stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_task_storage

protected

Static pool of TSize KernelTask slots (free slots have m_user == nullptr).

Definition at line 1994 of file stk.h.

Referenced by AllocateNewTask(), FindTaskBySP(), FindTaskByStack(), FindTaskByUserTask(), Kernel(), OnStart(), Start(), UpdateTaskRequest(), and UpdateTaskState().

The documentation for this class was generated from the following file:

stk.h

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ ExitTrapStackMemory

◆ SleepTrapStackMemory

◆ SyncObjectList

◆ TaskStorageType

Member Enumeration Documentation

◆ EConsts

◆ EFsmEvent

◆ EFsmState

◆ ERequest

◆ EState

Constructor & Destructor Documentation

◆ Kernel()

◆ ~Kernel()

Member Function Documentation

◆ AddKernelTask()

◆ AddTask() [1/2]

◆ AddTask() [2/2]

◆ AllocateAndAddNewTask()

◆ AllocateNewTask()

◆ FetchNextEvent()

◆ FindTaskBySP()

◆ FindTaskByStack()

◆ FindTaskByUserTask()

◆ GetNewFsmState()

◆ GetPlatform()

◆ GetState()

◆ GetSwitchStrategy()

◆ HrtAllocateAndAddNewTask()

◆ Initialize()

◆ InitTraps()

◆ IsDynamicMode()

◆ IsHrtMode()

◆ IsInitialized()

◆ IsStarted()

◆ IsStaticMode()

◆ IsSyncMode()

◆ IsTicklessMode()

◆ IsValidFsmState()

◆ OnGetTid()

◆ OnStart()

◆ OnStop()

◆ OnTaskExit()

◆ OnTaskSleep()

◆ OnTaskSleepUntil()

◆ OnTaskSwitch()

◆ OnTaskWait()

◆ OnTick()

◆ RemoveTask() [1/2]

◆ RemoveTask() [2/2]

◆ RequestAddTask()

◆ ScheduleAddTask()

◆ Start()

◆ StateExit()

◆ StateSleep()

◆ StateSwitch()

◆ StateWake()

◆ UpdateFsmState()

◆ UpdateSyncObjects()

◆ UpdateTaskRequest()

◆ UpdateTasks()

◆ UpdateTaskState()

Member Data Documentation

◆ m_exit_trap

◆ m_fsm

◆ m_fsm_state

◆ m_platform

◆ m_request

◆ m_service

◆ m_sleep_trap

◆ m_state

◆ m_strategy