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::SwitchStrategyRoundRobinT< NoSleepYield > Class Template Referencefinal

Round-Robin task-switching strategy: each runnable task receives one time slice (one tick interval) in turn before the kernel moves to the next task. More...

#include <stk_strategy_rrobin.h>

Inheritance diagram for stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >:
Collaboration diagram for stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >:

Public Types

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

Public Member Functions

 SwitchStrategyRoundRobinT ()
 Construct an empty strategy with no tasks and a null cursor.
STK_VIRT_DTOR ~SwitchStrategyRoundRobinT ()=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
 Advance cursor and return the next runnable task.
IKernelTask * GetFirst () override
 Get first task in the managed set (reference task for the kernel, used when it starts and when all tasks sleep).
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.
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.
virtual void OnTaskWeightChange (IKernelTask *task, Weight old_weight)
 Notification that a runnable task's scheduling weight has changed.

Protected Member Functions

 STK_NONCOPYABLE_CLASS (SwitchStrategyRoundRobinT)
void AddActive (IKernelTask *task)
 Append a task to m_tasks and restore the cursor if necessary.
void RemoveActive (IKernelTask *task)
 Remove a task from m_tasks and update the cursor.

Protected Attributes

IKernelTask::ListHeadType m_tasks
 Runnable tasks eligible for scheduling.
IKernelTask::ListHeadType m_sleep
 Sleeping (blocked) tasks not eligible for scheduling.
IKernelTask * m_prev
 Iterator cursor: the most recently scheduled task, or nullptr when no runnable tasks exist. GetNext() advances from this position.

Detailed Description

template<bool NoSleepYield>
class stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >

Round-Robin task-switching strategy: each runnable task receives one time slice (one tick interval) in turn before the kernel moves to the next task.

Internally maintains two intrusive lists:

  • m_tasks — tasks currently eligible for scheduling (runnable).
  • m_sleep — tasks that called Sleep() or are otherwise blocked.

The iterator cursor (m_prev) points to the most recently scheduled task. On each call to GetNext() the cursor advances by one position in m_tasks, wrapping around at the end (closed-loop list). When m_tasks is empty, GetNext() returns nullptr and the kernel transitions to the sleep trap.

Template Parameters
NoSleepYieldIf true, Yield() keeps the task in the runnable set and the strategy rotates the cursor (see OnTaskYield). If false, the kernel performs the legacy yield: the task sleeps for YIELD_TICKS.
Note
All runnable tasks receive equal CPU time regardless of creation order or any other factor. There is no priority or weight mechanism in this strategy (WEIGHT_API = 0).
Requires the kernel Sleep API (SLEEP_EVENT_API = 1): the kernel must call OnTaskSleep() and OnTaskWake() when a task's sleep state changes.
See also
SwitchStrategyRR, SwitchStrategyRR_NSY, ITaskSwitchStrategy

Definition at line 47 of file stk_strategy_rrobin.h.

Member Enumeration Documentation

◆ EConfig

template<bool NoSleepYield>
enum stk::sched::SwitchStrategyRoundRobinT::EConfig

Compile-time capability flags reported to the kernel.

Enumerator
WEIGHT_API 

This strategy does not use per-task weights; all tasks are treated equally.

SLEEP_EVENT_API 

This strategy requires OnTaskSleep() / OnTaskWake() events to maintain the active/sleep list split.

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 

(1) enables OnTaskYield(): yielding task stays runnable instead of sleeping.

TIMESLICE_API 

This strategy does not support KERNEL_TIMESLICE mode.

Definition at line 53 of file stk_strategy_rrobin.h.

54 {
55 WEIGHT_API = 0,
56 SLEEP_EVENT_API = 1,
60 TIMESLICE_API = 0
61 };
Round-Robin task-switching strategy: each runnable task receives one time slice (one tick interval) i...
@ TIMESLICE_API
This strategy does not support KERNEL_TIMESLICE mode.
@ DEADLINE_MISSED_API
This strategy does not use OnTaskDeadlineMissed() events.
@ NOSLEEP_YIELD_API
(1) enables OnTaskYield(): yielding task stays runnable instead of sleeping.
@ PRIORITY_INHERITANCE_API
This strategy does not require Priority Inheritance and OnTaskWeightChange() events.
@ WEIGHT_API
This strategy does not use per-task weights; all tasks are treated equally.
@ SLEEP_EVENT_API
This strategy requires OnTaskSleep() / OnTaskWake() events to maintain the active/sleep list split.

Constructor & Destructor Documentation

◆ SwitchStrategyRoundRobinT()

template<bool NoSleepYield>
stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::SwitchStrategyRoundRobinT ( )
inline

Construct an empty strategy with no tasks and a null cursor.

Definition at line 65 of file stk_strategy_rrobin.h.

65 : m_tasks(), m_sleep(), m_prev(nullptr)
66 {}
IKernelTask::ListHeadType m_sleep
Sleeping (blocked) tasks not eligible for scheduling.
IKernelTask * m_prev
Iterator cursor: the most recently scheduled task, or nullptr when no runnable tasks exist....
IKernelTask::ListHeadType m_tasks
Runnable tasks eligible for scheduling.

◆ ~SwitchStrategyRoundRobinT()

template<bool NoSleepYield>
STK_VIRT_DTOR stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::~SwitchStrategyRoundRobinT ( )
default

Destructor.

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

Member Function Documentation

◆ AddActive()

template<bool NoSleepYield>
void stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::AddActive ( IKernelTask * task)
inlineprotected

Append a task to m_tasks and restore the cursor if necessary.

Parameters
[in]taskTask to make runnable.
Note
Cursor invariant: if m_prev is nullptr (all tasks were previously sleeping), it is set to the newly added task so GetNext() immediately returns a valid task on the next call rather than returning nullptr and causing a spurious sleep cycle.

Definition at line 231 of file stk_strategy_rrobin.h.

232 {
233 m_tasks.LinkBack(task);
234
235 // update pointer: if all tasks were sleeping, this task will change state
236 // of the kernel to active
237 if (m_prev == nullptr)
238 {
239 m_prev = task;
240 }
241 }
IKernelTask * m_prev
Iterator cursor: the most recently scheduled task, or nullptr when no runnable tasks exist....
IKernelTask::ListHeadType m_tasks
Runnable tasks eligible for scheduling.

Referenced by stk::sched::SwitchStrategyRoundRobinT< false >::OnTaskWake().

Here is the caller graph for this function:

◆ AddTask()

template<bool NoSleepYield>
void stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::AddTask ( IKernelTask * task)
inlineoverridevirtual

Add task to the runnable set.

Parameters
[in]taskTask to add. Must not be nullptr and must not already be in any list.
Note
The task is appended to the back of m_tasks.
Cursor invariant: if m_prev was pointing at the tail before insertion (or the list was empty), it is moved to the new tail. GetNext() then continues with the head and the new task waits for its turn at the end of the current rotation.

Implements stk::ITaskSwitchStrategy.

Definition at line 80 of file stk_strategy_rrobin.h.

81 {
82 STK_ASSERT(task != nullptr);
83 STK_ASSERT(task->GetHead() == nullptr);
84
85 const bool tail = (m_prev == m_tasks.GetLast());
86
87 m_tasks.LinkBack(task);
88
89 // if pointer was pointing to the tail, become a tail
90 if (tail)
91 {
92 m_prev = task;
93 }
94 }
#define STK_ASSERT(e)
Runtime assertion. Halts execution if the expression e evaluates to false.
Definition stk_defs.h:532

◆ GetFirst()

template<bool NoSleepYield>
IKernelTask * stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::GetFirst ( )
inlineoverridevirtual

Get first task in the managed set (reference task for the kernel, used when it starts and when all tasks sleep).

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
Preference is given to runnable tasks. The sleep fallback allows the kernel to identify any task even when all are currently sleeping.

Implements stk::ITaskSwitchStrategy.

Definition at line 146 of file stk_strategy_rrobin.h.

147 {
148 STK_ASSERT(GetSize() != 0U);
149
150 return (*(!m_tasks.IsEmpty() ? m_tasks.GetFirst() : m_sleep.GetFirst()));
151 }
size_t GetSize() const override
Get total number of tasks managed by this strategy.
IKernelTask::ListHeadType m_sleep
Sleeping (blocked) tasks not eligible for scheduling.

◆ GetNext()

template<bool NoSleepYield>
IKernelTask * stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::GetNext ( )
inlineoverridevirtual

Advance cursor and return the next runnable task.

Returns
Pointer to the next task in m_tasks after the cursor position, or nullptr if m_tasks is empty (no runnable tasks — kernel will sleep).
Note
The cursor (m_prev) is updated to the returned task on each call. Because m_tasks is a closed-loop list the cursor wraps automatically from the last task back to the first, producing continuous round-robin rotation.
If the cursor itself is nullptr (all tasks were sleeping and none have woken), the method returns nullptr immediately without touching m_prev.

Implements stk::ITaskSwitchStrategy.

Definition at line 127 of file stk_strategy_rrobin.h.

128 {
130
131 if (next != nullptr)
132 {
133 next = (*next->GetNext());
134 m_prev = next;
135 }
136
137 return next;
138 }
IKernelTask * GetNext() override
Advance cursor and return the next runnable task.

◆ GetSize()

template<bool NoSleepYield>
size_t stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::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 156 of file stk_strategy_rrobin.h.

157 {
158 return m_tasks.GetSize() + m_sleep.GetSize();
159 }

Referenced by stk::sched::SwitchStrategyRoundRobinT< false >::GetFirst(), and stk::sched::SwitchStrategyRoundRobinT< false >::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()

template<bool NoSleepYield>
void stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::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
Moves the task from m_tasks to m_sleep via RemoveActive(), which also updates the cursor so GetNext() continues correctly.

Implements stk::ITaskSwitchStrategy.

Definition at line 166 of file stk_strategy_rrobin.h.

167 {
168 STK_ASSERT(task != nullptr);
169 STK_ASSERT(task->IsSleeping());
170 STK_ASSERT(task->GetHead() == &m_tasks);
171
173 m_sleep.LinkBack(task);
174 }
void RemoveActive(IKernelTask *task)
Remove a task from m_tasks and update the cursor.

◆ 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()

template<bool NoSleepYield>
void stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::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
Moves the task from m_sleep to m_tasks via AddActive(), which also restores the cursor if it was null (i.e. this is the first runnable task after a period where all tasks were sleeping).

Implements stk::ITaskSwitchStrategy.

Definition at line 182 of file stk_strategy_rrobin.h.

183 {
184 STK_ASSERT(task != nullptr);
185 STK_ASSERT(!task->IsSleeping());
186 STK_ASSERT(task->GetHead() == &m_sleep);
187
188 m_sleep.Unlink(task);
190 }
void AddActive(IKernelTask *task)
Append a task to m_tasks and restore the cursor if necessary.

◆ 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()

template<bool NoSleepYield>
bool stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::OnTaskYield ( IKernelTask * task)
inlineoverridevirtual

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.

Reimplemented from stk::ITaskSwitchStrategy.

Definition at line 199 of file stk_strategy_rrobin.h.

200 {
202 {
203 STK_ASSERT(task != nullptr);
204
205 bool handled = false;
206
207 if (task->GetHead() == &m_tasks)
208 {
209 m_prev = task; // GetNext() will return task's successor (or task itself if alone)
210 handled = true;
211 }
212
213 return handled;
214 }
215 else
216 {
218 return false;
219 }
220 }
#define __stk_constexpr_cpp17
constexpr definition for C++17 and above.
Definition stk_defs.h:505

◆ RemoveActive()

template<bool NoSleepYield>
void stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::RemoveActive ( IKernelTask * task)
inlineprotected

Remove a task from m_tasks and update the cursor.

Parameters
[in]taskRunnable task to remove.
Note
Cursor update algorithm: the cursor is repositioned only if it pointed at the removed task, so that the next call to GetNext() returns the task that would have followed the removed one. If the cursor points at another task it is left untouched, otherwise the rotation would be disturbed (e.g. the running task, or a task that has just yielded, would be selected again).
  • Capture next = task->GetNext() (the successor in the closed-loop list) before unlinking, while the list links are still valid.
  • After unlinking, if next != task (i.e. other tasks remain) and the cursor was on the removed task, set m_prev = next->GetPrev(). GetNext() will then advance from m_prev to next, preserving the round-robin sequence without skipping a task.
  • If next == task the removed task was the only element; set m_prev to nullptr so GetNext() returns nullptr and the kernel sleeps.

Definition at line 259 of file stk_strategy_rrobin.h.

260 {
261 IKernelTask *const next = (*task->GetNext());
262
263 m_tasks.Unlink(task);
264
265 // update pointer: if there are no tasks left GetNext() will return nullptr causing a sleep
266 // state for the kernel
267 if (next == task)
268 {
269 m_prev = nullptr;
270 }
271 else if (m_prev == task)
272 {
273 // cursor was on the removed task: step back so that GetNext() returns its successor
274 m_prev = (*next->GetPrev());
275 }
276 else
277 {
278 // cursor is on another task: leave the rotation untouched
279 }
280 }

Referenced by stk::sched::SwitchStrategyRoundRobinT< false >::OnTaskSleep(), and stk::sched::SwitchStrategyRoundRobinT< false >::RemoveTask().

Here is the caller graph for this function:

◆ RemoveTask()

template<bool NoSleepYield>
void stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::RemoveTask ( IKernelTask * task)
inlineoverridevirtual

Remove task from whichever list it currently occupies.

Parameters
[in]taskTask to remove. Must not be nullptr and must belong to either m_tasks or m_sleep (asserted).
Note
If the task is in m_tasks, delegates to RemoveActive() which also updates the cursor. If the task is in m_sleep, simply unlinks it.

Implements stk::ITaskSwitchStrategy.

Definition at line 102 of file stk_strategy_rrobin.h.

103 {
104 STK_ASSERT(task != nullptr);
105 STK_ASSERT(GetSize() != 0);
106 STK_ASSERT((task->GetHead() == &m_tasks) || (task->GetHead() == &m_sleep));
107
108 if (task->GetHead() == &m_tasks)
109 {
111 }
112 else
113 {
114 m_sleep.Unlink(task);
115 }
116 }

◆ STK_NONCOPYABLE_CLASS()

template<bool NoSleepYield>
stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::STK_NONCOPYABLE_CLASS ( SwitchStrategyRoundRobinT< NoSleepYield > )
protected

Member Data Documentation

◆ m_prev

template<bool NoSleepYield>
IKernelTask* stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::m_prev
protected

Iterator cursor: the most recently scheduled task, or nullptr when no runnable tasks exist. GetNext() advances from this position.

Definition at line 284 of file stk_strategy_rrobin.h.

◆ m_sleep

template<bool NoSleepYield>
IKernelTask::ListHeadType stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::m_sleep
protected

Sleeping (blocked) tasks not eligible for scheduling.

Definition at line 283 of file stk_strategy_rrobin.h.

◆ m_tasks

template<bool NoSleepYield>
IKernelTask::ListHeadType stk::sched::SwitchStrategyRoundRobinT< NoSleepYield >::m_tasks
protected

Runnable tasks eligible for scheduling.

Definition at line 282 of file stk_strategy_rrobin.h.


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