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

Merge remote-tracking branch 'origin/thread_scheduler' into thread_scheduler

Browse Source 
# Conflicts:
#	src/kernel/synch.rs
This commit is contained in:
Rémi Rativel
2023-03-13 23:41:20 +01:00
parent 5b7a12ab0f 3391d3cb65
commit dc6c454250
27 changed files with 628 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
src/kernel/scheduler.rs
View File

@ -3,12 +3,12 @@ use std::rc::Rc;
use crate::utility::list::List;
use crate::kernel::thread::Thread;
use super::system::System;
use super::thread_manager::ThreadManager;
#[derive(PartialEq)]
pub struct Scheduler {
ready_list: List<Rc<RefCell<Thread>>>
ready_list: List<Rc<RefCell<Thread>>>,
pub thread_manager: Option<Rc<RefCell<ThreadManager>>>
}
impl Scheduler {
@ -18,7 +18,8 @@ impl Scheduler {
/// Initilize the list of ready thread
pub fn new() -> Self {
Self {
ready_list: List::new()
ready_list: List::new(),
thread_manager: Option::None
}
}
@ -53,16 +54,21 @@ impl Scheduler {
/// ## Parameter
///
/// **next_thread** thread to dispatch to the CPU
pub fn switch_to(&self, system: &System, next_thread: Rc<RefCell<Thread>>) {
/* if let Some(old_thread) = system.get_g_current_thread() {
old_thread.save_processor_state();
old_thread.save_simulator_state();
pub fn switch_to(&mut self, next_thread: Rc<RefCell<Thread>>) {
if let Some(tm) = &self.thread_manager {
let rc = Rc::clone(&tm);
if let Some(old_thread) = tm.borrow_mut().get_g_current_thread() {
rc.borrow_mut().thread_save_processor_state(Rc::clone(&old_thread));
// old_thread.save_simulator_state();
if old_thread != &next_thread {
next_thread.restore_processor_state();
next_thread.restore_simulator_state();
system.set_g_current_thread(Option::Some(next_thread));
if old_thread != &next_thread {
rc.borrow_mut().thread_restore_processor_state(Rc::clone(&next_thread));
// next_thread.restore_simulator_state();
rc.borrow_mut().set_g_current_thread(Option::Some(next_thread));
}
}
} */
} else {
panic!("thread manager shouldn't be none");
}
}
}

4
src/kernel/synch.rs
View File

@ -111,7 +111,7 @@ impl<'t> Lock<'_> {
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.held_by_current_thread(current_thread) {
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));
@ -123,7 +123,7 @@ impl<'t> Lock<'_> {
machine.interrupt.set_status(old_status);
}
pub fn held_by_current_thread(&mut self, current_thread: Rc<RefCell<Thread>>) -> bool {
pub fn is_held_by_current_thread(&mut self, current_thread: Rc<RefCell<Thread>>) -> bool {
Rc::ptr_eq(&self.owner, &current_thread)
}
}

41
src/kernel/system.rs
View File

@ -1,4 +1,4 @@
use std::cell::RefCell;
use std::{cell::RefCell, rc::Rc};
use crate::simulator::machine::Machine;
@ -15,24 +15,27 @@ use super::thread_manager::ThreadManager;
/// - The thread to be destroyed next
/// - The scheduler which acts upon these threads
#[derive(PartialEq)]
pub struct System<'a> {
pub struct System {
g_machine: RefCell<Machine>,
thread_manager: ThreadManager<'a>
thread_manager: Rc<RefCell<ThreadManager>>
}
impl<'a> System<'a> {
impl System {
/// System constructor
pub fn new(machine: Machine) -> System<'a> {
pub fn new(machine: Machine) -> System {
Self {
g_machine: RefCell::new(machine),
thread_manager: ThreadManager::new()
thread_manager: Rc::new(RefCell::new(ThreadManager::new()))
}
}
/// use thread_manager setter to send it system instance
pub fn freeze(&'a mut self) {
self.thread_manager.system.set(Option::Some(self));
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
@ -61,4 +64,26 @@ pub enum ObjectType {
FileType,
ThreadType,
InvalidType
}
#[cfg(test)]
mod tests {
use crate::{System, Machine};
macro_rules! init_system {
() => {{
let m = Machine::init_machine();
init_system!(m)
}};
($a:expr) => {{
System::new($a)
}};
}
#[test]
fn test_init_system() {
init_system!();
}
}

71
src/kernel/thread_manager.rs
View File

@ -1,21 +1,21 @@
use std::{rc::Rc, cell::{Cell, RefCell, RefMut, Ref}};
use std::{rc::Rc, cell::{RefCell, RefMut, Ref}};
use crate::{utility::list::List, simulator::machine::{NUM_INT_REGS, NUM_FP_REGS}};
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;
#[derive(PartialEq)]
pub struct ThreadManager<'a> {
pub g_current_thread: Option<Thread>,
pub g_thread_to_be_destroyed: Option<Thread>,
pub struct ThreadManager {
pub g_current_thread: Option<Rc<RefCell<Thread>>>,
pub g_thread_to_be_destroyed: Option<Rc<RefCell<Thread>>>,
pub g_alive: List<Rc<RefCell<Thread>>>,
pub g_scheduler: Scheduler,
pub system: Cell<Option<&'a System<'a>>>
pub system: Option<Rc<RefCell<System>>>
}
impl<'a> ThreadManager<'a> {
impl ThreadManager {
pub fn new() -> Self {
Self {
@ -23,13 +23,19 @@ impl<'a> ThreadManager<'a> {
g_thread_to_be_destroyed: Option::None,
g_alive: List::new(),
g_scheduler: Scheduler::new(),
system: Cell::new(None)
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);
@ -37,7 +43,7 @@ impl<'a> ThreadManager<'a> {
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));
self.g_scheduler.ready_to_run(Rc::clone(&thread));
Result::Ok(())
}
@ -52,15 +58,17 @@ impl<'a> ThreadManager<'a> {
///
/// 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.get() {
let mut machine = system.get_g_machine().borrow_mut();
if let Some(system) = &self.system {
let sys = system.borrow_mut();
let mut machine = sys.get_g_machine().borrow_mut();
let old_status = machine.interrupt.set_status(crate::simulator::interrupt::InterruptStatus::InterruptOff);
let next_thread = self.g_scheduler().find_next_to_run();
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 = self.g_scheduler();
let scheduler = &mut self.g_scheduler;
scheduler.ready_to_run(thread);
scheduler.switch_to(system, next_thread);
scheduler.switch_to(next_thread);
}
machine.interrupt.set_status(old_status);
}
@ -68,7 +76,21 @@ impl<'a> ThreadManager<'a> {
/// Put the thread to sleep and relinquish the processor
pub fn thread_sleep(&mut self, thread: Rc<RefCell<Thread>>) {
todo!();
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_g_machine().borrow_mut();
assert_eq!(machine.interrupt.get_status(), InterruptStatus::InterruptOff);
let mut next_thread = self.g_scheduler.find_next_to_run();
while next_thread.is_none() {
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
@ -77,8 +99,9 @@ impl<'a> ThreadManager<'a> {
}
pub fn thread_save_processor_state(&mut self, thread: Rc<RefCell<Thread>>) {
if let Some(system) = self.system.get() {
if let Some(system) = &self.system {
let mut t: RefMut<_> = thread.borrow_mut();
let system = system.borrow_mut();
for i in 0..NUM_INT_REGS {
t.thread_context.int_registers[i] = system.get_g_machine().borrow().read_int_register(i);
}
@ -91,7 +114,8 @@ impl<'a> ThreadManager<'a> {
}
pub fn thread_restore_processor_state(&self, thread: Rc<RefCell<Thread>>) {
if let Some(system) = self.system.get() {
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_g_machine();
@ -104,14 +128,14 @@ impl<'a> ThreadManager<'a> {
}
/// Currently running thread
pub fn get_g_current_thread(&mut self) -> &mut Option<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<Thread> {
pub fn get_g_thread_to_be_destroyed(&mut self) -> &mut Option<Rc<RefCell<Thread>>> {
&mut self.g_thread_to_be_destroyed
}
@ -120,18 +144,13 @@ impl<'a> ThreadManager<'a> {
&mut self.g_alive
}
/// Current scheduler
pub fn g_scheduler(&mut self) -> &mut Scheduler {
&mut self.g_scheduler
}
/// Set currently running thread
pub fn set_g_current_thread(&mut self, thread: Option<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<Thread>) {
pub fn set_g_thread_to_be_destroyed(&mut self, thread: Option<Rc<RefCell<Thread>>>) {
self.g_thread_to_be_destroyed = thread
}

7
src/main.rs
View File

@ -13,11 +13,14 @@ mod kernel;
/// module containing useful tools which can be use in most part of the OS to ease the development of the OS
pub mod utility;
use std::{rc::Rc, cell::RefCell};
use kernel::system::System;
use simulator::machine::Machine;
fn main() {
let machine = Machine::init_machine();
let mut system = System::new(machine);
system.freeze();
let system = Rc::new(RefCell::new(System::new(machine)));
System::freeze(system);
}

6
src/simulator/interrupt.rs
View File

@ -29,9 +29,13 @@ impl Interrupt {
self.level
}
pub fn idle(&self) {
todo!();
}
}
#[derive(PartialEq, Clone, Copy)]
#[derive(PartialEq, Clone, Copy, Debug)]
pub enum InterruptStatus {
InterruptOff,
InterruptOn

45
src/simulator/machine.rs
View File

@ -6,6 +6,29 @@ use super::{decode::{Instruction, decode}, interrupt::Interrupt};
use super::global::*;
use std::fs::File;
/*
* Decommenter la variant si il est utilisé quelque part
*/
pub enum ExceptionType {
NO_EXCEPTION,//Everything ok!
//SYSCALL_EXCEPTION,//A program executed a system call.
PAGEFAULT_EXCEPTION,//Page fault exception
READONLY_EXCEPTION,//Write attempted to a page marked "read-only" */
//BUSERROR_EXCEPTION,
/* translation resulted
in an invalid physical
address (mis-aligned or
out-of-bounds) */
ADDRESSERROR_EXCEPTION, /* Reference that was
not mapped in the address
space */
//OVERFLOW_EXCEPTION, //Integer overflow in add or sub.
//ILLEGALINSTR_EXCEPTION, //Unimplemented or reserved instr.
//NUM_EXCEPTION_TYPES
}
pub const STACK_REG: usize = 2;
pub const NUM_INT_REGS: usize = 32;
@ -13,6 +36,8 @@ pub const NUM_FP_REGS: usize = 32;
/// doit disparaitre
const MEM_SIZE : usize = 0x500000;
//doit etre une puissance de deux
pub const PAGE_SIZE : u64 = 128;
pub trait RegisterNum: Add<Output=Self> + Sub<Output=Self> + PartialEq + Copy {}
@ -734,7 +759,7 @@ mod test {
mem_cmp::MemChecker::fill_memory_from_mem_checker(&memory_before, &mut m);
Machine::run(&mut m);
let expected_trace = fs::read_to_string("test/machine/memoryCompTrace.txt").unwrap();
let expected_trace = fs::read_to_string("test/machine/reg_traceComp.txt").unwrap();
assert!(mem_cmp::MemChecker::compare_machine_memory(&memory_after, &m));
assert!(expected_trace.contains(m.registers_trace.as_str()));
@ -748,7 +773,7 @@ mod test {
mem_cmp::MemChecker::fill_memory_from_mem_checker(&memory_before, &mut m);
Machine::run(&mut m);
let expected_trace = fs::read_to_string("test/machine/memoryDivTrace.txt").unwrap();
let expected_trace = fs::read_to_string("test/machine/reg_traceDiv.txt").unwrap();
assert!(mem_cmp::MemChecker::compare_machine_memory(&memory_after, &m));
assert!(expected_trace.contains(m.registers_trace.as_str()));
@ -762,7 +787,7 @@ mod test {
mem_cmp::MemChecker::fill_memory_from_mem_checker(&memory_before, &mut m);
Machine::run(&mut m);
let expected_trace = fs::read_to_string("test/machine/memoryIfTrace.txt").unwrap();
let expected_trace = fs::read_to_string("test/machine/reg_traceIf.txt").unwrap();
assert!(mem_cmp::MemChecker::compare_machine_memory(&memory_after, &m));
assert!(expected_trace.contains(m.registers_trace.as_str()));
@ -776,7 +801,7 @@ mod test {
mem_cmp::MemChecker::fill_memory_from_mem_checker(&memory_before, &mut m);
Machine::run(&mut m);
let expected_trace = fs::read_to_string("test/machine/memoryJumpTrace.txt").unwrap();
let expected_trace = fs::read_to_string("test/machine/reg_traceJump.txt").unwrap();
assert!(mem_cmp::MemChecker::compare_machine_memory(&memory_after, &m));
assert!(expected_trace.contains(m.registers_trace.as_str()));
@ -785,12 +810,12 @@ mod test {
#[test]
fn test_mul() {
let mut m = Machine::init_machine();
let memory_before = mem_cmp::MemChecker::from("test/machine/memoryMul.txt").unwrap();
let memory_after = mem_cmp::MemChecker::from("test/machine/memoryMulEnd.txt").unwrap();
let memory_before = mem_cmp::MemChecker::from("test/machine/memoryMult.txt").unwrap();
let memory_after = mem_cmp::MemChecker::from("test/machine/memoryMultEnd.txt").unwrap();
mem_cmp::MemChecker::fill_memory_from_mem_checker(&memory_before, &mut m);
Machine::run(&mut m);
let expected_trace = fs::read_to_string("test/machine/memoryMulTrace.txt").unwrap();
let expected_trace = fs::read_to_string("test/machine/reg_traceMult.txt").unwrap();
assert!(mem_cmp::MemChecker::compare_machine_memory(&memory_after, &m));
assert!(expected_trace.contains(m.registers_trace.as_str()));
@ -804,7 +829,7 @@ mod test {
mem_cmp::MemChecker::fill_memory_from_mem_checker(&memory_before, &mut m);
Machine::run(&mut m);
let expected_trace = fs::read_to_string("test/machine/memoryRetTrace.txt").unwrap();
let expected_trace = fs::read_to_string("test/machine/reg_traceRet.txt").unwrap();
assert!(mem_cmp::MemChecker::compare_machine_memory(&memory_after, &m));
assert!(expected_trace.contains(m.registers_trace.as_str()));
@ -818,7 +843,7 @@ mod test {
mem_cmp::MemChecker::fill_memory_from_mem_checker(&memory_before, &mut m);
Machine::run(&mut m);
let expected_trace = fs::read_to_string("test/machine/memorySubTrace.txt").unwrap();
let expected_trace = fs::read_to_string("test/machine/reg_traceSub.txt").unwrap();
assert!(mem_cmp::MemChecker::compare_machine_memory(&memory_after, &m));
assert!(expected_trace.contains(m.registers_trace.as_str()));
@ -832,7 +857,7 @@ mod test {
mem_cmp::MemChecker::fill_memory_from_mem_checker(&memory_before, &mut m);
Machine::run(&mut m);
let expected_trace = fs::read_to_string("test/machine/memorySwitchTrace.txt").unwrap();
let expected_trace = fs::read_to_string("test/machine/reg_traceSwitch.txt").unwrap();
assert!(mem_cmp::MemChecker::compare_machine_memory(&memory_after, &m));
assert!(expected_trace.contains(m.registers_trace.as_str()));

50
src/simulator/mmu.rs Normal file
View File

@ -0,0 +1,50 @@
use crate::simulator::translationtable::*;
use crate::simulator::machine::*;
use super::machine::ExceptionType;
pub struct MMU <'a>{
/* Un MMU possède une seule référence vers une table des pages à un instant donné
* Cette table est associée au processus courant
* Cette référence peut etre mise a jour par exemple lors d'un switchTo
*/
translationTable : Option<&'a mut TranslationTable>
}
impl <'a>MMU <'_>{
fn create() -> MMU <'a>{
MMU{
translationTable : None
}
}
fn translate(mmu : &mut MMU, virtAddr : u64, physAddr : &mut u64, size : usize, writing : bool) -> ExceptionType {
let virtual_page_index : u64 = virtAddr/PAGE_SIZE;
let offset : u64 = virtAddr%PAGE_SIZE;
match &mmu.translationTable {
None => {
println!("Error from translate : MMU refers to None (No page Table)");
return ExceptionType::ADDRESSERROR_EXCEPTION;
}
Some(table_ref) => {
//On verifie que notre index est valide
if virtual_page_index >= table_ref.get_max_num_pages(){
}
//is the page correctyl mapped ?
//if table_ref.pageTable.get
}
}
ExceptionType::NO_EXCEPTION
}
}

2
src/simulator/mod.rs
View File

@ -4,6 +4,8 @@ pub mod print;
pub mod mem_cmp;
pub mod loader;
pub mod interrupt;
pub mod translationtable;
pub mod mmu;
pub mod global {

193
src/simulator/translationtable.rs Normal file
View File

@ -0,0 +1,193 @@
//Nombre maximum de correspondances dans une table des pages
//Cette donnée devra a terme etre recupérée depuis un fichier de configuration
const MaxVirtPages : u64 = 200000;
/* Une table de correspondance propre à un processus
* Une variable de type TranslationTable devra etre possédée par un objet de type Process
*/
pub struct TranslationTable{
//capacité de cette table <=> nombre de correspondances possibles
//A voir si cette donnée doit etre immuable
pub maxNumPages : u64,
//la table en question
//Vec implemente le trait Index, donc un bon choix
pub pageTable : Vec<PageTableEntry>
}
impl TranslationTable {
pub fn create() -> TranslationTable {
let mut tmp_vec : Vec<PageTableEntry> = Vec::new();
for i in 0..MaxVirtPages {
tmp_vec.push(PageTableEntry::create());
}
TranslationTable{
maxNumPages : MaxVirtPages,
pageTable : tmp_vec
}
}
//vpn = virtual page number, c'est un index dans la table des page
//Assert a mettre dans chacune des fonctions suivantes
pub fn get_max_num_pages(&self) -> u64{
return self.maxNumPages;
}
pub fn set_physical_page(&mut self, vpn : u64, physical_page : i32){
self.pageTable[vpn as usize].physical_page = physical_page;
}
pub fn get_physical_page(&self, vpn : u64) -> i32{
self.pageTable[vpn as usize].physical_page
}
pub fn set_addr_disk(&mut self, vpn : u64, addr_disk : i32){
self.pageTable[vpn as usize].addr_disk = addr_disk;
}
pub fn get_addr_disk(&self, vpn : u64) -> i32 {
self.pageTable[vpn as usize].addr_disk
}
pub fn set_bit_valid(&mut self, vpn : u64){
self.pageTable[vpn as usize].valid = true;
}
pub fn clear_bit_valid(&mut self, vpn : u64){
self.pageTable[vpn as usize].valid = false;
}
pub fn get_bit_valid(&self, vpn : u64) -> bool{
self.pageTable[vpn as usize].valid
}
pub fn set_bit_io(&mut self, vpn : u64){
self.pageTable[vpn as usize].io = true;
}
pub fn clear_bit_io(&mut self, vpn : u64){
self.pageTable[vpn as usize].io = false;
}
pub fn get_bit_io(&self, vpn : u64) -> bool{
self.pageTable[vpn as usize].io
}
pub fn set_bit_swap(&mut self, vpn : u64){
self.pageTable[vpn as usize].swap = true;
}
pub fn clear_bit_swap(&mut self, vpn : u64){
self.pageTable[vpn as usize].swap = false;
}
pub fn get_bit_swap(&self, vpn : u64) -> bool{
self.pageTable[vpn as usize].swap
}
pub fn set_bit_write(&mut self, vpn : u64){
self.pageTable[vpn as usize].write_allowed = true;
}
pub fn clear_bit_write(&mut self, vpn : u64){
self.pageTable[vpn as usize].write_allowed = false;
}
pub fn get_bit_write(&self, vpn : u64) -> bool{
self.pageTable[vpn as usize].write_allowed
}
pub fn set_bit_read(&mut self, vpn : u64){
self.pageTable[vpn as usize].read_allowed = true;
}
pub fn clear_bit_read(&mut self, vpn : u64){
self.pageTable[vpn as usize].read_allowed = false;
}
pub fn get_bit_read(&self, vpn : u64) -> bool{
self.pageTable[vpn as usize].read_allowed
}
pub fn set_bit_U(&mut self, vpn : u64){
self.pageTable[vpn as usize].U = true;
}
pub fn clear_bit_U(&mut self, vpn : u64){
self.pageTable[vpn as usize].U = false;
}
pub fn get_bit_U(&self, vpn : u64) -> bool{
self.pageTable[vpn as usize].U
}
pub fn set_bit_M(&mut self, vpn : u64){
self.pageTable[vpn as usize].M = true;
}
pub fn clear_bit_M(&mut self, vpn : u64){
self.pageTable[vpn as usize].M = false;
}
pub fn get_bit_M(&self, vpn : u64) -> bool{
self.pageTable[vpn as usize].M
}
}
/* Une correspondance + données sur cette correspondance
*/
pub struct PageTableEntry{
//true <=> la correspondance est valide et la page est présente dans la ram
valid : bool,
//true <=> la page a été accédée (lecture/ecriture) récemment
U : bool,
//true <=> page modifiée mais non sauvegardée sur disque
M : bool,
//droits d'accès sur cette page
read_allowed : bool,
write_allowed : bool,
//numero de page physique <=> c'est notre correspondance
physical_page : i32,
//true <=> cette page doit etre chargée depuis la swap zone du disque
swap : bool,
//a définir plus tard, en relation avec swap
addr_disk : i32,
//mis à 1 par le système quand cette page est impliquée dans une opération d'IO
io : bool
}
impl PageTableEntry{
//Default PageTableEntry Constructor
pub fn create() -> PageTableEntry {
PageTableEntry {
valid : false,
U : false,
M : false,
read_allowed : false,
write_allowed : false,
physical_page : -1i32,
swap : false,
addr_disk : -1i32,
io : false
}
}
}