Add thread save and restore processor context

src/kernel/system.rs

@@ -1,3 +1,5 @@
+use std::cell::RefCell;
+
 use crate::simulator::machine::Machine;
 
 use super::thread_manager::ThreadManager;
@@ -14,7 +16,7 @@ use super::thread_manager::ThreadManager;
 /// - The scheduler which acts upon these threads
 #[derive(PartialEq)]
 pub struct System<'a> {
-    g_machine: Machine,
+    g_machine: RefCell<Machine>,
     thread_manager: ThreadManager<'a>
 }
 
@@ -23,7 +25,7 @@ impl<'a> System<'a> {
     /// System constructor
     pub fn new(machine: Machine) -> System<'a> {
         Self {
-            g_machine: machine,
+            g_machine: RefCell::new(machine),
             thread_manager: ThreadManager::new()
         }
     }
@@ -37,14 +39,14 @@ impl<'a> System<'a> {
     /// Returns the Machine
     /// 
     /// Useful to access RAM, devices, ...
-    pub fn get_g_machine(&mut self) -> &mut Machine {
-        &mut self.g_machine
+    pub fn get_g_machine(&self) -> &RefCell<Machine> {
+        &self.g_machine
     }
 
     // Setters
 
     /// Assign a machine to the system
-    pub fn set_g_machine(&mut self, machine: Machine) {
+    pub fn set_g_machine(&mut self, machine: RefCell<Machine>) {
         self.g_machine = machine
     }
 

src/kernel/thread.rs

@@ -1,13 +1,12 @@
-use super::{process::Process, system::ObjectType};
+use super::{process::Process, system::ObjectType, thread_manager::SIMULATORSTACKSIZE};
 use crate::{simulator::machine::{NUM_INT_REGS, NUM_FP_REGS, STACK_REG}};
 
-const SIMULATORSTACKSIZE: usize = 32 * 1024;
 const STACK_FENCEPOST: u32 = 0xdeadbeef;
 
 #[derive(PartialEq)]
-struct ThreadContext {
+pub struct ThreadContext {
     pub int_registers: [i64; NUM_INT_REGS],
-    pub float_registers: [i64; NUM_FP_REGS],
+    pub float_registers: [f32; NUM_FP_REGS],
     pc: i64,
 }
 
@@ -16,8 +15,8 @@ pub struct Thread {
     name: String,
     pub process: Option<Process>,
     // simulation_context: UContextT,
-    thread_context: ThreadContext,
-    stack_pointer: i32,
+    pub thread_context: ThreadContext,
+    pub stack_pointer: i32,
     object_type: ObjectType
 }
 
@@ -31,7 +30,7 @@ impl Thread {
             // simulation_context: UContextT::new(),
             thread_context: ThreadContext { 
                 int_registers: [0; NUM_INT_REGS], 
-                float_registers: [0; NUM_FP_REGS], 
+                float_registers: [0f32; NUM_FP_REGS], 
                 pc: 0 
             },
             stack_pointer: 0,
@@ -60,27 +59,18 @@ impl Thread {
         // self.simulation_context.stackBottom[0] = STACK_FENCEPOST;
     }
     
-    /// Put the thread to sleep and relinquish the processor
-    pub fn sleep(&self) {
-        todo!();
-    }
-
-    /// Finish the execution of the thread and prepare its deallocation
-    pub fn finish(&self) {
-        todo!();
-    }
-    
     /// Check if a thread has overflowed its stack
+    /// 
+    /// This assertion doesn't catch all stack overflow conditions and your program may still crash because of an overflow.
+    /// 
     pub fn check_overflow(&self) {
-        todo!();
+        // if self.simulator_context.stackBottom != STACK_FENCEPOST {
+        //     panic!("thread {} has overflowed", self.get_name())
+        // }
     }
 
-    pub fn save_processor_state(&self) {
-        todo!();
-    }
-
-    pub fn restore_processor_state(&self) {
-        todo!();
+    pub fn sleep(&self) {
+        unreachable!("Has been moved to thread manager");
     }
 
     pub fn save_simulator_state(&self) {

src/kernel/thread_manager.rs

@@ -1,10 +1,10 @@
-use std::{rc::Rc, cell::Cell};
+use std::{rc::Rc, cell::{Cell, RefCell, RefMut, Ref}};
 
-use crate::utility::list::List;
+use crate::{utility::list::List, simulator::machine::{NUM_INT_REGS, NUM_FP_REGS}};
 
 use super::{scheduler::Scheduler, thread::Thread, system::System, mgerror::ErrorCode, process::Process};
 
-const SIMULATORSTACKSIZE: usize = 32 * 1024;
+pub const SIMULATORSTACKSIZE: usize = 32 * 1024;
 
 #[derive(PartialEq)]
 pub struct ThreadManager<'a> {
@@ -44,17 +44,54 @@ impl<'a> ThreadManager<'a> {
     /// Wait for another thread to finish its execution
     pub fn thread_join(&mut self, id_thread: Rc<Thread>) {
         while self.get_g_alive().contains(&Rc::clone(&id_thread)) {
-            self.thread_yield();
+            self.thread_yield(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) {
+    pub fn thread_yield(&mut self, thread: Rc<Thread>) {
         todo!();
     }
 
+    /// Put the thread to sleep and relinquish the processor
+    pub fn thread_sleep(&mut self, thread: Rc<Thread>) {
+        todo!();
+    }
+
+    /// Finish the execution of the thread and prepare its deallocation
+    pub fn thread_finish(&self, thread: Rc<Thread>) {
+        todo!();
+    }
+
+    pub fn thread_save_processor_state(&mut self, thread: Rc<RefCell<Thread>>) {
+        if let Some(system) = self.system.get() {
+            let mut t: RefMut<_> = thread.borrow_mut();
+            for i in 0..NUM_INT_REGS {
+                t.thread_context.int_registers[i] = system.get_g_machine().borrow().read_int_register(i);
+            }
+            for i in 0..NUM_FP_REGS {
+                t.thread_context.float_registers[i] = system.get_g_machine().borrow().read_fp_register(i);
+            }
+        } else {
+            unreachable!("System is None")
+        }
+    }
+
+    pub fn thread_restore_processor_state(&self, thread: Rc<RefCell<Thread>>) {
+        if let Some(system) = self.system.get() {
+            let t: Ref<_> = thread.borrow();
+            for i in 0..NUM_INT_REGS {
+                let machine = system.get_g_machine();
+                let mut machine = machine.borrow_mut();
+                machine.write_int_register(i, t.thread_context.int_registers[i]);
+            }
+        } else {
+            unreachable!("System is None")
+        }
+    }
+
     /// Currently running thread
     pub fn get_g_current_thread(&mut self) -> &mut Option<Thread> {
         &mut self.g_current_thread

src/kernel/ucontext.rs

@@ -1,5 +1,5 @@
 
-// use std::mem::MaybeUninit;
+use std::mem::MaybeUninit;
 
 /// Safe wrapper for ucontext_t struct of linux-gnu libc
 /// 
@@ -12,10 +12,11 @@
 pub struct UContextT {
     #[cfg(not(target_os = "windows"))] // struct non disponible sur la libc sur windows
     pub buf: libc::ucontext_t,
-    pub stackBottom: Vec<i8>
+    pub stack_bottom: Vec<i8>
 }
 
 #[cfg(not(target_os = "windows"))]
+#[allow(unused)] // Temporary as we currently doesn't use this structure (this structure may disapear in a near future)
 impl UContextT {
 
     pub fn new() -> Self {
@@ -23,7 +24,7 @@ impl UContextT {
         unsafe { libc::getcontext(context.as_mut_ptr()) };
         Self {
             buf: unsafe  { context.assume_init() },
-            stackBottom: Vec::default(),
+            stack_bottom: Vec::default(),
         }
     }
 

src/simulator/machine.rs

@@ -616,6 +616,22 @@ impl Machine {
 		machine.pc += 8;
 
 	}
+
+	pub fn read_int_register(&self, index: usize) -> i64 {
+		self.int_reg.get_reg(index)
+	}
+
+	pub fn read_fp_register(&self, index: usize) -> f32 {
+		self.fp_reg.get_reg(index)
+	}
+
+	pub fn write_int_register(&mut self, index: usize, value: i64) {
+		self.int_reg.set_reg(index, value);
+	}
+	
+	pub fn write_fp_register(&mut self, index: usize, value: f32) {
+		self.fp_reg.set_reg(index, value);
+	}
 }
 
 #[cfg(test)]