Internal per-slot kernel descriptor that wraps a user ITask instance. More...

#include <stk.h>

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

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

Classes
class	AddTaskRequest
	Payload for an in-flight AddTask() request issued by a running task. More...
class	SrtInfo
	Per-task soft real-time (SRT) metadata. More...
class	HrtInfo
	Per-task Hard Real-Time (HRT) scheduling metadata. More...
class	WaitObject
	Concrete implementation of IWaitObject, embedded in each KernelTask slot. More...

Public Types
typedef DLHeadType	ListHeadType
	List head type for IKernelTask elements.
typedef DLEntryType	ListEntryType
	List entry type of IKernelTask elements.
typedef DListEntry< IKernelTask, _ClosedLoop >	DLEntryType
	Convenience alias for this entry type. Used to avoid repeating the full template spelling.
typedef DListHead< IKernelTask, _ClosedLoop >	DLHeadType
	Convenience alias for the corresponding list head type.

Public Member Functions
	KernelTask ()
	Construct a free (unbound) task slot. All fields set to zero/null.
ITask *	GetUserTask ()
	Get bound user task.
Stack *	GetUserStack ()
	Get stack descriptor for this task slot.
bool	IsBusy () const
	Check whether this slot is bound to a user task.
bool	IsSleeping () const
	Check whether this task is currently sleeping (waiting for a tick or a wake event).
TId	GetTid () const
	Get task identifier.
void	Wake ()
	Wake this task on the next scheduling tick.
void	SetCurrentWeight (int32_t weight)
	Update the run-time scheduling weight (weighted strategies only).
int32_t	GetWeight () const
	Get static scheduling weight from the user task.
int32_t	GetCurrentWeight () const
	Get current (run-time) scheduling weight.
Timeout	GetHrtPeriodicity () const
	Get HRT scheduling periodicity.
Timeout	GetHrtDeadline () const
	Get absolute HRT deadline (ticks elapsed since task was activated).
Timeout	GetHrtRelativeDeadline () const
	Get remaining HRT deadline (ticks left before the deadline expires).
Timeout	GetSleepTicks (Timeout sleep_ticks)
DLHeadType *	GetHead () const
	Get the list head this entry currently belongs to.
DLEntryType *	GetNext () const
	Get the next entry in the list.
DLEntryType *	GetPrev () const
	Get the previous entry in the list.
bool	IsLinked () const
	Check whether this entry is currently a member of any list.
	operator IKernelTask * ()
	Implicit conversion to a mutable pointer to the host object (T).
	operator const IKernelTask * () const
	Implicit conversion to a const pointer to the host object (T).

Protected Member Functions
	~KernelTask ()
	Destructor.
void	Bind (TPlatform platform, ITask user_task)
	Bind this slot to a user task: set access mode, task ID, and initialize the stack.
void	Unbind ()
	Reset this slot to the free (unbound) state, clearing all scheduling metadata.
void	ScheduleRemoval ()
	Schedule the removal of the task from the kernel on next tick.
bool	IsPendingRemoval () const
	Check if task is pending removal.
bool	IsMemoryOfSP (Word SP) const
	Check if Stack Pointer (SP) belongs to this task.
void	HrtInit (Timeout periodicity_tc, Timeout deadline_tc, Timeout start_delay_tc)
	Initialize task with HRT info.
void	HrtOnSwitchedIn ()
	Called when task is switched into the scheduling process.
void	HrtOnSwitchedOut (IPlatform *)
	Called when task is switched out from the scheduling process.
void	HrtHardFailDeadline (IPlatform *platform)
	Hard-fail HRT task when it missed its deadline.
void	HrtOnWorkCompleted ()
	Called when task process called IKernelService::SwitchToNext to inform Kernel that work is completed.
bool	HrtIsDeadlineMissed (Timeout duration) const
	Check if deadline missed.
void	ScheduleSleep (Timeout ticks)
	Put the task into a sleeping state for the specified number of ticks.
void	BusyWaitWhileSleeping () const
	Block further execution of the task's context while in sleeping state.

Protected Attributes
ITask *	m_user
	Bound user task, or `NULL` when slot is free.
Stack	m_stack
	Stack descriptor (SP register value + access mode + optional tid).
volatile uint32_t	m_state
	Bitmask of EStateFlags. Written by task thread, read/cleared by kernel tick.
volatile Timeout	m_time_sleep
	Sleep countdown: negative while sleeping (absolute value = ticks remaining), zero when awake.
SrtInfo	m_srt [((((TMode) &(KERNEL_HRT)) !=0U) ?(0) :(1))]
	SRT metadata. Zero-size (no memory) in KERNEL_HRT mode.
HrtInfo	m_hrt [((((TMode) &(KERNEL_HRT)) !=0U) ?(1) :(0))]
	HRT metadata. Zero-size (no memory) in non-HRT mode.
int32_t	m_rt_weight [((((TStrategy::WEIGHT_API) &(1)) !=0U) ?(1) :(0))]
	Run-time weight for weighted-round-robin scheduling. Zero-size for unweighted strategies.
WaitObject	m_wait_obj [((((TMode) &(KERNEL_SYNC)) !=0U) ?(1) :(0))]
	Embedded wait object for synchronization. Zero-size (no memory) if KERNEL_SYNC is not set.

Private Types
enum	EStateFlags { STATE_NONE = 0 , STATE_REMOVE_PENDING = (1 << 0) , STATE_SLEEP_PENDING = (1 << 1) }
	Bitmask of transient state flags. Set by the task or the kernel and consumed (cleared) during UpdateTaskState() on the next tick. More...

Private Member Functions
void	Link (DLHeadType head, DLEntryType next, DLEntryType *prev)
	Wire this entry into a list between prev and next.
void	Unlink ()
	Remove this entry from its current list.

Private Attributes
DLHeadType *	m_head
	Owning list head, or `NULL` when the entry is not linked.
DLEntryType *	m_next
	Next entry in the list, or `NULL` (open list boundary) / first entry (closed loop).
DLEntryType *	m_prev
	Previous entry in the list, or `NULL` (open list boundary) / last entry (closed loop).

Friends
class	Kernel

Detailed Description

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

Internal per-slot kernel descriptor that wraps a user ITask instance.

Holds the kernel-side state for one task slot: the Stack descriptor, sleep timer, HRT or SRT scheduling metadata, optional wait object (KERNEL_SYNC), and optional weight (weighted strategies). The task-switching strategy operates on KernelTask pointers rather than ITask pointers directly.

A slot is "free" when m_user == NULL (IsBusy() == false). The Kernel pre-allocates TSize slots in m_task_storage; AddTask() finds a free slot and calls Bind().

Definition at line 116 of file stk.h.

Member Typedef Documentation

◆ DLEntryType

typedef DListEntry<IKernelTask, _ClosedLoop> stk::util::DListEntry< IKernelTask, _ClosedLoop >::DLEntryType

inherited

Convenience alias for this entry type. Used to avoid repeating the full template spelling.

Definition at line 70 of file stk_linked_list.h.

◆ DLHeadType

typedef DListHead<IKernelTask, _ClosedLoop> stk::util::DListEntry< IKernelTask, _ClosedLoop >::DLHeadType

inherited

Convenience alias for the corresponding list head type.

Definition at line 75 of file stk_linked_list.h.

◆ ListEntryType

typedef DLEntryType stk::IKernelTask::ListEntryType

inherited

List entry type of IKernelTask elements.

Definition at line 572 of file stk_common.h.

◆ ListHeadType

typedef DLHeadType stk::IKernelTask::ListHeadType

inherited

List head type for IKernelTask elements.

Definition at line 567 of file stk_common.h.

Member Enumeration Documentation

◆ EStateFlags

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

enum stk::Kernel::KernelTask::EStateFlags

private

Bitmask of transient state flags. Set by the task or the kernel and consumed (cleared) during UpdateTaskState() on the next tick.

Enumerator
STATE_NONE	No pending state flags.
STATE_REMOVE_PENDING	Task returned from its Run function; slot will be freed on the next tick (KERNEL_DYNAMIC only).
STATE_SLEEP_PENDING	Task called Sleep/SleepUntil/Yield; strategy's OnTaskSleep() will be invoked on the next tick (sleep-aware strategies only).

Definition at line 124 of file stk.h.

        {
            STATE_NONE           = 0,        
            STATE_REMOVE_PENDING = (1 << 0), 
            STATE_SLEEP_PENDING  = (1 << 1)  
        };

Constructor & Destructor Documentation

◆ KernelTask()

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

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

inlineexplicit

Construct a free (unbound) task slot. All fields set to zero/null.

Note: In KERNEL_SYNC mode the embedded WaitObject back-pointer is wired to this KernelTask at construction so the wait object can wake its owning task.

Definition at line 148 of file stk.h.

                              : m_user(nullptr), m_stack(), m_state(STATE_NONE), m_time_sleep(0),
            m_srt(), m_hrt(), m_rt_weight()
        {
            // bind to wait object
            if (IsSyncMode())
                m_wait_obj->m_task = this;
        }

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsSyncMode(), m_hrt, m_rt_weight, m_srt, m_stack, m_state, m_time_sleep, m_user, m_wait_obj, and STATE_NONE.

Here is the call graph for this function:

◆ ~KernelTask()

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

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

inlineprotected

Destructor.

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

Definition at line 285 of file stk.h.

286 {}

Member Function Documentation

◆ Bind()

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

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

inlineprotected

Bind this slot to a user task: set access mode, task ID, and initialize the stack.

Parameters

[in]	platform	Platform driver used to initialize the stack frame.
[in]	user_task	User task to bind. Asserts that the stack is successfully initialized.

Definition at line 445 of file stk.h.

        {
            // set access mode for this stack
            m_stack.mode = user_task->GetAccessMode();
 
            // set task id for tracking purpose
        #if STK_NEED_TASK_ID
            m_stack.tid = user_task->GetId();
        #endif
 
            // init stack of the user task
            if (!platform->InitStack(STACK_USER_TASK, &m_stack, user_task, user_task))
            {
                STK_ASSERT(false);
            }
 
            // bind user task
            m_user = user_task;
        }

References stk::ITask::GetAccessMode(), stk::ITask::GetId(), m_stack, m_user, stk::STACK_USER_TASK, and STK_ASSERT.

Here is the call graph for this function:

◆ BusyWaitWhileSleeping()

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

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::BusyWaitWhileSleeping ( ) const

inlineprotected

Block further execution of the task's context while in sleeping state.

Definition at line 618 of file stk.h.

        {
            while (IsSleeping())
            {
                __stk_relax_cpu();
            }
        }

References IsSleeping().

Here is the call graph for this function:

◆ GetCurrentWeight()

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

int32_t stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetCurrentWeight ( ) const

inlinevirtual

Get current (run-time) scheduling weight.

Returns: m_rt_weight[0] if WEIGHT_API is true; 1 otherwise.

Note: The run-time weight is decremented each tick by the weighted strategy and reset to GetWeight() when exhausted.

Implements stk::IKernelTask.

Definition at line 212 of file stk.h.

212{ return (TStrategy::WEIGHT_API ? m_rt_weight[0] : 1); }

References m_rt_weight.

◆ GetHead()

DLHeadType * stk::util::DListEntry< IKernelTask, _ClosedLoop >::GetHead ( ) const

inlineinherited

Get the list head this entry currently belongs to.

Returns: Pointer to the owning DListHead, or NULL if the entry is not linked.

Definition at line 80 of file stk_linked_list.h.

80{ return m_head; }

stk::util::DListEntry

Intrusive doubly-linked list node. Embed this as a base class in any object (T) that needs to partici...

Definition stk_linked_list.h:58

◆ GetHrtDeadline()

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

Timeout stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetHrtDeadline ( ) const

inlinevirtual

Get absolute HRT deadline (ticks elapsed since task was activated).

Returns: Deadline in ticks. The task must complete its work within this many ticks of being switched in, or OnDeadlineMissed() is invoked.

Note: KERNEL_HRT mode only. Asserts if called outside HRT mode.

Implements stk::IKernelTask.

Definition at line 230 of file stk.h.

        {
            STK_ASSERT(IsHrtMode());
 
            return (IsHrtMode() ? m_hrt[0].deadline : 0);
        }

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsHrtMode(), m_hrt, and STK_ASSERT.

Here is the call graph for this function:

◆ GetHrtPeriodicity()

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

Timeout stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetHrtPeriodicity ( ) const

inlinevirtual

Get HRT scheduling periodicity.

Returns: Period in ticks between successive activations of this task.

Note: KERNEL_HRT mode only. Asserts if called outside HRT mode.

Implements stk::IKernelTask.

Definition at line 218 of file stk.h.

        {
            STK_ASSERT(IsHrtMode());
 
            return (IsHrtMode() ? m_hrt[0].periodicity : 0);
        }

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsHrtMode(), m_hrt, and STK_ASSERT.

Here is the call graph for this function:

◆ GetHrtRelativeDeadline()

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

Timeout stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetHrtRelativeDeadline ( ) const

inlinevirtual

Get remaining HRT deadline (ticks left before the deadline expires).

Returns: deadline - duration: ticks remaining before the task must call Yield(). A negative or zero value means the deadline has been missed.

Note: KERNEL_HRT mode only. Asserts if called outside HRT mode or while sleeping.

Implements stk::IKernelTask.

Definition at line 242 of file stk.h.

        {
            STK_ASSERT(IsHrtMode());
            STK_ASSERT(!IsSleeping());
 
            return (IsHrtMode() ? (m_hrt[0].deadline - m_hrt[0].duration) : 0);
        }

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsHrtMode(), IsSleeping(), m_hrt, and STK_ASSERT.

Here is the call graph for this function:

◆ GetNext()

DLEntryType * stk::util::DListEntry< IKernelTask, _ClosedLoop >::GetNext ( ) const

inlineinherited

Get the next entry in the list.

Returns: Pointer to the next DListEntry, or NULL if this is the last entry (open list) or the first entry (closed loop, where next wraps to first).

Note: In a closed loop (_ClosedLoop == true) this pointer is never NULL when the entry is linked.

Definition at line 88 of file stk_linked_list.h.

88{ return m_next; }

◆ GetPrev()

DLEntryType * stk::util::DListEntry< IKernelTask, _ClosedLoop >::GetPrev ( ) const

inlineinherited

Get the previous entry in the list.

Returns: Pointer to the previous DListEntry, or NULL if this is the first entry (open list) or the last entry (closed loop, where prev wraps to last).

Note: In a closed loop (_ClosedLoop == true) this pointer is never NULL when the entry is linked.

Definition at line 96 of file stk_linked_list.h.

96{ return m_prev; }

◆ GetSleepTicks()

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

Timeout stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetSleepTicks ( Timeout sleep_ticks )

inline

Definition at line 250 of file stk.h.

        {
            // note: task sleep time is negative
            Timeout task_sleep = Max<Timeout>(0, -m_time_sleep);
 
            if (IsSyncMode())
            {
                // likely task is sleeping during sync operation (see Wait)
                if (m_wait_obj->IsWaiting())
                {
                    // note: sync wait time is positive
                    task_sleep = 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 = Min(sleep_ticks, task_sleep);
                }
                else
                {
                    sleep_ticks = Min(sleep_ticks, task_sleep);
                }
            }
            else
            {
                sleep_ticks = Min(sleep_ticks, task_sleep);
            }
 
            // clamp to [1, STK_TICKLESS_TICKS_MAX] range
            return Max<Timeout>(1, sleep_ticks);
        }

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsSyncMode(), m_time_sleep, m_wait_obj, stk::Max(), and stk::Min().

Here is the call graph for this function:

◆ GetTid()

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

TId stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetTid ( ) const

inline

Get task identifier.

Returns: TId derived from the bound ITask pointer address (unique per task instance).

Definition at line 179 of file stk.h.

179{ return hw::PtrToWord(m_user); }

stk::hw::PtrToWord

__stk_forceinline Word PtrToWord(T *ptr) noexcept

Cast a pointer to a CPU register-width integer.

Definition stk_arch.h:94

References m_user, and stk::hw::PtrToWord().

Here is the call graph for this function:

◆ GetUserStack()

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

Stack * stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetUserStack ( )

inlinevirtual

Get stack descriptor for this task slot.

Returns: Pointer to the Stack (SP register value and access mode flags).

Implements stk::IKernelTask.

Definition at line 164 of file stk.h.

164{ return &m_stack; }

References m_stack.

◆ GetUserTask()

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

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

inlinevirtual

Get bound user task.

Returns: Pointer to the ITask, or NULL if the slot is free (IsBusy() == false).

Implements stk::IKernelTask.

Definition at line 159 of file stk.h.

159{ return m_user; }

References m_user.

◆ GetWeight()

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

int32_t stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::GetWeight ( ) const

inlinevirtual

Get static scheduling weight from the user task.

Returns: ITask::GetWeight() if WEIGHT_API is true; 1 otherwise.

Implements stk::IKernelTask.

Definition at line 205 of file stk.h.

205{ return (TStrategy::WEIGHT_API ? m_user->GetWeight() : 1); }

References m_user.

◆ HrtHardFailDeadline()

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

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::HrtHardFailDeadline ( IPlatform * platform )

inlineprotected

Hard-fail HRT task when it missed its deadline.

Note: Related to stk::KERNEL_HRT mode only.

Parameters

[in] platform Platform driver instance.

Definition at line 567 of file stk.h.

        {
            const Timeout duration = m_hrt[0].duration;
 
            STK_ASSERT(duration >= 0);
            STK_ASSERT(HrtIsDeadlineMissed(duration));
 
            m_user->OnDeadlineMissed(duration);
            platform->ProcessHardFault();
        }

References HrtIsDeadlineMissed(), m_hrt, m_user, stk::IPlatform::ProcessHardFault(), and STK_ASSERT.

Here is the call graph for this function:

◆ HrtInit()

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

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::HrtInit	(	Timeout	periodicity_tc,
		Timeout	deadline_tc,
		Timeout	start_delay_tc )

inlineprotected

Initialize task with HRT info.

Note: Related to stk::KERNEL_HRT mode only.

Parameters

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

Definition at line 523 of file stk.h.

        {
            STK_ASSERT(periodicity_tc > 0);
            STK_ASSERT(deadline_tc > 0);
            STK_ASSERT(start_delay_tc >= 0);
            STK_ASSERT(periodicity_tc < INT32_MAX);
            STK_ASSERT(deadline_tc < INT32_MAX);
 
            m_hrt[0].periodicity = periodicity_tc;
            m_hrt[0].deadline    = deadline_tc;
 
            if (start_delay_tc > 0)
                ScheduleSleep(start_delay_tc);
        }

References m_hrt, ScheduleSleep(), and STK_ASSERT.

Here is the call graph for this function:

◆ HrtIsDeadlineMissed()

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

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::HrtIsDeadlineMissed ( Timeout duration ) const

inlineprotected

Check if deadline missed.

Note: Related to stk::KERNEL_HRT mode only.

Definition at line 590 of file stk.h.

590{ return (duration > m_hrt[0].deadline); }

References m_hrt.

Referenced by HrtHardFailDeadline().

Here is the caller graph for this function:

◆ HrtOnSwitchedIn()

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

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

inlineprotected

Called when task is switched into the scheduling process.

Note: Related to stk::KERNEL_HRT mode only.

Parameters

[in] ticks Current ticks of the Kernel.

Definition at line 542 of file stk.h.

542{}

◆ HrtOnSwitchedOut()

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

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::HrtOnSwitchedOut ( IPlatform * )

inlineprotected

Called when task is switched out from the scheduling process.

Note: Related to stk::KERNEL_HRT mode only.

Parameters

[in]	platform	Platform driver instance.
[in]	ticks	Current ticks of the Kernel.

Definition at line 549 of file stk.h.

        {
            const Timeout duration = m_hrt[0].duration;
 
            STK_ASSERT(duration >= 0);
 
            Timeout sleep = m_hrt[0].periodicity - duration;
            if (sleep > 0)
                ScheduleSleep(sleep);
 
            m_hrt[0].duration = 0;
            m_hrt[0].done     = false;
        }

References m_hrt, ScheduleSleep(), and STK_ASSERT.

Here is the call graph for this function:

◆ HrtOnWorkCompleted()

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

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

inlineprotected

Called when task process called IKernelService::SwitchToNext to inform Kernel that work is completed.

Note: Related to stk::KERNEL_HRT mode only.

Definition at line 581 of file stk.h.

        {
            m_hrt[0].done = true;
            __stk_full_memfence();
        }

References m_hrt.

Referenced by ScheduleRemoval().

Here is the caller graph for this function:

◆ IsBusy()

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

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

inline

Check whether this slot is bound to a user task.

Returns: true if a user task is assigned (m_user != NULL); false if the slot is free.

Definition at line 169 of file stk.h.

169{ return (m_user != nullptr); }

References m_user.

◆ IsLinked()

bool stk::util::DListEntry< IKernelTask, _ClosedLoop >::IsLinked ( ) const

inlineinherited

Check whether this entry is currently a member of any list.

Returns: true if linked (m_head != NULL); false otherwise.

Definition at line 101 of file stk_linked_list.h.

101{ return (GetHead() != nullptr); }

stk::util::DListEntry< IKernelTask, true >::GetHead

DLHeadType * GetHead() const

Definition stk_linked_list.h:80

◆ IsMemoryOfSP()

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

bool stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::IsMemoryOfSP ( Word SP ) const

inlineprotected

Check if Stack Pointer (SP) belongs to this task.

Parameters

[in] SP Stack Pointer.

Definition at line 509 of file stk.h.

        {
            Word *start = m_user->GetStack();
            Word *end   = start + m_user->GetStackSize();
 
            return (SP >= hw::PtrToWord(start)) && (SP <= hw::PtrToWord(end));
        }

References m_user, and stk::hw::PtrToWord().

Here is the call graph for this function:

◆ IsPendingRemoval()

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

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

inlineprotected

Check if task is pending removal.

Definition at line 504 of file stk.h.

504{ return ((m_state & STATE_REMOVE_PENDING) != 0U); }

References m_state, and STATE_REMOVE_PENDING.

◆ IsSleeping()

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

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

inlinevirtual

Check whether this task is currently sleeping (waiting for a tick or a wake event).

Returns: true if m_time_sleep < 0 (negative value encodes remaining sleep ticks).

Implements stk::IKernelTask.

Definition at line 174 of file stk.h.

174{ return (m_time_sleep < 0); }

References m_time_sleep.

Referenced by BusyWaitWhileSleeping(), GetHrtRelativeDeadline(), and Wake().

Here is the caller graph for this function:

◆ Link()

void stk::util::DListEntry< IKernelTask, _ClosedLoop >::Link	(	DLHeadType *	head,
		DLEntryType *	next,
		DLEntryType *	prev )

inlineprivateinherited

Wire this entry into a list between prev and next.

Parameters

[in]	head	The owning DListHead. Stored as a back-pointer for IsLinked() and ownership checks.
[in]	next	The entry that will follow this one, or `NULL` if this becomes the last entry.
[in]	prev	The entry that will precede this one, or `NULL` if this becomes the first entry.

Note: Called exclusively by DListHead::Link(). Assumes the entry is not currently linked. Updates the neighbours' forward/back pointers to splice this entry in.

Definition at line 137 of file stk_linked_list.h.

    {
        m_head = head;
        m_next = next;
        m_prev = prev;
 
        if (m_prev != nullptr)
            m_prev->m_next = this;
 
        if (m_next != nullptr)
            m_next->m_prev = this;
    }

◆ operator const IKernelTask *()

stk::util::DListEntry< IKernelTask, _ClosedLoop >::operator const IKernelTask * ( ) const

inlineinherited

Implicit conversion to a const pointer to the host object (T).

Note: Safe because T must derive from DListEntry<T, _ClosedLoop>. Eliminates the need for explicit static_cast at call sites.; MISRA deviation: [STK-DEV-004] Rule 5-2-x.

Definition at line 115 of file stk_linked_list.h.

115{ return static_cast<const T *>(this); }

◆ operator IKernelTask *()

stk::util::DListEntry< IKernelTask, _ClosedLoop >::operator IKernelTask* ( )

inlineinherited

Implicit conversion to a mutable pointer to the host object (T).

Note: Safe because T must derive from DListEntry<T, _ClosedLoop>. Eliminates the need for explicit static_cast at call sites.; MISRA deviation: [STK-DEV-004] Rule 5-2-x.

Definition at line 108 of file stk_linked_list.h.

108{ return static_cast<T *>(this); }

◆ ScheduleRemoval()

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

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

inlineprotected

Schedule the removal of the task from the kernel on next tick.

Definition at line 489 of file stk.h.

        {
            // make this task sleeping to switch it out from scheduling process
            ScheduleSleep(WAIT_INFINITE);
 
            // mark it as done HRT task
            if (IsHrtMode())
                HrtOnWorkCompleted();
 
            // mark it as pending for removal
            m_state |= STATE_REMOVE_PENDING;
        }

References HrtOnWorkCompleted(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsHrtMode(), m_state, ScheduleSleep(), STATE_REMOVE_PENDING, and stk::WAIT_INFINITE.

Here is the call graph for this function:

◆ ScheduleSleep()

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

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::ScheduleSleep ( Timeout ticks )

inlineprotected

Put the task into a sleeping state for the specified number of ticks.

Parameters

[in] ticks Number of ticks to sleep. Must be > 0.

Note: Stores -ticks in m_time_sleep (negative values indicate sleeping; UpdateTaskState() increments toward 0 each tick until the task wakes).; If the strategy uses SLEEP_EVENT_API and the task is not already sleeping, sets STATE_SLEEP_PENDING so OnTaskSleep() is delivered on the next tick.; A full memory fence is emitted after the assignment so that the ISR-side scheduler sees the updated value without delay.

Definition at line 601 of file stk.h.

        {
            STK_ASSERT(ticks > 0);
 
            // set state first as kernel checks it when task IsSleeping
            if (TStrategy::SLEEP_EVENT_API)
            {
                if (m_time_sleep >= 0)
                    m_state |= STATE_SLEEP_PENDING;
            }
 
            m_time_sleep = -ticks;
            __stk_full_memfence();
        }

References m_state, m_time_sleep, STATE_SLEEP_PENDING, and STK_ASSERT.

Referenced by HrtInit(), HrtOnSwitchedOut(), and ScheduleRemoval().

Here is the caller graph for this function:

◆ SetCurrentWeight()

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

void stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::SetCurrentWeight ( int32_t weight )

inlinevirtual

Update the run-time scheduling weight (weighted strategies only).

Parameters

[in] weight New current weight. Ignored unless TStrategy::WEIGHT_API is true.

Implements stk::IKernelTask.

Definition at line 196 of file stk.h.

        {
            if (TStrategy::WEIGHT_API)
                m_rt_weight[0] = weight;
        }

References m_rt_weight.

◆ Unbind()

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

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

inlineprotected

Reset this slot to the free (unbound) state, clearing all scheduling metadata.

Note: Called by RemoveTask(). After Unbind() the slot is available for the next AddTask().

Definition at line 468 of file stk.h.

        {
            if (IsSyncMode())
            {
                // should be freed from waiting on task exit
                STK_ASSERT(!m_wait_obj->IsWaiting());
            }
 
            m_user       = nullptr;
            m_stack      = {};
            m_state      = STATE_NONE;
            m_time_sleep = 0;
 
            if (IsHrtMode())
                m_hrt[0].Clear();
            else
                m_srt->Clear();
        }

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsHrtMode(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsSyncMode(), m_hrt, m_srt, m_stack, m_state, m_time_sleep, m_user, m_wait_obj, STATE_NONE, and STK_ASSERT.

Here is the call graph for this function:

◆ Unlink()

void stk::util::DListEntry< IKernelTask, _ClosedLoop >::Unlink ( )

inlineprivateinherited

Remove this entry from its current list.

Note: Called exclusively by DListHead::Unlink(). Patches the neighbours' pointers to bridge over this entry, then clears m_head, m_next, and m_prev to NULL so the entry is in a clean unlinked state.; Does not update DListHead::m_count or m_first / m_last — those are the responsibility of the calling DListHead::Unlink().

Definition at line 157 of file stk_linked_list.h.

    {
        if (m_prev != nullptr)
            m_prev->m_next = m_next;
 
        if (m_next != nullptr)
            m_next->m_prev = m_prev;
 
        m_head = nullptr;
        m_next = nullptr;
        m_prev = nullptr;
    }

◆ Wake()

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

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

inlinevirtual

Wake this task on the next scheduling tick.

Note: Sets m_time_sleep to -1 (one tick remaining) so the task exits sleep state on the next UpdateTaskState() pass. Asserts that the task is currently sleeping.

Implements stk::IKernelTask.

Definition at line 185 of file stk.h.

        {
            STK_ASSERT(IsSleeping());
 
            // wakeup on a next cycle
            m_time_sleep = -1;
        }

References IsSleeping(), m_time_sleep, and STK_ASSERT.

Here is the call graph for this function:

◆ Kernel

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

friend class Kernel

friend

Definition at line 118 of file stk.h.

References Kernel.

Referenced by Kernel.

Member Data Documentation

◆ m_head

DLHeadType* stk::util::DListEntry< IKernelTask, _ClosedLoop >::m_head

privateinherited

Owning list head, or NULL when the entry is not linked.

Definition at line 170 of file stk_linked_list.h.

◆ m_hrt

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

HrtInfo stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_hrt[((((TMode) &(KERNEL_HRT)) !=0U) ?(1) :(0))]

protected

HRT metadata. Zero-size (no memory) in non-HRT mode.

Definition at line 631 of file stk.h.

Referenced by GetHrtDeadline(), GetHrtPeriodicity(), GetHrtRelativeDeadline(), HrtHardFailDeadline(), HrtInit(), HrtIsDeadlineMissed(), HrtOnSwitchedOut(), HrtOnWorkCompleted(), KernelTask(), and Unbind().

◆ m_next

DLEntryType* stk::util::DListEntry< IKernelTask, _ClosedLoop >::m_next

privateinherited

Next entry in the list, or NULL (open list boundary) / first entry (closed loop).

Definition at line 171 of file stk_linked_list.h.

◆ m_prev

DLEntryType* stk::util::DListEntry< IKernelTask, _ClosedLoop >::m_prev

privateinherited

Previous entry in the list, or NULL (open list boundary) / last entry (closed loop).

Definition at line 172 of file stk_linked_list.h.

◆ m_rt_weight

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

int32_t stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_rt_weight[((((TStrategy::WEIGHT_API) &(1)) !=0U) ?(1) :(0))]

protected

Run-time weight for weighted-round-robin scheduling. Zero-size for unweighted strategies.

Definition at line 632 of file stk.h.

Referenced by GetCurrentWeight(), KernelTask(), and SetCurrentWeight().

◆ m_srt

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

SrtInfo stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_srt[((((TMode) &(KERNEL_HRT)) !=0U) ?(0) :(1))]

protected

SRT metadata. Zero-size (no memory) in KERNEL_HRT mode.

Definition at line 630 of file stk.h.

Referenced by KernelTask(), and Unbind().

◆ m_stack

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

Stack stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_stack

protected

Stack descriptor (SP register value + access mode + optional tid).

Definition at line 627 of file stk.h.

Referenced by Bind(), GetUserStack(), KernelTask(), and Unbind().

◆ m_state

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

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

protected

Bitmask of EStateFlags. Written by task thread, read/cleared by kernel tick.

Definition at line 628 of file stk.h.

Referenced by IsPendingRemoval(), KernelTask(), ScheduleRemoval(), ScheduleSleep(), and Unbind().

◆ m_time_sleep

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

volatile Timeout stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_time_sleep

protected

Sleep countdown: negative while sleeping (absolute value = ticks remaining), zero when awake.

Definition at line 629 of file stk.h.

Referenced by GetSleepTicks(), IsSleeping(), KernelTask(), ScheduleSleep(), Unbind(), and Wake().

◆ m_user

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

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

protected

Bound user task, or NULL when slot is free.

Definition at line 626 of file stk.h.

Referenced by Bind(), GetTid(), GetUserTask(), GetWeight(), HrtHardFailDeadline(), IsBusy(), IsMemoryOfSP(), KernelTask(), and Unbind().

◆ m_wait_obj

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

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

protected

Embedded wait object for synchronization. Zero-size (no memory) if KERNEL_SYNC is not set.

Definition at line 633 of file stk.h.

Referenced by GetSleepTicks(), KernelTask(), and Unbind().

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

stk.h

Classes

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ DLEntryType

◆ DLHeadType

◆ ListEntryType

◆ ListHeadType

Member Enumeration Documentation

◆ EStateFlags

Constructor & Destructor Documentation

◆ KernelTask()

◆ ~KernelTask()

Member Function Documentation

◆ Bind()

◆ BusyWaitWhileSleeping()

◆ GetCurrentWeight()

◆ GetHead()

◆ GetHrtDeadline()

◆ GetHrtPeriodicity()

◆ GetHrtRelativeDeadline()

◆ GetNext()

◆ GetPrev()

◆ GetSleepTicks()

◆ GetTid()

◆ GetUserStack()

◆ GetUserTask()

◆ GetWeight()

◆ HrtHardFailDeadline()

◆ HrtInit()

◆ HrtIsDeadlineMissed()

◆ HrtOnSwitchedIn()

◆ HrtOnSwitchedOut()

◆ HrtOnWorkCompleted()

◆ IsBusy()

◆ IsLinked()

◆ IsMemoryOfSP()

◆ IsPendingRemoval()

◆ IsSleeping()

◆ Link()

◆ operator const IKernelTask *()

◆ operator IKernelTask *()

◆ ScheduleRemoval()

◆ ScheduleSleep()

◆ SetCurrentWeight()

◆ Unbind()

◆ Unlink()

◆ Wake()

Friends And Related Symbol Documentation

◆ Kernel

Member Data Documentation

◆ m_head

◆ m_hrt

◆ m_next

◆ m_prev

◆ m_rt_weight

◆ m_srt

◆ m_stack

◆ m_state

◆ m_time_sleep

◆ m_user

◆ m_wait_obj