burritos/src/kernel/synch.rs

use crate::utility::list::List;
use crate::kernel::thread::Thread;
use crate::simulator::interrupt::InterruptStatus::InterruptOff;
use crate::simulator::machine::Machine;
use std::cell::RefCell;
use std::rc::Rc;


use super::scheduler::Scheduler;
use super::thread_manager::ThreadManager;

///     Structure of a Semaphore used for synchronisation
pub struct Semaphore<'t> {

    counter:i32,
    waiting_queue:List<Rc<RefCell<Thread>>>,
    thread_manager: Rc<RefCell<ThreadManager<'t>>> // On s'assure que le tm vit plus longtemps que les semaphore avec le lifetime

}

impl<'t> Semaphore<'_> {

    ///     Decrement the value, and wait if it becomes < 0. Checking the
    ///	value and decrementing must be done atomically, so we
    ///	need to disable interrupts before checking the value.
    ///
    ///	Note that thread_manager::thread_sleep assumes that interrupts are disabled
    ///	when it is called.
    ///
    /// ### Parameters
    /// - *current_thread* the current thread
    /// - *machine* the machine where the threads are executed
    pub fn p(&mut self, current_thread: Rc<RefCell<Thread>>, machine: &mut Machine){
        let old_status = machine.interrupt.set_status(InterruptOff);
        self.counter -= 1;
        if self.counter < 0 {
            self.waiting_queue.push(Rc::clone(&current_thread));
            self.thread_manager.borrow_mut().thread_sleep(current_thread);
        }
        machine.interrupt.set_status(old_status);
    }

    ///      Increment semaphore value, waking up a waiting thread if any.
    ///	As with P(), this operation must be atomic, so we need to disable
    ///	interrupts.
    ///
    /// scheduler::ready_to_run() assumes that interrupts
    ///	are disabled when it is called.
    ///
    /// ### Parameters
    /// - **machine** the machine where the threads are executed
    /// - **scheduler** the scheduler which determine which thread to execute
    pub fn v(&mut self, machine: &mut Machine, scheduler: &mut Scheduler){
        let old_status = machine.interrupt.set_status(InterruptOff);
        self.counter -= 1;
        if self.waiting_queue.peek() != None {
            scheduler.ready_to_run(self.waiting_queue.pop().unwrap());
        }
        machine.interrupt.set_status(old_status);
    }
}

/// Lock used for synchronisation, can be interpreted has a Semaphore with a
/// counter of 1
/// It's used for critical parts
pub struct Lock<'t>{

    owner: Rc<RefCell<Thread>>,
    waiting_queue:List<Rc<RefCell<Thread>>>,
    thread_manager: Rc<RefCell<ThreadManager<'t>>>,
    free: bool

}

impl<'t> Lock<'_> {

    ///    Wait until the lock become free.  Checking the
    ///	state of the lock (free or busy) and modify it must be done
    ///	atomically, so we need to disable interrupts before checking
    ///	the value of free.
    ///
    ///	Note that thread_manager::thread_seep assumes that interrupts are disabled
    ///	when it is called.
    ///
    /// ### Parameters
    /// - **current_thread** the current thread
    /// - **machine** the machine where the threads are executed
    pub fn acquire(&mut self, current_thread: Rc<RefCell<Thread>>, machine: &mut Machine) {
        let old_status = machine.interrupt.set_status(InterruptOff);

        if self.free {
            self.free = false;
            self.owner = current_thread;
        } else {
            self.waiting_queue.push(Rc::clone(&current_thread));
            self.thread_manager.borrow_mut().thread_sleep(current_thread);
        }

        machine.interrupt.set_status(old_status);
    }

    ///     Wake up a waiter if necessary, or release it if no thread is waiting.
    /// We check that the lock is held by the g_current_thread.
    ///	As with Acquire, this operation must be atomic, so we need to disable
    ///	interrupts.  scheduler::ready_to_run() assumes that threads
    ///	are disabled when it is called.
    ///
    /// ### Parameters
    /// - **machine** the machine where the code is executed
    /// - **scheduler** the scheduler which determine which thread to execute
    pub fn release(&mut self, machine: &mut Machine, scheduler: &mut Scheduler, current_thread: Rc<RefCell<Thread>>) {
        let old_status = machine.interrupt.set_status(InterruptOff);

        if self.is_held_by_current_thread(current_thread) {
            if self.waiting_queue.peek() != None {
                self.owner = self.waiting_queue.pop().unwrap();
                scheduler.ready_to_run(Rc::clone(&self.owner));
            } else {
                self.free = true;
            }
        }

        machine.interrupt.set_status(old_status);
    }

    pub fn is_held_by_current_thread(&mut self, current_thread: Rc<RefCell<Thread>>) -> bool {
        Rc::ptr_eq(&self.owner, &current_thread)
    }
}

/// Structure of a condition used for synchronisation
pub struct Condition<'t>{

    waiting_queue:List<Rc<RefCell<Thread>>>,
    thread_manager: Rc<RefCell<ThreadManager<'t>>>,
    
}

impl<'t> Condition<'_> {

    ///  Block the calling thread (put it in the wait queue).
    ///  This operation must be atomic, so we need to disable interrupts.
    ///
    /// ### Parameters
    /// - **current_thread** the current thread
    /// - **machine** the machine where threads are executed
    pub fn wait(&mut self, current_thread: Rc<RefCell<Thread>>, machine: &mut Machine) {
        let old_status = machine.interrupt.set_status(InterruptOff);

        self.waiting_queue.push(Rc::clone(&current_thread));
        self.thread_manager.borrow_mut().thread_sleep(current_thread);

        machine.interrupt.set_status(old_status);
    }

    /// Wake up the first thread of the wait queue (if any).
    /// This operation must be atomic, so we need to disable interrupts.
    ///
    /// ### Parameters
    /// - **machine** the machine where the code is executed
    /// - **scheduler** the scheduler which determine which thread to execute
    pub fn signal(&mut self, machine: &mut Machine, scheduler: &mut Scheduler) {
        let old_status = machine.interrupt.set_status(InterruptOff);

        if self.waiting_queue.peek() != None {
            scheduler.ready_to_run(self.waiting_queue.pop().unwrap());
        }

        machine.interrupt.set_status(old_status);

    }

    /// Wake up all threads waiting in the waitqueue of the condition
    /// This operation must be atomic, so we need to disable interrupts.
    ///
    /// ### Parameters
    /// - **machine** the machine where the code is executed
    /// - **scheduler** the scheduler which determine which thread to execute
    pub fn broadcast(&mut self, machine: &mut Machine, scheduler: &mut Scheduler) {
        let old_status = machine.interrupt.set_status(InterruptOff);

        while self.waiting_queue.peek() != None {
            scheduler.ready_to_run(self.waiting_queue.pop().unwrap());
        }
        machine.interrupt.set_status(old_status);

    }

}