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.
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.
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	OnTaskSleepCancel (TId task_id)
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)
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.
static constexpr bool	IsStaticMode ()
static constexpr bool	IsDynamicMode ()
static constexpr bool	IsHrtMode ()
static constexpr bool	IsSyncMode ()
static constexpr bool	IsTicklessMode ()

Protected Attributes
KernelService	m_service
	Kernel service singleton exposed to running tasks via IKernelService::GetInstance().
TPlatform	m_platform
	Platform driver (SysTick, PendSV, context switch implementation).
TStrategy	m_strategy
	Task-switching strategy (determines which task runs next).
KernelTask *	m_task_now
	Currently executing task, or `nullptr` before Start() or after all tasks exit.
TaskStorageType	m_task_storage
	Static pool of TSize KernelTask slots (free slots have m_user == nullptr).
SleepTrapStack	m_sleep_trap [1]
	Sleep trap (always present): executed when all tasks are sleeping.
ExitTrapStack	m_exit_trap [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_STATIC and KERNEL_DYNAMIC are mutually exclusive.
TSize	Maximum number of concurrent tasks. Must be > 0.
TStrategy	Task-switching strategy type (e.g. SwitchStrategyRoundRobin). Must inherit ITaskSwitchStrategy.
TPlatform	Platform driver type (e.g. PlatformArmCortexM, or PlatformDefault). Must inherit IPlatform.

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

Usage example:

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

Definition at line 87 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 104 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 98 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 2899 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 2861 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 1583 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 1569 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 1455 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 110 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 1161 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 1683 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 1231 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 1270 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 1700 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 1643 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 1428 of file stk.h.

    {
        STK_ASSERT(user_task != nullptr);
 
        if __stk_constexpr_cpp17 (IsSyncMode())
        {
            // avoid race with OnTick
            const hw::CriticalSection::ScopedLock cs_;
 
            KernelTask *const task = FindTaskByUserTask(user_task);
            STK_ASSERT(task != nullptr);
 
            // only cancel if actually blocked in OnTaskWait() on a sync object; no-op otherwise
            // (e.g. task is running, suspended via SuspendTask(), or plainly sleeping)
            if (task->m_wait_obj->IsWaiting())
            {
                task->m_wait_obj->Cancel();
            }
        }
        else
        {
            // kernel operating mode must include KERNEL_SYNC for tasks to be able to wait
            STK_ASSERT(false);
        }
    }

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

   {
       size_t count = 0U;
       const size_t limit = Min(tasks.GetSize(), TASKS_MAX);
 
       // avoid race with OnTick
       const hw::CriticalSection::ScopedLock cs_;
 
       for (size_t i = 0U; i < limit; ++i)
       {
           KernelTask *const 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 1482 of file stk.h.

    {
        size_t count = 0U;
        const size_t limit = Min(user_tasks.GetSize(), TASKS_MAX);
 
        // avoid race with OnTick
        const hw::CriticalSection::ScopedLock cs_;
 
        for (size_t i = 0U; i < limit; ++i)
        {
            KernelTask *const 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 1579 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 2561 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 1804 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 1783 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()

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

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

inlineprotected

Find kernel task by the bound ITask instance.

Parameters

[in] user_task User task.

Returns: Kernel task.

Definition at line 1762 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->GetUserTask() == user_task)
            {
                found_task = task;
                break;
            }
        }
 
        return found_task;
    }

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

1545{ 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 1554 of file stk.h.

1554{ 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 1550 of file stk.h.

1550{ return &m_strategy; }

◆ 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 1715 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 1194 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 1609 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 2830 of file stk.h.

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

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

2795{ 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 1537 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 2829 of file stk.h.

2829{ 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 2832 of file stk.h.

2832{ 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< 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:

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

2833{ 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:

◆ 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 1602 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 1988 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 2235 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 2268 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 2315 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);
    }

◆ 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 2288 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 1869 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 1934 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 2243 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 2155 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
 
            // notify kernel to execute removal
            {
                // make change to HRT/sleep/removal state atomic (same as OnTaskSleep/OnTaskSleepUntil)
                const hw::CriticalSection::ScopedLock cs_;
 
                task->ScheduleRemoval();
            }
        }
        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 2073 of file stk.h.

    {
        KernelTask *const task = FindTaskBySP(caller_SP);
        STK_ASSERT(task != nullptr);
 
        // 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:

◆ OnTaskSleepCancel()

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

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::OnTaskSleepCancel ( TId task_id )

inlineprotected

Definition at line 2141 of file stk.h.

    {
        KernelTask *const task = FindTaskByUserTask(GetUserTaskFromTid(task_id));
        if (task != nullptr)
        {
            const hw::CriticalSection::ScopedLock cs_;
 
            if (task->IsSleeping())
            {
                task->Wake();
            }
        }
    }

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

    {
        KernelTask *const task = FindTaskBySP(caller_SP);
        STK_ASSERT(task != nullptr);
 
        bool result = true;
 
        // 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 2027 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;
                {
                    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 2182 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);
 
            // configure waiting
            task->m_wait_obj->SetupWait(sync_obj, timeout);
 
            // register ISyncObject if not yet
            if (sync_obj->GetHead() == nullptr)
            {
                m_sync_list->LinkBack(sync_obj);
            }
 
            // start sleeping infinitely, we rely on a Wake call via WaitObject
            task->ScheduleSleep(WAIT_INFINITE);
 
            // 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 = task->m_wait_obj->GetWaitResult();
            task->m_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 1961 of file stk.h.

    {
    #if !STK_TICKLESS_IDLE
        // in non-tickless mode kernel is advancing strictly by 1 tick on every OnTick call
        enum { ticks = 1 };
    #endif
 
        // advance internal timestamp
        m_service.IncrementTicks(ticks);
 
        // consume elapsed and update to ticks to sleep
    #if STK_TICKLESS_IDLE
        ticks = (
    #else
        // notify compiler that we ignore a return value of UpdateTasks
        STK_UNUSED(
    #endif
        UpdateTasks(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 2349 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(), 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 2360 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 1295 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 1844 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 1729 of file stk.h.

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

    {
        STK_ASSERT(user_task != nullptr);
 
        // 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 2801 of file stk.h.

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

    {
        if __stk_constexpr_cpp17 (IsDynamicMode())
        {
            STK_ASSERT(user_task != nullptr);
            STK_ASSERT(IsStarted());
 
            const hw::CriticalSection::ScopedLock cs_;
 
            KernelTask *const task = FindTaskByUserTask(user_task);
            if (task != nullptr)
            {
                task->ScheduleRemoval();
            }
        }
        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 1510 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 2766 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 2735 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 2656 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 2703 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 1348 of file stk.h.

    {
        STK_ASSERT(user_task != nullptr);
 
        bool self = false;
 
        // 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)
                {
                #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)
        {
            m_task_now->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 2613 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 2510 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 2529 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];
 
                    if (task->m_srt[0].add_task_req != nullptr)
                    {
                        AllocateAndAddNewTask(task->m_srt[0].add_task_req->user_task);
 
                        task->m_srt[0].add_task_req = nullptr;
                        __stk_full_memfence();
                    }
                }
            }
        }
    }

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 2333 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 2396 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())
                    {
                        task->m_hrt[0].duration += elapsed_ticks;
 
                        // check if deadline is missed (HRT failure)
                        if (task->HrtIsDeadlineMissed(task->m_hrt[0].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:

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 2907 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 2913 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 2908 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 2910 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 2902 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 2909 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 2901 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 2906 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 2903 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 2911 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 2904 of file stk.h.

◆ 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 2905 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 1151 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 1598 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()

◆ GetNewFsmState()

◆ GetPlatform()

◆ GetState()

◆ GetSwitchStrategy()

◆ HrtAllocateAndAddNewTask()

◆ Initialize()

◆ InitTraps()

◆ IsDynamicMode()

◆ IsHrtMode()

◆ IsInitialized()

◆ IsStarted()

◆ IsStaticMode()

◆ IsSyncMode()

◆ IsTicklessMode()

◆ IsValidFsmState()

◆ OnForceContextSwitch()

◆ OnGetTid()

◆ OnInheritWeight()

◆ OnRestoreWeight()

◆ OnSetWeight()

◆ OnStart()

◆ OnStop()

◆ OnSuspend()

◆ OnTaskExit()

◆ OnTaskSleep()

◆ OnTaskSleepCancel()

◆ OnTaskSleepUntil()

◆ OnTaskSwitch()

◆ OnTaskWait()

◆ OnTick()

◆ ProcessTaskPendingSleep()

◆ ProcessTaskPendingYield()

◆ RemoveTask() [1/2]

◆ RemoveTask() [2/2]

◆ RequestAddTask()

◆ ResumeTask()

◆ ScheduleAddTask()

◆ ScheduleTaskRemoval()

◆ Start()

◆ StateExit()

◆ StateSleep()

◆ StateSwitch()

◆ StateWake()