Struct Scheduler 

pub struct Scheduler { /* private fields */ }

The round-robin scheduler (per-CPU queues)

Implementations

impl Scheduler

pub fn new(cpu_count: usize) -> Self

Create a new scheduler instance

pub fn add_task(&mut self, task: Arc<Task>) -> Option<usize>

Add a task to the scheduler

pub fn add_task_with_parent( &mut self, task: Arc<Task>, parent: TaskId, ) -> Option<usize>

Performs the add task with parent operation.

pub fn clear_task_wake_deadline_locked(&mut self, id: TaskId) -> bool

Performs the clear task wake deadline locked operation.

pub fn set_task_wake_deadline_locked( &mut self, id: TaskId, deadline: u64, ) -> bool

Sets task wake deadline locked.

pub fn wake_task_locked(&mut self, id: TaskId) -> (bool, Option<usize>)

Performs the wake task locked operation.

Returns (was_woken, ipi_cpu). The caller must send a resched IPI to ipi_cpu after releasing the scheduler lock.

pub fn try_reap_child_locked( &mut self, parent: TaskId, target: Option<TaskId>, ) -> WaitChildResult

Attempts to reap child locked.

pub fn pick_next_task(&mut self, cpu_index: usize) -> Arc<Task>

Pick the next task to run on cpu_index.

1. Re-queues the current Running task (round-robin). The idle task is never re-queued — it is always available as the last-resort fallback. Keeping it out of the ready queue ensures the queue becomes truly empty when there is no real work, which lets work-stealing kick in on other CPUs.
2. Pops from the local ready queue.
3. Falls back to work-stealing from the busiest other CPU.
4. Falls back to the per-CPU idle task.

pub fn steal_task(&mut self, dst_cpu: usize, now_tick: u64) -> Option<Arc<Task>>

Try to steal one task from the most-loaded other CPU.

We steal from the back of the source queue (the task added most recently — least likely to have warm cache data on that CPU). We only steal when the source has ≥ 2 tasks, so it keeps at least one.

pub fn migrate_ready_tasks_for_new_class_table(&mut self)

Performs the migrate ready tasks for new class table operation.