BurritOS/src/kernel/thread_manager.rs

use std::{rc::Rc, cell::{RefCell, RefMut, Ref}};

use crate::{utility::list::List, simulator::{machine::{NUM_INT_REGS, NUM_FP_REGS}, interrupt::InterruptStatus}};

use super::{scheduler::Scheduler, thread::Thread, system::System, mgerror::ErrorCode, process::Process};

pub const SIMULATORSTACKSIZE: usize = 32 * 1024;

/// # Thread manager
/// 
/// An instance of this struct is responsible for managing threads on behalf of the system
#[derive(PartialEq)]
pub struct ThreadManager {
    /// Current running thread
    pub g_current_thread: Option<Rc<RefCell<Thread>>>,
    /// The thread to be destroyed next
    pub g_thread_to_be_destroyed: Option<Rc<RefCell<Thread>>>,
    /// The list of alive threads
    pub g_alive: List<Rc<RefCell<Thread>>>,
    /// The thread scheduler
    pub g_scheduler: Scheduler,
    /// The system owning the thread manager
    pub system: Option<Rc<RefCell<System>>>
}

impl ThreadManager {

    /// Thread manager constructor
    pub fn new() -> Self {
        Self { 
            g_current_thread: Option::None, 
            g_thread_to_be_destroyed: Option::None, 
            g_alive: List::new(),
            g_scheduler: Scheduler::new(), 
            system: Option::None
        }
    }

    pub fn freeze(this: &Rc<RefCell<ThreadManager>>) {
        let copy = Rc::clone(this);
        this.borrow_mut().g_scheduler.thread_manager = Option::Some(copy);
    }

    /// Start a thread, attaching it to a process
    pub fn start_thread(&mut self, thread: Rc<RefCell<Thread>>, owner: Process, func_pc: i64, argument: i64) -> Result<(), ErrorCode> {
        let mut thread_m = thread.borrow_mut();
        assert_eq!(thread_m.process, Option::None);
        thread_m.process = Option::Some(owner);
        let ptr = 0; // todo addrspace
        thread_m.init_thread_context(func_pc, ptr, argument);
        let base_stack_addr: [i8; SIMULATORSTACKSIZE] = [0; SIMULATORSTACKSIZE]; // todo AllocBoundedArray
        thread_m.init_simulator_context(base_stack_addr);
        thread_m.process.as_mut().unwrap().num_thread += 1;
        self.get_g_alive().push(Rc::clone(&thread));
        self.g_scheduler.ready_to_run(Rc::clone(&thread));
        Result::Ok(())
    }

    /// Wait for another thread to finish its execution
    pub fn thread_join(&mut self, id_thread: Rc<RefCell<Thread>>) {
        while self.get_g_alive().contains(&Rc::clone(&id_thread)) {
            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, thread: Rc<RefCell<Thread>>) {
        if let Some(system) = &self.system {
            let sys = system.borrow_mut();
            let mut machine = sys.get_machine();
            let old_status = machine.interrupt.set_status(crate::simulator::interrupt::InterruptStatus::InterruptOff);
            
            assert_eq!(Option::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(next_thread);
            }
            machine.interrupt.set_status(old_status);
        }
    }

    /// Put the thread to sleep and relinquish the processor
    pub fn thread_sleep(&mut self, thread: Rc<RefCell<Thread>>) {
        
        assert_eq!(Option::Some(Rc::clone(&thread)), self.g_current_thread);
        if let Some(system) = &self.system {
            let sys = system.borrow_mut();
            let machine = sys.get_machine();
            assert_eq!(machine.interrupt.get_status(), InterruptStatus::InterruptOff);

            let mut next_thread = self.g_scheduler.find_next_to_run();
            while next_thread.is_none() {
                eprintln!("Nobody to run => idle");
                machine.interrupt.idle();
                next_thread = self.g_scheduler.find_next_to_run();
            }
            self.g_scheduler.switch_to(Rc::clone(&next_thread.unwrap()));
            
        }
    }

    /// Finish the execution of the thread and prepare its deallocation
    pub fn thread_finish(&mut self, thread: Rc<RefCell<Thread>>) {
        if let Some(system) = &self.system {
            let sys = Rc::clone(system);
            let sys = sys.borrow_mut();
            let mut machine = sys.get_machine();
            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(Rc::clone(&thread));
            machine.interrupt.set_status(old_status);
        }
    }

    pub fn thread_save_processor_state(&mut self, thread: Rc<RefCell<Thread>>) {
        if let Some(system) = &self.system {
            let mut t: RefMut<_> = thread.borrow_mut();
            let system = system;
            for i in 0..NUM_INT_REGS {
                t.thread_context.int_registers[i] = system.get_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);
            }
        } else {
            unreachable!("System is None")
        }
    }

    pub fn thread_restore_processor_state(&self, thread: Rc<RefCell<Thread>>) {
        if let Some(system) = &self.system {
            let system = system.borrow_mut();
            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]);
            }
        } else {
            unreachable!("System is None")
        }
    }

    /// Currently running thread
    pub fn get_g_current_thread(&mut self) -> &mut Option<Rc<RefCell<Thread>>> {
        &mut self.g_current_thread
    }

    /// Thread to be destroyed by [...]
    /// 
    /// TODO: Finish the comment with the relevant value
    pub fn get_g_thread_to_be_destroyed(&mut self) -> &mut Option<Rc<RefCell<Thread>>> {
        &mut self.g_thread_to_be_destroyed
    }

    /// List of alive threads
    pub fn get_g_alive(&mut self) -> &mut List<Rc<RefCell<Thread>>> {
        &mut self.g_alive
    }

    /// Set currently running thread
    pub fn set_g_current_thread(&mut self, thread: Option<Rc<RefCell<Thread>>>) {
        self.g_current_thread = thread
    }

    /// Set thread to be destroyed next
    pub fn set_g_thread_to_be_destroyed(&mut self, thread: Option<Rc<RefCell<Thread>>>) {
        self.g_thread_to_be_destroyed = thread
    }

}