Fix thread

src/kernel/scheduler.rs

@@ -1,13 +1,11 @@
-use std::sync::Arc;
+use std::{sync::Arc, rc::Rc};
 
 use crate::utility::list::List;
 use crate::kernel::thread::Thread;
 
-use super::system::{G_CURRENT_THREAD, G_THREAD_TO_BE_DESTROYED};
-
 #[derive(PartialEq)]
 pub struct Scheduler {
-    ready_list: List<Arc<Thread>>
+    ready_list: List<Rc<Thread>>
 }
 
 impl Scheduler {
@@ -28,7 +26,7 @@ impl Scheduler {
     /// ## Pamameter
     /// 
     /// **thread** is the thread to be put on the read list
-    pub fn ready_to_run(&mut self, thread: Arc<Thread>) {
+    pub fn ready_to_run(&mut self, thread: Rc<Thread>) {
         self.ready_list.push(thread);
     }
     
@@ -38,7 +36,7 @@ impl Scheduler {
     /// Thread is removed from the ready list.
     /// 
     /// **return** Thread thread to be scheduled
-    pub fn find_next_to_run(&mut self) -> Option<Arc<Thread>> {
+    pub fn find_next_to_run(&mut self) -> Option<Rc<Thread>> {
         self.ready_list.pop()
     }
 

src/kernel/thread.rs

@@ -51,23 +51,9 @@ impl Thread {
         let base_stack_addr: [i8; SIMULATORSTACKSIZE] = [0; SIMULATORSTACKSIZE]; // todo AllocBoundedArray
         self.init_simulator_context(base_stack_addr);
         self.process.as_mut().unwrap().num_thread += 1;
-        match G_ALIVE.write() {
+        let this = Rc::new(self);
-            Ok(mut alive) => {
+        self.system.get_g_alive().push(Rc::clone(&this));
-                let this = Arc::new(self);
+        self.system.g_scheduler().ready_to_run(Rc::clone(&this));
-                alive.push(Arc::clone(&this));
-                match G_SCHEDULER.write() {
-                    Ok(mut scheduler) => {
-                        scheduler.ready_to_run(Arc::clone(&this));
-                    },
-                    Err(err) => {
-                        panic!("RwLock poisonned, {}", err);
-                    }
-                }
-            },
-            Err(err) => {
-                panic!("RwLock poisonned, {}", err);
-            }
-        }
         Result::Ok(())
     }
 
@@ -93,16 +79,9 @@ impl Thread {
     }
 
     /// Wait for another thread to finish its execution
-    pub fn join(&self, id_thread: Arc<Thread>) {
+    pub fn join(&self, id_thread: Rc<Thread>) {
-        match G_ALIVE.write() {
+        while self.system.get_g_alive().contains(&Rc::clone(&id_thread)) {
-            Ok(alive) => {
+            self.t_yield();
-                while alive.contains(&Arc::clone(&id_thread)) {
-                    self.t_yield();
-                }
-            },
-            Err(err) => {
-                panic!("RwLock poisonned, {}", err)
-            }
         }
     }