67 lines
1.9 KiB
Rust
67 lines
1.9 KiB
Rust
use std::rc::Rc;
|
|
|
|
use crate::utility::list::List;
|
|
use crate::kernel::thread::Thread;
|
|
|
|
use super::system::System;
|
|
|
|
#[derive(PartialEq)]
|
|
pub struct Scheduler {
|
|
ready_list: List<Rc<Thread>>
|
|
}
|
|
|
|
impl Scheduler {
|
|
|
|
/// Constructor
|
|
///
|
|
/// Initilize the list of ready thread
|
|
pub fn new() -> Self {
|
|
Self {
|
|
ready_list: List::new()
|
|
}
|
|
}
|
|
|
|
/// Mark a thread as aready, but not necessarily running yet.
|
|
///
|
|
/// Put it in the ready list, for later scheduling onto the CPU.
|
|
///
|
|
/// ## Pamameter
|
|
///
|
|
/// **thread** is the thread to be put on the read list
|
|
pub fn ready_to_run(&mut self, thread: Rc<Thread>) {
|
|
self.ready_list.push(thread);
|
|
}
|
|
|
|
/// Return the next thread to be scheduled onto the CPU.
|
|
/// If there are no ready threads, return Option::None
|
|
///
|
|
/// Thread is removed from the ready list.
|
|
///
|
|
/// **return** Thread thread to be scheduled
|
|
pub fn find_next_to_run(&mut self) -> Option<Rc<Thread>> {
|
|
self.ready_list.pop()
|
|
}
|
|
|
|
/// Dispatch the CPU to next_thread. Save the state of the old thread
|
|
/// and load the state of the new thread.
|
|
///
|
|
/// We assume the state of the previously running thread has already been changed from running to blocked or ready.
|
|
///
|
|
/// Global variable g_current_thread become next_thread
|
|
///
|
|
/// ## Parameter
|
|
///
|
|
/// **next_thread** thread to dispatch to the CPU
|
|
pub fn switch_to(&self, system: Rc<System>, next_thread: Thread) {
|
|
/* if let Some(old_thread) = system.get_g_current_thread() {
|
|
old_thread.save_processor_state();
|
|
old_thread.save_simulator_state();
|
|
|
|
if old_thread != &next_thread {
|
|
next_thread.restore_processor_state();
|
|
next_thread.restore_simulator_state();
|
|
system.set_g_current_thread(Option::Some(next_thread));
|
|
}
|
|
} */
|
|
}
|
|
} |