stk::test::KernelMock< TMode, TSize, TStrategy, TPlatform > Class Template Reference

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

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

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

Public Member Functions
BaseType::EFsmState	GetNewFsmState (typename BaseType::KernelTask *&next) override
void	ForceUpdateInvalidFsmState (bool max_val)
void	Initialize (uint32_t resolution_us=PERIODICITY_DEFAULT)
	Prepare kernel for use: reset state, configure the platform, and register the service singleton.
void	AddTask (ITask *user_task)
	Register task for a soft real-time (SRT) scheduling.
void	AddTask (ITask *user_task, Timeout periodicity_tc, Timeout deadline_tc, Timeout start_delay_tc)
	Register a task for hard real-time (HRT) scheduling.
void	RemoveTask (ITask *user_task)
	Remove a previously added task from the kernel before Start().
void	Start ()
	Start the scheduler. This call does not return until all tasks have exited (KERNEL_DYNAMIC mode) or indefinitely (KERNEL_STATIC mode).
bool	IsStarted () const
	Check whether scheduler is currently running.
IPlatform *	GetPlatform ()
	Get platform driver instance owned by this kernel.
ITaskSwitchStrategy *	GetSwitchStrategy ()
	Get task-switching strategy instance owned by this kernel.
EState	GetState () const
	Get kernel state.

Public Attributes
uint8_t	m_fsm_state_mock = KernelMock::FSM_STATE_NONE

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

Protected Member Functions
void	RemoveTask (KernelTask *task)
	Remove kernel task.
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	OnStart (Stack *&active)
	Called by platform driver immediately after a scheduler start (first tick).
void	OnStop ()
	Called by the platform driver after a scheduler stop (all tasks have exited).
bool	OnTick (Stack *&idle, Stack *&active)
	Process one scheduler tick. Called from the platform timer/tick ISR.
void	OnTaskSwitch (Word caller_SP)
	Called by Thread process (via IKernelService::SwitchToNext) to switch to a next task.
void	OnTaskSleep (Word caller_SP, Timeout ticks)
	Called by Thread process (via IKernelService::Sleep) for exclusion of the calling process from scheduling (sleeping).
void	OnTaskSleepUntil (Word caller_SP, Ticks timestamp)
	Called by Thread process (via IKernelService::SleepUntil) for exclusion of the calling process from scheduling (sleeping).
void	OnTaskExit (Stack *stack)
	Called from the Thread process when task finished (its Run function exited by return).
IWaitObject *	OnTaskWait (Word caller_SP, ISyncObject *sync_obj, IMutex *mutex, Timeout timeout)
	Called from the Thread process when task needs to wait.
TId	OnGetTid (Word caller_SP)
	Called from the Thread process when for getting task/thread id of the process.
Timeout	UpdateTasks (const Timeout elapsed_ticks)
	Update tasks (sleep, requests).
Timeout	UpdateTaskState (const Timeout elapsed_ticks)
	Update task state: process removals, advance sleep timers, and track HRT durations.
void	UpdateSyncObjects (const Timeout elapsed_ticks)
	Update synchronization objects.
void	UpdateTaskRequest ()
	Update pending task requests.
EFsmEvent	FetchNextEvent (KernelTask *&next)
	Fetch next event for the FSM.
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]

Private Types
typedef Kernel< TMode, TSize, TStrategy, TPlatform >	BaseType

Detailed Description

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

Definition at line 20 of file stktest_kernel.cpp.

Member Typedef Documentation

BaseType

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

typedef Kernel<TMode, TSize, TStrategy, TPlatform> stk::test::KernelMock< TMode, TSize, TStrategy, TPlatform >::BaseType

private

Definition at line 22 of file stktest_kernel.cpp.

ExitTrapStackMemory

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

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

protectedinherited

Stack memory wrapper type for the exit trap.

See also

ExitTrapStack, STACK_SIZE_MIN

Definition at line 95 of file stk.h.

SleepTrapStackMemory

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

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

protectedinherited

Stack memory wrapper type for the sleep trap.

See also

SleepTrapStack, STK_SLEEP_TRAP_STACK_SIZE

Definition at line 89 of file stk.h.

SyncObjectList

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

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

protectedinherited

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

Definition at line 1988 of file stk.h.

TaskStorageType

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

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

protectedinherited

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

Definition at line 1950 of file stk.h.

Member Enumeration Documentation

EConsts

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

enum stk::Kernel::EConsts

inherited

Constants.

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

Definition at line 762 of file stk.h.

    {
        TASKS_MAX = TSize 
    };

EFsmEvent

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

enum stk::Kernel::EFsmEvent : int8_t

protectedinherited

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

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

Definition at line 984 of file stk.h.

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

EFsmState

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

enum stk::Kernel::EFsmState : int8_t

protectedinherited

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

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

Definition at line 970 of file stk.h.

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

ERequest

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

enum stk::Kernel::ERequest : uint8_t

protectedinherited

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

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

Definition at line 101 of file stk.h.

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

EState

enum stk::IKernel::EState : uint8_t

inherited

Kernel state.

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

Definition at line 859 of file stk_common.h.

    {
        STATE_INACTIVE = 0, 
        STATE_READY,        
        STATE_RUNNING       
    };

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 )

inlineprotectedinherited

Add kernel task to the scheduling strategy.

Parameters

[in]

task

Pointer to the kernel task.

Definition at line 1073 of file stk.h.

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

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

Referenced by AllocateAndAddNewTask(), and HrtAllocateAndAddNewTask().

Here is the call graph for this function:

Here is the caller graph for this function:

AddTask() [1/2]

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

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

inlinevirtualinherited

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

Parameters

[in]

user_task

User task to add. Must not already be registered. Must not be nullptr.

Note

Before Start(): allocates a free KernelTask slot and adds it to the strategy immediately.

After Start() (KERNEL_DYNAMIC only): serialises the request via RequestAddTask() — the calling task yields and the kernel processes the request on the next tick.

Warning

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

Implements stk::IKernel.

Definition at line 832 of file stk.h.

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

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

Referenced by stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TestAlgorithm(), stk::test::TestHrtTaskExitDuringSleepState(), stk::test::TestPriorityNext(), stk::test::TestTaskExit(), and stk::test::TestTaskSleep().

Here is the call graph for this function:

AddTask() [2/2]

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

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

inlinevirtualinherited

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

Parameters

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

Note

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

Warning

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

Implements stk::IKernel.

Definition at line 871 of file stk.h.

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

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

Here is the call graph for this function:

AllocateAndAddNewTask()

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

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

inlineprotectedinherited

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

Parameters

[in]

user_task

User task for which kernel task object is allocated.

Returns

Kernel task.

Definition at line 1089 of file stk.h.

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

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

Referenced by AddTask(), and UpdateTaskRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

AllocateNewTask()

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

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

inlineprotectedinherited

Allocate new instance of KernelTask.

Parameters

[in]

user_task

User task for which kernel task object is allocated.

Returns

Kernel task.

Definition at line 1037 of file stk.h.

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

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

Referenced by AllocateAndAddNewTask(), and HrtAllocateAndAddNewTask().

Here is the call graph for this function:

Here is the caller graph for this function:

FetchNextEvent()

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

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

inlineprotectedinherited

Fetch next event for the FSM.

Parameters

[out]

next

Next kernel task to which Kernel can switch.

Returns

FSM event.

Definition at line 1656 of file stk.h.

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

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

Referenced by GetNewFsmState().

Here is the call graph for this function:

Here is the caller graph for this function:

FindTaskBySP()

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

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

inlineprotectedinherited

Find kernel task for a Stack Pointer (SP).

Parameters

[in]

SP

Stack pointer.

Returns

Kernel task.

Definition at line 1175 of file stk.h.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

FindTaskByStack()

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

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

inlineprotectedinherited

Find kernel task by the bound Stack instance.

Parameters

[in]

stack

Stack.

Returns

Kernel task.

Definition at line 1159 of file stk.h.

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

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

Referenced by OnTaskExit().

Here is the call graph for this function:

Here is the caller graph for this function:

FindTaskByUserTask()

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

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

inlineprotectedinherited

Find kernel task by the bound ITask instance.

Parameters

[in]

user_task

User task.

Returns

Kernel task.

Definition at line 1143 of file stk.h.

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

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

Referenced by RemoveTask().

Here is the call graph for this function:

Here is the caller graph for this function:

ForceUpdateInvalidFsmState()

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

void stk::test::KernelMock< TMode, TSize, TStrategy, TPlatform >::ForceUpdateInvalidFsmState ( bool max_val )

inline

Definition at line 36 of file stktest_kernel.cpp.

    {
        m_fsm_state_mock = KernelMock::FSM_STATE_MAX + (max_val ? 0 : 1);
 
        Stack *idle = nullptr, *active = this->m_task_now->GetUserStack();
        KernelMock::UpdateFsmState(idle, active);
    }

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::FSM_STATE_MAX, m_fsm_state_mock, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_task_now, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::UpdateFsmState().

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

Here is the call graph for this function:

Here is the caller graph for this function:

GetNewFsmState()

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

BaseType::EFsmState stk::test::KernelMock< TMode, TSize, TStrategy, TPlatform >::GetNewFsmState ( typename BaseType::KernelTask *& next )

inlineoverride

Definition at line 28 of file stktest_kernel.cpp.

    {
        if (m_fsm_state_mock != (uint8_t)KernelMock::FSM_STATE_NONE)
            return static_cast<typename BaseType::EFsmState>(m_fsm_state_mock);
 
        return BaseType::GetNewFsmState(next);
    }

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::FSM_STATE_NONE, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetNewFsmState(), and m_fsm_state_mock.

Here is the call graph for this function:

GetPlatform()

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

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

inlinevirtualinherited

Get platform driver instance owned by this kernel.

Returns

Pointer to the internal TPlatform cast to IPlatform*.

Implements stk::IKernel.

Definition at line 954 of file stk.h.

{ return &m_platform; }

References m_platform.

Referenced by stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TestHrtTaskExitDuringSleepState(), stk::test::TestTaskExit(), and stk::test::TestTaskSleep().

Here is the caller graph for this function:

GetState()

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

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

inlinevirtualinherited

Get kernel state.

Implements stk::IKernel.

Definition at line 963 of file stk.h.

{ return m_state; }

References m_state.

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

Here is the caller graph for this function:

GetSwitchStrategy()

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

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

inlinevirtualinherited

Get task-switching strategy instance owned by this kernel.

Returns

Pointer to the internal TStrategy cast to ITaskSwitchStrategy*.

Implements stk::IKernel.

Definition at line 959 of file stk.h.

{ return &m_strategy; }

References m_strategy.

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

Here is the caller graph for this function:

HrtAllocateAndAddNewTask()

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

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

inlineprotectedinherited

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

Note

Related to stk::KERNEL_HRT mode only.

Parameters

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

Returns

Kernel task.

Definition at line 1105 of file stk.h.

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

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

Referenced by AddTask().

Here is the call graph for this function:

Here is the caller graph for this function:

Initialize()

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

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

inlinevirtualinherited

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

Parameters

[in]

resolution_us

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

Note

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

Implements stk::IKernel.

Definition at line 805 of file stk.h.

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

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

Referenced by stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TestAlgorithm(), stk::test::TestHrtTaskExitDuringSleepState(), stk::test::TestPriorityNext(), stk::test::TestTaskExit(), and stk::test::TestTaskSleep().

Here is the call graph for this function:

InitTraps()

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

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

inlineprotectedinherited

Initialize stack of the traps.

Definition at line 1003 of file stk.h.

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

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

Referenced by Start().

Here is the call graph for this function:

Here is the caller graph for this function:

IsDynamicMode()

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

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

inlinestaticprotectedinherited

Definition at line 1923 of file stk.h.

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

References __stk_forceinline, and stk::KERNEL_DYNAMIC.

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

Here is the caller graph for this function:

IsHrtMode()

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

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

inlinestaticprotectedinherited

Definition at line 1924 of file stk.h.

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

References __stk_forceinline, and stk::KERNEL_HRT.

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

Here is the caller graph for this function:

IsInitialized()

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

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

inlineprotectedinherited

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

Returns

true if Initialize() was called, false otherwise.

Definition at line 1888 of file stk.h.

{ return (m_state != STATE_INACTIVE); }

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

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

Here is the caller graph for this function:

IsStarted()

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

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

inlineinherited

Check whether scheduler is currently running.

Returns

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

Definition at line 946 of file stk.h.

    {
        return (m_task_now != nullptr);
    }

References m_task_now.

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

Here is the caller graph for this function:

IsStaticMode()

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

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

inlinestaticprotectedinherited

Definition at line 1922 of file stk.h.

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

References __stk_forceinline, and stk::KERNEL_STATIC.

IsSyncMode()

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

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

inlinestaticprotectedinherited

Definition at line 1925 of file stk.h.

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

References __stk_forceinline, and stk::KERNEL_SYNC.

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

Here is the caller graph for this function:

IsTicklessMode()

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

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

inlinestaticprotectedinherited

Definition at line 1926 of file stk.h.

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

References __stk_forceinline, and stk::KERNEL_TICKLESS.

Referenced by UpdateTaskState().

Here is the caller graph for this function:

IsValidFsmState()

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

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

inlinestaticprotectedinherited

Check if FSM state is valid.

Definition at line 995 of file stk.h.

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

References __stk_forceinline, FSM_STATE_MAX, and FSM_STATE_NONE.

Referenced by GetNewFsmState().

Here is the caller graph for this function:

OnGetTid()

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

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

inlineprotectedvirtualinherited

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

Parameters

[in]

caller_SP

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

Returns

Task/thread id of the process.

Implements stk::IPlatform::IEventHandler.

Definition at line 1460 of file stk.h.

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

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

Here is the call graph for this function:

OnStart()

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

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

inlineprotectedvirtualinherited

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

Parameters

[out]

active

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

Note

Delivers initial OnTaskSleep notifications to sleep-aware strategies for any tasks that were added in a sleeping state before Start() was called.

Selects the first runnable task via GetNewFsmState() and transitions the kernel to STATE_RUNNING.

If STK_SEGGER_SYSVIEW is enabled, emits a task-start trace event for the first task.

Warning

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

Implements stk::IPlatform::IEventHandler.

Definition at line 1223 of file stk.h.

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

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

Here is the call graph for this function:

OnStop()

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

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

inlineprotectedvirtualinherited

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

Note

KERNEL_DYNAMIC mode only: resets FSM to FSM_STATE_NONE and transitions kernel back to STATE_READY so Start() may be called again.

Has no effect in KERNEL_STATIC mode (static kernels never stop).

Implements stk::IPlatform::IEventHandler.

Definition at line 1290 of file stk.h.

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

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

Here is the call graph for this function:

OnTaskExit()

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

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

inlineprotectedvirtualinherited

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

Parameters

[out]

stack

Stack of the exited task.

Implements stk::IPlatform::IEventHandler.

Definition at line 1401 of file stk.h.

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

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

Here is the call graph for this function:

OnTaskSleep()

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

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

inlineprotectedvirtualinherited

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

Parameters

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

Implements stk::IPlatform::IEventHandler.

Definition at line 1352 of file stk.h.

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

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

Referenced by OnTaskSwitch().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTaskSleepUntil()

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

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

inlineprotectedvirtualinherited

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

Parameters

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

Implements stk::IPlatform::IEventHandler.

Definition at line 1374 of file stk.h.

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

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

Here is the call graph for this function:

OnTaskSwitch()

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

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

inlineprotectedvirtualinherited

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

Parameters

[in]

caller_SP

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

Implements stk::IPlatform::IEventHandler.

Definition at line 1344 of file stk.h.

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

References OnTaskSleep().

Here is the call graph for this function:

OnTaskWait()

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

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

inlineprotectedvirtualinherited

Called from the Thread process when task needs to wait.

Parameters

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

Implements stk::IPlatform::IEventHandler.

Definition at line 1417 of file stk.h.

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

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

Here is the call graph for this function:

OnTick()

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

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

inlineprotectedvirtualinherited

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

Parameters

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

Returns

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

Note

In non-tickless mode the internal tick counter always advances by exactly 1 per call.

In tickless mode (KERNEL_TICKLESS) the counter advances by the ticks value supplied by the platform driver, which may be greater than 1 after a suppressed interval.

Implements stk::IPlatform::IEventHandler.

Definition at line 1317 of file stk.h.

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

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

Here is the call graph for this function:

RemoveTask() [1/2]

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

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

inlinevirtualinherited

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

Parameters

[in]

user_task

User task to remove. Must not be nullptr.

Note

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

Warning

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

Implements stk::IKernel.

Definition at line 895 of file stk.h.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveTask() [2/2]

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

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

inlineprotectedinherited

Remove kernel task.

Note

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

Parameters

[in]

task

Kernel task.

Definition at line 1201 of file stk.h.

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

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

Here is the call graph for this function:

RequestAddTask()

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

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

inlineprotectedinherited

Request to add new task.

Note

Must be called by the task process only!

Parameters

[in]

user_task

User task to add.

Definition at line 1119 of file stk.h.

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

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

Referenced by AddTask().

Here is the call graph for this function:

Here is the caller graph for this function:

ScheduleAddTask()

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

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

inlineprotectedinherited

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

Note

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

Definition at line 1894 of file stk.h.

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

References m_request, and REQUEST_ADD_TASK.

Referenced by RequestAddTask().

Here is the caller graph for this function:

Start()

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

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

inlinevirtualinherited

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

Note

Re-initialises trap stacks on every call so Start() can be called again after a previous scheduling session ended.

If STK_SEGGER_SYSVIEW is enabled, starts tracing and registers all pre-added tasks.

Warning

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

Implements stk::IKernel.

Definition at line 921 of file stk.h.

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

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

Referenced by stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TEST(), stk::test::TestHrtTaskExitDuringSleepState(), stk::test::TestTaskExit(), and stk::test::TestTaskSleep().

Here is the call graph for this function:

StateExit()

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

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

inlineprotectedinherited

Exits from scheduling.

Note

FSM state: stk::FSM_STATE_EXITING.

Exits only if stk::KERNEL_DYNAMIC mode is specified, otherwise ignored.

Parameters

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

Definition at line 1859 of file stk.h.

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

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

Referenced by UpdateFsmState().

Here is the call graph for this function:

Here is the caller graph for this function:

StateSleep()

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

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

inlineprotectedinherited

Enters into a sleeping mode.

Note

FSM state: stk::FSM_STATE_SLEEPING.

Parameters

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

Definition at line 1826 of file stk.h.

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

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

Referenced by UpdateFsmState().

Here is the call graph for this function:

Here is the caller graph for this function:

StateSwitch()

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

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

inlineprotectedinherited

Switches contexts.

Note

FSM state: stk::FSM_STATE_SWITCHING.

Parameters

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

Definition at line 1748 of file stk.h.

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

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

Referenced by UpdateFsmState().

Here is the call graph for this function:

Here is the caller graph for this function:

StateWake()

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

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

inlineprotectedinherited

Wakes up after sleeping.

Note

FSM state: stk::FSM_STATE_WAKING.

Parameters

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

Definition at line 1794 of file stk.h.

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

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

Referenced by UpdateFsmState().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateFsmState()

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

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

inlineprotectedinherited

Update FSM state.

Parameters

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

Returns

FSM state.

Definition at line 1708 of file stk.h.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateSyncObjects()

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

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

inlineprotectedinherited

Update synchronization objects.

Definition at line 1600 of file stk.h.

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

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

Referenced by UpdateTasks().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateTaskRequest()

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

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

inlineprotectedinherited

Update pending task requests.

Definition at line 1621 of file stk.h.

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

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

Referenced by UpdateTasks().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateTasks()

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

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

inlineprotectedinherited

Update tasks (sleep, requests).

Definition at line 1470 of file stk.h.

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

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

Referenced by OnTick().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateTaskState()

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

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

inlineprotectedinherited

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

Parameters

[in]

elapsed_ticks

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

Returns

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

Definition at line 1490 of file stk.h.

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

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::HrtInfo::duration, FSM_STATE_SLEEPING, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::HrtHardFailDeadline(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::HrtIsDeadlineMissed(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::IsBusy(), IsDynamicMode(), IsHrtMode(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::IsPendingRemoval(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::IsSleeping(), IsSyncMode(), IsTicklessMode(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::WaitObject::IsWaiting(), m_fsm_state, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_hrt, m_platform, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_state, m_strategy, m_task_now, m_task_storage, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_time_sleep, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::WaitObject::m_time_wait, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_wait_obj, stk::Max(), stk::Min(), RemoveTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::STATE_SLEEP_PENDING, STK_TICKLESS_TICKS_MAX, and TASKS_MAX.

Referenced by UpdateTasks().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_exit_trap

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

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

protectedinherited

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

Definition at line 1996 of file stk.h.

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

m_fsm

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

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

protectedinherited

Initial value:

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

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

Definition at line 2002 of file stk.h.

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

Referenced by GetNewFsmState().

m_fsm_state

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

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

protectedinherited

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

Definition at line 1997 of file stk.h.

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

m_fsm_state_mock

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

uint8_t stk::test::KernelMock< TMode, TSize, TStrategy, TPlatform >::m_fsm_state_mock = KernelMock::FSM_STATE_NONE

Definition at line 25 of file stktest_kernel.cpp.

Referenced by ForceUpdateInvalidFsmState(), and GetNewFsmState().

m_platform

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

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

protectedinherited

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

Definition at line 1991 of file stk.h.

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

m_request

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

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

protectedinherited

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

Definition at line 1998 of file stk.h.

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

m_service

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

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

protectedinherited

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

Definition at line 1990 of file stk.h.

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

m_sleep_trap

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

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

protectedinherited

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

Definition at line 1995 of file stk.h.

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

m_state

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

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

protectedinherited

Current kernel state.

Definition at line 1999 of file stk.h.

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

m_strategy

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

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

protectedinherited

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

Definition at line 1992 of file stk.h.

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

m_sync_list

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

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

protectedinherited

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

Definition at line 2000 of file stk.h.

Referenced by OnTaskWait(), and UpdateSyncObjects().

m_task_now

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

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

protectedinherited

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

Definition at line 1993 of file stk.h.

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

m_task_storage

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

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

protectedinherited

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

Definition at line 1994 of file stk.h.

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

---

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

• stktest_kernel.cpp