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	EKernelState : uint8_t { KSTATE_INACTIVE = 0 , KSTATE_READY , KSTATE_RUNNING , KSTATE_SUSPENDED }
	Kernel state. More...

Public Member Functions
	Kernel ()
	Construct the kernel with all storage zero-initialized, m_request cleared to REQ_NONE, and m_kstate set to KSTATE_INACTIVE (indicating uninitialized state; advanced to KSTATE_READY by Initialize()).
	~Kernel ()=default
	Destructor.
void	Initialize (uint32_t resolution_us=PERIODICITY_DEFAULT) override
	Initialize kernel.
void	AddTask (ITask *user_task) override
	Register task for a soft real-time (SRT) scheduling.
void	AddTask (ITask *user_task, Timeout periodicity_tc, Timeout deadline_tc, Timeout start_delay_tc) override
	Register a task for hard real-time (HRT) scheduling.
void	RemoveTask (ITask *user_task) override
	Remove a previously added task from the kernel when it is not started.
void	ScheduleTaskRemoval (ITask *user_task) override
	Schedule task removal from scheduling (exit).
void	SuspendTask (ITask *user_task, bool &suspended) override
	Suspend task.
void	ResumeTask (ITask *user_task) override
	Resume task.
void	CancelTaskWait (ITask *user_task) override
	Cancel task's in-progress wait on a synchronization object.
bool	GetTaskState (ITask *user_task, TaskStateInfo &info) const override
	Get a snapshot of the kernel-side state of a task.
size_t	EnumerateKernelTasks (ArrayView< IKernelTask * > tasks) override
	Enumerate kernel tasks.
size_t	EnumerateTasks (ArrayView< ITask * > user_tasks) override
	Enumerate user tasks.
void	Start () override
	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 () override
	Get platform driver instance owned by this kernel.
ITaskSwitchStrategy *	GetSwitchStrategy () override
	Get task-switching strategy instance owned by this kernel.
EKernelState	GetState () const override
	Get kernel state.
template<size_t TMaxCount, typename TCallback>
size_t	EnumerateTasksT (TCallback &&callback)
	Enumerate tasks, invoking a callback for each active task.

Static Public Attributes
static constexpr size_t	TASKS_MAX = TSize
	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.

Protected Types
enum	ERequest : uint8_t { REQ_NONE = 0 , REQ_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<((32U))>	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 *const user_task)
	Request to add new task.
KernelTask *	FindTaskByUserTask (const ITask *user_task)
	Find kernel task by the bound ITask instance (Non-const version).
const KernelTask *	FindTaskByUserTask (const ITask *user_task) const
	Find kernel task by the bound ITask instance (Const version).
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) override
	Called by platform driver immediately after a scheduler start (first tick).
void	OnStop () override
	Called by the platform driver after a scheduler stop (all tasks have exited).
bool	OnTick (Stack &idle, Stack &active, Timeout &ticks) override
	Process one scheduler tick. Called from the platform timer/tick ISR.
bool	OnForceContextSwitch (TId id, Stack &idle, Stack &active)
	Called when task state change forces a context switch (Sleep, SleepUntil, Wait).
void	OnTaskSwitch (Word caller_SP) override
	Called by Thread process (via IKernelService::SwitchToNext) to switch to a next task.
void	OnTaskSleep (Word caller_SP, Timeout ticks) override
	Called by Thread process (via IKernelService::Sleep) for exclusion of the calling process from scheduling (sleeping).
bool	OnTaskSleepUntil (Word caller_SP, Ticks timestamp) override
	Called by Thread process (via IKernelService::SleepUntil) for exclusion of the calling process from scheduling (sleeping).
void	OnTaskExit (Stack *stack) override
	Called from the Thread process when task finished (its Run function exited by return).
EWaitResult	OnTaskWait (Word caller_SP, ISyncObject sync_obj, IMutex mutex, Timeout timeout) override
	Called from the Thread process when task needs to wait.
TId	OnGetTid (Word caller_SP) override
	Called from the Thread process when for getting task/thread id of the process.
void	OnSuspend (bool suspended) override
	Called from the Thread process to suspend scheduling.
void	OnInheritWeight (TId tid, Weight weight)
Weight	OnSetWeight (TId tid, Weight weight)
Timeout	OnSetTimeSlice (TId tid, Timeout ticks)
void	UpdateTimeslice (const Timeout elapsed_ticks)
	Charge the running task and rotate it behind its same-priority peers when its slice expires.
void	OnRestoreWeight (TId tid, ISyncObject *sobj)
Timeout	UpdateTasks (const Timeout elapsed_ticks)
	Update tasks (sleep, requests).
void	ProcessTaskPendingSleep (KernelTask *const task)
void	ProcessTaskPendingYield (KernelTask *const task)
Timeout	UpdateTaskState (const Timeout elapsed_ticks)
	Update task state: process removals, deliver sleep/wake notifications, 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.
template<typename TaskPtr, typename Storage>
static TaskPtr	FindTaskByUserTaskImpl (const ITask *user_task, Storage &task_storage)
static constexpr bool	IsStaticMode ()
static constexpr bool	IsDynamicMode ()
static constexpr bool	IsHrtMode ()
static constexpr bool	IsSyncMode ()
static constexpr bool	IsTicklessMode ()
static constexpr bool	IsTimesliceMode ()
static constexpr bool	IsTelemetryMode ()

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 [STK_ALLOCATE_COUNT< TMode, KERNEL_DYNAMIC, 1U, 0U >::Value]
	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 EKernelState	m_kstate
	Current kernel state.
SyncObjectList	m_sync_list [STK_ALLOCATE_COUNT< TMode, KERNEL_SYNC, 1U, 0U >::Value]
	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]

Static Protected Attributes
static constexpr Timeout	YIELD_TICKS = 1
	Ticks to yield.

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_TIMESLICE - enables time-slicing: a running task is rotated behind its same-priority peers when its quantum (ITask::GetTimeSlice, IKernelService::SetTimeSlice) expires. Requires a strategy with TIMESLICE_API == 1 (e.g. SwitchStrategyPT32_TS), incompatible with KERNEL_HRT (TIMESLICE_HRT_CONFLICT).

KERNEL_TELEMETRY - enables introspection functions for diagnostics / telemetry (IKernel::GetTaskState). Without it these functions are compiled out and report failure. Combines with any other mode. KERNEL_STATIC and KERNEL_DYNAMIC are mutually exclusive.

Template Parameters

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 95 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 112 of file stk.h.

◆ SleepTrapStackMemory

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

typedef StackMemoryWrapper< ( (32U) )> 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 106 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 3238 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 3200 of file stk.h.

Member Enumeration Documentation

◆ 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 1828 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 1814 of file stk.h.

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

◆ EKernelState

enum stk::IKernel::EKernelState : uint8_t

inherited

Kernel state.

Enumerator
KSTATE_INACTIVE	Not ready, IKernel::Initialize() must be called.
KSTATE_READY	Ready to start, IKernel::Start() must be called.
KSTATE_RUNNING	Initialized and running, IKernel::Start() was called successfully.
KSTATE_SUSPENDED	Scheduling is suspended with IKernelService::Suspend().

Definition at line 1529 of file stk_common.h.

    {
        KSTATE_INACTIVE = 0, 
        KSTATE_READY,        
        KSTATE_RUNNING,      
        KSTATE_SUSPENDED     
    };

◆ 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
REQ_NONE	No pending requests.
REQ_ADD_TASK	An AddTask() request is pending from a running task (KERNEL_DYNAMIC only).

Definition at line 118 of file stk.h.

    {
        REQ_NONE     = 0,       
        REQ_ADD_TASK = (1 << 0) 
    };

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-initialized, m_request cleared to REQ_NONE, and m_kstate set to KSTATE_INACTIVE (indicating uninitialized state; advanced to KSTATE_READY 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 1305 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(REQ_NONE), m_kstate(KSTATE_INACTIVE)
    {
    #ifdef _DEBUG
        // TPlatform must inherit IPlatform
        IPlatform *platform = &m_platform;
        STK_UNUSED(platform);
 
        // TStrategy must inherit ITaskSwitchStrategy
        ITaskSwitchStrategy *strategy = &m_strategy;
        STK_UNUSED(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
    }

◆ ~Kernel()

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

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

default

Destructor.

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

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 1928 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::AllocateAndAddNewTask(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::HrtAllocateAndAddNewTask().

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 )

inlineoverridevirtual

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 1375 of file stk.h.

    {
        if __stk_constexpr_cpp17 (!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 __stk_constexpr_cpp17 (IsDynamicMode())
                {
                    RequestAddTask(user_task);
                }
                else
                {
                    STK_ASSERT(false);
                }
            }
            else
            {
                AllocateAndAddNewTask(user_task);
            }
        }
        else
        {
            STK_ASSERT(false);
        }
    }

◆ 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 )

inlineoverridevirtual

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 1414 of file stk.h.

    {
        if __stk_constexpr_cpp17 (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);
        }
    }

◆ 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.

Definition at line 1945 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::AddTask(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::UpdateTaskRequest().

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 1888 of file stk.h.

    {
        // look for a free kernel task
        KernelTask *new_task = nullptr;
        for (size_t i = 0U; i < TASKS_MAX; ++i)
        {
            KernelTask *const 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
            }
            else
            {
                // noop, continue to the next slot
            }
        }
 
        // 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;
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::AllocateAndAddNewTask(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::HrtAllocateAndAddNewTask().

Here is the caller graph for this function:

◆ CancelTaskWait()

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

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

inlineoverridevirtual

Cancel task's in-progress wait on a synchronization object.

Parameters

[in] user_task Pointer to the user task whose wait should be cancelled.

Implements stk::IKernel.

Definition at line 1579 of file stk.h.

    {
        STK_ASSERT(user_task != nullptr);
 
        KernelTask *const task = FindTaskByUserTask(user_task);
        if (task != nullptr)
        {
            // critical section: avoid race with OnTick
 
            const hw::CriticalSection::ScopedLock cs_;
 
            bool canceled_wait = false;
 
            if __stk_constexpr_cpp17 (IsSyncMode())
            {
                // a task blocked in OnTaskWait() also counts as sleeping (ScheduleSleep(WAIT_INFINITE)), but
                // its WaitObject is still linked into the sync object's wait list: waking only the task
                // would leave a stale entry behind (later signaled or ticked as a timeout while the task is
                // not waiting), so cancel the wait itself, this unlinks it, records WAIT_RESULT_CANCELED
                // and wakes the task
                canceled_wait = task->m_wait_obj[0].CancelIfWaiting();
            }
 
            if (!canceled_wait && task->IsSleeping())
            {
                task->Wake();
            }
        }
    }

◆ EnumerateKernelTasks()

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

size_t stk::Kernel< TMode, TSize, TStrategy, TPlatform >::EnumerateKernelTasks ( ArrayView< IKernelTask * > tasks )

inlineoverridevirtual

Enumerate kernel tasks.

Parameters

[in] tasks Reference to the ArrayView of IKernelTask pointers.

Returns: Number of tasks in the array.

Implements stk::IKernel.

Definition at line 1699 of file stk.h.

   {
       size_t count = 0U;
       const size_t limit = Min(tasks.GetSize(), TASKS_MAX);
 
       // critical section: avoid race with OnTick
       {
           const hw::CriticalSection::ScopedLock cs_;
 
           for (size_t i = 0U; i < limit; ++i)
           {
               KernelTask &task = m_task_storage[i];
               if (task.IsBusy())
               {
                    tasks[count++] = &task;
               }
           }
       }
 
       return count;
   }

◆ EnumerateTasks()

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

size_t stk::Kernel< TMode, TSize, TStrategy, TPlatform >::EnumerateTasks ( ArrayView< ITask * > user_tasks )

inlineoverridevirtual

Enumerate user tasks.

Parameters

[in] user_tasks Reference to the ArrayView of ITask pointers.

Returns: Number of tasks in the array.

Implements stk::IKernel.

Definition at line 1725 of file stk.h.

    {
        size_t count = 0U;
        const size_t limit = Min(user_tasks.GetSize(), TASKS_MAX);
 
        // critical section: avoid race with OnTick
        {
            const hw::CriticalSection::ScopedLock cs_;
 
            for (size_t i = 0U; i < limit; ++i)
            {
                KernelTask &task = m_task_storage[i];
                if (task.IsBusy())
                {
                    user_tasks[count++] = task.GetUserTask();
                }
            }
        }
 
        return count;
    }

◆ EnumerateTasksT()

template<size_t TMaxCount, typename TCallback>

size_t stk::IKernel::EnumerateTasksT ( TCallback && callback )

inlineinherited

Enumerate tasks, invoking a callback for each active task.

Template Parameters

TMaxCount	Maximum number of tasks to enumerate. Should match or exceed the kernel's task capacity. Determines the size of the internal stack-allocated buffer (TMaxCount * sizeof(ITask*) bytes on the stack).
TCallback	Callable type, deduced automatically. Must satisfy: bool(ITask*)

Parameters

[in] callback Callable invoked for each active task. Return true to continue, false to stop early.

Returns: Number of tasks visited (up to TMaxCount).

Warning: ISR-safe.

Example:

kernel.EnumerateTasks<_STK_KERNEL_TASKS_COUNT>([](ITask *t) {
    Log(t->GetTraceName());
    return true; // continue
});

Definition at line 1674 of file stk_common.h.

    {
        STK_STATIC_ASSERT(TMaxCount > 0U);
 
        ITask *tasks[TMaxCount] = {};        
        size_t count = EnumerateTasks(ArrayView<ITask *>(tasks, TMaxCount));
        size_t i = 0U;
        bool fetch_next = true;
 
        while ((i < count) && fetch_next)
        {
            fetch_next = callback(tasks[i]);
            ++i;
        }
 
        return i;
    }

References EnumerateTasks(), and STK_STATIC_ASSERT.

Here is the call 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 2884 of file stk.h.

    {
        EFsmEvent type = FSM_EVENT_SLEEP;
 
        // try getting next task for scheduling
        next = util::DListCast::ListEntryToParent<KernelTask>(m_strategy.GetNext());
 
        // sleep-aware strategy returns nullptr if no active tasks available
        if (next != nullptr)
        {
            // strategy must provide active-only task
            STK_ASSERT(!next->IsSleeping());
 
            // if was sleeping, process wake event first
            type = (m_fsm_state == FSM_STATE_SLEEPING ? FSM_EVENT_WAKE : FSM_EVENT_SWITCH);
        }
        // start sleeping
        else
        {
            if __stk_constexpr_cpp17 (IsDynamicMode())
            {
                // if nullptr is returned then either strategy has all tasks sleeping or none left,
                // if KERNEL_DYNAMIC mode and no tasks left then exit from scheduling
                if (m_strategy.GetSize() == 0U)
                {
                    next = nullptr;
                    type = FSM_EVENT_EXIT;
                }
            }
        }
 
        return type;
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::GetNewFsmState().

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 2067 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnGetTid(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnTaskSleep(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnTaskSleepUntil(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnTaskSwitch(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnTaskWait(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::RequestAddTask().

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 2046 of file stk.h.

    {
        KernelTask *found_task = nullptr;
      
        for (size_t i = 0U; i < TASKS_MAX; ++i)
        {
            KernelTask *const task = &m_task_storage[i];
            if (task->GetUserStackPtr() == stack)
            {
                found_task = task;
                break;
            }
        }
 
        return found_task;
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnTaskExit().

Here is the caller graph for this function:

◆ FindTaskByUserTask() [1/2]

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 (Non-const version).

Parameters

[in] user_task User task.

Returns: Kernel task (mutable).

Definition at line 2028 of file stk.h.

    {
        return FindTaskByUserTaskImpl<KernelTask *>(user_task, m_task_storage);
    }

Here is the caller graph for this function:

◆ FindTaskByUserTask() [2/2]

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

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

inlineprotected

Find kernel task by the bound ITask instance (Const version).

Parameters

[in] user_task User task.

Returns: Kernel task (const).

Definition at line 2037 of file stk.h.

    {
        return FindTaskByUserTaskImpl<const KernelTask *>(user_task, m_task_storage);
    }

◆ FindTaskByUserTaskImpl()

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

template<typename TaskPtr, typename Storage>

TaskPtr stk::Kernel< TMode, TSize, TStrategy, TPlatform >::FindTaskByUserTaskImpl	(	const ITask *	user_task,
		Storage &	task_storage )

inlinestaticprotected

Definition at line 2006 of file stk.h.

    {
        TaskPtr found_task = nullptr;
 
        for (size_t i = 0U; i < TASKS_MAX; ++i)
        {
            TaskPtr const task = &task_storage[i];
 
            if (task->GetUserTask() == user_task)
            {
                found_task = task;
                break;
            }
        }
 
        return found_task;
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::FindTaskByUserTask(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::FindTaskByUserTask().

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 2925 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnStart(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::UpdateFsmState().

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 ( )

inlineoverridevirtual

Get platform driver instance owned by this kernel.

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

Implements stk::IKernel.

Definition at line 1790 of file stk.h.

1790{ return &m_platform; }

◆ GetState()

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

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

inlineoverridevirtual

Get kernel state.

Implements stk::IKernel.

Definition at line 1799 of file stk.h.

1799{ return m_kstate; }

◆ GetSwitchStrategy()

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

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

inlineoverridevirtual

Get task-switching strategy instance owned by this kernel.

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

Implements stk::IKernel.

Definition at line 1795 of file stk.h.

1795{ return &m_strategy; }

◆ GetTaskState()

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

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetTaskState	(	ITask *	user_task,
		TaskStateInfo &	info ) const

inlineoverridevirtual

Get a snapshot of the kernel-side state of a task.

Parameters

[in]	user_task	Pointer to the user task to query. Must not be `nullptr`.
[out]	info	Receives the snapshot. Written only if the function returns `true`.

Returns: true on success, false if user_task is nullptr or the kernel is built without KERNEL_TELEMETRY (info is left unchanged). See IKernel::GetTaskState().

Note: The order of the checks matters: SuspendTask() and OnTaskWait() both put the task to an infinite sleep (ScheduleSleep), so IsSleeping() is also true for suspended and blocked tasks.; KERNEL_TELEMETRY mode only.

Implements stk::IKernel.

Definition at line 1618 of file stk.h.

    {
        bool result;
 
        if (IsTelemetryMode())
        {
            if (user_task != nullptr)
            {
                info.state     = TASK_STATE_REMOVED;
                info.wait_obj  = nullptr;
                info.remaining = WAIT_INFINITE;
 
                // critical section: consistent view against OnTick
                const hw::CriticalSection::ScopedLock cs_;
 
                const KernelTask *const task = FindTaskByUserTask(user_task);
                if (task != nullptr)
                {
                    bool resolved = false;
 
                    if ((task->m_state & KernelTask::STATE_REMOVE_PENDING) != 0U)
                    {
                        info.state = TASK_STATE_EXITING;
                        resolved   = true;
                    }
                    else if ((task->m_state & KernelTask::STATE_SUSPENDED) != 0U)
                    {
                        info.state = TASK_STATE_SUSPENDED;
                        resolved   = true;
                    }
                    else
                    {
                        if __stk_constexpr_cpp17 (IsSyncMode())
                        {
                            const typename KernelTask::WaitObject &wait_obj = task->m_wait_obj[0];
 
                            if (wait_obj.IsWaiting())
                            {
                                info.state     = TASK_STATE_WAITING;
                                info.wait_obj  = wait_obj.m_sync_obj;
                                info.remaining = wait_obj.m_time_wait;
                                resolved       = true;
                            }
                        }
                    }
 
                    if (!resolved)
                    {
                        const Timeout time_sleep = task->m_time_sleep;
 
                        if (time_sleep < 0)
                        {
                            info.state     = TASK_STATE_SLEEPING;
                            info.remaining = -time_sleep; // -(-WAIT_INFINITE) == WAIT_INFINITE for an infinite sleep
                        }
                        else
                        {
                            info.state = TASK_STATE_READY;
                        }
                    }
                }
 
                result = true;
            }
            else
            {
                result = false;
            }
        }
        else
        {
            result = false;
        }
 
        return result;
    }

◆ 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).

Definition at line 1960 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::AddTask().

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 )

inlineoverridevirtual

Initialize kernel.

Parameters

[in] resolution_us Resolution of the system tick (SysTick) timer in microseconds. Defaults to PERIODICITY_DEFAULT (1000 µs = 1 ms).

Note: Must be called before AddTask() and Start().; If running on an STM32 device with HAL driver or on QEMU, do not change the default resolution (PERIODICITY_DEFAULT). STM32's HAL expects 1 millisecond resolution and QEMU does not have enough resolution on Windows to operate correctly at sub-millisecond resolution.; Kernel must be in KSTATE_INACTIVE state.

Implements stk::IKernel.

Definition at line 1338 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   = REQ_NONE;
        
        // exit trap is required only for KERNEL_DYNAMIC mode
        Stack *exit_trap;
        if __stk_constexpr_cpp17 (IsDynamicMode())
        {
            exit_trap = &m_exit_trap[0].stack;
        }
        else
        {
            exit_trap = nullptr;
        }
 
        m_service.Initialize(this);
        m_platform.Initialize(this, &m_service, resolution_us, exit_trap);
 
        // now ready to Start()
        m_kstate = KSTATE_READY;
    }

◆ 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 1854 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::Start().

Here is the caller graph for this function:

◆ IsDynamicMode()

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

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

inlinestaticconstexprprotected

Definition at line 3157 of file stk.h.

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

Here is the caller graph for this function:

◆ IsHrtMode()

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

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

inlinestaticconstexprprotected

Definition at line 3158 of file stk.h.

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

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 3118 of file stk.h.

3118{ return (m_kstate != KSTATE_INACTIVE); }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::AddTask(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::AddTask(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::Initialize(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::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 1782 of file stk.h.

    {
        return (m_task_now != nullptr);
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::AddKernelTask(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::AddTask(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::AddTask(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::RemoveTask(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::ScheduleTaskRemoval().

Here is the caller graph for this function:

◆ IsStaticMode()

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

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

inlinestaticconstexprprotected

Definition at line 3156 of file stk.h.

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

◆ IsSyncMode()

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

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

inlinestaticconstexprprotected

Definition at line 3159 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::CancelTaskWait(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetSleepTicks(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::GetTaskState(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::KernelTask(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnTaskWait(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::ScheduleRemoval(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::Unbind(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::UpdateTasks(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelService::Wait(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelService::Wake().

Here is the caller graph for this function:

◆ IsTelemetryMode()

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

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

inlinestaticconstexprprotected

Definition at line 3162 of file stk.h.

3162{ return ((TMode & KERNEL_TELEMETRY) != 0U); }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::GetTaskState().

Here is the caller graph for this function:

◆ IsTicklessMode()

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

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

inlinestaticconstexprprotected

Definition at line 3160 of file stk.h.

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

Referenced by stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelService::Resume(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelService::Suspend(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::UpdateTaskState().

Here is the caller graph for this function:

◆ IsTimesliceMode()

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

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

inlinestaticconstexprprotected

Definition at line 3161 of file stk.h.

3161{ return ((TMode & KERNEL_TIMESLICE) != 0U); }

Referenced by stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::Bind(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnTick(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::ScheduleSleep(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::ScheduleYield(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelService::SetTimeSlice(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::Unbind().

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 1847 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::GetNewFsmState().

Here is the caller graph for this function:

◆ OnForceContextSwitch()

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

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

inlineprotectedvirtual

Called when task state change forces a context switch (Sleep, SleepUntil, Wait).

Parameters

[in]	id	Task id causing this forced context switch.
[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: True if context switch is required, False otherwise.

Implements stk::IPlatform::IEventHandler.

Definition at line 2260 of file stk.h.

    {
        bool switch_context = false;
        KernelTask *const task = m_task_now;
 
        STK_ASSERT(task != nullptr);
 
        // note: called from inside ISR, therefore protection by critical section is not needed
 
        if (task->GetTid() == id)
        {
            // current task is busy-waiting to be de-scheduled
            if (task->IsSleeping())
            {
                if ((task->m_state & KernelTask::STATE_SLEEP_PENDING) != 0U)
                {
                    ProcessTaskPendingSleep(task);
 
                    switch_context = UpdateFsmState(idle, active);
                }
            }
            else
            {
                if __stk_constexpr_cpp17 (TStrategy::NOSLEEP_YIELD_API)
                {
                    // current task yielded and stays runnable: let the strategy pick the next task
                    if ((task->m_state & KernelTask::STATE_YIELD_PENDING) != 0U)
                    {
                        ProcessTaskPendingYield(task);
 
                        switch_context = UpdateFsmState(idle, active);
                    }
                }
            }
        }
 
        return switch_context;
    }

◆ OnGetTid()

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

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

inlineoverrideprotectedvirtual

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 (returns always valid TId belonging to a task).

Implements stk::IPlatform::IEventHandler.

Definition at line 2505 of file stk.h.

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

◆ OnInheritWeight()

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

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::OnInheritWeight	(	TId	tid,
		Weight	weight )

inlineprotected

Definition at line 2538 of file stk.h.

    {
        STK_ASSERT(tid != TID_NONE);
        STK_ASSERT(TStrategy::WEIGHT_API && TStrategy::PRIORITY_INHERITANCE_API);
 
        if (weight != NO_WEIGHT)
        {
            KernelTask *const task = FindTaskByUserTask(GetUserTaskFromTid(tid));
            STK_ASSERT(task != nullptr);
 
            const Weight prev_weight = task->GetWeight();
 
            if (prev_weight < weight)
            {
                task->SetCurrentWeight(weight);
                m_strategy.OnTaskWeightChange(task, prev_weight);
            }
        }
    }

◆ OnRestoreWeight()

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

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::OnRestoreWeight	(	TId	tid,
		ISyncObject *	sobj )

inlineprotected

Definition at line 2634 of file stk.h.

    {
        STK_ASSERT(tid != TID_NONE);
        STK_ASSERT(TStrategy::WEIGHT_API && TStrategy::PRIORITY_INHERITANCE_API);
 
        KernelTask *const task = FindTaskByUserTask(GetUserTaskFromTid(tid));
        STK_ASSERT(task != nullptr);
 
        const Weight prev_weight = task->GetWeight();
 
        // restore to original or boost from wait objects
        task->SetCurrentWeight(sobj != nullptr ? sobj->FindWeightHigherThan(task->GetWeight()) : NO_WEIGHT);
 
        m_strategy.OnTaskWeightChange(task, prev_weight);
    }

◆ OnSetTimeSlice()

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

Timeout stk::Kernel< TMode, TSize, TStrategy, TPlatform >::OnSetTimeSlice	(	TId	tid,
		Timeout	ticks )

inlineprotected

Definition at line 2585 of file stk.h.

    {
        STK_ASSERT(tid != TID_NONE);
        STK_ASSERT(ticks >= NO_TIME_SLICE);
 
        KernelTask *const task = FindTaskByUserTask(GetUserTaskFromTid(tid));
        STK_ASSERT(task != nullptr);
 
        typename KernelTask::TsInfo &ts = task->m_ts[0];
 
        const Timeout prev = ts.quantum;
 
        ts.quantum = ticks;
        ts.Reload();
 
        return prev;
    }

◆ OnSetWeight()

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

Weight stk::Kernel< TMode, TSize, TStrategy, TPlatform >::OnSetWeight	(	TId	tid,
		Weight	weight )

inlineprotected

Definition at line 2558 of file stk.h.

    {
        STK_ASSERT(tid != TID_NONE);
        STK_ASSERT(TStrategy::WEIGHT_API && TStrategy::PRIORITY_INHERITANCE_API);
        STK_ASSERT(weight != NO_WEIGHT);
 
        KernelTask *const task = FindTaskByUserTask(GetUserTaskFromTid(tid));
        STK_ASSERT(task != nullptr);
 
        const Weight prev_weight = task->GetWeight();     // effective weight (base or inherited)
        const Weight prev_base   = task->GetBaseWeight();
 
        task->SetBaseWeight(weight);
 
        // an inherited weight that does not exceed the new base weight is no longer a boost
        if ((task->GetCurrentWeight() != NO_WEIGHT) && (task->GetCurrentWeight() <= weight))
        {
            task->SetCurrentWeight(NO_WEIGHT);
        }
 
        // always notify: the strategy may depend on parts of the weight that do not change
        // the effective weight while a boost is active (e.g. preemption-threshold)
        m_strategy.OnTaskWeightChange(task, prev_weight);
 
        return prev_base;
    }

◆ OnStart()

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

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

inlineoverrideprotectedvirtual

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 KSTATE_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 2132 of file stk.h.

    {
        STK_ASSERT(m_strategy.GetSize() != 0);
 
        // iterate tasks and generate OnTaskSleep for a strategy for all initially sleeping tasks
        for (size_t i = 0U; i < TASKS_MAX; ++i)
        {
            KernelTask *const task = &m_task_storage[i];
 
            if ((task->m_state & KernelTask::STATE_SLEEP_PENDING) != 0U)
            {
                STK_ASSERT(task->IsSleeping());
 
                task->m_state &= ~KernelTask::STATE_SLEEP_PENDING;
 
                // notify strategy that task is sleeping
                if __stk_constexpr_cpp17 (TStrategy::SLEEP_EVENT_API)
                {
                    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->GetUserStackPtr();
 
                if __stk_constexpr_cpp17 (IsHrtMode())
                {
                    next->HrtOnSwitchedIn();
                }
            }
            else
            if (m_fsm_state == FSM_STATE_SLEEPING)
            {
                m_task_now = util::DListCast::ListEntryToParent<KernelTask>(m_strategy.GetFirst());
                active     = &m_sleep_trap[0].stack;
            }
            else
            {
                // unexpected state
                STK_KERNEL_PANIC(KERNEL_PANIC_BAD_STATE);
            }
        }
 
        // is in running state
        m_kstate = KSTATE_RUNNING;
    }

◆ OnStop()

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

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

inlineoverrideprotectedvirtual

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 KSTATE_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 2197 of file stk.h.

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

◆ OnSuspend()

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

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::OnSuspend ( bool suspended )

inlineoverrideprotectedvirtual

Called from the Thread process to suspend scheduling.

Parameters

[in] suspended true if scheduling was successfully suspended, false otherwise.

Implements stk::IPlatform::IEventHandler.

Definition at line 2513 of file stk.h.

    {
        // toggle kernel state
        if (suspended)
        {
            if (m_kstate == KSTATE_RUNNING) 
            {
                m_kstate = KSTATE_SUSPENDED;
            }
        }
        else
        {
            if (m_kstate == KSTATE_SUSPENDED) 
            {
                m_kstate = KSTATE_RUNNING;
            }
        }
 
        // force yield for a currently active task
        if (!m_task_now->IsSleeping())
        {
            m_task_now->ScheduleSleep(YIELD_TICKS);
        }
    }

◆ OnTaskExit()

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

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

inlineoverrideprotectedvirtual

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 2415 of file stk.h.

    {
        if __stk_constexpr_cpp17 (IsDynamicMode())
        {
            KernelTask *const task = FindTaskByStack(stack);
            STK_ASSERT(task != nullptr);
 
            // task is being stopped and will terminate
        #if STK_SEGGER_SYSVIEW
            SEGGER_SYSVIEW_OnTaskStopExec();
        #endif
 
            // critical section: avoid race with OnTick
            {
                // make change to HRT/sleep/removal state atomic (same as OnTaskSleep/OnTaskSleepUntil)
                const hw::CriticalSection::ScopedLock cs_;
 
                // notify kernel to execute removal (asynchronous operation)
                task->ScheduleRemoval(this);
            }
        }
        else
        {
            // kernel operating mode must be KERNEL_DYNAMIC for tasks to be able to exit
            STK_KERNEL_PANIC(KERNEL_PANIC_BAD_MODE);
        }
    }

◆ 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 )

inlineoverrideprotectedvirtual

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 2347 of file stk.h.

    {
        KernelTask *const task = FindTaskBySP(caller_SP);
        STK_ASSERT(task != nullptr);
 
        // // critical section: make change to HRT state and sleep time atomic
        {
            const hw::CriticalSection::ScopedLock cs_;
 
            if __stk_constexpr_cpp17 (IsHrtMode())
            {
                task->HrtOnWorkCompleted();
            }
 
            if (ticks > 0)
            {
                task->ScheduleSleep(ticks);
 
                // trace blocked on Sleep
            #if STK_SEGGER_SYSVIEW
                SEGGER_SYSVIEW_OnTaskStopReady(task->GetUserStackPtr()->tid, TRACE_EVENT_SLEEP);
            #endif
            }
        }
 
        // note: we do not spin long here, kernel will switch this task out from scheduling on the next tick
        task->BusyWaitWhileSleeping(this);
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnTaskSwitch().

Here is the caller graph for this function:

◆ OnTaskSleepUntil()

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

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

inlineoverrideprotectedvirtual

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).

Returns: True if sleep succeeded, false otherwise.

Implements stk::IPlatform::IEventHandler.

Definition at line 2376 of file stk.h.

    {
        KernelTask *const task = FindTaskBySP(caller_SP);
        STK_ASSERT(task != nullptr);
 
        bool result = true;
 
        // critical section: make change to HRT state and sleep time atomic
        {
            const hw::CriticalSection::ScopedLock cs_;
 
            // calculate signed delta (handles wrap-around correctly)
            const Ticks delta = timestamp - m_service.m_ticks;
 
            if (delta > 0)
            {
                const Ticks infinite_ticks = WAIT_INFINITE;              
                task->ScheduleSleep(static_cast<Timeout>(Min(delta, infinite_ticks)));
 
                // trace blocked on on SleepUntil
            #if STK_SEGGER_SYSVIEW
                SEGGER_SYSVIEW_OnTaskStopReady(task->GetUserStackPtr()->tid, TRACE_EVENT_SLEEP);
            #endif
            }
            else
            {
                result = false; // deadline already hit or passed
            }
        }
 
        // note: we do not spin long here, kernel will switch this task out from scheduling on the next tick
        if (result)
        {
            task->BusyWaitWhileSleeping(this);
        }
 
        return result;
    }

◆ OnTaskSwitch()

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

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

inlineoverrideprotectedvirtual

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 2299 of file stk.h.

    {
        // let the strategy handle the yield without putting the task to sleep (e.g. to hand
        // the CPU to same-priority peers only), not applicable in HRT mode where Yield()
        // means work completion
        if __stk_constexpr_cpp17 (TStrategy::NOSLEEP_YIELD_API && !IsHrtMode())
        {
            KernelTask *const task = FindTaskBySP(caller_SP);
            STK_ASSERT(task != nullptr);
 
            if (task != nullptr)
            {
                bool handled = false;
 
                // critical section: avoid race with OnTick
                {
                    const hw::CriticalSection::ScopedLock cs_;
 
                    if (!task->IsSleeping())
                    {
                        if (m_strategy.OnTaskYield(task))
                        {
                            task->ScheduleYield();
                            handled = true;
                        }
                    }
                }
 
                if (handled)
                {
                    task->BusyWaitWhileYielding(this);
                }
                else
                {
                    OnTaskSleep(caller_SP, YIELD_TICKS);
                }
            }
            else
            {
                // defensive: do nothing on null task
            }
        }
        else
        {
            OnTaskSleep(caller_SP, YIELD_TICKS);
        }
    }

◆ OnTaskWait()

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

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

inlineoverrideprotectedvirtual

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 2443 of file stk.h.

    {
        if __stk_constexpr_cpp17 (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 *const task = FindTaskBySP(caller_SP);
            STK_ASSERT(task != nullptr);
 
            typename KernelTask::WaitObject &wait_obj = task->m_wait_obj[0];
 
            // critical section: avoid race with OnTick
            {
                // keep the task from being de-scheduled between ScheduleSleep() and the end of mutex->Unlock():
                // otherwise a tick can switch it out (sleeping) while it still owns the mutex
                const hw::CriticalSection::ScopedLock cs_;
 
                // configure waiting
                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);
 
                // trace blocked on sync object's Wait
            #if STK_SEGGER_SYSVIEW
                SEGGER_SYSVIEW_OnTaskStopReady(task->GetUserStackPtr()->tid, TRACE_EVENT_WAIT);
            #endif
 
                // 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
            task->BusyWaitWhileSleeping(this);
 
            // extract & clear this wait's result BEFORE mutex->Lock(): a contended Lock() recurses
            // into OnTaskWait() and reuses this same per-task WaitObject, which would otherwise
            // silently overwrite/clear our still-unread result
            const EWaitResult result = wait_obj.GetWaitResult();
            wait_obj.ClearState();
 
            // re-lock mutex when returning to the task's execution space
            mutex->Lock();
 
            return result;
        }
        else
        {
            STK_ASSERT(false);
            return WAIT_RESULT_FAIL;
        }
    }

◆ OnTick()

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

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

inlineoverrideprotectedvirtual

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 2224 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
 
        // elapsed ticks must be captured here: in tickless mode "ticks" is overwritten below
        const Timeout elapsed_ticks = ticks;
 
        // advance internal timestamp
        m_service.IncrementTicks(elapsed_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
        STK_UNUSED(
    #endif
        UpdateTasks(elapsed_ticks));
 
        // time-slice accounting for the task that just ran (after sleep/wake updates, before the FSM picks next)
        if __stk_constexpr_cpp17 (IsTimesliceMode())
        {
            UpdateTimeslice(elapsed_ticks);
        }
 
        // decide on a context switch
        return UpdateFsmState(idle, active);
    }

◆ ProcessTaskPendingSleep()

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

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

inlineprotected

Definition at line 2668 of file stk.h.

    {
        task->m_state &= ~(KernelTask::STATE_SLEEP_PENDING | KernelTask::STATE_WAKE_PENDING);
 
        // notify strategy that task is sleeping
        if __stk_constexpr_cpp17 (TStrategy::SLEEP_EVENT_API)
        {
            m_strategy.OnTaskSleep(task);
        }
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnForceContextSwitch(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::ScheduleRemoval(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::UpdateTaskState().

Here is the caller graph for this function:

◆ ProcessTaskPendingYield()

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

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

inlineprotected

Definition at line 2679 of file stk.h.

    {
        task->m_state &= ~KernelTask::STATE_YIELD_PENDING;
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnForceContextSwitch().

Here is the caller 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 )

inlineoverridevirtual

Remove a previously added task from the kernel when it is not started.

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 1439 of file stk.h.

    {
        if __stk_constexpr_cpp17 (IsDynamicMode())
        {
            STK_ASSERT(user_task != nullptr);
            STK_ASSERT(!IsStarted());
 
            KernelTask *const 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);
        }
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::RemoveTask(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::UpdateTaskState().

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 2107 of file stk.h.

    {
        STK_ASSERT(task != nullptr);
 
    #if STK_SEGGER_SYSVIEW
        SEGGER_SYSVIEW_OnTaskTerminate(task->GetUserStackPtr()->tid);
    #endif
 
        // notify task about pending exit
        task->GetUserTask()->OnExit();
 
        m_strategy.RemoveTask(task);
        task->Unbind();
    }

◆ RequestAddTask()

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

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RequestAddTask ( ITask *const 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 1974 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::AddTask().

Here is the caller graph for this function:

◆ ResumeTask()

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

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

inlineoverridevirtual

Resume task.

Parameters

[in] user_task Pointer to the user task to resume.

Warning: Must not be called on a task blocked in OnTaskWait() on a sync object - asserts. Use CancelTaskWait() instead.

Implements stk::IKernel.

Definition at line 1551 of file stk.h.

    {
        STK_ASSERT(user_task != nullptr);
 
        // critical section: avoid race with OnTick
 
        const hw::CriticalSection::ScopedLock cs_;
 
        KernelTask *const task = FindTaskByUserTask(user_task);
        STK_ASSERT(task != nullptr);
 
        // must be suspended by SuspendTask, otherwise noop
        if ((task->m_state & KernelTask::STATE_SUSPENDED) != 0U)
        {
            // clear state
            task->m_state &= ~KernelTask::STATE_SUSPENDED;
 
            // wake up
            if (task->IsSleeping())
            {
                task->Wake();
            }
        }
    }

◆ 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 REQ_ADD_TASK bit in m_request under a hw::CriticalSection::ScopedLock, so the ISR-side tick handler observes the flag safely without a data race.

Definition at line 3124 of file stk.h.

    {
        // critical section: avoid race with OnTick
        {
            const hw::CriticalSection::ScopedLock cs_;
 
            m_request |= REQ_ADD_TASK;
        }
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::RequestAddTask().

Here is the caller graph for this function:

◆ ScheduleTaskRemoval()

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

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

inlineoverridevirtual

Schedule task removal from scheduling (exit).

Parameters

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

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 1464 of file stk.h.

    {
        if __stk_constexpr_cpp17 (IsDynamicMode())
        {
            STK_ASSERT(user_task != nullptr);
            STK_ASSERT(IsStarted());
 
            // critical section: avoid race with OnTick
 
            const hw::CriticalSection::ScopedLock cs_;
 
            KernelTask *const task = FindTaskByUserTask(user_task);
            if (task != nullptr)
            {
                task->ScheduleRemoval(this);
            }
        }
        else
        {
            // kernel operating mode must be KERNEL_DYNAMIC for tasks to be able to be removed
            STK_ASSERT(false);
        }
    }

◆ Start()

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

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

inlineoverridevirtual

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

Note: Re-initializes 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 1755 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 (size_t i = 0U; i < TASKS_MAX; ++i)
        {
            KernelTask *task = &m_task_storage[i];
            if (task->IsBusy())
            {
                SendTaskTraceInfo(task);
            }
        }
    #endif
 
        m_platform.Start();
    }

◆ 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 3089 of file stk.h.

    {
        STK_UNUSED(now);
        STK_UNUSED(next);
 
        if __stk_constexpr_cpp17 (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
        {
            STK_UNUSED(idle);
            STK_UNUSED(active);
        }
 
        return false;
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::UpdateFsmState().

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 3058 of file stk.h.

    {
        STK_UNUSED(next);
 
        STK_ASSERT(now != nullptr);
        STK_ASSERT(m_sleep_trap[0].stack.SP != 0);
 
        idle   = now->GetUserStackPtr();
        active = &m_sleep_trap[0].stack;
 
        m_task_now = util::DListCast::ListEntryToParent<KernelTask>(m_strategy.GetFirst());
 
        if __stk_constexpr_cpp17 (IsHrtMode())
        {
            if (!now->IsPendingRemoval())
            {
                now->HrtOnSwitchedOut();
            }
        }
 
        return true; // switch context
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::UpdateFsmState().

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 2979 of file stk.h.

    {
        STK_ASSERT(now != nullptr);
        STK_ASSERT(next != nullptr);
        
        bool switch_context = false;
 
        // if equal: do not switch context because task did not change
        if (next != now)
        {
            idle   = now->GetUserStackPtr();
            active = next->GetUserStackPtr();
 
            // if stack memory is exceeded these assertions will be hit
        #if STK_STACK_GUARD
            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);
        #endif
 
            m_task_now = next;
 
            if __stk_constexpr_cpp17 (IsHrtMode())
            {
                if (now->m_hrt[0].done)
                {
                    now->HrtOnSwitchedOut();
                    next->HrtOnSwitchedIn();
                }
            }
 
            switch_context = true;
        }
 
        return switch_context;
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::UpdateFsmState().

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 3026 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::UpdateFsmState().

Here is the caller graph for this function:

◆ SuspendTask()

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

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::SuspendTask	(	ITask *	user_task,
		bool &	suspended )

inlineoverridevirtual

Suspend task.

Parameters

[in]	user_task	Pointer to the user task to suspend.
[out]	suspended	Set to true if task is suspended.

Note: hw::CriticalSection must not be active otherwise a deadlock will happen if task is suspending self.

Implements stk::IKernel.

Definition at line 1494 of file stk.h.

    {
        STK_ASSERT(user_task != nullptr);
 
        bool self = false;
        KernelTask *self_task = nullptr;
 
        // critical section: avoid race with OnTick
        {
            const hw::CriticalSection::ScopedLock cs_;
 
            KernelTask *const task = FindTaskByUserTask(user_task);
            STK_ASSERT(task != nullptr);
 
            // nesting not supported, must not be suspended by SuspendTask
            STK_ASSERT((task->m_state & KernelTask::STATE_SUSPENDED) == 0U);
 
            // only suspend if the task is currently awake: if it is already sleeping
            // (e.g. blocked on a mutex or timed Sleep), do not overwrite m_time_sleep,
            // that would corrupt the original sleep state and, for sync-object waits,
            // would interfere with WaitObject::Tick()
            suspended = !task->IsSleeping();
            if (suspended == true)
            {
                task->ScheduleSleep(WAIT_INFINITE);
 
                // check if suspending self
                self = (task == m_task_now);
 
                // trace blocked via Suspend
                if (self)
                {
                    // keep the pointer: m_task_now may change as soon as the critical section is released
                    self_task = task;
 
                #if STK_SEGGER_SYSVIEW
                    SEGGER_SYSVIEW_OnTaskStopReady(task->GetUserStackPtr()->tid, TRACE_EVENT_SUSPEND);
                #endif
                }
 
                // set state
                task->m_state |= KernelTask::STATE_SUSPENDED;
            }
        }
 
        // note: we do not spin long here, kernel will switch this task out from scheduling on the next tick
        if (self_task != nullptr)
        {
            self_task->BusyWaitWhileSleeping(this);
        }
    }

◆ 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 2936 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnForceContextSwitch(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnTick().

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 2831 of file stk.h.

    {
        ISyncObject::ListEntryType *itr = m_sync_list->GetFirst();
 
        while (itr != nullptr)
        {
            ISyncObject::ListEntryType *const next = itr->GetNext();
 
            if (!util::DListCast::ListEntryToParent<ISyncObject>(itr)->Tick(elapsed_ticks))
            {
                m_sync_list->Unlink(itr);
            }
 
            itr = next;
        }
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::UpdateTasks().

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 2850 of file stk.h.

    {
        // 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 __stk_constexpr_cpp17 (IsDynamicMode() && !IsHrtMode())
        {
            // process serialized AddTask request made from another active task, requesting process
            // is currently waiting due to SwitchToNext()
            if ((m_request & REQ_ADD_TASK) != 0U)
            {
                m_request &= ~REQ_ADD_TASK;
 
                for (size_t i = 0U; i < TASKS_MAX; ++i)
                {
                    KernelTask *const task = &m_task_storage[i];
 
                    typename KernelTask::SrtInfo &srt = task->m_srt[0];
 
                    if (srt.add_task_req != nullptr)
                    {
                        AllocateAndAddNewTask(srt.add_task_req->user_task);
 
                        srt.add_task_req = nullptr;
                        __stk_full_memfence();
                    }
                }
            }
        }
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::UpdateTasks().

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 2652 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 __stk_constexpr_cpp17 (IsSyncMode())
        {
            UpdateSyncObjects(elapsed_ticks);
        }
 
        if (m_request != REQ_NONE)
        {
            UpdateTaskRequest();
        }
 
        return UpdateTaskState(elapsed_ticks);
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnTick().

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, deliver sleep/wake notifications, 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.

Note: Sleep entry/exit protocol: ScheduleSleep() sets STATE_SLEEP_PENDING and stores m_time_sleep = -ticks. This function's first pass over a newly-sleeping task (the "entry tick") consumes STATE_SLEEP_PENDING and delivers OnTaskSleep() to the strategy, but does NOT also advance m_time_sleep on that same pass - doing both in one call would let a 1-tick sleep collapse to zero elapsed time (OnTaskSleep and OnTaskWake firing back-to-back before the task was ever excluded from scheduling). The entry tick is therefore required to be a single, uncoalesced tick (asserted below); this holds because a task can only enter STATE_SLEEP_PENDING by putting itself to sleep, which means it was actively running (not idle) up to that point, so tickless coalescing, which only suppresses ticks while the CPU is idle, cannot have applied yet. If Wake()/SleepCancel() races in before the entry tick runs, STATE_WAKE_PENDING is set alongside STATE_SLEEP_PENDING. The entry tick then delivers OnTaskSleep() followed immediately by the normal advance (and OnTaskWake(), since m_time_sleep was already primed to -1 by Wake()) in the same pass, so the task still resumes on the next tick as promised, with the two notifications correctly paired instead of an orphaned OnTaskWake(). Tasks sleeping via WAIT_INFINITE (IsSleepInfinite()) are excluded from the per-tick advance entirely so they never spuriously time out; only an explicit Wake() (which directly sets m_time_sleep = -1) ends an infinite sleep.

Definition at line 2715 of file stk.h.

    {
        Timeout sleep_ticks = GetInitialSleepTicks<IsTicklessMode()>();
 
        for (size_t i = 0U; i < TASKS_MAX; ++i)
        {
            KernelTask *const task = &m_task_storage[i];
 
            if __stk_constexpr_cpp17 (TStrategy::NOSLEEP_YIELD_API)
            {
                // a pending yield is consumed by this tick (the strategy already moved its cursor)
                if ((task->m_state & KernelTask::STATE_YIELD_PENDING) != 0U)
                {
                    task->m_state &= ~KernelTask::STATE_YIELD_PENDING;
                }
            }
 
            if (task->IsSleeping())
            {
                if __stk_constexpr_cpp17 (IsDynamicMode())
                {
                    // task is pending removal, wait until it is switched out
                    if (task->IsPendingRemoval())
                    {
                        const size_t tasks_left = m_strategy.GetSize();
                      
                        if ((task != m_task_now) ||
                            ((tasks_left == 1U) && (m_fsm_state == FSM_STATE_SLEEPING)))
                        {
                            RemoveTask(task);
                            continue;
                        }
                    }
                }
 
                bool just_entered_sleep = false;
 
                // note: only currently scheduled task can be pending to sleep
                if ((task->m_state & KernelTask::STATE_SLEEP_PENDING) != 0U)
                {
                    STK_ASSERT(elapsed_ticks == 1); // entry tick must be a single, uncoalesced tick
 
                    // if Wake() raced in before this entry tick ran, STATE_WAKE_PENDING is set:
                    // deliver OnTaskSleep() below as usual, then fall through to the advance block
                    // in this same pass instead of waiting an extra tick, so the paired OnTaskWake()
                    // still fires on schedule.
                    const bool wake_pending = ((task->m_state & KernelTask::STATE_WAKE_PENDING) != 0U);
 
                    ProcessTaskPendingSleep(task);
 
                    just_entered_sleep = !wake_pending;
                }
 
                if (!just_entered_sleep && !task->IsSleepInfinite())
                {
                    // advance sleep time by number of elapsed ticks (always 1 if non-Tickless)
                    task->m_time_sleep += elapsed_ticks;
 
                    // deliver sleep event to the strategy
                    if __stk_constexpr_cpp17 (TStrategy::SLEEP_EVENT_API)
                    {
                        // notify strategy that the task woke up
                        if (!task->IsSleeping())
                        {
                            m_strategy.OnTaskWake(task);
                        }
                    }
                }
            }
            else
            {
                if __stk_constexpr_cpp17 (IsHrtMode())
                {
                    // in HRT mode we trace how long task spent in active state (doing some work)
                    if (task->IsBusy())
                    {
                        typename KernelTask::HrtInfo &hrt = task->m_hrt[0];
 
                        hrt.duration += elapsed_ticks;
 
                        // check if deadline is missed (HRT failure)
                        if (task->HrtIsDeadlineMissed(hrt.duration))
                        {
                            // report deadline overrun to the strategy which supports overrun recovery
                            if __stk_constexpr_cpp17 (TStrategy::DEADLINE_MISSED_API)
                            {                                
                                if (!m_strategy.OnTaskDeadlineMissed(task))
                                {
                                    // report failure if it could not be recovered by the scheduling strategy
                                    task->HrtHardFailDeadline(&m_platform);
                                }
                            }
                            else
                            {
                                task->HrtHardFailDeadline(&m_platform);
                            }
                        }
                    }
                }
            }
 
            // get the number of ticks the driver has to keep CPU in Idle
            if __stk_constexpr_cpp17 (IsTicklessMode())
            {
                if ((sleep_ticks > 1) && task->IsBusy())
                {
                    sleep_ticks = task->GetSleepTicks(sleep_ticks);
                }
            }
        }
 
        return sleep_ticks;
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::UpdateTasks().

Here is the caller graph for this function:

◆ UpdateTimeslice()

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

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

inlineprotected

Charge the running task and rotate it behind its same-priority peers when its slice expires.

Note: KERNEL_TIMESLICE only. Called from OnTick() after UpdateTasks() and before UpdateFsmState().

Parameters

[in] elapsed_ticks Ticks since the previous OnTick() (always 1 in non-tickless mode).

Definition at line 2607 of file stk.h.

    {
        KernelTask *const task = m_task_now;
 
        // only a real, runnable task is charged: not the sleep trap, not a task which is leaving
        if ((task != nullptr) &&
            ((m_fsm_state == FSM_STATE_SWITCHING) || (m_fsm_state == FSM_STATE_WAKING)) &&
            task->IsBusy() && !task->IsSleeping())
        {
            typename KernelTask::TsInfo &ts = task->m_ts[0];
 
            if (ts.quantum != NO_TIME_SLICE)
            {
                ts.left -= elapsed_ticks;
 
                if (ts.left <= 0)
                {
                    ts.Reload();
 
                    // strategy rotates to a same-priority peer if there is one, otherwise (or if the
                    // task is not eligible) the task keeps running with a fresh slice
                    STK_UNUSED(m_strategy.OnTaskTimeSlice(task));
                }
            }
        }
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnTick().

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[STK_ALLOCATE_COUNT< TMode, KERNEL_DYNAMIC, 1U, 0U >::Value]

protected

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

Definition at line 3246 of file stk.h.

◆ 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 3252 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
    }; 

◆ 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 3247 of file stk.h.

◆ m_kstate

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

volatile EKernelState stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_kstate

protected

Current kernel state.

Definition at line 3249 of file stk.h.

◆ 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 3241 of file stk.h.

Referenced by stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::BusyWaitWhileSleeping(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::BusyWaitWhileYielding().

◆ 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 3248 of file stk.h.

◆ 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 3240 of file stk.h.

◆ 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 3245 of file stk.h.

◆ 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 3242 of file stk.h.

◆ m_sync_list

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

SyncObjectList stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_sync_list[STK_ALLOCATE_COUNT< TMode, KERNEL_SYNC, 1U, 0U >::Value]

protected

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

Definition at line 3250 of file stk.h.

◆ 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 3243 of file stk.h.

Referenced by stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::ScheduleRemoval().

◆ 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 3244 of file stk.h.

◆ TASKS_MAX

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

size_t stk::Kernel< TMode, TSize, TStrategy, TPlatform >::TASKS_MAX = TSize

staticconstexpr

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 1295 of file stk.h.

◆ YIELD_TICKS

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

Timeout stk::Kernel< TMode, TSize, TStrategy, TPlatform >::YIELD_TICKS = 1

staticconstexprprotected

Ticks to yield.

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.

Definition at line 1843 of file stk.h.

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

stk.h

Classes

Public Types

Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Member Typedef Documentation

◆ ExitTrapStackMemory

◆ SleepTrapStackMemory

◆ SyncObjectList

◆ TaskStorageType

Member Enumeration Documentation

◆ EFsmEvent

◆ EFsmState

◆ EKernelState

◆ ERequest

Constructor & Destructor Documentation

◆ Kernel()

◆ ~Kernel()

Member Function Documentation

◆ AddKernelTask()

◆ AddTask() [1/2]

◆ AddTask() [2/2]

◆ AllocateAndAddNewTask()

◆ AllocateNewTask()

◆ CancelTaskWait()

◆ EnumerateKernelTasks()

◆ EnumerateTasks()

◆ EnumerateTasksT()

◆ FetchNextEvent()

◆ FindTaskBySP()

◆ FindTaskByStack()

◆ FindTaskByUserTask() [1/2]

◆ FindTaskByUserTask() [2/2]

◆ FindTaskByUserTaskImpl()

◆ GetNewFsmState()

◆ GetPlatform()

◆ GetState()

◆ GetSwitchStrategy()

◆ GetTaskState()

◆ HrtAllocateAndAddNewTask()

◆ Initialize()

◆ InitTraps()

◆ IsDynamicMode()

◆ IsHrtMode()

◆ IsInitialized()

◆ IsStarted()

◆ IsStaticMode()

◆ IsSyncMode()

◆ IsTelemetryMode()

◆ IsTicklessMode()

◆ IsTimesliceMode()

◆ IsValidFsmState()

◆ OnForceContextSwitch()

◆ OnGetTid()

◆ OnInheritWeight()

◆ OnRestoreWeight()

◆ OnSetTimeSlice()

◆ OnSetWeight()

◆ OnStart()

◆ OnStop()

◆ OnSuspend()

◆ OnTaskExit()

◆ OnTaskSleep()

◆ OnTaskSleepUntil()

◆ OnTaskSwitch()

◆ OnTaskWait()

◆ OnTick()

◆ ProcessTaskPendingSleep()

◆ ProcessTaskPendingYield()

◆ RemoveTask() [1/2]

◆ RemoveTask() [2/2]

◆ RequestAddTask()

◆ ResumeTask()

◆ ScheduleAddTask()

◆ ScheduleTaskRemoval()