From fa64d4314d217292c99039ec3b7eb27b528ba41e Mon Sep 17 00:00:00 2001 From: Quentin Legot Date: Wed, 15 Mar 2023 17:57:53 +0100 Subject: [PATCH] decrease some dependencies --- src/kernel/scheduler.rs | 11 ++++++----- src/kernel/synch.rs | 27 ++++++++++++++------------- src/kernel/system.rs | 3 ++- src/kernel/thread_manager.rs | 36 ++++++++++++++++-------------------- 4 files changed, 38 insertions(+), 39 deletions(-) diff --git a/src/kernel/scheduler.rs b/src/kernel/scheduler.rs index 01ad40f..a3e2c6a 100644 --- a/src/kernel/scheduler.rs +++ b/src/kernel/scheduler.rs @@ -3,6 +3,7 @@ use std::rc::Rc; use crate::utility::list::List; use crate::kernel::thread::Thread; +use crate::simulator::machine::Machine; use super::system::System; use super::thread_manager::ThreadManager; @@ -53,15 +54,15 @@ impl Scheduler { /// ## Parameter /// /// **next_thread** thread to dispatch to the CPU - pub fn switch_to(&mut self, system: &mut System, next_thread: Rc>) { - let old_thread = system.get_thread_manager().get_g_current_thread().as_ref().unwrap(); - system.get_thread_manager().thread_save_processor_state(system, Rc::clone(&old_thread)); + pub fn switch_to(&mut self, machine: &mut Machine, thread_manager: &mut ThreadManager, next_thread: Rc>) { + let old_thread = thread_manager.get_g_current_thread().as_ref().unwrap(); + thread_manager.thread_save_processor_state(machine, Rc::clone(&old_thread)); // old_thread.save_simulator_state(); if old_thread != &next_thread { - system.get_thread_manager().thread_restore_processor_state(system, Rc::clone(&next_thread)); + thread_manager.thread_restore_processor_state(machine, Rc::clone(&next_thread)); // next_thread.restore_simulator_state(); - system.get_thread_manager().set_g_current_thread(Option::Some(next_thread)); + thread_manager.set_g_current_thread(Some(next_thread)); } } diff --git a/src/kernel/synch.rs b/src/kernel/synch.rs index 89df690..30b32b3 100644 --- a/src/kernel/synch.rs +++ b/src/kernel/synch.rs @@ -41,19 +41,19 @@ impl Semaphore { /// ### Parameters TODO Refaire /// - *current_thread* the current thread /// - *machine* the machine where the threads are executed - pub fn p(&mut self, system: &mut System) { - let old_status = system.get_machine().interrupt.set_status(InterruptOff); + pub fn p(&mut self, machine: &mut Machine, thread_manager: &mut ThreadManager) { + let old_status = machine.interrupt.set_status(InterruptOff); self.counter -= 1; if self.counter < 0 { - match system.get_thread_manager().get_g_current_thread() { + match 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)); + thread_manager.thread_sleep(machine, Rc::clone(thread)); }, None => unreachable!("Current thread should not be None") } } - system.get_machine().interrupt.set_status(old_status); + machine.interrupt.set_status(old_status); } /// Increment semaphore value, waking up a waiting thread if any. @@ -112,30 +112,31 @@ impl Lock { /// ### Parameters /// - **current_thread** the current thread /// - **machine** the machine where the threads are executed - pub fn acquire(&mut self, system: &mut System) { - let old_status = system.get_machine().interrupt.set_status(InterruptOff); + pub fn acquire(&mut self, thread_manager: &mut ThreadManager, machine: &mut Machine) { + let old_status = machine.interrupt.set_status(InterruptOff); if self.free { self.free = false; - self.owner = Option::Some(match system.get_thread_manager().get_g_current_thread() { + self.owner = Option::Some(match thread_manager.get_g_current_thread() { Some(th) => { Rc::clone(th) }, None => unreachable!() }); } else { - let t = system.get_thread_manager().get_g_current_thread(); + let t = 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)); + + thread_manager.thread_sleep(machine, Rc::clone(&x)); }, None => unreachable!("Current thread should not be None") } } - system.get_machine().interrupt.set_status(old_status); + machine.interrupt.set_status(old_status); } /// Wake up a waiter if necessary, or release it if no thread is waiting. @@ -266,10 +267,10 @@ mod test { fn test_semaphore_single() { // Init let system = init_system!(); - let mut semaphore = Semaphore::new(1, Rc::clone(&system.borrow_mut().get_thread_manager())); + let mut semaphore = Semaphore::new(1); let thread = Rc::new(RefCell::new(Thread::new("test_semaphore"))); // P - semaphore.p(thread, Rc::clone(&system)); + semaphore.p(system, thread); assert_eq!(semaphore.counter, 0); assert!(semaphore.waiting_queue.is_empty()); // V diff --git a/src/kernel/system.rs b/src/kernel/system.rs index 6104dc3..bb3d5a2 100644 --- a/src/kernel/system.rs +++ b/src/kernel/system.rs @@ -49,7 +49,8 @@ impl System { /// Sets a thread asleep /// pub fn thread_sleep(&mut self, thread: Rc>) { - self.thread_manager.thread_sleep(self, thread); + let machine = self.get_machine(); + self.thread_manager.thread_sleep(machine, thread); } // GETTERS diff --git a/src/kernel/thread_manager.rs b/src/kernel/thread_manager.rs index 5820906..d63b563 100644 --- a/src/kernel/thread_manager.rs +++ b/src/kernel/thread_manager.rs @@ -1,6 +1,7 @@ use std::{rc::Rc, cell::{RefCell, RefMut, Ref}}; use crate::{utility::list::List, simulator::{machine::{NUM_INT_REGS, NUM_FP_REGS}, interrupt::InterruptStatus}}; +use crate::simulator::machine::Machine; use super::{scheduler::Scheduler, thread::Thread, system::System, mgerror::ErrorCode, process::Process}; @@ -52,33 +53,31 @@ impl ThreadManager { } /// Wait for another thread to finish its execution - pub fn thread_join(&mut self, system: &mut System, id_thread: Rc>) { + pub fn thread_join(&mut self, machine: &mut Machine, thread_manager: &mut ThreadManager, id_thread: Rc>) { while self.get_g_alive().contains(&Rc::clone(&id_thread)) { - self.thread_yield(system, Rc::clone(&id_thread)); + self.thread_yield(machine, thread_manager, Rc::clone(&id_thread)); } } /// Relinquish the CPU if any other thread is runnable. /// /// Cannot use yield as a function name -> reserved name in rust - pub fn thread_yield(&mut self, system: &mut System, thread: Rc>) { - let mut machine = system.get_machine(); - let old_status = machine.interrupt.set_status(crate::simulator::interrupt::InterruptStatus::InterruptOff); + pub fn thread_yield(&mut self, machine: &mut Machine, thread_manager: &mut ThreadManager, thread: Rc>) { + let old_status = machine.interrupt.set_status(InterruptStatus::InterruptOff); - assert_eq!(Option::Some(Rc::clone(&thread)), self.g_current_thread); + assert_eq!(Some(Rc::clone(&thread)), self.g_current_thread); let next_thread = self.g_scheduler.find_next_to_run(); 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(machine, thread_manager, next_thread); } machine.interrupt.set_status(old_status); } /// Put the thread to sleep and relinquish the processor - pub fn thread_sleep(&mut self, system: &mut System, thread: Rc>) { - assert_eq!(Option::Some(Rc::clone(&thread)), self.g_current_thread); - let machine = system.get_machine(); + pub fn thread_sleep(&mut self, machine: &mut Machine, thread: Rc>) { + assert_eq!(Some(Rc::clone(&thread)), self.g_current_thread); assert_eq!(machine.interrupt.get_status(), InterruptStatus::InterruptOff); let mut next_thread = self.g_scheduler.find_next_to_run(); while next_thread.is_none() { @@ -86,36 +85,33 @@ 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(machine, self, Rc::clone(&next_thread.unwrap())); } /// Finish the execution of the thread and prepare its deallocation - pub fn thread_finish(&mut self, system: &mut System, thread: Rc>) { - let mut machine = system.get_machine(); + pub fn thread_finish(&mut self, machine: &mut Machine, thread_manager: &mut ThreadManager, thread: Rc>) { let old_status = machine.interrupt.set_status(InterruptStatus::InterruptOff); self.g_thread_to_be_destroyed = Option::Some(Rc::clone(&thread)); self.g_alive.remove(Rc::clone(&thread)); // g_objets_addrs->removeObject(self.thread) // a ajouté plus tard - self.thread_sleep(system, Rc::clone(&thread)); + self.thread_sleep(machine, Rc::clone(&thread)); machine.interrupt.set_status(old_status); } - pub fn thread_save_processor_state(&mut self, system: &mut System, thread: Rc>) { + pub fn thread_save_processor_state(&mut self, machine: &mut Machine, thread: Rc>) { let mut t: RefMut<_> = thread.borrow_mut(); for i in 0..NUM_INT_REGS { - t.thread_context.int_registers[i] = system.get_machine().read_int_register(i); + t.thread_context.int_registers[i] = machine.read_int_register(i); } for i in 0..NUM_FP_REGS { - t.thread_context.float_registers[i] = system.get_machine().read_fp_register(i); + t.thread_context.float_registers[i] = machine.read_fp_register(i); } } - pub fn thread_restore_processor_state(&self, system: &mut System, thread: Rc>) { + pub fn thread_restore_processor_state(&self, machine: &mut Machine, thread: Rc>) { let t: Ref<_> = thread.borrow(); for i in 0..NUM_INT_REGS { - let machine = system.get_machine(); - let mut machine = machine; machine.write_int_register(i, t.thread_context.int_registers[i]); } }