stk::SwitchStrategyMonotonic< _Type > Class Template Reference

Monotonic scheduling strategy: Rate-Monotonic (RM) or Deadline-Monotonic (DM), selected at compile time by the _Type template parameter. More...

#include <stk_strategy_monotonic.h>

Inheritance diagram for stk::SwitchStrategyMonotonic< _Type >:

Collaboration diagram for stk::SwitchStrategyMonotonic< _Type >:

Public Types
enum	EConfig {   WEIGHT_API = 0 ,   SLEEP_EVENT_API = 0 ,   DEADLINE_MISSED_API = 0 }
	Compile-time capability flags reported to the kernel. More...

Public Member Functions
	SwitchStrategyMonotonic ()
	Construct an empty strategy with no tasks.
	~SwitchStrategyMonotonic ()
	Destructor.
void	AddTask (IKernelTask *task)
	Add a task to the priority-sorted runnable list.
void	RemoveTask (IKernelTask *task)
	Remove a task from the list.
IKernelTask *	GetNext ()
	Select and return the highest-priority non-sleeping task.
IKernelTask *	GetFirst () const
	Get the first task in the managed set (used by the kernel for initial scheduling).
size_t	GetSize () const
	Get the total number of tasks managed by this strategy.
void	OnTaskSleep (IKernelTask *)
	Not supported, asserts unconditionally.
void	OnTaskWake (IKernelTask *)
	Not supported, asserts unconditionally.
bool	OnTaskDeadlineMissed (IKernelTask *)
	Not supported, asserts unconditionally.

Private Member Functions
	STK_NONCOPYABLE_CLASS (SwitchStrategyMonotonic)

Private Attributes
IKernelTask::ListHeadType	m_tasks
	All tasks (runnable and sleeping) in priority order. GetNext() skips sleeping tasks via IsSleeping(). AddTask() maintains sort order.

Detailed Description

template<EMonotonicSwitchStrategyType _Type>
class stk::SwitchStrategyMonotonic< _Type >

Monotonic scheduling strategy: Rate-Monotonic (RM) or Deadline-Monotonic (DM), selected at compile time by the _Type template parameter.

Template Parameters

_Type

Policy selector (EMonotonicSwitchStrategyType): MSS_TYPE_RATE - Rate-Monotonic: tasks with a shorter scheduling period receive higher priority. The most frequently activating task always runs first. MSS_TYPE_DEADLINE - Deadline-Monotonic: tasks with a shorter execution deadline receive higher priority.

Sorted-list design

m_tasks is maintained as a priority-sorted intrusive list. AddTask() inserts each new task at the correct sorted position (O(n) insertion sort) so that GetNext() need only scan from the front: the first non-sleeping task it encounters is always the highest-priority runnable task. No re-sorting occurs at runtime after a task is added.

Sleep handling - no separate sleep list

Unlike RR, SWRR, EDF, and FP strategies, this strategy does not maintain a separate sleep list (SLEEP_EVENT_API = 0). Sleeping tasks remain in m_tasks in their sorted position and are skipped by GetNext() via IKernelTask::IsSleeping(). OnTaskSleep() and OnTaskWake() assert unconditionally, the kernel must not be configured to deliver these events to this strategy.

HRT mode requirement

This strategy reads GetHrtPeriodicity() and GetHrtDeadline() from each task during AddTask() to determine its priority. These values are only populated in KERNEL_HRT mode; using this strategy without KERNEL_HRT produces undefined priority ordering.

Note

Does not use per-task weights (WEIGHT_API = 0). Priority is derived entirely from HRT timing parameters set via IKernel::AddTask(periodicity_tc, deadline_tc, ...).

For schedulability analysis of the configured task set use SchedulabilityCheck::IsSchedulableWCRT().

See also

SwitchStrategyRM, SwitchStrategyDM, SchedulabilityCheck, ITaskSwitchStrategy

Definition at line 69 of file stk_strategy_monotonic.h.

Member Enumeration Documentation

EConfig

template<EMonotonicSwitchStrategyType _Type>

enum stk::SwitchStrategyMonotonic::EConfig

Compile-time capability flags reported to the kernel.

Enumerator
WEIGHT_API	This strategy does not use per-task weights. Priority is derived from HRT timing parameters (GetHrtPeriodicity() for RM, GetHrtDeadline() for DM) at AddTask() time.
SLEEP_EVENT_API	This strategy does not use OnTaskSleep() / OnTaskWake() events. Sleeping tasks remain in m_tasks and are skipped by GetNext() via IKernelTask::IsSleeping(). Delivering these events will trigger an assertion.
DEADLINE_MISSED_API	This strategy does not use OnTaskDeadlineMissed() events.

Definition at line 75 of file stk_strategy_monotonic.h.

    {
        WEIGHT_API          = 0, 
        SLEEP_EVENT_API     = 0, 
        DEADLINE_MISSED_API = 0  
    };

Constructor & Destructor Documentation

SwitchStrategyMonotonic()

template<EMonotonicSwitchStrategyType _Type>

stk::SwitchStrategyMonotonic< _Type >::SwitchStrategyMonotonic ( )

inlineexplicit

Construct an empty strategy with no tasks.

Definition at line 84 of file stk_strategy_monotonic.h.

                                       : m_tasks()
    {}

~SwitchStrategyMonotonic()

template<EMonotonicSwitchStrategyType _Type>

stk::SwitchStrategyMonotonic< _Type >::~SwitchStrategyMonotonic ( )

inline

Destructor.

Note

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

Definition at line 90 of file stk_strategy_monotonic.h.

    {}

Member Function Documentation

AddTask()

template<EMonotonicSwitchStrategyType _Type>

void stk::SwitchStrategyMonotonic< _Type >::AddTask ( IKernelTask * task )

inlinevirtual

Add a task to the priority-sorted runnable list.

Parameters

[in]

task

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

Note

Performs an O(n) insertion sort into m_tasks so that higher-priority tasks appear closer to the head. The sort key depends on _Type:

• MSS_TYPE_RATE: key = GetHrtPeriodicity() (smaller -> nearer to head).
• MSS_TYPE_DEADLINE: key = GetHrtDeadline() (smaller -> nearer to head).

Three insertion cases handled:

1. Empty list: insert at front (LinkFront).
2. New task has a strictly smaller key than the current head: insert at front (LinkFront), becoming the new highest-priority task.
3. Otherwise: scan forward until a task with a larger-or-equal key is found, then insert immediately before it (Link), or append at back (LinkBack) if the scan reaches the end of the list.

Tasks with equal keys are ordered by registration time: later-added tasks go behind earlier-added tasks with the same key.

Implements stk::ITaskSwitchStrategy.

Definition at line 109 of file stk_strategy_monotonic.h.

    {
        STK_ASSERT(task != nullptr);
        STK_ASSERT(task->GetHead() == nullptr);
 
        if (m_tasks.IsEmpty())
        {
            m_tasks.LinkFront(task);
        }
        else
        {
            IKernelTask *itr = (*m_tasks.GetFirst()), * const start = itr;
 
            for (;;)
            {
                bool higher_priority;
                switch (_Type)
                {
                case MSS_TYPE_RATE:
                    higher_priority = (task->GetHrtPeriodicity() < itr->GetHrtPeriodicity());
                    break;
                case MSS_TYPE_DEADLINE:
                    higher_priority = (task->GetHrtDeadline() < itr->GetHrtDeadline());
                    break;
                default:
                    STK_ASSERT(false);
                    break;
                }
 
                if (higher_priority)
                {
                    if (itr == start)
                    {
                        m_tasks.LinkFront(task);
                        break;
                    }
 
                    m_tasks.Link(task, itr, itr->GetPrev());
                    break;
                }
 
                // end of the list
                if ((itr = (*itr->GetNext())) == start)
                {
                    m_tasks.LinkBack(task);
                    break;
                }
            }
        }
    }

GetFirst()

template<EMonotonicSwitchStrategyType _Type>

IKernelTask * stk::SwitchStrategyMonotonic< _Type >::GetFirst ( ) const

inlinevirtual

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

Returns

The first task in m_tasks (highest priority due to sort order). Asserts if m_tasks is empty.

Note

Because all tasks (runnable and sleeping) reside in m_tasks there is no sleep-list fallback path, unlike RR, SWRR, EDF, and FP strategies. The returned task may be sleeping; the kernel uses it only to seed the initial context before the first GetNext() call.

Implements stk::ITaskSwitchStrategy.

Definition at line 217 of file stk_strategy_monotonic.h.

    {
        STK_ASSERT(m_tasks.GetSize() != 0U);
 
        return (*m_tasks.GetFirst());
    }

GetNext()

template<EMonotonicSwitchStrategyType _Type>

IKernelTask * stk::SwitchStrategyMonotonic< _Type >::GetNext ( )

inlinevirtual

Select and return the highest-priority non-sleeping task.

Returns

The first non-sleeping task in m_tasks, or NULL if every task in the list is currently sleeping (kernel will sleep until the next activation).

Note

Because m_tasks is sorted in descending priority order by AddTask(), a linear scan from the head is sufficient: the first task for which IsSleeping() returns false is always the highest-priority runnable task. Complexity is O(k) where k is the number of sleeping tasks at the front of the list (i.e. higher-priority tasks currently between activations).

Asserts if m_tasks is empty; at least one task must be registered before GetNext() is called.

Implements stk::ITaskSwitchStrategy.

Definition at line 186 of file stk_strategy_monotonic.h.

    {
        STK_ASSERT(!m_tasks.IsEmpty());
 
        IKernelTask *itr = (*m_tasks.GetFirst()), * const start = itr;
        IKernelTask *next = nullptr;
 
        // Scan from head (highest priority). Skip tasks that are sleeping between
        // periodic activations; return the first task ready to run.
        do
        {
            if (!itr->IsSleeping())
            {
                next = itr;
                break; // list is sorted by priority; no need to continue
            }
        }
        while ((itr = (*itr->GetNext())) != start);
 
        // nullptr means all tasks are sleeping, return idle signal to kernel
        return next;
    }

GetSize()

template<EMonotonicSwitchStrategyType _Type>

size_t stk::SwitchStrategyMonotonic< _Type >::GetSize ( ) const

inlinevirtual

Get the total number of tasks managed by this strategy.

Returns

Number of tasks in m_tasks. Includes both runnable and sleeping tasks since this strategy does not maintain a separate sleep list.

Implements stk::ITaskSwitchStrategy.

Definition at line 228 of file stk_strategy_monotonic.h.

    {
        return m_tasks.GetSize();
    }

Referenced by stk::SwitchStrategyMonotonic< MSS_TYPE_RATE >::RemoveTask().

Here is the caller graph for this function:

OnTaskDeadlineMissed()

template<EMonotonicSwitchStrategyType _Type>

bool stk::SwitchStrategyMonotonic< _Type >::OnTaskDeadlineMissed ( IKernelTask * )

inlinevirtual

Not supported, asserts unconditionally.

Note

This strategy uses DEADLINE_MISSED_API = 0. See OnTaskDeadlineMissed() for rationale.

Implements stk::ITaskSwitchStrategy.

Definition at line 256 of file stk_strategy_monotonic.h.

    {
        // Budget Overrun API unsupported
        STK_ASSERT(false);
        return false;
    }

OnTaskSleep()

template<EMonotonicSwitchStrategyType _Type>

void stk::SwitchStrategyMonotonic< _Type >::OnTaskSleep ( IKernelTask * )

inlinevirtual

Not supported, asserts unconditionally.

Note

This strategy uses SLEEP_EVENT_API = 0. Sleeping tasks remain in m_tasks in their sorted position and are detected by IsSleeping() in GetNext(). Calling this method indicates a kernel/strategy configuration mismatch.

Implements stk::ITaskSwitchStrategy.

Definition at line 238 of file stk_strategy_monotonic.h.

    {
        // Sleep API unsupported: RM/DM keeps a single sorted non-volatile list.
        STK_ASSERT(false);
    }

OnTaskWake()

template<EMonotonicSwitchStrategyType _Type>

void stk::SwitchStrategyMonotonic< _Type >::OnTaskWake ( IKernelTask * )

inlinevirtual

Not supported, asserts unconditionally.

Note

This strategy uses SLEEP_EVENT_API = 0. See OnTaskSleep() for rationale.

Implements stk::ITaskSwitchStrategy.

Definition at line 247 of file stk_strategy_monotonic.h.

    {
        // Sleep API unsupported: RM/DM keeps a single sorted non-volatile list.
        STK_ASSERT(false);
    }

RemoveTask()

template<EMonotonicSwitchStrategyType _Type>

void stk::SwitchStrategyMonotonic< _Type >::RemoveTask ( IKernelTask * task )

inlinevirtual

Remove a task from the list.

Parameters

[in]

task

Task to remove. Must not be NULL. Must be in m_tasks (asserted).

Note

Unlike RR, SWRR, EDF, and FP strategies there is no separate sleep list: all tasks, runnable and sleeping, reside in m_tasks, so this method simply unlinks the task unconditionally without a list-membership check.

Implements stk::ITaskSwitchStrategy.

Definition at line 166 of file stk_strategy_monotonic.h.

    {
        STK_ASSERT(task != nullptr);
        STK_ASSERT(GetSize() != 0U);
        STK_ASSERT(task->GetHead() == &m_tasks);
 
        m_tasks.Unlink(task);
    }

STK_NONCOPYABLE_CLASS()

template<EMonotonicSwitchStrategyType _Type>

stk::SwitchStrategyMonotonic< _Type >::STK_NONCOPYABLE_CLASS ( SwitchStrategyMonotonic< _Type > )

private

Member Data Documentation

m_tasks

template<EMonotonicSwitchStrategyType _Type>

IKernelTask::ListHeadType stk::SwitchStrategyMonotonic< _Type >::m_tasks

private

All tasks (runnable and sleeping) in priority order. GetNext() skips sleeping tasks via IsSleeping(). AddTask() maintains sort order.

Definition at line 266 of file stk_strategy_monotonic.h.

---

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

• stk_strategy_monotonic.h