quentinlegot/burritos
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update synch.rs

Browse Source
This commit is contained in:
Samy Solhi 2023-03-15 16:28:29 +01:00
parent 1906ec836c
commit b22b1dea21
4 changed files with 87 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/kernel/scheduler.rs
View File

@ -3,12 +3,12 @@ use std::rc::Rc;
use crate::utility::list::List;
use crate::kernel::thread::Thread;
use super::system::System;
use super::thread_manager::ThreadManager;
#[derive(PartialEq)]
pub struct Scheduler {
ready_list: List<Rc<RefCell<Thread>>>
ready_list: List<Rc<RefCell<Thread>>>,
pub thread_manager: Option<Rc<RefCell<ThreadManager>>>
}
impl Scheduler {
@ -18,7 +18,8 @@ impl Scheduler {
/// Initilize the list of ready thread
pub fn new() -> Self {
Self {
ready_list: List::new()
ready_list: List::new(),
thread_manager: Option::None
}
}
@ -53,17 +54,21 @@ impl Scheduler {
/// ## Parameter
///
/// **next_thread** thread to dispatch to the CPU
pub fn switch_to(&mut self, system: &mut System, next_thread: Rc<RefCell<Thread>>) {
let thread_manager = system.get_thread_manager();
if let Some(old_thread) = thread_manager.get_g_current_thread() {
thread_manager.thread_save_processor_state(system, Rc::clone(&old_thread));
pub fn switch_to(&mut self, next_thread: Rc<RefCell<Thread>>) {
if let Some(tm) = &self.thread_manager {
let rc = Rc::clone(&tm);
if let Some(old_thread) = tm.borrow_mut().get_g_current_thread() {
rc.borrow_mut().thread_save_processor_state(Rc::clone(&old_thread));
// old_thread.save_simulator_state();
if old_thread != &next_thread {
thread_manager.thread_restore_processor_state(system, Rc::clone(&next_thread));
rc.borrow_mut().thread_restore_processor_state(Rc::clone(&next_thread));
// next_thread.restore_simulator_state();
thread_manager.set_g_current_thread(Option::Some(next_thread));
rc.borrow_mut().set_g_current_thread(Option::Some(next_thread));
}
}
} else {
panic!("thread manager shouldn't be none");
}
}
}

84
src/kernel/synch.rs
View File

@ -40,17 +40,22 @@ impl Semaphore {
/// Note that thread_manager::thread_sleep assumes that interrupts are disabled
/// when it is called.
///
/// ### Parameters
/// ### Parameters TODO Refaire
/// - *current_thread* the current thread
/// - *machine* the machine where the threads are executed
pub fn p(&mut self, current_thread: Rc<RefCell<Thread>>, system: Rc<RefCell<System>>) {
let old_status = system.borrow_mut().get_g_machine().borrow_mut().interrupt.set_status(InterruptOff);
pub fn p(&mut self, system: &mut System) {
let old_status = system.get_machine().interrupt.set_status(InterruptOff);
self.counter -= 1;
if self.counter < 0 {
self.waiting_queue.push(Rc::clone(&current_thread));
self.thread_manager.borrow_mut().thread_sleep(current_thread);
match system.get_thread_manager().get_g_current_thread() {
Some(thread) => {
self.waiting_queue.push(Rc::clone(thread));
system.get_thread_manager().thread_sleep(system, Rc::clone(thread));
},
None => unreachable!("Current thread should not be None")
}
system.borrow_mut().get_g_machine().borrow_mut().interrupt.set_status(old_status);
}
system.get_machine().interrupt.set_status(old_status);
}
/// Increment semaphore value, waking up a waiting thread if any.
@ -63,13 +68,13 @@ impl Semaphore {
/// ### Parameters
/// - **machine** the machine where the threads are executed
/// - **scheduler** the scheduler which determine which thread to execute
pub fn v(&mut self, system: Rc<RefCell<System>>){
let old_status = system.borrow_mut().get_g_machine().borrow_mut().interrupt.set_status(InterruptOff);
pub fn v(&mut self, system: &mut System){
let old_status = system.get_machine().interrupt.set_status(InterruptOff);
self.counter += 1;
if self.waiting_queue.peek() != None {
system.borrow_mut().get_thread_manager().borrow_mut().g_scheduler.ready_to_run(self.waiting_queue.pop().unwrap());
system.get_thread_manager().g_scheduler.ready_to_run(self.waiting_queue.pop().unwrap());
}
system.borrow_mut().get_g_machine().borrow_mut().interrupt.set_status(old_status);
system.get_machine().interrupt.set_status(old_status);
}
}
@ -111,23 +116,30 @@ impl Lock {
/// ### Parameters
/// - **current_thread** the current thread
/// - **machine** the machine where the threads are executed
pub fn acquire(&mut self, current_thread: Option<Rc<RefCell<Thread>>>, system: Rc<RefCell<System>>) {
let old_status = system.borrow_mut().get_g_machine().borrow_mut().interrupt.set_status(InterruptOff);
pub fn acquire(&mut self, system: &mut System) {
let old_status = system.get_machine().interrupt.set_status(InterruptOff);
if self.free {
self.free = false;
self.owner = current_thread;
} else {
match current_thread {
Some(x) => {
self.waiting_queue.push(Rc::clone(&x));
self.thread_manager.borrow_mut().thread_sleep(x)
self.owner = Option::Some(match system.get_thread_manager().get_g_current_thread() {
Some(th) => {
Rc::clone(th)
},
None => ()
None => unreachable!()
});
} else {
let t = system.get_thread_manager().get_g_current_thread();
match t {
Some(x) => {
let x = Rc::clone(x);
self.waiting_queue.push(Rc::clone(&x));
system.thread_sleep(Rc::clone(&x));
},
None => unreachable!("Current thread should not be None")
}
}
system.borrow_mut().get_g_machine().borrow_mut().interrupt.set_status(old_status);
system.get_machine().interrupt.set_status(old_status);
}
/// Wake up a waiter if necessary, or release it if no thread is waiting.
@ -139,17 +151,16 @@ impl Lock {
/// ### Parameters
/// - **machine** the machine where the code is executed
/// - **scheduler** the scheduler which determine which thread to execute
pub fn release(&mut self, system: Rc<RefCell<System>>, current_thread: Rc<RefCell<Thread>>) {
let old_status = system.borrow_mut().get_g_machine().borrow_mut().interrupt.set_status(InterruptOff);
pub fn release(&mut self, system: &mut System) {
let old_status = system.get_machine().interrupt.set_status(InterruptOff);
if self.held_by_current_thread(current_thread) {
match system.get_thread_manager().get_g_current_thread() {
Some(thread) => {
if self.held_by_current_thread(system) {
if self.waiting_queue.peek() != None {
self.owner = Some(self.waiting_queue.pop().unwrap());
let sys = system.borrow_mut();
let tm = sys.get_thread_manager();
let scheduler = &mut tm.borrow_mut().g_scheduler;
match &self.owner {
Some(x) => scheduler.ready_to_run(Rc::clone(&x)),
Some(x) => system.get_thread_manager().g_scheduler.ready_to_run(Rc::clone(&x)),
None => ()
}
} else {
@ -157,13 +168,20 @@ impl Lock {
self.owner = None;
}
}
system.borrow_mut().get_g_machine().borrow_mut().interrupt.set_status(old_status);
}
None => ()
}
pub fn held_by_current_thread(&mut self, current_thread: Rc<RefCell<Thread>>) -> bool {
system.get_machine().interrupt.set_status(old_status);
}
pub fn held_by_current_thread(&mut self, system: &mut System) -> bool {
match &self.owner {
Some(x) => Rc::ptr_eq(&x, &current_thread),
Some(x) =>
match system.get_thread_manager().get_g_current_thread() {
Some(thread) => Rc::ptr_eq(&x, thread),
None => false
}
None => false
}
}
@ -195,11 +213,11 @@ impl Condition {
/// ### Parameters
/// - **current_thread** the current thread
/// - **machine** the machine where threads are executed
pub fn wait(&mut self, current_thread: Rc<RefCell<Thread>>, machine: &mut Machine) {
pub fn wait(&mut self, current_thread: Rc<RefCell<Thread>>, machine: &mut Machine, system: &mut System) {
let old_status = machine.interrupt.set_status(InterruptOff);
self.waiting_queue.push(Rc::clone(&current_thread));
self.thread_manager.borrow_mut().thread_sleep(current_thread);
self.thread_manager.borrow_mut().thread_sleep(system, current_thread);
machine.interrupt.set_status(old_status);
}

16
src/kernel/system.rs
View File

@ -6,7 +6,7 @@ use std::{cell::RefCell, rc::Rc};
use crate::simulator::machine::Machine;
use super::thread_manager::ThreadManager;
use super::{thread_manager::ThreadManager, thread::Thread};
/// This macro properly initializes the system
#[macro_export]
@ -46,17 +46,23 @@ impl System {
}
}
/// Sets a thread asleep
///
pub fn thread_sleep(&mut self, thread: Rc<RefCell<Thread>>) {
&self.thread_manager.thread_sleep(self, thread);
}
// GETTERS
/// Returns the Machine
///
/// Useful to access RAM, devices, ...
pub fn get_machine(&self) -> &Machine {
&self.machine
pub fn get_machine(&mut self) -> &mut Machine {
&mut self.machine
}
pub fn get_thread_manager(&self) -> &ThreadManager {
&self.thread_manager
pub fn get_thread_manager(&mut self) -> &mut ThreadManager {
&mut self.thread_manager
}
// Setters

4
src/kernel/thread_manager.rs
View File

@ -70,7 +70,7 @@ impl ThreadManager {
if let Some(next_thread) = next_thread {
let scheduler = &mut self.g_scheduler;
scheduler.ready_to_run(thread);
scheduler.switch_to(system, next_thread);
scheduler.switch_to(next_thread);
}
machine.interrupt.set_status(old_status);
}
@ -86,7 +86,7 @@ impl ThreadManager {
machine.interrupt.idle();
next_thread = self.g_scheduler.find_next_to_run();
}
self.g_scheduler.switch_to(system, Rc::clone(&next_thread.unwrap()));
self.g_scheduler.switch_to(Rc::clone(&next_thread.unwrap()));
}
/// Finish the execution of the thread and prepare its deallocation