burritos/src/kernel/system.rs

//! # System module
//! 
//! Module containing structs and methods pertaining to the state of the operating system

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

use crate::simulator::machine::Machine;

use super::thread_manager::ThreadManager;

/// This macro properly initializes the system
#[macro_export]
macro_rules! init_system {
    () => {{
        let m = Machine::init_machine();
        init_system!(m)
    }};
    ($a:expr) => {{
        let sys = std::rc::Rc::new(std::cell::RefCell::new(crate::System::new($a)));
        crate::System::freeze(std::rc::Rc::clone(&sys));
        sys

    }};
}

/// # System
/// 
/// This structure represents the state of the threads running on the operating system.
/// It contains references to the following:
/// 
/// - The simulated machine
/// - The current running thread
/// - The list of active threads
/// - The thread to be destroyed next
/// - The scheduler which acts upon these threads
#[derive(PartialEq)]
pub struct System {
    g_machine: RefCell<Machine>,
    thread_manager: Rc<RefCell<ThreadManager>>
}

impl System {

    /// System constructor
    pub fn new(machine: Machine) -> System {
        Self {
            g_machine: RefCell::new(machine),
            thread_manager: Rc::new(RefCell::new(ThreadManager::new()))
        }
    }

    /// use thread_manager setter to send it system instance
    pub fn freeze(this: Rc<RefCell<System>>) {
        let copy = Rc::clone(&this);
        let tm = &this.borrow_mut().thread_manager;
        tm.borrow_mut().system = Option::Some(copy);
        ThreadManager::freeze(tm);
    }

    // GETTERS

    /// Returns the Machine
    /// 
    /// Useful to access RAM, devices, ...
    pub fn get_g_machine(&self) -> &RefCell<Machine> {
        &self.g_machine
    }

    pub fn get_thread_manager(&self) -> Rc<RefCell<ThreadManager>> {
        Rc::clone(&self.thread_manager)
    }

    // Setters

    /// Assign a machine to the system
    pub fn set_g_machine(&mut self, machine: RefCell<Machine>) {
        self.g_machine = machine
    }

}

#[derive(PartialEq, Debug)]
pub enum ObjectType {
    SemaphoreType,
    LockType,
    ConditionType,
    FileType,
    ThreadType,
    InvalidType
}

#[cfg(test)]
mod tests {

    use crate::{System, Machine};

    #[test]
    fn test_init_system() {
        init_system!();
    }

}