Fixed-priority preemptive scheduling strategy with round-robin arbitration within each priority level. More...

#include <stk_strategy_fpriority.h>

Inheritance diagram for stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >:

Collaboration diagram for stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >:

Public Types
enum	EConfig { WEIGHT_API = 1 , SLEEP_EVENT_API = 1 , DEADLINE_MISSED_API = 0 , PRIORITY_INHERITANCE_API = 1 , NOSLEEP_YIELD_API = NoSleepYield , TIMESLICE_API = 0 }
	Compile-time capability flags reported to the kernel. More...
enum	EPriority { PRIORITY_HIGHEST = (MAX_PRIORITIES - 1) , PRIORITY_HIGH = ((MAX_PRIORITIES / 2) + (MAX_PRIORITIES - 1)) / 2 , PRIORITY_ABOVE_NORMAL = (MAX_PRIORITIES / 2) + 1 , PRIORITY_NORMAL = (MAX_PRIORITIES / 2) , PRIORITY_BELOW_NORMAL = (MAX_PRIORITIES / 2) - 1 , PRIORITY_LOWER = (MAX_PRIORITIES / 4) , PRIORITY_ABOVE_LOWEST = (0 + 1) , PRIORITY_LOWEST = 0 }
	Symbolic priority level constants for common use cases. More...

Public Member Functions
	SwitchStrategyFixedPriority ()
	Construct an empty strategy with all priority levels empty, a clear bitmap, and null cursors.
STK_VIRT_DTOR	~SwitchStrategyFixedPriority ()=default
	Destructor.
void	AddTask (IKernelTask *task) override
	Add task to the runnable set at its fixed priority level.
void	RemoveTask (IKernelTask *task) override
	Remove task from whichever list it currently occupies.
IKernelTask *	GetNext () override
	Select and return the next task to run.
IKernelTask *	GetFirst () override
	Get the first task in the managed set (used by the kernel for initial scheduling).
size_t	GetSize () const override
	Get the total number of tasks managed by this strategy.
void	OnTaskSleep (IKernelTask *task) override
	Notification that a task has entered the sleeping state.
void	OnTaskWake (IKernelTask *task) override
	Notification that a task has become runnable again.
void	OnTaskWeightChange (IKernelTask *task, Weight old_weight) override
	Move a runnable task to a new priority level after its weight changed.
bool	OnTaskYield (IKernelTask *task) override
	Notification that the running task called Yield() (non-HRT kernel modes only).
virtual bool	OnTaskTimeSlice (IKernelTask *task)
	Notification that the running task's time slice expired (KERNEL_TIMESLICE only).
virtual bool	OnTaskDeadlineMissed (IKernelTask *task)
	Notification that a task has exceeded its HRT deadline; returns whether the strategy can recover without a hard fault.

Protected Types
typedef uint8_t	Priority
	Priority type.

Protected Member Functions
void	AddActive (IKernelTask *task)
	Append a task to its priority level's runnable list and update the bitmap.
void	RemoveActive (IKernelTask *task, const Priority prio)
	Remove a task from its priority level's runnable list and update the bitmap/cursor.

Static Protected Member Functions
static __stk_forceinline Priority	GetTaskPriorityFromWeight (int32_t weight)
	Get priority from the task.
static __stk_forceinline Priority	GetTaskPriority (IKernelTask *task)
	Get priority from the task.
static __stk_forceinline Priority	GetHighestReadyPriority (uint32_t bitmap)
	Find the index of the highest set bit in bitmap.

Private Member Functions
	STK_NONCOPYABLE_CLASS (SwitchStrategyFixedPriority)

Private Attributes
IKernelTask::ListHeadType	m_tasks [MAX_PRIORITIES]
	Per-priority runnable task lists. m_tasks[i] holds all runnable tasks at priority level i.
IKernelTask::ListHeadType	m_sleep
	Sleeping (blocked) tasks. Priority is retained in GetWeight() and restored on OnTaskWake().
uint32_t	m_ready_bitmap
	Bitmask of non-empty priority levels: bit i is set when m_tasks[i] has at least one runnable task. Updated by AddActive() (bit set) and RemoveActive() (bit cleared on last removal).
IKernelTask *	m_prev [MAX_PRIORITIES]
	Per-priority round-robin cursor. m_prev[i] is the most recently scheduled task at level i, or `nullptr` when level i is empty. GetNext() advances from this position.

Detailed Description

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>
class stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >

Fixed-priority preemptive scheduling strategy with round-robin arbitration within each priority level.

Template Parameters

MAX_PRIORITIES	Number of distinct priority levels. Must be in the range [1, 32] (enforced by a compile-time assertion). Bit `i` of the 32-bit `m_ready_bitmap` represents priority level `i`. The concrete alias SwitchStrategyFP32 uses MAX_PRIORITIES = 32.
NoSleepYield	If true, Yield() keeps the task in the runnable set and hands the CPU to the next task at the same priority level (see OnTaskYield). If false (default), the kernel performs the legacy yield: the task sleeps for YIELD_TICKS, which also lets lower-priority tasks run during that tick.

Priority assignment: Each task's priority is read from ITask::GetWeight(), cast to uint8_t, and must be in the range [0, MAX_PRIORITIES - 1]. Tasks do not use the dynamic current-weight mechanism, the static weight value is the priority. Configure a task's priority by overriding ITask::GetWeight() to return the desired level.

Scheduling rules

The highest runnable priority level is always selected. A task at priority N will never run while any task at priority > N is runnable.
Tasks at the same priority level are scheduled in round-robin order (one tick slice each), using a per-level cursor (m_prev[prio]).
Higher numeric value = higher priority. 0 is the lowest, MAX_PRIORITIES - 1 is highest.

No-sleep yield: When NoSleepYield is true, OnTaskYield() moves the yielding task's per-level cursor onto the task itself, so the following GetNext() returns its successor at the same priority level. If the task is alone at its level, it is selected again (no context switch): a yield never hands the CPU to a lower priority level, unlike the legacy sleep-based yield.

Priority detection — O(1) bitmap: m_ready_bitmap is a 32-bit bitmask where bit i is set whenever priority level i has at least one runnable task. GetNext() and GetFirst() locate the highest set bit in O(1) via __builtin_clz (GCC/Clang) or a portable 32->0 scan fallback. The bitmap is kept consistent by AddActive() (bit set) and RemoveActive() (bit cleared on last removal).

Note: Uses the Weight API (WEIGHT_API = 1): GetWeight() is interpreted as the task's fixed priority level. The dynamic weight functions (SetCurrentWeight / GetCurrentWeight) are not used by this strategy.; Requires the kernel Sleep API (SLEEP_EVENT_API = 1): OnTaskSleep() and OnTaskWake() maintain the per-priority runnable lists and keep m_ready_bitmap accurate.

See also: SwitchStrategyFP32, SwitchStrategyFP32_NSY, ITaskSwitchStrategy, ITask::GetWeight

Definition at line 69 of file stk_strategy_fpriority.h.

Member Typedef Documentation

◆ Priority

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

typedef uint8_t stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::Priority

protected

Priority type.

Definition at line 339 of file stk_strategy_fpriority.h.

Member Enumeration Documentation

◆ EConfig

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

enum stk::SwitchStrategyFixedPriority::EConfig

Compile-time capability flags reported to the kernel.

Enumerator
WEIGHT_API	This strategy interprets GetWeight() as the task's fixed priority level (0 .. MAX_PRIORITIES - 1). Dynamic weight functions are not used.
SLEEP_EVENT_API	This strategy requires OnTaskSleep() / OnTaskWake() events to maintain per-priority runnable lists and keep `m_ready_bitmap` accurate.
DEADLINE_MISSED_API	This strategy does not use OnTaskDeadlineMissed() events.
PRIORITY_INHERITANCE_API	This strategy expects OnTaskPriorityChange() events to support priority inheritance requests.
NOSLEEP_YIELD_API	(1) enables OnTaskYield(): yielding task stays runnable and hands the CPU to same-priority peers.
TIMESLICE_API	This strategy does not support KERNEL_TIMESLICE mode.

Definition at line 75 of file stk_strategy_fpriority.h.

    {
        WEIGHT_API               = 1, 
        SLEEP_EVENT_API          = 1, 
        DEADLINE_MISSED_API      = 0, 
        PRIORITY_INHERITANCE_API = 1, 
        NOSLEEP_YIELD_API        = NoSleepYield, 
        TIMESLICE_API            = 0  
    };

◆ EPriority

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

enum stk::SwitchStrategyFixedPriority::EPriority

Symbolic priority level constants for common use cases.

Note: Concrete values depend on MAX_PRIORITIES. For SwitchStrategyFP32 (MAX_PRIORITIES = 32): PRIORITY_HIGHEST = 31, PRIORITY_HIGH = 23, PRIORITY_ABOVE_NORMAL = 17, PRIORITY_NORMAL = 16, PRIORITY_BELOW_NORMAL = 15, PRIORITY_LOWER = 8, PRIORITY_ABOVE_LOWEST = 1, PRIORITY_LOWEST = 0.

Enumerator
PRIORITY_HIGHEST	Highest available priority level.
PRIORITY_HIGH	High priority; mid-point between NORMAL and HIGHEST.
PRIORITY_ABOVE_NORMAL	Slightly elevated priority; one step above NORMAL.
PRIORITY_NORMAL	Mid-range priority level (MAX_PRIORITIES / 2).
PRIORITY_BELOW_NORMAL	Slightly reduced priority; one step below NORMAL.
PRIORITY_LOWER	Lower priority; mid-point between LOWEST and NORMAL.
PRIORITY_ABOVE_LOWEST	Slightly elevated low priority; one step above LOWEST.
PRIORITY_LOWEST	Lowest priority level; tasks only run when idle.

Definition at line 92 of file stk_strategy_fpriority.h.

    {
        PRIORITY_HIGHEST      = (MAX_PRIORITIES - 1),     
        PRIORITY_HIGH         = ((MAX_PRIORITIES / 2) + (MAX_PRIORITIES - 1)) / 2, 
        PRIORITY_ABOVE_NORMAL = (MAX_PRIORITIES / 2) + 1, 
        PRIORITY_NORMAL       = (MAX_PRIORITIES / 2),     
        PRIORITY_BELOW_NORMAL = (MAX_PRIORITIES / 2) - 1, 
        PRIORITY_LOWER        = (MAX_PRIORITIES / 4),     
        PRIORITY_ABOVE_LOWEST = (0 + 1),                  
        PRIORITY_LOWEST       = 0                         
    };

Constructor & Destructor Documentation

◆ SwitchStrategyFixedPriority()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::SwitchStrategyFixedPriority ( )

inlineexplicit

Construct an empty strategy with all priority levels empty, a clear bitmap, and null cursors.

Note: A compile-time assertion enforces MAX_PRIORITIES <= 32, matching the width of the 32-bit m_ready_bitmap. Instantiating with MAX_PRIORITIES > 32 is a compile error.

Definition at line 108 of file stk_strategy_fpriority.h.

                                           : m_tasks(), m_sleep(), m_ready_bitmap(0U), m_prev()
    {
        STK_STATIC_ASSERT_DESC(MAX_PRIORITIES <= 32U, "MAX_PRIORITIES exceeds 32-bit bitmap width");
    }

◆ ~SwitchStrategyFixedPriority()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

STK_VIRT_DTOR stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::~SwitchStrategyFixedPriority ( )

default

Destructor.

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

Member Function Documentation

◆ AddActive()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

void stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::AddActive ( IKernelTask * task )

inlineprotected

Append a task to its priority level's runnable list and update the bitmap.

Parameters

[in] task Task to make runnable.

Note: Appends to the back of m_tasks[prio].; Bitmap and cursor are only updated when the level was previously empty (GetSize() == 1 after LinkBack): m_ready_bitmap bit prio is set and m_prev[prio] is initialized to task. Subsequent additions at the same level leave the cursor untouched (the tail-adjustment in AddTask() handles the cursor for non-first additions).

Definition at line 350 of file stk_strategy_fpriority.h.

    {
        const Priority prio = GetTaskPriority(task);
 
        m_tasks[prio].LinkBack(task);
 
        // init pointer
        if (m_tasks[prio].GetSize() == 1U)
        {
            m_prev[prio] = task;
 
            m_ready_bitmap |= (1U << prio);
        }
    }

Referenced by stk::SwitchStrategyFixedPriority< 32 >::AddTask(), stk::SwitchStrategyFixedPriority< 32 >::OnTaskWake(), and stk::SwitchStrategyFixedPriority< 32 >::OnTaskWeightChange().

Here is the caller graph for this function:

◆ AddTask()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

void stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::AddTask ( IKernelTask * task )

inlineoverridevirtual

Add task to the runnable set at its fixed priority level.

Parameters

[in] task Task to add. Must not be NULL and must not already be in any list.

Note: Priority is extracted by casting GetWeight() to uint8_t. The result must be less than MAX_PRIORITIES (asserted); passing a task whose GetWeight() is out of range is a programming error.; Delegates to AddActive() which appends the task to m_tasks[prio], sets m_ready_bitmap bit prio if this is the first task at that level, and initializes m_prev[prio].; Tail-cursor invariant (same as RR): if m_prev[prio] was already pointing at the tail before insertion, it is advanced to the new tail so GetNext() will include the new task in the very next rotation at this priority level.

Implements stk::ITaskSwitchStrategy.

Definition at line 130 of file stk_strategy_fpriority.h.

    {
        STK_ASSERT(task != nullptr);
        STK_ASSERT(task->GetHead() == nullptr);
        STK_ASSERT(GetTaskPriority(task) < MAX_PRIORITIES);
 
        const Priority prio = GetTaskPriority(task);
        const bool is_tail = (m_prev[prio] == m_tasks[prio].GetLast());
 
        AddActive(task);
 
        // if pointer was pointing to the tail, become a tail
        if (is_tail)
        {
            m_prev[prio] = task;
        }
    }

◆ GetFirst()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

IKernelTask * stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::GetFirst ( )

inlineoverridevirtual

Get the first task in the managed set (used by the kernel for initial scheduling).

Returns: The first task in the highest runnable priority level if any task is runnable (bitmap non-zero); otherwise the first task in m_sleep. Asserts if the combined set is empty (GetSize() == 0).

Note: Uses m_ready_bitmap to determine whether any runnable task exists, consistent with GetNext(). The sleep fallback allows the kernel to identify any task even when all are currently sleeping.

Implements stk::ITaskSwitchStrategy.

Definition at line 204 of file stk_strategy_fpriority.h.

    {
        STK_ASSERT(GetSize() != 0U);
 
        IKernelTask *first_task = nullptr;
 
        if (m_ready_bitmap == 0U)
        {
            first_task = (*m_sleep.GetFirst());
        }
        else
        {
            const Priority prio = GetHighestReadyPriority(m_ready_bitmap);
            first_task = (*m_tasks[prio].GetFirst());
        }
 
        return first_task;
    }

◆ GetHighestReadyPriority()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

__stk_forceinline Priority stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::GetHighestReadyPriority ( uint32_t bitmap )

inlinestaticprotected

Find the index of the highest set bit in bitmap.

Parameters

[in] bitmap Bitmask of ready priority levels. Must not be 0 (behaviour is undefined for __builtin_clz(0); callers must check before calling).

Returns: Index of the most-significant set bit (0-based), which is the highest runnable priority level.

Note: On GCC/Clang: uses __builtin_clz for an O(1) hardware instruction (BSR on x86, CLZ on ARM). On other compilers: falls back to a portable O(32) linear scan from bit 31 down to 0.

Definition at line 432 of file stk_strategy_fpriority.h.

    {
        return GetTaskPriorityFromWeight(31U - CountLeadingZeros(bitmap));
    }

Referenced by stk::SwitchStrategyFixedPriority< 32 >::GetFirst(), and stk::SwitchStrategyFixedPriority< 32 >::GetNext().

Here is the caller graph for this function:

◆ GetNext()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

IKernelTask * stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::GetNext ( )

inlineoverridevirtual

Select and return the next task to run.

Returns: The next task in the highest runnable priority level's round-robin rotation, or nullptr if no runnable tasks exist (m_ready_bitmap == 0, kernel sleeps).

Note: Priority selection is O(1) via GetHighestReadyPriority() on m_ready_bitmap. Within the selected level the cursor (m_prev[prio]) is advanced by one position in the closed-loop list, implementing round-robin within the level.; Tasks at a lower priority are never returned while any higher-priority task has its bitmap bit set — preemption is enforced entirely by the bitmap lookup.

Implements stk::ITaskSwitchStrategy.

Definition at line 181 of file stk_strategy_fpriority.h.

    {
        IKernelTask *next = nullptr;
 
        if (m_ready_bitmap != 0U)
        {
            const Priority prio = GetHighestReadyPriority(m_ready_bitmap);
 
            next = (*m_prev[prio]->GetNext());
            m_prev[prio] = next;
        }
 
        return next;
    }

◆ GetSize()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

size_t stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::GetSize ( ) const

inlineoverridevirtual

Get the total number of tasks managed by this strategy.

Returns: Sum of tasks across all priority levels in m_tasks plus tasks in m_sleep.

Note: O(MAX_PRIORITIES): iterates all priority levels to accumulate the count. Unlike the RR and SWRR strategies this is not O(1).

Implements stk::ITaskSwitchStrategy.

Definition at line 228 of file stk_strategy_fpriority.h.

    {
        size_t total = m_sleep.GetSize();
        for (Priority i = 0U; i < MAX_PRIORITIES; ++i)
        {
            total += m_tasks[i].GetSize();
        }
 
        return total;
    }

Referenced by stk::SwitchStrategyFixedPriority< 32 >::AddActive(), stk::SwitchStrategyFixedPriority< 32 >::GetFirst(), and stk::SwitchStrategyFixedPriority< 32 >::RemoveTask().

Here is the caller graph for this function:

◆ GetTaskPriority()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

__stk_forceinline Priority stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::GetTaskPriority ( IKernelTask * task )

inlinestaticprotected

Get priority from the task.

Parameters

[in] task Pointer to the task. Priority is read from GetWeight().

Returns: Priority level.

Definition at line 418 of file stk_strategy_fpriority.h.

    {
        return GetTaskPriorityFromWeight(task->GetWeight());
    }

Referenced by stk::SwitchStrategyFixedPriority< 32 >::AddActive(), stk::SwitchStrategyFixedPriority< 32 >::AddTask(), stk::SwitchStrategyFixedPriority< 32 >::OnTaskSleep(), stk::SwitchStrategyFixedPriority< 32 >::OnTaskWeightChange(), stk::SwitchStrategyFixedPriority< 32 >::OnTaskYield(), and stk::SwitchStrategyFixedPriority< 32 >::RemoveTask().

Here is the caller graph for this function:

◆ GetTaskPriorityFromWeight()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

__stk_forceinline Priority stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::GetTaskPriorityFromWeight ( int32_t weight )

inlinestaticprotected

Get priority from the task.

Parameters

[in] weight Weight of the task read from GetWeight().

Returns: Weight value.

Definition at line 409 of file stk_strategy_fpriority.h.

    {
        return static_cast<Priority>(weight);
    }

Referenced by stk::SwitchStrategyFixedPriority< 32 >::GetHighestReadyPriority(), stk::SwitchStrategyFixedPriority< 32 >::GetTaskPriority(), and stk::SwitchStrategyFixedPriority< 32 >::OnTaskWeightChange().

Here is the caller graph for this function:

◆ OnTaskDeadlineMissed()

virtual bool stk::ITaskSwitchStrategy::OnTaskDeadlineMissed ( IKernelTask * task )

inlinevirtualinherited

Notification that a task has exceeded its HRT deadline; returns whether the strategy can recover without a hard fault.

Parameters

[in] task The task whose deadline was missed. Must not be nullptr.

Returns: true — the strategy has absorbed the overrun (e.g. by escalating its scheduling mode): the kernel must not call HrtHardFailDeadline() for this tick. false — the strategy cannot recover: the kernel must call HrtHardFailDeadline() as normal.

Note: Budget Overrun API. Called by the kernel from UpdateTaskState() within a tick, after GetNext() has already been called for that tick. Only invoked when DEADLINE_MISSED_API == 1 in the concrete strategy's EConfig. Strategies that set DEADLINE_MISSED_API = 0 do not need to implement this method; the kernel will not call it and will proceed directly to HrtHardFailDeadline().; Returning true carries no implicit side-effects on task sleep state or duration counters — normal tick-driven scheduling remains responsible for those. This call only communicates "do not hard-fault this tick."; The base implementation returns false (unrecoverable), which is the correct default for strategies that do not implement overrun recovery.

Definition at line 1487 of file stk_common.h.

    {
        STK_UNUSED(task);
        return false;
    }

References STK_UNUSED.

◆ OnTaskSleep()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

void stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::OnTaskSleep ( IKernelTask * task )

inlineoverridevirtual

Notification that a task has entered the sleeping state.

Parameters

[in] task The task that is now sleeping. Must be in m_tasks[priority] (asserted).

Note: Delegates to RemoveActive() which unlinks the task from its priority level list, updates the per-level cursor, and clears bit prio in m_ready_bitmap if this was the last runnable task at that level. Then appends the task to m_sleep.

Implements stk::ITaskSwitchStrategy.

Definition at line 245 of file stk_strategy_fpriority.h.

    {
        STK_ASSERT(task != nullptr);
        STK_ASSERT(task->IsSleeping());
        STK_ASSERT(task->GetHead() == &m_tasks[GetTaskPriority(task)]);
 
        RemoveActive(task, GetTaskPriority(task));
        m_sleep.LinkBack(task);
    }

◆ OnTaskTimeSlice()

virtual bool stk::ITaskSwitchStrategy::OnTaskTimeSlice ( IKernelTask * task )

inlinevirtualinherited

Notification that the running task's time slice expired (KERNEL_TIMESLICE only).

Parameters

[in] task Pointer to the running task, currently in the runnable set.

Returns: true if the strategy rotated to a same-priority peer (the following GetNext() returns it); false to keep running the task (no peer, or the task is not eligible for time-slicing).

Note: Unlike OnTaskYield() this must not release preemption-threshold style holds.; Called from the tick handler. Only invoked when TIMESLICE_API == 1.

See also: SwitchStrategyPreemptionThreshold::OnTaskTimeSlice

Reimplemented in stk::SwitchStrategyPreemptionThreshold< MAX_PRIORITIES, TIMESLICE >, stk::SwitchStrategyPreemptionThreshold< 32 >, and stk::SwitchStrategyPreemptionThreshold< 32, true >.

Definition at line 1461 of file stk_common.h.

    {
        STK_UNUSED(task);
        return false;
    }

References STK_UNUSED.

◆ OnTaskWake()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

void stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::OnTaskWake ( IKernelTask * task )

inlineoverridevirtual

Notification that a task has become runnable again.

Parameters

[in] task The task that woke up. Must be in m_sleep (asserted).

Note: Unlinks the task from m_sleep and delegates to AddActive() which appends it to m_tasks[priority] and sets the bitmap bit if the level was empty.; Unlike SwitchStrategySmoothWeightedRoundRobin, no priority boost is applied. The waking task re-enters its natural priority level and waits its turn in the round-robin rotation at that level. Its preemption guarantee is provided solely by its fixed priority relative to other runnable levels.

Implements stk::ITaskSwitchStrategy.

Definition at line 264 of file stk_strategy_fpriority.h.

    {
        STK_ASSERT(task != nullptr);
        STK_ASSERT(!task->IsSleeping());
        STK_ASSERT(task->GetHead() == &m_sleep);
 
        m_sleep.Unlink(task);
        AddActive(task);
    }

◆ OnTaskWeightChange()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

void stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::OnTaskWeightChange	(	IKernelTask *	task,
		Weight	old_weight )

inlineoverridevirtual

Move a runnable task to a new priority level after its weight changed.

Parameters

[in]	task	Task whose weight was just updated.
[in]	old_weight	Priority level the task occupied before the change.

Note: Removes from the old-priority list (using old_weight to locate it), then re-inserts via AddActive() which reads the new GetWeight(). m_ready_bitmap is updated by both RemoveActive and AddActive.; No-op if old and new priority are identical.; Called from within a hw::CriticalSection.

Reimplemented from stk::ITaskSwitchStrategy.

Definition at line 283 of file stk_strategy_fpriority.h.

    {
        const Priority old_prio = GetTaskPriorityFromWeight(old_weight);
 
        STK_ASSERT(GetTaskPriority(task) < MAX_PRIORITIES);
        STK_ASSERT(old_prio < MAX_PRIORITIES);
 
        if (task->GetHead() != &m_sleep)
        {
            STK_ASSERT(task->GetHead() == &m_tasks[old_prio]);
 
            // remove from the old priority list
            RemoveActive(task, old_prio);
 
            // re-add to the current priority list
            AddActive(task);
        }
    }

◆ OnTaskYield()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

bool stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::OnTaskYield ( IKernelTask * task )

inlineoverridevirtual

Notification that the running task called Yield() (non-HRT kernel modes only).

Parameters

[in] task Pointer to the yielding task, currently in the runnable set.

Returns: true if the strategy handled the yield itself: the task stays runnable (it is NOT put to sleep) and the following GetNext() returns its successor at the same priority level, or the task itself if it is alone at its level (a yield never selects a lower priority level); false if the kernel shall perform the legacy yield, i.e. sleep the task for YIELD_TICKS.

Note: If a higher priority level became ready in the meantime it is selected as usual; the yielding task then only loses its place in its own level's rotation.; Called from within a hw::CriticalSection.

Reimplemented from stk::ITaskSwitchStrategy.

Definition at line 313 of file stk_strategy_fpriority.h.

    {
        if __stk_constexpr_cpp17 (NoSleepYield)
        {
            STK_ASSERT(task != nullptr);
 
            bool handled = false;
            const Priority prio = GetTaskPriority(task);
 
            if (task->GetHead() == &m_tasks[prio])
            {
                m_prev[prio] = task; // GetNext() will return task's successor at this level (or task itself if alone)
                handled      = true;
            }
 
            return handled;
        }
        else
        {
            STK_UNUSED(task);
            return false;
        }
    }

◆ RemoveActive()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

void stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::RemoveActive	(	IKernelTask *	task,
		const Priority	prio )

inlineprotected

Remove a task from its priority level's runnable list and update the bitmap/cursor.

Parameters

[in]	task	Runnable task to remove.
[in]	prio	Priority of the task with which it was registered with AddActive.

Note

Cursor update algorithm (same as SwitchStrategyRoundRobin::RemoveActive, applied per priority level):

Capture next = task->GetNext() before unlinking.
If next != task (other tasks remain at this level) and the cursor m_prev[prio] pointed at the removed task: set m_prev[prio] = next->GetPrev() so GetNext() returns next without skipping it. If the cursor pointed at another task it is left untouched so that the rotation is not disturbed.
If next == task (last task at this level): set m_prev[prio] = NULL and clear bit prio in m_ready_bitmap. GetNext() will then select the next highest set bit, falling through to a lower priority level.

Definition at line 380 of file stk_strategy_fpriority.h.

    {
        IKernelTask *next = (*task->GetNext());
 
        m_tasks[prio].Unlink(task);
 
        // update pointer
        if (next == task)
        {
            m_prev[prio] = nullptr;
 
            // this will cause a switch to a lower priority task list
            m_ready_bitmap &= ~(1U << prio);
        }
        else if (m_prev[prio] == task)
        {
            // cursor was on the removed task: step back so that GetNext() returns its successor
            m_prev[prio] = (*next->GetPrev());
        }
        else
        {
            // cursor is on another task: leave the rotation untouched
        }
    }

Referenced by stk::SwitchStrategyFixedPriority< 32 >::OnTaskSleep(), stk::SwitchStrategyFixedPriority< 32 >::OnTaskWeightChange(), and stk::SwitchStrategyFixedPriority< 32 >::RemoveTask().

Here is the caller graph for this function:

◆ RemoveTask()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

void stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::RemoveTask ( IKernelTask * task )

inlineoverridevirtual

Remove task from whichever list it currently occupies.

Parameters

[in] task Task to remove. Must not be NULL and must belong to either m_tasks[priority] or m_sleep (asserted).

Note: Dispatch checks m_sleep first (reversed from the RR/SWRR pattern). If sleeping, simply unlinks from m_sleep. If runnable, delegates to RemoveActive() which also updates the cursor and clears the bitmap bit if the priority level becomes empty.

Implements stk::ITaskSwitchStrategy.

Definition at line 156 of file stk_strategy_fpriority.h.

    {
        STK_ASSERT(task != nullptr);
        STK_ASSERT(GetSize() != 0U);
        STK_ASSERT((task->GetHead() == &m_tasks[GetTaskPriority(task)]) || (task->GetHead() == &m_sleep));
 
        if (task->GetHead() == &m_sleep)
        {
            m_sleep.Unlink(task);
        }
        else
        {
            RemoveActive(task, GetTaskPriority(task));
        }
    }

◆ STK_NONCOPYABLE_CLASS()

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::STK_NONCOPYABLE_CLASS ( SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield > )

private

Member Data Documentation

◆ m_prev

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

IKernelTask* stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::m_prev[MAX_PRIORITIES]

private

Per-priority round-robin cursor. m_prev[i] is the most recently scheduled task at level i, or nullptr when level i is empty. GetNext() advances from this position.

Definition at line 443 of file stk_strategy_fpriority.h.

◆ m_ready_bitmap

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

uint32_t stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::m_ready_bitmap

private

Bitmask of non-empty priority levels: bit i is set when m_tasks[i] has at least one runnable task. Updated by AddActive() (bit set) and RemoveActive() (bit cleared on last removal).

Definition at line 442 of file stk_strategy_fpriority.h.

◆ m_sleep

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

IKernelTask::ListHeadType stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::m_sleep

private

Sleeping (blocked) tasks. Priority is retained in GetWeight() and restored on OnTaskWake().

Definition at line 441 of file stk_strategy_fpriority.h.

◆ m_tasks

template<uint8_t MAX_PRIORITIES, bool NoSleepYield = false>

IKernelTask::ListHeadType stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield >::m_tasks[MAX_PRIORITIES]

private

Per-priority runnable task lists. m_tasks[i] holds all runnable tasks at priority level i.

Definition at line 440 of file stk_strategy_fpriority.h.

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

stk_strategy_fpriority.h

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Priority

Member Enumeration Documentation

◆ EConfig

◆ EPriority

Constructor & Destructor Documentation

◆ SwitchStrategyFixedPriority()

◆ ~SwitchStrategyFixedPriority()

Member Function Documentation

◆ AddActive()

◆ AddTask()

◆ GetFirst()

◆ GetHighestReadyPriority()

◆ GetNext()

◆ GetSize()

◆ GetTaskPriority()

◆ GetTaskPriorityFromWeight()

◆ OnTaskDeadlineMissed()

◆ OnTaskSleep()

◆ OnTaskTimeSlice()

◆ OnTaskWake()

◆ OnTaskWeightChange()

◆ OnTaskYield()

◆ RemoveActive()

◆ RemoveTask()

◆ STK_NONCOPYABLE_CLASS()

Member Data Documentation

◆ m_prev

◆ m_ready_bitmap

◆ m_sleep

◆ m_tasks