SuperTinyKernel™ RTOS 1.08.x
Lightweight, high-performance, deterministic, bare-metal C++ RTOS for resource-constrained embedded systems. MIT Open Source License.
Loading...
Searching...
No Matches
stk::sched::SwitchStrategyEDF Class Referencefinal

Earliest Deadline First (EDF) scheduling strategy: always selects the runnable task with the least time remaining before its deadline expires. More...

#include <stk_strategy_edf.h>

Inheritance diagram for stk::sched::SwitchStrategyEDF:
Collaboration diagram for stk::sched::SwitchStrategyEDF:

Public Types

enum  EConfig {
  WEIGHT_API = 0 ,
  SLEEP_EVENT_API = 1 ,
  DEADLINE_MISSED_API = 0 ,
  PRIORITY_INHERITANCE_API = 0 ,
  NOSLEEP_YIELD_API = 0 ,
  TIMESLICE_API = 0
}
 Compile-time capability flags reported to the kernel. More...

Public Member Functions

 SwitchStrategyEDF ()
 Construct an empty strategy with no tasks.
STK_VIRT_DTOR ~SwitchStrategyEDF ()=default
 Destructor.
void AddTask (IKernelTask *task) override
 Add task to the runnable set.
void RemoveTask (IKernelTask *task) override
 Remove task from whichever list it currently occupies.
IKernelTask * GetNext () override
 Select and return the task with the earliest (minimum) relative deadline.
IKernelTask * GetFirst () override
 Get first task in the managed set (reference task for the kernel).
size_t GetSize () const override
 Get 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.
virtual bool OnTaskYield (IKernelTask *task)
 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.
virtual void OnTaskWeightChange (IKernelTask *task, Weight old_weight)
 Notification that a runnable task's scheduling weight has changed.

Protected Member Functions

 STK_NONCOPYABLE_CLASS (SwitchStrategyEDF)

Protected Attributes

IKernelTask::ListHeadType m_tasks
 Runnable tasks eligible for scheduling. Scanned in full by GetNext() each tick to find the minimum relative deadline.
IKernelTask::ListHeadType m_sleep
 Sleeping (blocked) tasks not eligible for scheduling, e.g. HRT tasks waiting for their next activation.

Detailed Description

Earliest Deadline First (EDF) scheduling strategy: always selects the runnable task with the least time remaining before its deadline expires.

Selection metric
GetNext() compares each runnable task's relative deadline, obtained via IKernelTask::GetHrtRelativeDeadline() = deadline - duration (ticks remaining before the task must complete and call Yield()). The task with the minimum relative deadline, i.e. the one closest to missing its deadline is selected.
HRT mode requirement
This strategy is only meaningful when used with KERNEL_HRT mode. In HRT mode the kernel tracks duration (active ticks elapsed) per task, making GetHrtRelativeDeadline() produce meaningful, monotonically decreasing values. Outside HRT mode GetHrtRelativeDeadline() asserts (debug builds) and returns 0 for every task, so every comparison ties and the first runnable task in m_tasks always wins: the other tasks do not run until it sleeps.
Tie-breaking
When two or more tasks share the same relative deadline the first such task encountered during the linear scan of m_tasks wins, i.e. the one nearest the list head. List order therefore determines tie priority: tasks keep the order in which they were added, except that a task which sleeps and wakes is re-appended at the back (see OnTaskWake()). This behaviour is implementation-defined and not guaranteed to remain stable across kernel versions.
Complexity
GetNext() performs an O(n) linear scan over all runnable tasks on every call (once per kernel tick). This is inherent to EDF: unlike fixed-priority strategies there is no O(1) data structure that maintains a sorted deadline order under arbitrary insertions and removals without additional memory cost.
Note
This strategy does not use per-task weights (WEIGHT_API = 0). The EDF deadline is tracked internally by the kernel in KERNEL_HRT mode, tasks do not need to override ITask::GetWeight().
NOSLEEP_YIELD_API = 0 by design: in HRT mode Yield() signals completion of the job and the task then sleeps until its next period, the strategy does not handle Yield() itself.
Requires the kernel Sleep API (SLEEP_EVENT_API = 1): the kernel must call OnTaskSleep() and OnTaskWake() to maintain the runnable/sleeping list split.
Unlike SwitchStrategyRoundRobin and SwitchStrategyFixedPriority, EDF maintains no per-task cursor. Task insertion and removal do not update any scheduling state beyond the list membership, all scheduling decisions are deferred to GetNext().
See also
ITaskSwitchStrategy, IKernelTask::GetHrtRelativeDeadline
Examples
hrt/example.cpp.

Definition at line 66 of file stk_strategy_edf.h.

Member Enumeration Documentation

◆ EConfig

Compile-time capability flags reported to the kernel.

Enumerator
WEIGHT_API 

This strategy does not use per-task weights. Deadline tracking is handled by the kernel in KERNEL_HRT mode via GetHrtRelativeDeadline().

SLEEP_EVENT_API 

This strategy requires OnTaskSleep() / OnTaskWake() events to move tasks between the runnable and sleeping lists.

DEADLINE_MISSED_API 

This strategy does not use OnTaskDeadlineMissed() events.

PRIORITY_INHERITANCE_API 

This strategy does not require Priority Inheritance and OnTaskWeightChange() events.

NOSLEEP_YIELD_API 

This strategy does not handle Yield() itself (OnTaskYield() is not used); the kernel puts the yielding task to sleep for a tick.

TIMESLICE_API 

This strategy does not support KERNEL_TIMESLICE mode.

Definition at line 72 of file stk_strategy_edf.h.

73 {
74 WEIGHT_API = 0,
75 SLEEP_EVENT_API = 1,
79 TIMESLICE_API = 0
80 };
@ PRIORITY_INHERITANCE_API
This strategy does not require Priority Inheritance and OnTaskWeightChange() events.
@ SLEEP_EVENT_API
This strategy requires OnTaskSleep() / OnTaskWake() events to move tasks between the runnable and sle...
@ WEIGHT_API
This strategy does not use per-task weights. Deadline tracking is handled by the kernel in KERNEL_HRT...
@ DEADLINE_MISSED_API
This strategy does not use OnTaskDeadlineMissed() events.
@ NOSLEEP_YIELD_API
This strategy does not handle Yield() itself (OnTaskYield() is not used); the kernel puts the yieldin...
@ TIMESLICE_API
This strategy does not support KERNEL_TIMESLICE mode.

Constructor & Destructor Documentation

◆ SwitchStrategyEDF()

stk::sched::SwitchStrategyEDF::SwitchStrategyEDF ( )
inlineexplicit

Construct an empty strategy with no tasks.

Definition at line 84 of file stk_strategy_edf.h.

84 : m_tasks(), m_sleep()
85 {}
IKernelTask::ListHeadType m_tasks
Runnable tasks eligible for scheduling. Scanned in full by GetNext() each tick to find the minimum re...
IKernelTask::ListHeadType m_sleep
Sleeping (blocked) tasks not eligible for scheduling, e.g. HRT tasks waiting for their next activatio...

References m_sleep, and m_tasks.

Referenced by STK_NONCOPYABLE_CLASS().

Here is the caller graph for this function:

◆ ~SwitchStrategyEDF()

STK_VIRT_DTOR stk::sched::SwitchStrategyEDF::~SwitchStrategyEDF ( )
default

Destructor.

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

References STK_VIRT_DTOR.

Member Function Documentation

◆ AddTask()

void stk::sched::SwitchStrategyEDF::AddTask ( IKernelTask * task)
inlineoverridevirtual

Add task to the runnable set.

Parameters
[in]taskTask to add. Must not be NULL and must not already be in any list.
Note
The task is appended to the back of m_tasks. Unlike RR and FP strategies, no cursor or bitmap state is updated here — all scheduling decisions are deferred to GetNext(), which scans m_tasks at selection time.
List order determines tie-breaking: when two tasks share the same relative deadline, the one closer to the list head (added earlier, unless it has since slept and woken, see OnTaskWake()) wins.

Implements stk::ITaskSwitchStrategy.

Definition at line 101 of file stk_strategy_edf.h.

102 {
103 STK_ASSERT(task != nullptr);
104 STK_ASSERT(task->GetHead() == nullptr);
105
106 m_tasks.LinkBack(task);
107 }
#define STK_ASSERT(e)
Runtime assertion. Halts execution if the expression e evaluates to false.
Definition stk_defs.h:532

References stk::detail::DListEntry< T, TClosedLoop >::GetHead(), m_tasks, and STK_ASSERT.

Here is the call graph for this function:

◆ GetFirst()

IKernelTask * stk::sched::SwitchStrategyEDF::GetFirst ( )
inlineoverridevirtual

Get first task in the managed set (reference task for the kernel).

Returns
The first task in m_tasks if any task is runnable; otherwise the first task in m_sleep. Asserts if the combined set is empty (GetSize() == 0).
Note
Returns the list-head task regardless of its deadline. The kernel uses it when it starts and when all tasks are sleeping; EDF ordering applies to GetNext() only.

Implements stk::ITaskSwitchStrategy.

Definition at line 182 of file stk_strategy_edf.h.

183 {
184 STK_ASSERT(GetSize() != 0U);
185
186 return (*(!m_tasks.IsEmpty() ? m_tasks.GetFirst() : m_sleep.GetFirst()));
187 }
size_t GetSize() const override
Get total number of tasks managed by this strategy.

References GetSize(), m_sleep, m_tasks, and STK_ASSERT.

Here is the call graph for this function:

◆ GetNext()

IKernelTask * stk::sched::SwitchStrategyEDF::GetNext ( )
inlineoverridevirtual

Select and return the task with the earliest (minimum) relative deadline.

Returns
The runnable task whose GetHrtRelativeDeadline() is smallest, or NULL if m_tasks is empty (no runnable tasks — kernel will sleep).
Note
Algorithm (O(n) linear scan over runnable tasks):
  1. If m_tasks is empty, return NULL immediately.
  2. Initialize next to the first task in m_tasks and cache its relative deadline as the initial minimum (avoids the need for a special INT32_MAX guard).
  3. Iterate the remaining tasks; replace next whenever a task has a strictly smaller GetHrtRelativeDeadline() value.
  4. Return next.
Tie-breaking: if two tasks share the same relative deadline the one closer to the head of m_tasks is returned (see the class documentation).
This method is called once per kernel tick. On an n-task system it performs n−1 comparisons and n GetHrtRelativeDeadline() calls per tick.

Implements stk::ITaskSwitchStrategy.

Definition at line 146 of file stk_strategy_edf.h.

147 {
148 IKernelTask *next = nullptr;
149
150 if (!m_tasks.IsEmpty())
151 {
152 IKernelTask *const start = (*m_tasks.GetFirst());
153
154 next = start; // initialize earliest found task to the first one
155
156 Timeout earliest = next->GetHrtRelativeDeadline();
157 IKernelTask *itr = (*start->GetNext());
158
159 while (itr != start)
160 {
161 const Timeout deadline = itr->GetHrtRelativeDeadline();
162
163 if (deadline < earliest)
164 {
165 earliest = deadline;
166 next = itr;
167 }
168
169 itr = (*itr->GetNext());
170 }
171 }
172
173 return next;
174 }
int32_t Timeout
Timeout time (ticks).
Definition stk_common.h:216

References stk::IKernelTask::GetHrtRelativeDeadline(), stk::detail::DListEntry< T, TClosedLoop >::GetNext(), and m_tasks.

Here is the call graph for this function:

◆ GetSize()

size_t stk::sched::SwitchStrategyEDF::GetSize ( ) const
inlineoverridevirtual

Get total number of tasks managed by this strategy.

Returns
Sum of tasks in m_tasks (runnable) and m_sleep (sleeping).

Implements stk::ITaskSwitchStrategy.

Definition at line 192 of file stk_strategy_edf.h.

193 {
194 return m_tasks.GetSize() + m_sleep.GetSize();
195 }

References m_sleep, and m_tasks.

Referenced by GetFirst(), and RemoveTask().

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]taskThe 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 1501 of file stk_common.h.

1502 {
1503 STK_UNUSED(task);
1504 return false;
1505 }
#define STK_UNUSED(X)
Explicitly marks a variable as unused to suppress compiler warnings.
Definition stk_defs.h:715

References STK_UNUSED.

◆ OnTaskSleep()

void stk::sched::SwitchStrategyEDF::OnTaskSleep ( IKernelTask * task)
inlineoverridevirtual

Notification that a task has entered the sleeping state.

Parameters
[in]taskThe task that is now sleeping. Must be in m_tasks (asserted).
Note
Unlinks from m_tasks and appends to m_sleep. No cursor or bitmap state is affected — EDF maintains no per-task cursor, so this is a simpler operation than the equivalent in RR or FP strategies.

Implements stk::ITaskSwitchStrategy.

Definition at line 203 of file stk_strategy_edf.h.

204 {
205 STK_ASSERT(task != nullptr);
206 STK_ASSERT(task->IsSleeping());
207 STK_ASSERT(task->GetHead() == &m_tasks);
208
209 m_tasks.Unlink(task);
210 m_sleep.LinkBack(task);
211 }

References stk::detail::DListEntry< T, TClosedLoop >::GetHead(), stk::IKernelTask::IsSleeping(), m_sleep, m_tasks, and STK_ASSERT.

Here is the call graph for this function:

◆ OnTaskTimeSlice()

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

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

Parameters
[in]taskPointer 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::sched::SwitchStrategyPreemptionThreshold< MAX_PRIORITIES, TIMESLICE, ReadyBitmap >, stk::sched::SwitchStrategyPreemptionThreshold< 32 >, stk::sched::SwitchStrategyPreemptionThreshold< 32 >, stk::sched::SwitchStrategyPreemptionThreshold< 32, true >, stk::sched::SwitchStrategyPreemptionThreshold< 32, true >, stk::sched::SwitchStrategyPreemptionThreshold< 64 >, stk::sched::SwitchStrategyPreemptionThreshold< 64 >, stk::sched::SwitchStrategyPreemptionThreshold< 64, true >, stk::sched::SwitchStrategyPreemptionThreshold< 64, true >, and stk::SwitchStrategyPreemptionThreshold< MAX_PRIORITIES, TIMESLICE, ReadyBitmap >.

Definition at line 1475 of file stk_common.h.

1476 {
1477 STK_UNUSED(task);
1478 return false;
1479 }

References STK_UNUSED.

◆ OnTaskWake()

void stk::sched::SwitchStrategyEDF::OnTaskWake ( IKernelTask * task)
inlineoverridevirtual

Notification that a task has become runnable again.

Parameters
[in]taskThe task that woke up. Must be in m_sleep (asserted).
Note
Unlinks from m_sleep and appends to the back of m_tasks. No priority boost is applied (unlike SwitchStrategySmoothWeightedRoundRobin) and no bitmap is updated (unlike SwitchStrategyFixedPriority). The waking task's deadline urgency is determined naturally by GetHrtRelativeDeadline() on the next GetNext() call.

Implements stk::ITaskSwitchStrategy.

Definition at line 221 of file stk_strategy_edf.h.

222 {
223 STK_ASSERT(task != nullptr);
224 STK_ASSERT(!task->IsSleeping());
225 STK_ASSERT(task->GetHead() == &m_sleep);
226
227 m_sleep.Unlink(task);
228 m_tasks.LinkBack(task);
229 }

References stk::detail::DListEntry< T, TClosedLoop >::GetHead(), stk::IKernelTask::IsSleeping(), m_sleep, m_tasks, and STK_ASSERT.

Here is the call graph for this function:

◆ OnTaskWeightChange()

virtual void stk::ITaskSwitchStrategy::OnTaskWeightChange ( IKernelTask * task,
Weight old_weight )
inlinevirtualinherited

Notification that a runnable task's scheduling weight has changed.

Parameters
[in]taskThe task whose weight was just updated via SetWeight().
[in]old_weightThe previous weight of this task (required to remove it from the priority list belonging to that weight).
Note
Called for any bound task, including a sleeping one (e.g. SetWeight() on it), so the strategy must not assume the task is in its runnable set. The strategy must reflect the new weight in its data structures. For strategies with WEIGHT_API = 0 this is a no-op. For SwitchStrategyFixedPriority it moves a runnable task from its old priority-level list to the new one and updates m_ready_bitmap.
Called from within a critical section (see hw::CriticalSection).

Reimplemented in stk::sched::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield, ReadyBitmap >, stk::sched::SwitchStrategyFixedPriority< 32 >, stk::sched::SwitchStrategyFixedPriority< 32 >, stk::sched::SwitchStrategyFixedPriority< 32, true >, stk::sched::SwitchStrategyFixedPriority< 32, true >, stk::sched::SwitchStrategyFixedPriority< 64 >, stk::sched::SwitchStrategyFixedPriority< 64 >, stk::sched::SwitchStrategyFixedPriority< 64, true >, stk::sched::SwitchStrategyFixedPriority< 64, true >, stk::sched::SwitchStrategyPreemptionThreshold< MAX_PRIORITIES, TIMESLICE, ReadyBitmap >, stk::sched::SwitchStrategyPreemptionThreshold< 32 >, stk::sched::SwitchStrategyPreemptionThreshold< 32 >, stk::sched::SwitchStrategyPreemptionThreshold< 32, true >, stk::sched::SwitchStrategyPreemptionThreshold< 32, true >, stk::sched::SwitchStrategyPreemptionThreshold< 64 >, stk::sched::SwitchStrategyPreemptionThreshold< 64 >, stk::sched::SwitchStrategyPreemptionThreshold< 64, true >, stk::sched::SwitchStrategyPreemptionThreshold< 64, true >, stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield, ReadyBitmap >, and stk::SwitchStrategyPreemptionThreshold< MAX_PRIORITIES, TIMESLICE, ReadyBitmap >.

Definition at line 1518 of file stk_common.h.

1519 {
1520 STK_UNUSED(task);
1521 STK_UNUSED(old_weight);
1522 }

References STK_UNUSED.

◆ OnTaskYield()

virtual bool stk::ITaskSwitchStrategy::OnTaskYield ( IKernelTask * task)
inlinevirtualinherited

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

Parameters
[in]taskPointer 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 strategy must arrange for the following GetNext() to return another task according to its own policy; false (default) if the kernel shall perform the legacy yield, i.e. sleep the task for YIELD_TICKS.
Note
Called from within a critical section, in the context of the yielding task.
Never called in KERNEL_HRT mode, where Yield() signals job completion.
See also
SwitchStrategyPreemptionThreshold::OnTaskYield

Reimplemented in stk::sched::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield, ReadyBitmap >, stk::sched::SwitchStrategyFixedPriority< 32 >, stk::sched::SwitchStrategyFixedPriority< 32 >, stk::sched::SwitchStrategyFixedPriority< 32, true >, stk::sched::SwitchStrategyFixedPriority< 32, true >, stk::sched::SwitchStrategyFixedPriority< 64 >, stk::sched::SwitchStrategyFixedPriority< 64 >, stk::sched::SwitchStrategyFixedPriority< 64, true >, stk::sched::SwitchStrategyFixedPriority< 64, true >, stk::sched::SwitchStrategyPreemptionThreshold< MAX_PRIORITIES, TIMESLICE, ReadyBitmap >, stk::sched::SwitchStrategyPreemptionThreshold< 32 >, stk::sched::SwitchStrategyPreemptionThreshold< 32 >, stk::sched::SwitchStrategyPreemptionThreshold< 32, true >, stk::sched::SwitchStrategyPreemptionThreshold< 32, true >, stk::sched::SwitchStrategyPreemptionThreshold< 64 >, stk::sched::SwitchStrategyPreemptionThreshold< 64 >, stk::sched::SwitchStrategyPreemptionThreshold< 64, true >, stk::sched::SwitchStrategyPreemptionThreshold< 64, true >, stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >, stk::sched::SwitchStrategyRoundRobinT< false >, stk::sched::SwitchStrategyRoundRobinT< false >, stk::sched::SwitchStrategyRoundRobinT< true >, stk::sched::SwitchStrategyRoundRobinT< true >, stk::sched::SwitchStrategySmoothWeightedRoundRobinT< NoSleepYield >, stk::sched::SwitchStrategySmoothWeightedRoundRobinT< false >, stk::sched::SwitchStrategySmoothWeightedRoundRobinT< false >, stk::sched::SwitchStrategySmoothWeightedRoundRobinT< true >, stk::sched::SwitchStrategySmoothWeightedRoundRobinT< true >, stk::SwitchStrategyFixedPriority< MAX_PRIORITIES, NoSleepYield, ReadyBitmap >, stk::SwitchStrategyPreemptionThreshold< MAX_PRIORITIES, TIMESLICE, ReadyBitmap >, stk::SwitchStrategyRoundRobinT< NoSleepYield >, and stk::SwitchStrategySmoothWeightedRoundRobinT< NoSleepYield >.

Definition at line 1460 of file stk_common.h.

1461 {
1462 STK_UNUSED(task);
1463 return false;
1464 }

References STK_UNUSED.

◆ RemoveTask()

void stk::sched::SwitchStrategyEDF::RemoveTask ( IKernelTask * task)
inlineoverridevirtual

Remove task from whichever list it currently occupies.

Parameters
[in]taskTask to remove. Must not be NULL and must belong to either m_tasks or m_sleep (asserted).
Note
Dispatch is by list membership check. No cursor or bitmap state is affected because EDF maintains no per-task scheduling state outside list membership.

Implements stk::ITaskSwitchStrategy.

Definition at line 115 of file stk_strategy_edf.h.

116 {
117 STK_ASSERT(task != nullptr);
118 STK_ASSERT(GetSize() != 0U);
119 STK_ASSERT((task->GetHead() == &m_tasks) || (task->GetHead() == &m_sleep));
120
121 if (task->GetHead() == &m_tasks)
122 {
123 m_tasks.Unlink(task);
124 }
125 else
126 {
127 m_sleep.Unlink(task);
128 }
129 }

References stk::detail::DListEntry< T, TClosedLoop >::GetHead(), GetSize(), m_sleep, m_tasks, and STK_ASSERT.

Here is the call graph for this function:

◆ STK_NONCOPYABLE_CLASS()

stk::sched::SwitchStrategyEDF::STK_NONCOPYABLE_CLASS ( SwitchStrategyEDF )
protected

References SwitchStrategyEDF().

Here is the call graph for this function:

Member Data Documentation

◆ m_sleep

IKernelTask::ListHeadType stk::sched::SwitchStrategyEDF::m_sleep
protected

Sleeping (blocked) tasks not eligible for scheduling, e.g. HRT tasks waiting for their next activation.

Definition at line 235 of file stk_strategy_edf.h.

Referenced by GetFirst(), GetSize(), OnTaskSleep(), OnTaskWake(), RemoveTask(), and SwitchStrategyEDF().

◆ m_tasks

IKernelTask::ListHeadType stk::sched::SwitchStrategyEDF::m_tasks
protected

Runnable tasks eligible for scheduling. Scanned in full by GetNext() each tick to find the minimum relative deadline.

Definition at line 234 of file stk_strategy_edf.h.

Referenced by AddTask(), GetFirst(), GetNext(), GetSize(), OnTaskSleep(), OnTaskWake(), RemoveTask(), and SwitchStrategyEDF().


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