Don't store idle tasks on each runqueue (theseus-os#982)

* As part of our ongoing scheduler/runqueue redesign,
  there is no real reason to store each CPU's idle task
  in a scheduler runqueue. They are only used separately
  as a "last resort" when no runnable tasks exist, so we
  can store them alongside the runqueue rather than inside it.

* Also, we change the creation of idle tasks to be done
  as part of initializing the tasking subsystem on each CPU
  rather than as an explicit step in the captain's init routine.

* In the future, each CPU's idle task can be stored in
  CPU-local storage, since they ideologically "belong" to
  a CPU instance rather than a runqueue instance.

* Unrelated: move `state_transfer` to old crates, as it
  currently doesn't build any more due to the ongoing
  scheduler/runqueue changes.

Signed-off-by: Klimenty Tsoutsman <[email protected]>

Author: tsoutsman

Cargo.lock

@@ -109,7 +109,6 @@ pub fn kstart_ap(
     // per-CPU storage, tasking, and create the idle task for this CPU.
     per_cpu::init(cpu_id).unwrap();
     let bootstrap_task = spawn::init(kernel_mmi_ref.clone(), cpu_id, this_ap_stack).unwrap();
-    spawn::create_idle_task().unwrap();
 
     // The PAT must be initialized explicitly on every CPU,
     // but it is not a fatal error if it doesn't exist.

kernel/ap_start/src/lib.rs

@@ -212,13 +212,11 @@ pub fn init(
     // The following final initialization steps are important, and order matters:
     // 1. Drop any other local stack variables that still exist.
     drop(kernel_mmi_ref);
-    // 2. Create the idle task for this CPU.
-    spawn::create_idle_task()?;
-    // 3. Cleanup bootstrap tasks, which handles this one and all other APs' bootstrap tasks.
+    // 2. Cleanup bootstrap tasks, which handles this one and all other APs' bootstrap tasks.
     spawn::cleanup_bootstrap_tasks(cpu_count)?;
-    // 4. "Finish" this bootstrap task, indicating it has exited and no longer needs to run.
+    // 3. "Finish" this bootstrap task, indicating it has exited and no longer needs to run.
     bootstrap_task.finish();
-    // 5. Enable interrupts such that other tasks can be scheduled in.
+    // 4. Enable interrupts such that other tasks can be scheduled in.
     enable_interrupts();
     // ****************************************************
     // NOTE: nothing below here is guaranteed to run again!

kernel/captain/src/lib.rs

@@ -28,8 +28,8 @@ use runqueue::RunQueue;
 
 
 /// Creates a new `RunQueue` for the given core, which is an `apic_id`.
-pub fn init(which_core: u8) -> Result<(), &'static str> {
-    RunQueue::init(which_core)
+pub fn init(which_core: u8, idle_task: TaskRef) -> Result<(), &'static str> {
+    RunQueue::init(which_core, idle_task)
 }
 
 /// Returns the `RunQueue` of the given core, which is an `apic_id`.

kernel/runqueue/src/lib.rs

@@ -68,6 +68,7 @@ static RUNQUEUES: AtomicMap<u8, PreemptionSafeRwLock<RunQueue>> = AtomicMap::new
 pub struct RunQueue {
     core: u8,
     queue: VecDeque<EpochTaskRef>,
+    idle_task: TaskRef,
 }
 
 impl Deref for RunQueue {
@@ -102,12 +103,13 @@ impl RunQueue {
     }
 
     /// Creates a new `RunQueue` for the given core, which is an `apic_id`
-    pub fn init(which_core: u8) -> Result<(), &'static str> {
+    pub fn init(which_core: u8, idle_task: TaskRef) -> Result<(), &'static str> {
         #[cfg(not(loscd_eval))]
         trace!("Created runqueue (priority) for core {}", which_core);
         let new_rq = PreemptionSafeRwLock::new(RunQueue {
             core: which_core,
             queue: VecDeque::new(),
+            idle_task,
         });
 
         if RUNQUEUES.insert(which_core, new_rq).is_some() {
@@ -226,6 +228,10 @@ impl RunQueue {
         Ok(())
     }
 
+    pub fn idle_task(&self) -> &TaskRef {
+        &self.idle_task
+    }
+
     fn get_priority(&self, task: &TaskRef) -> Option<u8> {
         for epoch_task in self.iter() {
             if &epoch_task.task == task {

kernel/runqueue_epoch/src/lib.rs

@@ -94,6 +94,7 @@ static RUNQUEUES: AtomicMap<u8, PreemptionSafeRwLock<RunQueue>> = AtomicMap::new
 pub struct RunQueue {
     core: u8,
     queue: VecDeque<PriorityTaskRef>,
+    idle_task: TaskRef,
 }
 
 impl Deref for RunQueue {
@@ -134,12 +135,13 @@ impl RunQueue {
     }
 
     /// Creates a new `RunQueue` for the given core, which is an `apic_id`
-    pub fn init(which_core: u8) -> Result<(), &'static str> {
+    pub fn init(which_core: u8, idle_task: TaskRef) -> Result<(), &'static str> {
         #[cfg(not(loscd_eval))]
         trace!("Created runqueue (priority) for core {}", which_core);
         let new_rq = PreemptionSafeRwLock::new(RunQueue {
             core: which_core,
             queue: VecDeque::new(),
+            idle_task,
         });
 
         if RUNQUEUES.insert(which_core, new_rq).is_some() {
@@ -262,6 +264,10 @@ impl RunQueue {
         Ok(())
     }
 
+    pub fn idle_task(&self) -> &TaskRef {
+        &self.idle_task
+    }
+
     /// The internal function that sets the periodicity of a given `Task` in a single `RunQueue`
     /// then reinserts the `PriorityTaskRef` at the proper location
     fn set_periodicity_internal(

kernel/runqueue_priority/src/lib.rs

@@ -49,6 +49,7 @@ pub struct RoundRobinTaskRef{
 
 impl Deref for RoundRobinTaskRef {
     type Target = TaskRef;
+
     fn deref(&self) -> &TaskRef {
         &self.taskref
     }
@@ -87,6 +88,7 @@ pub static RUNQUEUES: AtomicMap<u8, PreemptionSafeRwLock<RunQueue>> = AtomicMap:
 #[derive(Debug)]
 pub struct RunQueue {
     core: u8,
+    idle_task: TaskRef,
     queue: VecDeque<RoundRobinTaskRef>,
 }
 // impl Drop for RunQueue {
@@ -97,6 +99,7 @@ pub struct RunQueue {
 
 impl Deref for RunQueue {
     type Target = VecDeque<RoundRobinTaskRef>;
+
     fn deref(&self) -> &VecDeque<RoundRobinTaskRef> {
         &self.queue
     }
@@ -121,10 +124,11 @@ impl RunQueue {
     }
 
     /// Creates a new `RunQueue` for the given core, which is an `apic_id`.
-    pub fn init(which_core: u8) -> Result<(), &'static str> {
+    pub fn init(which_core: u8, idle_task: TaskRef) -> Result<(), &'static str> {
         trace!("Created runqueue (round robin) for core {}", which_core);
         let new_rq = PreemptionSafeRwLock::new(RunQueue {
             core: which_core,
+            idle_task,
             queue: VecDeque::new(),
         });
 
@@ -138,6 +142,10 @@ impl RunQueue {
         }
     }
 
+    pub fn idle_task(&self) -> &TaskRef {
+        &self.idle_task
+    }
+
     /// Returns the `RunQueue` for the given core, which is an `apic_id`.
     pub fn get_runqueue(which_core: u8) -> Option<&'static PreemptionSafeRwLock<RunQueue>> {
         RUNQUEUES.get(&which_core)

kernel/runqueue_round_robin/src/lib.rs

@@ -39,31 +39,18 @@ pub fn get_priority(task: &TaskRef) -> Option<u8> {
 /// This defines the priority scheduler policy.
 /// Returns None if there is no schedule-able task.
 pub fn select_next_task(apic_id: u8) -> Option<TaskRef> {
-    let priority_taskref_with_result = select_next_task_priority(apic_id);
-    match priority_taskref_with_result {
-        // A task has been selected
-        Some(task) => {
-            // If the selected task is idle task we begin a new scheduling epoch
-            if task.idle_task {
-                assign_tokens(apic_id);
-                select_next_task_priority(apic_id).and_then(|m| m.taskref)
-            }
-            // If the selected task is not idle we return the taskref
-            else {
-                task.taskref
-            }
-        }
-
-        // If no task is picked we pick a new scheduling epoch
-        None => {
-            assign_tokens(apic_id);
-            select_next_task_priority(apic_id).and_then(|m| m.taskref)
-        }
+    let next_task = select_next_task_priority(apic_id)?;
+    // If the selected task is idle task we begin a new scheduling epoch
+    if next_task.idle_task {
+        assign_tokens(apic_id);
+        select_next_task_priority(apic_id)?.taskref
+    } else {
+        next_task.taskref
     }
 }
 
 /// this defines the priority scheduler policy.
-/// Returns None if there is no schedule-able task.
+/// Returns None if there is no runqueue
 /// Otherwise returns a task with a flag indicating whether its an idle task.
 fn select_next_task_priority(apic_id: u8) -> Option<NextTaskResult> {
     let mut runqueue_locked = match RunQueue::get_runqueue(apic_id) {
@@ -76,62 +63,31 @@ fn select_next_task_priority(apic_id: u8) -> Option<NextTaskResult> {
         }
     };
 
-    let mut idle_task_index: Option<usize> = None;
-    let mut chosen_task_index: Option<usize> = None;
-    let mut idle_task = true;
-
-    for (i, t) in runqueue_locked.iter().enumerate() {
-        // we skip the idle task, and only choose it if no other tasks are runnable
-        if t.is_an_idle_task {
-            idle_task_index = Some(i);
-            continue;
-        }
-
-        // must be runnable
-        if !t.is_runnable() {
-            continue;
-        }
-
-        // if this task is pinned, it must not be pinned to a different core
-        if let Some(pinned) = t.pinned_cpu() {
-            if pinned.into_u8() != apic_id {
-                // with per-core runqueues, this should never happen!
-                error!(
-                    "select_next_task() (AP {}) found a task pinned to a different core: {:?}",
-                    apic_id, t
-                );
-                return None;
+    if let Some((task_index, _)) = runqueue_locked
+        .iter()
+        .enumerate()
+        .find(|(_, task)| task.is_runnable())
+    {
+        let modified_tokens = {
+            let chosen_task = runqueue_locked.get(task_index);
+            match chosen_task.map(|m| m.tokens_remaining) {
+                Some(x) => x.saturating_sub(1),
+                None => 0,
             }
-        }
-
-        // if the task has no remaining tokens we ignore the task
-        if t.tokens_remaining == 0 {
-            continue;
-        }
-
-        // found a runnable task!
-        chosen_task_index = Some(i);
-        idle_task = false;
-        // debug!("select_next_task(): AP {} chose Task {:?}", apic_id, &*t);
-        break;
-    }
+        };
 
-    // We then reduce the number of tokens of the task by one
-    let modified_tokens = {
-        let chosen_task = chosen_task_index.and_then(|index| runqueue_locked.get(index));
-        match chosen_task.map(|m| m.tokens_remaining) {
-            Some(x) => x.saturating_sub(1),
-            None => 0,
-        }
-    };
+        let task = runqueue_locked.update_and_move_to_end(task_index, modified_tokens);
 
-    chosen_task_index
-        .or(idle_task_index)
-        .and_then(|index| runqueue_locked.update_and_move_to_end(index, modified_tokens))
-        .map(|taskref| NextTaskResult {
-            taskref: Some(taskref),
-            idle_task,
+        Some(NextTaskResult {
+            taskref: task,
+            idle_task: false,
         })
+    } else {
+        Some(NextTaskResult {
+            taskref: Some(runqueue_locked.idle_task().clone()),
+            idle_task: true,
+        })
+    }
 }
 
 /// This assigns tokens between tasks.

kernel/scheduler_epoch/src/lib.rs

@@ -3,6 +3,7 @@ authors = ["Jacob Earle <[email protected]>"]
 name = "scheduler_priority"
 description = "Provides a priority scheduler"
 version = "0.1.0"
+edition = "2021"
 
 [dependencies.log]
 version = "0.4.8"

kernel/scheduler_priority/Cargo.toml

@@ -1,17 +1,16 @@
 //! This scheduler implements a priority algorithm.
 //!
-//! Because the [`runqueue_priority::RunQueue`] internally sorts the tasks 
-//! in increasing order of periodicity, it's trivially easy to choose the next task.
+//! Because the [`runqueue_priority::RunQueue`] internally sorts the tasks
+//! in increasing order of periodicity, it's trivially easy to choose the next
+//! task.
 
 #![no_std]
 
 extern crate alloc;
-#[macro_use] extern crate log;
-extern crate task;
-extern crate runqueue_priority;
 
-use task::TaskRef;
+use log::error;
 use runqueue_priority::RunQueue;
+use task::TaskRef;
 
 /// Set the periodicity of a given `Task` in all `RunQueue` structures.
 /// A reexport of the set_periodicity function from runqueue_priority
@@ -23,35 +22,18 @@ pub fn select_next_task(apic_id: u8) -> Option<TaskRef> {
     let mut runqueue_locked = match RunQueue::get_runqueue(apic_id) {
         Some(rq) => rq.write(),
         _ => {
-            error!("BUG: select_next_task_round_robin(): couldn't get runqueue for core {}", apic_id);
+            error!("BUG: select_next_task_priority(): couldn't get runqueue for core {apic_id}",);
             return None;
         }
     };
 
-    let mut idle_task_index: Option<usize> = None;
-    let mut chosen_task_index: Option<usize> = None;
-    
-    for (i, taskref) in runqueue_locked.iter().enumerate() {
-        let t = taskref;
-
-        // we skip the idle task, and only choose it if no other tasks are runnable
-        if t.is_an_idle_task {
-            idle_task_index = Some(i);
-            continue;
-        }
-
-        // must be runnable
-        if !t.is_runnable() {
-            continue;
-        }
-
-        // found a runnable task
-        chosen_task_index = Some(i);
-        break;
+    if let Some((task_index, _)) = runqueue_locked
+        .iter()
+        .enumerate()
+        .find(|(_, task)| task.is_runnable())
+    {
+        runqueue_locked.update_and_reinsert(task_index)
+    } else {
+        Some(runqueue_locked.idle_task().clone())
     }
-
-    // idle task is backup iff no other task has been chosen
-    chosen_task_index
-        .or(idle_task_index)
-        .and_then(|index| runqueue_locked.update_and_reinsert(index))
 }

kernel/scheduler_priority/src/lib.rs

@@ -3,6 +3,7 @@ authors = ["Kevin Boos <[email protected]>"]
 name = "scheduler_round_robin"
 description = "Provides Round robin scheduling functionality and picks the next task"
 version = "0.1.0"
+edition = "2021"
 
 [dependencies]
 spin = "0.9.4"