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	EState : uint8_t { STATE_INACTIVE = 0 , STATE_READY , STATE_RUNNING , STATE_SUSPENDED }
	Kernel state. More...

Public Member Functions
	Kernel ()
	Construct the kernel with all storage zero-initialized and the request flag set to ~0 (indicating uninitialized state; cleared to REQUEST_NONE by Initialize()).
	~Kernel ()
	Destructor.
void	Initialize (uint32_t resolution_us=PERIODICITY_DEFAULT)
	Initialize kernel.
void	AddTask (ITask *user_task)
	Register task for a soft real-time (SRT) scheduling.
void	AddTask (ITask *user_task, Timeout periodicity_tc, Timeout deadline_tc, Timeout start_delay_tc)
	Register a task for hard real-time (HRT) scheduling.
void	RemoveTask (ITask *user_task)
	Remove a previously added task from the kernel before Start().
void	ScheduleTaskRemoval (ITask *user_task)
	Schedule task removal from scheduling (exit).
void	SuspendTask (ITask *user_task, bool &suspended)
	Suspend task.
void	ResumeTask (ITask *user_task)
	Resume task.
size_t	EnumerateTasks (ITask **user_tasks, const size_t max_size)
	Enumerate tasks.
void	Start ()
	Start the scheduler. This call does not return until all tasks have exited (KERNEL_DYNAMIC mode) or indefinitely (KERNEL_STATIC mode).
bool	IsStarted () const
	Check whether scheduler is currently running.
IPlatform *	GetPlatform ()
	Get platform driver instance owned by this kernel.
ITaskSwitchStrategy *	GetSwitchStrategy ()
	Get task-switching strategy instance owned by this kernel.
EState	GetState () const
	Get kernel state.
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 uint32_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 { REQUEST_NONE = 0 , REQUEST_ADD_TASK = (1 << 0) }
	Bitmask flags for pending inter-task requests that must be processed by the kernel on the next tick (in UpdateTaskRequest()). More...
enum	EFsmState : int8_t { FSM_STATE_NONE = -1 , FSM_STATE_SWITCHING , FSM_STATE_SLEEPING , FSM_STATE_WAKING , FSM_STATE_EXITING , FSM_STATE_MAX }
	Finite-state machine (FSM) state. Encodes what the kernel is currently doing between two consecutive tick events. More...
enum	EFsmEvent : int8_t { FSM_EVENT_SWITCH = 0 , FSM_EVENT_SLEEP , FSM_EVENT_WAKE , FSM_EVENT_EXIT , FSM_EVENT_MAX }
	Finite-state machine (FSM) event. Computed by FetchNextEvent() each tick based on strategy output and current kernel state. More...
typedef StackMemoryWrapper<(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 *user_task)
	Request to add new task.
KernelTask *	FindTaskByUserTask (const ITask *user_task)
	Find kernel task by the bound ITask instance.
KernelTask *	FindTaskByStack (const Stack *stack)
	Find kernel task by the bound Stack instance.
KernelTask *	FindTaskBySP (Word SP)
	Find kernel task for a Stack Pointer (SP).
void	RemoveTask (KernelTask *task)
	Remove kernel task.
void	OnStart (Stack *&active)
	Called by platform driver immediately after a scheduler start (first tick).
void	OnStop ()
	Called by the platform driver after a scheduler stop (all tasks have exited).
bool	OnTick (Stack &idle, Stack &active)
	Process one scheduler tick. Called from the platform timer/tick ISR.
void	OnTaskSwitch (Word caller_SP)
	Called by Thread process (via IKernelService::SwitchToNext) to switch to a next task.
void	OnTaskSleep (Word caller_SP, Timeout ticks)
	Called by Thread process (via IKernelService::Sleep) for exclusion of the calling process from scheduling (sleeping).
void	OnTaskSleepUntil (Word caller_SP, Ticks timestamp)
	Called by Thread process (via IKernelService::SleepUntil) for exclusion of the calling process from scheduling (sleeping).
void	OnTaskExit (Stack *stack)
	Called from the Thread process when task finished (its Run function exited by return).
IWaitObject *	OnTaskWait (Word caller_SP, ISyncObject sync_obj, IMutex mutex, Timeout timeout)
	Called from the Thread process when task needs to wait.
TId	OnGetTid (Word caller_SP)
	Called from the Thread process when for getting task/thread id of the process.
void	OnSuspend (bool suspended)
	Called from the Thread process to suspend scheduling.
Timeout	UpdateTasks (const Timeout elapsed_ticks)
	Update tasks (sleep, requests).
Timeout	UpdateTaskState (const Timeout elapsed_ticks)
	Update task state: process removals, advance sleep timers, and track HRT durations.
void	UpdateSyncObjects (const Timeout elapsed_ticks)
	Update synchronization objects.
void	UpdateTaskRequest ()
	Update pending task requests.
EFsmEvent	FetchNextEvent (KernelTask *&next)
	Fetch next event for the FSM.
EFsmState	GetNewFsmState (KernelTask *&next)
	Get new FSM state.
bool	UpdateFsmState (Stack &idle, Stack &active)
	Update FSM state.
bool	StateSwitch (KernelTask now, KernelTask next, Stack &idle, Stack &active)
	Switches contexts.
bool	StateWake (KernelTask now, KernelTask next, Stack &idle, Stack &active)
	Wakes up after sleeping.
bool	StateSleep (KernelTask now, KernelTask next, Stack &idle, Stack &active)
	Enters into a sleeping mode.
bool	StateExit (KernelTask now, KernelTask next, Stack &idle, Stack &active)
	Exits from scheduling.
bool	IsInitialized () const
	Check whether Initialize() has been called and completed successfully.
void	ScheduleAddTask ()
	Signal the kernel to process a pending AddTask request on the next tick.

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

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

Static Protected Attributes
static constexpr Timeout	YIELD_TICKS = 2
	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 80 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 93 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 87 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 2097 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 2059 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 1113 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 1099 of file stk.h.

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

◆ ERequest

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

enum stk::Kernel::ERequest : uint8_t

protected

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

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

Definition at line 99 of file stk.h.

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

◆ EState

enum stk::IKernel::EState : uint8_t

inherited

Kernel state.

Enumerator
STATE_INACTIVE	Not ready, IKernel::Initialize() must be called.
STATE_READY	Ready to start, IKernel::Start() must be called.
STATE_RUNNING	Initialized and running, IKernel::Start() was called successfully.
STATE_SUSPENDED	Scheduling is suspended with IKernelService::Suspend().

Definition at line 966 of file stk_common.h.

    {
        STATE_INACTIVE = 0, 
        STATE_READY,        
        STATE_RUNNING,      
        STATE_SUSPENDED     
    };

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 and the request flag set to ~0 (indicating uninitialized state; cleared to REQUEST_NONE by Initialize()).

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

Definition at line 798 of file stk.h.

                      : m_platform(), m_strategy(), m_task_now(nullptr), m_task_storage(), m_sleep_trap(),
        m_exit_trap(), m_fsm_state(FSM_STATE_NONE), m_request(REQUEST_NONE), m_state(STATE_INACTIVE)
    {
    #ifdef _DEBUG
        // TPlatform must inherit IPlatform
        IPlatform *platform = &m_platform;
        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 ( )

inline

Destructor.

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

Definition at line 820 of file stk.h.

821 {}

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

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 16U, stk::SwitchStrategyFP32, stk::PlatformDefault >::AllocateAndAddNewTask(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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 )

inlinevirtual

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

Parameters

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

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

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

Implements stk::IKernel.

Definition at line 859 of file stk.h.

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

◆ AddTask() [2/2]

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

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

inlinevirtual

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

Parameters

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

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

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

Implements stk::IKernel.

Definition at line 898 of file stk.h.

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

◆ AllocateAndAddNewTask()

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

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

inlineprotected

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

Parameters

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

Returns: Kernel task.

Definition at line 1226 of file stk.h.

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

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

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

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

Here is the caller graph for this function:

◆ EnumerateTasks()

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

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

inlinevirtual

Enumerate tasks.

Parameters

[in,out]	user_tasks	Pointer to the array for ITask pointers.
[in]	max_size	Max size of the provided array.

Returns: Number of tasks in the array.

Implements stk::IKernel.

Definition at line 1025 of file stk.h.

    {
        size_t count = 0U;
 
        // avoid race with OnTick
        hw::CriticalSection::ScopedLock cs_;
 
        for (uint32_t i = 0U; i < Min(max_size, static_cast<size_t>(TASKS_MAX)); ++i)
        {
            KernelTask *task = &m_task_storage[i];
            if (task->IsBusy())
                user_tasks[count++] = task->GetUserTask();
        }
 
        return count;
    }

◆ EnumerateTasksT()

template<size_t TMaxCount, typename TCallback>

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

inlineinherited

Enumerate tasks, invoking a callback for each active task.

Template Parameters

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

Parameters

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

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

Warning: ISR-safe.

Example:

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

Definition at line 1062 of file stk_common.h.

    {
        STK_STATIC_ASSERT(TMaxCount > 0);
 
        ITask *tasks[TMaxCount] = {};
        size_t i = 0, count = EnumerateTasks(tasks, TMaxCount);
 
        while (i < count)
        {
            if (!callback(tasks[i++]))
                break;
        }
 
        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 1765 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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 1312 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 16U, stk::SwitchStrategyFP32, stk::PlatformDefault >::OnGetTid(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 16U, stk::SwitchStrategyFP32, stk::PlatformDefault >::OnTaskSleep(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 16U, stk::SwitchStrategyFP32, stk::PlatformDefault >::OnTaskSleepUntil(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 16U, stk::SwitchStrategyFP32, stk::PlatformDefault >::OnTaskWait(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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 1296 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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 1280 of file stk.h.

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

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

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 1806 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, 16U, stk::SwitchStrategyFP32, stk::PlatformDefault >::OnStart(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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 ( )

inlinevirtual

Get platform driver instance owned by this kernel.

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

Implements stk::IKernel.

Definition at line 1083 of file stk.h.

1083{ return &m_platform; }

◆ GetState()

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

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

inlinevirtual

Get kernel state.

Implements stk::IKernel.

Definition at line 1092 of file stk.h.

1092{ return m_state; }

◆ GetSwitchStrategy()

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

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

inlinevirtual

Get task-switching strategy instance owned by this kernel.

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

Implements stk::IKernel.

Definition at line 1088 of file stk.h.

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

Returns: Kernel task.

Definition at line 1242 of file stk.h.

    {
        KernelTask *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, 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 )

inlinevirtual

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 STATE_INACTIVE state.

Implements stk::IKernel.

Definition at line 832 of file stk.h.

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

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

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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>

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

inlinestaticprotected

Definition at line 2032 of file stk.h.

2032{ 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>

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

inlinestaticprotected

Definition at line 2033 of file stk.h.

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

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

Here is the caller graph for this function:

◆ IsInitialized()

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

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

inlineprotected

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

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

Definition at line 1997 of file stk.h.

1997{ return (m_state != STATE_INACTIVE); }

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

    {
        return (m_task_now != nullptr);
    }

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 16U, stk::SwitchStrategyFP32, stk::PlatformDefault >::AddKernelTask(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 16U, stk::SwitchStrategyFP32, stk::PlatformDefault >::AddTask(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 16U, stk::SwitchStrategyFP32, stk::PlatformDefault >::AddTask(), stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 16U, stk::SwitchStrategyFP32, stk::PlatformDefault >::RemoveTask(), and stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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>

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

inlinestaticprotected

Definition at line 2031 of file stk.h.

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

◆ IsSyncMode()

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

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

inlinestaticprotected

Definition at line 2034 of file stk.h.

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

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

Here is the caller graph for this function:

◆ IsTicklessMode()

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

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

inlinestaticprotected

Definition at line 2035 of file stk.h.

2035{ 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, 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 1132 of file stk.h.

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

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

Here is the caller graph for this function:

◆ OnGetTid()

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

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

inlineprotectedvirtual

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

Parameters

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

Returns: Task/thread id of the process (returns always valid TId belonging to a task).

Implements stk::IPlatform::IEventHandler.

Definition at line 1587 of file stk.h.

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

◆ OnStart()

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

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

inlineprotectedvirtual

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

Parameters

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

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

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

Implements stk::IPlatform::IEventHandler.

Definition at line 1363 of file stk.h.

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

◆ OnStop()

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

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

inlineprotectedvirtual

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

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

Implements stk::IPlatform::IEventHandler.

Definition at line 1430 of file stk.h.

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

◆ OnSuspend()

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

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

inlineprotectedvirtual

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

    {
        if (suspended)
            m_state = ((m_state == STATE_RUNNING) ? STATE_SUSPENDED : m_state);
        else
            m_state = ((m_state == STATE_SUSPENDED) ? STATE_RUNNING : m_state);
    }

◆ OnTaskExit()

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

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

inlineprotectedvirtual

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

Parameters

[out] stack Stack of the exited task.

Implements stk::IPlatform::IEventHandler.

Definition at line 1530 of file stk.h.

    {
        if (IsDynamicMode())
        {
            KernelTask *task = FindTaskByStack(stack);
            STK_ASSERT(task != nullptr);
 
            // notify kernel to execute removal
            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 )

inlineprotectedvirtual

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

Parameters

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

Implements stk::IPlatform::IEventHandler.

Definition at line 1489 of file stk.h.

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

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

Here is the caller graph for this function:

◆ OnTaskSleepUntil()

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

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

inlineprotectedvirtual

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

Parameters

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

Implements stk::IPlatform::IEventHandler.

Definition at line 1509 of file stk.h.

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

◆ OnTaskSwitch()

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

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

inlineprotectedvirtual

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

Parameters

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

Implements stk::IPlatform::IEventHandler.

Definition at line 1484 of file stk.h.

    {
        OnTaskSleep(caller_SP, YIELD_TICKS);
    }

◆ OnTaskWait()

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

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

inlineprotectedvirtual

Called from the Thread process when task needs to wait.

Parameters

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

Implements stk::IPlatform::IEventHandler.

Definition at line 1547 of file stk.h.

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

◆ OnTick()

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

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

inlineprotectedvirtual

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

Parameters

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

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

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

Implements stk::IPlatform::IEventHandler.

Definition at line 1457 of file stk.h.

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

◆ RemoveTask() [1/2]

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

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

inlinevirtual

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

Parameters

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

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

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

Implements stk::IKernel.

Definition at line 922 of file stk.h.

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

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

    {
        STK_ASSERT(task != nullptr);
 
    #if STK_SEGGER_SYSVIEW
        SEGGER_SYSVIEW_OnTaskTerminate(task->GetUserStack()->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 * 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 1256 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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 )

inlinevirtual

Resume task.

Parameters

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

Implements stk::IKernel.

Definition at line 1006 of file stk.h.

    {
        STK_ASSERT(user_task != nullptr);
 
        // avoid race with OnTick
        hw::CriticalSection::ScopedLock cs_;
 
        KernelTask *task = FindTaskByUserTask(user_task);
        STK_ASSERT(task != nullptr);
 
        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 REQUEST_ADD_TASK bit in m_request and emits a full memory fence so the ISR-side tick handler observes the flag without delay.

Definition at line 2003 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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 )

inlinevirtual

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

    {
        if (IsDynamicMode())
        {
            STK_ASSERT(user_task != nullptr);
            STK_ASSERT(IsStarted());
 
            hw::CriticalSection::ScopedLock cs_;
 
            KernelTask *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 ( )

inlinevirtual

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 1050 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 (uint32_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 1968 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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 1935 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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 1857 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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 1903 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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 )

inlinevirtual

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

    {
        STK_ASSERT(user_task != nullptr);
 
        bool self = false;
        KernelTask *task = nullptr;
 
        // avoid race with OnTick
        {
            hw::CriticalSection::ScopedLock cs_;
 
            task = FindTaskByUserTask(user_task);
            STK_ASSERT(task != nullptr);
 
            // 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()
            if ((suspended = !task->IsSleeping()) == true)
            {
                task->ScheduleSleep(WAIT_INFINITE);
 
                // check if suspending self
                self = (task == m_task_now);
            }
        }
 
        // note: we do not spin long here, kernel will switch this task out from scheduling on the next tick
        if (self)
            task->BusyWaitWhileSleeping();
    }

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

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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 1709 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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 1730 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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 1605 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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, advance sleep timers, and track HRT durations.

Parameters

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

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

Definition at line 1625 of file stk.h.

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

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC, 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[((((TMode) &(KERNEL_DYNAMIC)) !=0U) ?(1) :(0))]

protected

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

Definition at line 2105 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 2111 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 2106 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 2100 of file stk.h.

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

◆ m_state

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

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

protected

Current kernel state.

Definition at line 2108 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 2101 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[((((TMode) &(KERNEL_SYNC)) !=0U) ?(1) :(0))]

protected

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

Definition at line 2109 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 2102 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 2103 of file stk.h.

◆ TASKS_MAX

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

uint32_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 789 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 = 2

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 1128 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

◆ ERequest

◆ EState

Constructor & Destructor Documentation

◆ Kernel()

◆ ~Kernel()

Member Function Documentation

◆ AddKernelTask()

◆ AddTask() [1/2]

◆ AddTask() [2/2]

◆ AllocateAndAddNewTask()

◆ AllocateNewTask()

◆ EnumerateTasks()

◆ EnumerateTasksT()

◆ FetchNextEvent()

◆ FindTaskBySP()

◆ FindTaskByStack()

◆ FindTaskByUserTask()

◆ GetNewFsmState()

◆ GetPlatform()

◆ GetState()

◆ GetSwitchStrategy()

◆ HrtAllocateAndAddNewTask()

◆ Initialize()

◆ InitTraps()

◆ IsDynamicMode()

◆ IsHrtMode()

◆ IsInitialized()

◆ IsStarted()

◆ IsStaticMode()

◆ IsSyncMode()

◆ IsTicklessMode()

◆ IsValidFsmState()

◆ OnGetTid()

◆ OnStart()

◆ OnStop()

◆ OnSuspend()

◆ OnTaskExit()

◆ OnTaskSleep()

◆ OnTaskSleepUntil()

◆ OnTaskSwitch()

◆ OnTaskWait()

◆ OnTick()

◆ RemoveTask() [1/2]

◆ RemoveTask() [2/2]

◆ RequestAddTask()

◆ ResumeTask()

◆ ScheduleAddTask()

◆ ScheduleTaskRemoval()

◆ Start()

◆ StateExit()

◆ StateSleep()

◆ StateSwitch()

◆ StateWake()

◆ SuspendTask()

◆ UpdateFsmState()

◆ UpdateSyncObjects()

◆ UpdateTaskRequest()

◆ UpdateTasks()

◆ UpdateTaskState()

Member Data Documentation

◆ m_exit_trap

◆ m_fsm