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.
enum
	A tag for type-safe casts done by CastListEntryToParent. More...
typedef DListEntry< IKernelTask, TClosedLoop >	DLEntryType
	Convenience alias for this entry type. Used to avoid repeating the full template spelling.
typedef DListHead< IKernelTask, TClosedLoop >	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 () override
	Get bound user task.
Stack	GetUserStack () const override
	Get stack descriptor for this task slot.
bool	IsBusy () const
	Check whether this slot is bound to a user task.
bool	IsSleeping () const override
	Check whether this task is currently sleeping (waiting for a tick or a wake event).
bool	IsSleepInfinite () const
	Check whether this task is currently sleeping infinitely.
TId	GetTid () const
	Get task identifier.
void	Wake () override
	Wake this task on the next scheduling tick.
void	SetCurrentWeight (Weight weight) override
	Update the run-time scheduling weight (weighted strategies only).
Weight	GetWeight () const override
	Get static scheduling weight from the user task.
Weight	GetCurrentWeight () const override
	Get current (run-time) scheduling weight.
Timeout	GetHrtPeriodicity () const override
	Get HRT scheduling periodicity.
Timeout	GetHrtDeadline () const override
	Get absolute HRT deadline (ticks elapsed since task was activated).
Timeout	GetHrtRelativeDeadline () const override
	Get remaining HRT deadline (ticks left before the deadline expires).
Timeout	GetSleepTicks (Timeout sleep_ticks)
DLHeadType *	GetHead ()
	Get the list head this entry currently belongs to.
DLEntryType *	GetNext ()
	Get the next entry in the list.
DLEntryType *	GetPrev ()
	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 ()=default
	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 ()
	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 (Kernel *kernel) const
	Block further execution of the task's context while in sleeping state.
Stack *	GetUserStackPtr ()
	Get pointer to user Stack.

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 [STK_ALLOCATE_COUNT< TMode, KERNEL_HRT, 0U, 1U >::Value]
	SRT metadata. Zero-size (no memory) in KERNEL_HRT mode.
HrtInfo	m_hrt [STK_ALLOCATE_COUNT< TMode, KERNEL_HRT, 1U, 0U >::Value]
	HRT metadata. Zero-size (no memory) in non-HRT mode.
Weight	m_rt_weight [STK_ALLOCATE_COUNT< TStrategy::WEIGHT_API, 1U, 1U, 0U >::Value]
	Run-time weight for weighted-round-robin scheduling. Zero-size for unweighted strategies.
WaitObject	m_wait_obj [STK_ALLOCATE_COUNT< TMode, KERNEL_SYNC, 1U, 0U >::Value]
	Embedded wait object for synchronization. Zero-size (no memory) if KERNEL_SYNC is not set.

Private Types
enum	EStateFlags : uint32_t { STATE_NONE = 0 , STATE_REMOVE_PENDING = (1 << 0) , STATE_SLEEP_PENDING = (1 << 1) , STATE_WAKE_PENDING = (1 << 2) }
	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 125 of file stk.h.

Member Typedef Documentation

◆ DLEntryType

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

inherited

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

Definition at line 75 of file stk_linked_list.h.

◆ DLHeadType

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

inherited

Convenience alias for the corresponding list head type.

Definition at line 80 of file stk_linked_list.h.

◆ ListEntryType

typedef DLEntryType stk::IKernelTask::ListEntryType

inherited

List entry type of IKernelTask elements.

Definition at line 895 of file stk_common.h.

◆ ListHeadType

typedef DLHeadType stk::IKernelTask::ListHeadType

inherited

List head type for IKernelTask elements.

Definition at line 890 of file stk_common.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

inherited

A tag for type-safe casts done by CastListEntryToParent.

See also: CastListEntryToParent.

Definition at line 70 of file stk_linked_list.h.

70{ DLEntryTag = 1 };

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

◆ EStateFlags

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

enum stk::Kernel::KernelTask::EStateFlags : uint32_t

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).
STATE_WAKE_PENDING	Task wake is pending (see Wake).

Definition at line 133 of file stk.h.

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

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

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

References __stk_constexpr_cpp17, 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, stk::NO_WAIT, 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 ( )

protecteddefault

Destructor.

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

References STK_VIRT_DTOR.

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

        {
            // bind user task (GetTid depends on m_user)
            m_user = user_task;
 
            // set access mode for this stack
            m_stack.access_mode = user_task->GetAccessMode();
 
            // set task id for tracking purpose
        #if STK_STACK_NEEDS_TASK_ID
            m_stack.tid = GetTid();
            STK_ASSERT(m_stack.tid != TID_NONE);
        #endif
 
            // init stack of the user task
            platform->InitStack(STACK_USER_TASK, &m_stack, user_task, user_task);
 
            // initialize current weight to NO_WEIGHT for priority inheritance mechanism
            if __stk_constexpr_cpp17 (TStrategy::PRIORITY_INHERITANCE_API)
            {
                SetCurrentWeight(NO_WEIGHT);
            }
        }

References __stk_constexpr_cpp17, stk::ITask::GetAccessMode(), GetTid(), m_stack, m_user, stk::NO_WEIGHT, SetCurrentWeight(), stk::STACK_USER_TASK, STK_ASSERT, and stk::TID_NONE.

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 ( Kernel * kernel ) const

inlineprotected

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

Definition at line 767 of file stk.h.

        {
            kernel->m_platform.ForceContextSwitch(GetTid());
 
            while (IsSleeping())
            {
                __stk_relax_cpu();
            }
        }

References GetTid(), IsSleeping(), Kernel, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::m_platform.

Here is the call graph for this function:

◆ GetCurrentWeight()

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

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

inlineoverridevirtual

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

        {
            Weight cur_weight;
          
            if __stk_constexpr_cpp17 (TStrategy::WEIGHT_API)
            {
                cur_weight = m_rt_weight[0];
            }
            else
            {
                cur_weight = DEFAULT_WEIGHT;
            }
            
            return cur_weight;
        }

References __stk_constexpr_cpp17, stk::DEFAULT_WEIGHT, and m_rt_weight.

◆ GetHead()

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

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 85 of file stk_linked_list.h.

85{ return m_head; }

◆ GetHrtDeadline()

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

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

inlineoverridevirtual

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

        {
            STK_ASSERT(IsHrtMode());
            
            Timeout deadline;
 
            if __stk_constexpr_cpp17 (IsHrtMode())
            {
                deadline = m_hrt[0].deadline;
            }
            else
            {
                deadline = 0;
            }
            
            return deadline;
        }

References __stk_constexpr_cpp17, 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

inlineoverridevirtual

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

        {
            STK_ASSERT(IsHrtMode());
            
            Timeout to;
            
            if __stk_constexpr_cpp17 (IsHrtMode())
            {
                to = m_hrt[0].periodicity;
            }
            else
            {
                to = 0;
            }
            
            return to;
        }

References __stk_constexpr_cpp17, 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

inlineoverridevirtual

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

Returns: deadline - duration: ticks remaining before the task must call Yield(). Zero means this is the last tick still within the deadline; a negative value means the deadline has already been missed (see HrtIsDeadlineMissed(), which uses a strict duration > deadline comparison).

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

Implements stk::IKernelTask.

Definition at line 337 of file stk.h.

        {
            STK_ASSERT(IsHrtMode());
            STK_ASSERT(!IsSleeping());
            
            Timeout relative_deadline;
 
            if __stk_constexpr_cpp17 (IsHrtMode())
            {
                relative_deadline = (m_hrt[0].deadline - m_hrt[0].duration);
            }
            else
            {
                relative_deadline = 0;
            }
            
            return relative_deadline;
        }

References __stk_constexpr_cpp17, 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, TClosedLoop >::GetNext ( )

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 (TClosedLoop == true) this pointer is never NULL when the entry is linked.

Definition at line 98 of file stk_linked_list.h.

98{ return m_next; }

◆ GetPrev()

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

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 (TClosedLoop == true) this pointer is never NULL when the entry is linked.

Definition at line 114 of file stk_linked_list.h.

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

        {
            // note: task sleep time is negative
            Timeout task_sleep = Max<Timeout>(NO_WAIT, -m_time_sleep);
 
            if __stk_constexpr_cpp17 (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 > NO_WAIT)
                    {
                        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_constexpr_cpp17, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::IsSyncMode(), m_time_sleep, m_wait_obj, stk::Max(), stk::Min(), and stk::NO_WAIT.

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

196{ return GetTidFromUserTask(m_user); }

stk::GetTidFromUserTask

static constexpr TId GetTidFromUserTask(const ITask *task) noexcept

Get task identifier from ITask instance.

Definition stk_arch.h:716

References stk::GetTidFromUserTask(), and m_user.

Referenced by Bind(), and BusyWaitWhileSleeping().

Here is the call graph for this function:

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

inlineoverridevirtual

Get stack descriptor for this task slot.

Returns: Stack info (SP register value and access mode flags).

Implements stk::IKernelTask.

Definition at line 176 of file stk.h.

176{ return m_stack;}

References m_stack.

◆ GetUserStackPtr()

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

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

inlineprotected

Get pointer to user Stack.

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

Definition at line 780 of file stk.h.

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

inlineoverridevirtual

Get bound user task.

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

Implements stk::IKernelTask.

Definition at line 171 of file stk.h.

171{ return m_user; }

References m_user.

◆ GetWeight()

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

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

inlineoverridevirtual

Get static scheduling weight from the user task.

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

Implements stk::IKernelTask.

Definition at line 230 of file stk.h.

        {
            Weight static_weight;
 
            if __stk_constexpr_cpp17 (TStrategy::PRIORITY_INHERITANCE_API)
            {
                if (m_rt_weight[0] != NO_WEIGHT)
                {
                    static_weight = m_rt_weight[0];
                }
                else                   
                {
                    if __stk_constexpr_cpp17 (TStrategy::WEIGHT_API)
                    {
                        static_weight = m_user->GetWeight();
                    }
                    else
                    {
                        static_weight = DEFAULT_WEIGHT;
                    }
                }
            }
            else if __stk_constexpr_cpp17 (TStrategy::WEIGHT_API)
            {
                static_weight = m_user->GetWeight();
            }
            else
            {
                static_weight = DEFAULT_WEIGHT;
            }
 
            return static_weight;
        }

References __stk_constexpr_cpp17, stk::DEFAULT_WEIGHT, m_rt_weight, m_user, and stk::NO_WEIGHT.

◆ 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 713 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 668 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 736 of file stk.h.

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

Definition at line 688 of file stk.h.

688{}

◆ HrtOnSwitchedOut()

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

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

inlineprotected

Called when task is switched out from the scheduling process.

Note: Related to stk::KERNEL_HRT mode only.

Definition at line 693 of file stk.h.

        {
            const Timeout duration = m_hrt[0].duration;
 
            STK_ASSERT(duration >= 0);
 
            const 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 727 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 181 of file stk.h.

181{ return (m_user != nullptr); }

References m_user.

◆ IsLinked()

bool stk::util::DListEntry< IKernelTask, TClosedLoop >::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 127 of file stk_linked_list.h.

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

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

DLHeadType * GetHead()

Definition stk_linked_list.h:85

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

        {
            bool is_match = false;
 
            const Word start = hw::PtrToWord(m_user->GetStack());
            const Word end   = start + (m_user->GetStackSize() * sizeof(Word));
 
            if ((SP >= start) && (SP <= end))
            {
                is_match = true;
            }
        #if STK_TZ_SECURE // lookup Secure memory region too when on a Secure side
            else
            {
                IStackMemory *const secure_mem = m_user->GetSecureStackMemory();
 
                if (secure_mem != nullptr)
                {
                    const Word s_start = hw::PtrToWord(secure_mem->GetStack());
                    const Word s_end   = s_start + (secure_mem->GetStackSize() * sizeof(Word));
 
                    if ((SP >= s_start) && (SP <= s_end))
                    {
                        is_match = true;
                    }
                }
            }
        #endif
 
            return is_match;
        }

References stk::IStackMemory::GetStack(), stk::IStackMemory::GetStackSize(), 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 625 of file stk.h.

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

References m_state, and STATE_REMOVE_PENDING.

◆ IsSleepInfinite()

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

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

inline

Check whether this task is currently sleeping infinitely.

Returns: true if m_time_sleep == -WAIT_INFINITE.

Definition at line 191 of file stk.h.

191{ return (m_time_sleep == -WAIT_INFINITE); }

References __stk_forceinline, m_time_sleep, and stk::WAIT_INFINITE.

◆ IsSleeping()

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

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

inlineoverridevirtual

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

186{ return (m_time_sleep < 0); }

References __stk_forceinline, and m_time_sleep.

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

Here is the caller graph for this function:

◆ Link()

void stk::util::DListEntry< IKernelTask, TClosedLoop >::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 162 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, TClosedLoop >::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, TClosedLoop>. Eliminates the need for explicit static_cast at call sites.; MISRA deviation: [STK-DEV-004] Rule 5-2-x.

Definition at line 141 of file stk_linked_list.h.

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

◆ operator IKernelTask *()

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

inlineinherited

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

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

Definition at line 134 of file stk_linked_list.h.

134{ 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 608 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 __stk_constexpr_cpp17 (IsHrtMode())
            {
                HrtOnWorkCompleted();
            }
 
            // mark it as pending for removal
            m_state |= STATE_REMOVE_PENDING;
        }

References __stk_constexpr_cpp17, 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 750 of file stk.h.

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

References IsSleeping(), m_state, m_time_sleep, STATE_SLEEP_PENDING, and STK_ASSERT.

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

Here is the call graph for this function:

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

inlineoverridevirtual

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

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

References __stk_constexpr_cpp17, and m_rt_weight.

Referenced by Bind().

Here is the caller graph for this function:

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

        {
            if __stk_constexpr_cpp17 (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 __stk_constexpr_cpp17 (IsHrtMode())
            {
                m_hrt[0].Clear();
            }
            else
            {
                m_srt->Clear();
            }
        }

References __stk_constexpr_cpp17, 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, TClosedLoop >::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 186 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 ( )

inlineoverridevirtual

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

        {
            STK_ASSERT(IsSleeping());
 
            // wakeup on a next cycle
            m_time_sleep = -1;
 
            // notify kernel that this task, even if was going to sleep will be woken on a next tick
            if ((m_state & STATE_SLEEP_PENDING) != 0U)
            {
                m_state |= STATE_WAKE_PENDING;
            }
        }

References IsSleeping(), m_state, m_time_sleep, STATE_SLEEP_PENDING, STATE_WAKE_PENDING, 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 127 of file stk.h.

References Kernel.

Referenced by BusyWaitWhileSleeping(), and Kernel.

Member Data Documentation

◆ m_head

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

privateinherited

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

Definition at line 203 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[STK_ALLOCATE_COUNT< TMode, KERNEL_HRT, 1U, 0U >::Value]

protected

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

Definition at line 787 of file stk.h.

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

◆ m_next

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

privateinherited

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

Definition at line 204 of file stk_linked_list.h.

◆ m_prev

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

privateinherited

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

Definition at line 205 of file stk_linked_list.h.

◆ m_rt_weight

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

Weight stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::m_rt_weight[STK_ALLOCATE_COUNT< TStrategy::WEIGHT_API, 1U, 1U, 0U >::Value]

protected

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

Definition at line 788 of file stk.h.

Referenced by GetCurrentWeight(), GetWeight(), 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[STK_ALLOCATE_COUNT< TMode, KERNEL_HRT, 0U, 1U >::Value]

protected

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

Definition at line 786 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 783 of file stk.h.

Referenced by Bind(), GetUserStack(), GetUserStackPtr(), 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 784 of file stk.h.

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

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

Referenced by GetSleepTicks(), IsSleepInfinite(), 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 782 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[STK_ALLOCATE_COUNT< TMode, KERNEL_SYNC, 1U, 0U >::Value]

protected

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

Definition at line 789 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

◆ anonymous enum

◆ EStateFlags

Constructor & Destructor Documentation

◆ KernelTask()

◆ ~KernelTask()

Member Function Documentation

◆ Bind()

◆ BusyWaitWhileSleeping()

◆ GetCurrentWeight()

◆ GetHead()

◆ GetHrtDeadline()

◆ GetHrtPeriodicity()

◆ GetHrtRelativeDeadline()

◆ GetNext()

◆ GetPrev()

◆ GetSleepTicks()

◆ GetTid()

◆ GetUserStack()

◆ GetUserStackPtr()

◆ GetUserTask()

◆ GetWeight()

◆ HrtHardFailDeadline()

◆ HrtInit()

◆ HrtIsDeadlineMissed()

◆ HrtOnSwitchedIn()

◆ HrtOnSwitchedOut()

◆ HrtOnWorkCompleted()

◆ IsBusy()

◆ IsLinked()

◆ IsMemoryOfSP()

◆ IsPendingRemoval()

◆ IsSleepInfinite()

◆ 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