Struct rstubs::threading::scheduler::Scheduler

pub struct Scheduler {
    ready: ArrayDeque<usize, APPS>,
    threads: [Option<Thread>; 11],
    next_id: AtomicUsize,
    local: PerCPU<Local>,
}

The scheduler plans the threads’ execution order and, from this, selects the next thread to be running.

The scheduler manages the ready queue, that is the list of threads that are ready to execute. The scheduler arranges threads in a FIFO order, that is, when a thread is set ready, it will be appended to the end of the queue, while threads to be executed are taken from the front of the queue.

Fields

ready: ArrayDeque<usize, APPS>

Ready queue

threads: [Option<Thread>; 11]

Contains all threads

Note: the idle threads have the id and index of their corresponding CPU

next_id: AtomicUsize

Next thread id

local: PerCPU<Local>

Per-CPU data

Implementations

impl Scheduler

pub const fn new() -> Self

Construct the scheduler.

pub fn add(&mut self, thread: Thread) -> usize

Add and ready a new thread to the scheduler.

fn is_idle(thread: usize) -> bool

pub fn ready(&mut self, thread: usize)

Include a thread in scheduling decisions.

This method will register a thread for scheduling. It will be appended to the ready queue and dispatched once its time has come.

Note: New threads have to be added first with Scheduler::add.

pub fn active(&self) -> Option<usize>

pub fn thread(&self, thread: usize) -> Option<&Thread>

pub fn thread_mut(&mut self, thread: usize) -> Option<&mut Thread>

pub fn schedule(&mut self) -> !

Start the scheduling. This function does not return.

pub fn resume(&mut self, ready: bool)

Initiates a thread switch. This function returns then in the context of the next thread.

If ready, the currently running thread is added back to the ready list.

pub fn exit(&mut self) -> !

Terminates the currently running thread, directly continue with the next one.

pub fn kill(&mut self, thread: usize) -> bool

Terminates t, which might be running or waiting.

fn dispatch(&mut self, next: usize)

Updates the life pointer to next and issues a thread change from the old to the new life pointer.

fn next(&mut self) -> usize

Helper to retrieve next Thread.

pub extern "C" fn idle_action()

Action of the idle thread.