Rativel/BurritOS
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix Semaphore and Lock tests

Browse Source
This commit is contained in:
Samy Solhi 2023-03-22 14:59:28 +01:00
parent 977cb2bf96
commit 9d19f0630b
1 changed files with 123 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

243
src/kernel/synch.rs
View File

@ -1,3 +1,4 @@
use crate::kernel::thread_manager;
use crate::utility::list::List;
use crate::kernel::thread::Thread;
use crate::simulator::interrupt::InterruptStatus::InterruptOff;
@ -66,13 +67,13 @@ impl Semaphore {
/// ### Parameters
/// - **machine** the machine where the threads are executed
/// - **scheduler** the scheduler which determine which thread to execute
pub fn v(&mut self, system: &mut System){
let old_status = system.get_machine().interrupt.set_status(InterruptOff);
pub fn v(&mut self, machine: &mut Machine, thread_manager: &mut ThreadManager){
let old_status = machine.interrupt.set_status(InterruptOff);
self.counter += 1;
if self.waiting_queue.peek() != None {
system.get_thread_manager().ready_to_run(self.waiting_queue.pop().unwrap());
thread_manager.ready_to_run(self.waiting_queue.pop().unwrap());
}
system.get_machine().interrupt.set_status(old_status);
machine.interrupt.set_status(old_status);
}
}
@ -145,16 +146,16 @@ impl Lock {
/// ### Parameters
/// - **machine** the machine where the code is executed
/// - **scheduler** the scheduler which determine which thread to execute
pub fn release(&mut self, system: &mut System) {
let old_status = system.get_machine().interrupt.set_status(InterruptOff);
pub fn release(&mut self, machine: &mut Machine, thread_manager: &mut ThreadManager) {
let old_status = machine.interrupt.set_status(InterruptOff);
match system.get_thread_manager().get_g_current_thread() {
match thread_manager.get_g_current_thread() {
Some(thread) => {
if self.held_by_current_thread(system) {
if self.held_by_current_thread(thread_manager) {
if self.waiting_queue.peek() != None {
self.owner = Some(self.waiting_queue.pop().unwrap());
match &self.owner {
Some(x) => system.get_thread_manager().ready_to_run(Rc::clone(&x)),
Some(x) => thread_manager.ready_to_run(Rc::clone(&x)),
None => ()
}
} else {
@ -166,13 +167,13 @@ impl Lock {
None => ()
}
system.get_machine().interrupt.set_status(old_status);
machine.interrupt.set_status(old_status);
}
pub fn held_by_current_thread(&mut self, system: &mut System) -> bool {
pub fn held_by_current_thread(&mut self, thread_manager: &mut ThreadManager) -> bool {
match &self.owner {
Some(x) =>
match system.get_thread_manager().get_g_current_thread() {
match thread_manager.get_g_current_thread() {
Some(thread) => Rc::ptr_eq(&x, &thread),
None => false
}
@ -255,132 +256,134 @@ impl Condition {
}
// #[cfg(test)]
// mod test {
// use std::{rc::Rc, cell::RefCell};
#[cfg(test)]
mod test {
use std::{rc::Rc, cell::RefCell};
// use crate::{kernel::{thread::Thread, synch::{Semaphore, Lock}}, init_system, simulator::machine::Machine};
use crate::{kernel::{thread::Thread, synch::{Semaphore, Lock}, thread_manager::ThreadManager}, init_system, simulator::machine::Machine};
// #[test]
// fn test_semaphore_single() {
// // Init
// let system = init_system!();
// let mut semaphore = Semaphore::new(1);
// let thread = Rc::new(RefCell::new(Thread::new("test_semaphore")));
// // P
// semaphore.p(system, thread);
// assert_eq!(semaphore.counter, 0);
// assert!(semaphore.waiting_queue.is_empty());
// // V
// semaphore.v(Rc::clone(&system));
// assert_eq!(semaphore.counter, 1);
// assert!(semaphore.waiting_queue.is_empty());
// }
#[test]
fn test_semaphore_single() {
// Init
let mut machine = Machine::init_machine();
let mut thread_manager = ThreadManager::new();
let mut semaphore = Semaphore::new(1);
let thread = Rc::new(RefCell::new(Thread::new("test_semaphore")));
thread_manager.ready_to_run(Rc::clone(&thread));
thread_manager.set_g_current_thread(Some(thread));
// P
semaphore.p(&mut machine, &mut thread_manager);
assert_eq!(semaphore.counter, 0);
assert!(semaphore.waiting_queue.is_empty());
// V
semaphore.v(&mut machine, &mut thread_manager);
assert_eq!(semaphore.counter, 1);
assert!(semaphore.waiting_queue.is_empty());
}
// #[test]
// #[ignore]
// fn test_semaphore_multiple() {
// // Init
// let system = init_system!();
// let tm = system.borrow_mut().get_thread_manager();
// let mut semaphore = Semaphore::new(2, Rc::clone(&tm));
// let thread1 = Rc::new(RefCell::new(Thread::new("test_semaphore_1")));
// let thread2 = Rc::new(RefCell::new(Thread::new("test_semaphore_2")));
// let thread3 = Rc::new(RefCell::new(Thread::new("test_semaphore_3")));
#[test]
fn test_semaphore_multiple() {
// Init
let mut tm = ThreadManager::new();
let mut machine = Machine::init_machine();
let mut semaphore = Semaphore::new(2);
let thread1 = Rc::new(RefCell::new(Thread::new("test_semaphore_1")));
let thread2 = Rc::new(RefCell::new(Thread::new("test_semaphore_2")));
let thread3 = Rc::new(RefCell::new(Thread::new("test_semaphore_3")));
// let mut borrow_tm = tm.borrow_mut();
// let scheduler = &mut borrow_tm.g_scheduler;
// scheduler.ready_to_run(Rc::clone(&thread1));
// scheduler.ready_to_run(Rc::clone(&thread2));
// scheduler.ready_to_run(Rc::clone(&thread3));
// // P
// borrow_tm.set_g_current_thread(Some(Rc::clone(&thread1)));
// semaphore.p(thread1, Rc::clone(&system));
// assert_eq!(semaphore.counter, 1);
// assert!(semaphore.waiting_queue.is_empty());
// let mut borrow_tm = tm.borrow_mut();
// let scheduler = &mut tm.g_scheduler;
tm.ready_to_run(Rc::clone(&thread1));
tm.ready_to_run(Rc::clone(&thread2));
tm.ready_to_run(Rc::clone(&thread3));
// P
tm.set_g_current_thread(Some(Rc::clone(&thread1)));
semaphore.p(&mut machine, &mut tm);
assert_eq!(semaphore.counter, 1);
assert!(semaphore.waiting_queue.is_empty());
// borrow_tm.set_g_current_thread(Some(Rc::clone(&thread2)));
// semaphore.p(thread2, Rc::clone(&system));
// assert_eq!(semaphore.counter, 0);
// assert!(semaphore.waiting_queue.is_empty());
tm.set_g_current_thread(Some(Rc::clone(&thread2)));
semaphore.p(&mut machine, &mut tm);
assert_eq!(semaphore.counter, 0);
assert!(semaphore.waiting_queue.is_empty());
// borrow_tm.set_g_current_thread(Some(Rc::clone(&thread3)));
// semaphore.p(thread3, Rc::clone(&system));
// assert_eq!(semaphore.counter, -1);
// assert!(semaphore.waiting_queue.iter().count() == 1);
tm.set_g_current_thread(Some(Rc::clone(&thread3)));
semaphore.p(&mut machine, &mut tm);
assert_eq!(semaphore.counter, -1);
assert!(semaphore.waiting_queue.iter().count() == 1);
// // V
// semaphore.v(Rc::clone(&system));
// assert_eq!(semaphore.counter, 0);
// assert!(semaphore.waiting_queue.is_empty());
// V
semaphore.v(&mut machine, &mut tm);
assert_eq!(semaphore.counter, 0);
assert!(semaphore.waiting_queue.is_empty());
// semaphore.v(Rc::clone(&system));
// assert_eq!(semaphore.counter, 1);
// assert!(semaphore.waiting_queue.is_empty());
semaphore.v(&mut machine, &mut tm);
assert_eq!(semaphore.counter, 1);
assert!(semaphore.waiting_queue.is_empty());
// semaphore.v(Rc::clone(&system));
// assert_eq!(semaphore.counter, 2);
// assert!(semaphore.waiting_queue.is_empty());
// }
semaphore.v(&mut machine, &mut tm);
assert_eq!(semaphore.counter, 2);
assert!(semaphore.waiting_queue.is_empty());
}
// #[test]
// #[ignore]
// fn test_lock_simple() {
// let system = init_system!();
// let sys = system.borrow_mut();
// let tm = sys.get_thread_manager();
// let thread = Rc::new(RefCell::new(Thread::new("test_lock")));
// tm.borrow_mut().set_g_current_thread(Some(Rc::clone(&thread)));
// let mut lock = Lock::new(Rc::clone(&tm));
#[test]
fn test_lock_simple() {
let mut machine = Machine::init_machine();
let mut tm = ThreadManager::new();
let thread = Rc::new(RefCell::new(Thread::new("test_lock")));
tm.ready_to_run(Rc::clone(&thread));
tm.set_g_current_thread(Some(Rc::clone(&thread)));
let mut lock = Lock::new();
// assert!(lock.free);
// lock.acquire(Some(Rc::clone(&thread)), Rc::clone(&system));
// assert!(lock.held_by_current_thread(Rc::clone(&thread)));
assert!(lock.free);
lock.acquire(&mut machine, &mut tm);
assert!(lock.held_by_current_thread(&mut tm));
// assert!(!lock.free);
// lock.release(Rc::clone(&system), Rc::clone(&thread));
// assert!(!lock.held_by_current_thread(thread));
// assert!(lock.free);
// }
assert!(!lock.free);
lock.release(&mut machine, &mut tm);
assert!(!lock.held_by_current_thread(&mut tm));
assert!(lock.free);
}
// #[test]
// #[ignore]
// fn test_lock_multiple() {
// let system = init_system!();
// let thread1 = Rc::new(RefCell::new(Thread::new("test_lock1")));
// let thread2 = Rc::new(RefCell::new(Thread::new("test_lock2")));
// let thread3 = Rc::new(RefCell::new(Thread::new("test_lock3")));
// let tm = system.borrow_mut().get_thread_manager();
// tm.borrow_mut().set_g_current_thread(Some(Rc::clone(&thread1)));
// let mut lock = Lock::new(Rc::clone(&tm));
// assert!(lock.free);
// lock.acquire(Some(Rc::clone(&thread1)), Rc::clone(&system));
// assert!(lock.held_by_current_thread(Rc::clone(&thread1)));
// assert!(!lock.free);
// tm.borrow_mut().set_g_current_thread(Some(Rc::clone(&thread2)));
// lock.acquire(Some(Rc::clone(&thread2)), Rc::clone(&system));
// tm.borrow_mut().set_g_current_thread(Some(Rc::clone(&thread1)));
#[test]
fn test_lock_multiple() {
let thread1 = Rc::new(RefCell::new(Thread::new("test_lock1")));
let thread2 = Rc::new(RefCell::new(Thread::new("test_lock2")));
let mut machine = Machine::init_machine();
let mut tm = ThreadManager::new();
// assert!(lock.held_by_current_thread(Rc::clone(&thread1)));
// assert!(lock.waiting_queue.iter().count() == 1);
// assert!(!lock.free);
tm.ready_to_run(Rc::clone(&thread1));
tm.ready_to_run(Rc::clone(&thread2));
// lock.release(Rc::clone(&system), Rc::clone(&thread1));
// assert!(!lock.held_by_current_thread(thread1));
// assert!(lock.held_by_current_thread(Rc::clone(&thread2)));
// assert!(!lock.free);
tm.set_g_current_thread(Some(Rc::clone(&thread1)));
let mut lock = Lock::new();
// tm.borrow_mut().set_g_current_thread(Some(Rc::clone(&thread2)));
assert!(lock.free);
lock.acquire(&mut machine, &mut tm);
assert!(lock.held_by_current_thread(&mut tm));
assert!(!lock.free);
tm.set_g_current_thread(Some(Rc::clone(&thread2)));
lock.acquire(&mut machine, &mut tm);
tm.set_g_current_thread(Some(Rc::clone(&thread1)));
assert!(lock.held_by_current_thread(&mut tm));
assert!(lock.waiting_queue.iter().count() == 1);
assert!(!lock.free);
// lock.release(Rc::clone(&system), Rc::clone(&thread2));
// assert!(!lock.held_by_current_thread(thread2));
// assert!(lock.free);
// }
// }
lock.release(&mut machine, &mut tm);
assert!(!lock.held_by_current_thread(&mut tm));
tm.set_g_current_thread(Some(Rc::clone(&thread2)));
assert!(lock.held_by_current_thread(&mut tm));
assert!(!lock.free);
lock.release(&mut machine, &mut tm);
assert!(!lock.held_by_current_thread(&mut tm));
assert!(lock.free);
}
}