andrey/rCore-Tutorial-v3
1
0
Fork 0
mirror of https://github.com/rcore-os/rCore-Tutorial-v3.git synced 2024-11-24 10:26:25 +04:00
Code Issues Projects Releases Wiki Activity

usertest: Simplify using vload and vstore macro

Browse Source
This commit is contained in:
Yifan Wu 2024-01-22 00:02:05 +08:00
parent 56ae7b58ce
commit 2cd8795915
5 changed files with 23 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
user/src/bin/adder_peterson_spin.rs
View File

@ -8,7 +8,7 @@ extern crate user_lib;
extern crate alloc; extern crate alloc;
use alloc::vec::Vec; use alloc::vec::Vec;
use core::ptr::{addr_of, addr_of_mut, read_volatile}; use core::ptr::addr_of_mut;
use core::sync::atomic::{compiler_fence, Ordering}; use core::sync::atomic::{compiler_fence, Ordering};
use user_lib::{exit, get_time, thread_create, waittid}; use user_lib::{exit, get_time, thread_create, waittid};
@ -39,7 +39,7 @@ unsafe fn lock(id: usize) {
// Otherwise the compiler will assume that they will never // Otherwise the compiler will assume that they will never
// be changed on this thread. Thus, they will be accessed // be changed on this thread. Thus, they will be accessed
// only once! // only once!
while read_volatile(addr_of!(FLAG[j])) && read_volatile(addr_of!(TURN)) == j {} while vload!(FLAG[j]) && vload!(TURN) == j {}
} }
unsafe fn unlock(id: usize) { unsafe fn unlock(id: usize) {

4
user/src/bin/adder_simple_spin.rs
View File

@ -6,7 +6,7 @@ extern crate user_lib;
extern crate alloc; extern crate alloc;
use alloc::vec::Vec; use alloc::vec::Vec;
use core::ptr::{addr_of, addr_of_mut, read_volatile}; use core::ptr::addr_of_mut;
use user_lib::{exit, get_time, thread_create, waittid}; use user_lib::{exit, get_time, thread_create, waittid};
static mut A: usize = 0; static mut A: usize = 0;
@ -25,7 +25,7 @@ unsafe fn critical_section(t: &mut usize) {
} }
unsafe fn lock() { unsafe fn lock() {
while read_volatile(addr_of!(OCCUPIED)) {} while vload!(OCCUPIED) {}
OCCUPIED = true; OCCUPIED = true;
} }

19
user/src/bin/eisenberg.rs
View File

@ -8,7 +8,6 @@ extern crate core;
use alloc::vec::Vec; use alloc::vec::Vec;
use core::{ use core::{
ptr::{addr_of, addr_of_mut, read_volatile, write_volatile},
sync::atomic::{AtomicUsize, Ordering}, sync::atomic::{AtomicUsize, Ordering},
}; };
use user_lib::{exit, sleep, thread_create, waittid}; use user_lib::{exit, sleep, thread_create, waittid};
@ -44,15 +43,15 @@ unsafe fn eisenberg_enter_critical(id: usize) {
/* announce that we want to enter */ /* announce that we want to enter */
loop { loop {
println!("Thread[{}] try enter", id); println!("Thread[{}] try enter", id);
write_volatile(addr_of_mut!(FLAG[id]), FlagState::Want); vstore!(FLAG[id], FlagState::Want);
loop { loop {
/* check if any with higher priority is `Want` or `In` */ /* check if any with higher priority is `Want` or `In` */
let mut prior_thread: Option<usize> = None; let mut prior_thread: Option<usize> = None;
let turn = read_volatile(addr_of!(TURN)); let turn = vload!(TURN);
let ring_id = if id < turn { id + THREAD_NUM } else { id }; let ring_id = if id < turn { id + THREAD_NUM } else { id };
// FLAG.iter() may lead to some errors, use for-loop instead // FLAG.iter() may lead to some errors, use for-loop instead
for i in turn..ring_id { for i in turn..ring_id {
if read_volatile(addr_of!(FLAG[i % THREAD_NUM])) != FlagState::Out { if vload!(FLAG[i % THREAD_NUM]) != FlagState::Out {
prior_thread = Some(i % THREAD_NUM); prior_thread = Some(i % THREAD_NUM);
break; break;
} }
@ -68,13 +67,13 @@ unsafe fn eisenberg_enter_critical(id: usize) {
sleep(1); sleep(1);
} }
/* now tentatively claim the resource */ /* now tentatively claim the resource */
write_volatile(addr_of_mut!(FLAG[id]), FlagState::In); vstore!(FLAG[id], FlagState::In);
/* enforce the order of `claim` and `conflict check`*/ /* enforce the order of `claim` and `conflict check`*/
memory_fence!(); memory_fence!();
/* check if anthor thread is also `In`, which imply a conflict*/ /* check if anthor thread is also `In`, which imply a conflict*/
let mut conflict = false; let mut conflict = false;
for i in 0..THREAD_NUM { for i in 0..THREAD_NUM {
if i != id && read_volatile(addr_of!(FLAG[i])) == FlagState::In { if i != id && vload!(FLAG[i]) == FlagState::In {
conflict = true; conflict = true;
} }
} }
@ -85,7 +84,7 @@ unsafe fn eisenberg_enter_critical(id: usize) {
/* no need to sleep */ /* no need to sleep */
} }
/* clain the trun */ /* clain the trun */
write_volatile(addr_of_mut!(TURN), id); vstore!(TURN, id);
println!("Thread[{}] enter", id); println!("Thread[{}] enter", id);
} }
@ -95,14 +94,14 @@ unsafe fn eisenberg_exit_critical(id: usize) {
let ring_id = id + THREAD_NUM; let ring_id = id + THREAD_NUM;
for i in (id + 1)..ring_id { for i in (id + 1)..ring_id {
let idx = i % THREAD_NUM; let idx = i % THREAD_NUM;
if read_volatile(addr_of!(FLAG[idx])) == FlagState::Want { if vload!(FLAG[idx]) == FlagState::Want {
next = idx; next = idx;
break; break;
} }
} }
write_volatile(addr_of_mut!(TURN), next); vstore!(TURN, next);
/* All done */ /* All done */
write_volatile(addr_of_mut!(FLAG[id]), FlagState::Out); vstore!(FLAG[id], FlagState::Out);
println!("Thread[{}] exit, give turn to {}", id, next); println!("Thread[{}] exit, give turn to {}", id, next);
} }

9
user/src/bin/peterson.rs
View File

@ -7,7 +7,6 @@ extern crate alloc;
extern crate core; extern crate core;
use alloc::vec::Vec; use alloc::vec::Vec;
use core::ptr::{addr_of, addr_of_mut, read_volatile, write_volatile};
use core::sync::atomic::{AtomicUsize, Ordering}; use core::sync::atomic::{AtomicUsize, Ordering};
use user_lib::{exit, sleep, thread_create, waittid}; use user_lib::{exit, sleep, thread_create, waittid};
const N: usize = 1000; const N: usize = 1000;
@ -30,10 +29,10 @@ fn critical_test_exit() {
unsafe fn peterson_enter_critical(id: usize, peer_id: usize) { unsafe fn peterson_enter_critical(id: usize, peer_id: usize) {
// println!("Thread[{}] try enter", id); // println!("Thread[{}] try enter", id);
write_volatile(addr_of_mut!(FLAG[id]), true); vstore!(FLAG[id], true);
write_volatile(addr_of_mut!(TURN), peer_id); vstore!(TURN, peer_id);
memory_fence!(); memory_fence!();
while read_volatile(addr_of!(FLAG[peer_id])) && read_volatile(addr_of!(TURN)) == peer_id { while vload!(FLAG[peer_id]) && vload!(TURN) == peer_id {
// println!("Thread[{}] enter fail", id); // println!("Thread[{}] enter fail", id);
sleep(1); sleep(1);
// println!("Thread[{}] retry enter", id); // println!("Thread[{}] retry enter", id);
@ -42,7 +41,7 @@ unsafe fn peterson_enter_critical(id: usize, peer_id: usize) {
} }
unsafe fn peterson_exit_critical(id: usize) { unsafe fn peterson_exit_critical(id: usize) {
write_volatile(addr_of_mut!(FLAG[id]), false); vstore!(FLAG[id], false);
// println!("Thread[{}] exit", id); // println!("Thread[{}] exit", id);
} }

10
user/src/lib.rs
View File

@ -70,15 +70,17 @@ fn main(_argc: usize, _argv: &[&str]) -> i32 {
#[macro_export] #[macro_export]
macro_rules! vstore { macro_rules! vstore {
($var_ref: expr, $value: expr) => { ($var: expr, $value: expr) => {
unsafe { core::intrinsics::volatile_store($var_ref as *const _ as _, $value) } // unsafe { core::intrinsics::volatile_store($var_ref as *const _ as _, $value) }
unsafe { core::ptr::write_volatile(core::ptr::addr_of_mut!($var), $value); }
}; };
} }
#[macro_export] #[macro_export]
macro_rules! vload { macro_rules! vload {
($var_ref: expr) => { ($var: expr) => {
unsafe { core::intrinsics::volatile_load($var_ref as *const _ as _) } // unsafe { core::intrinsics::volatile_load($var_ref as *const _ as _) }
unsafe { core::ptr::read_volatile(core::ptr::addr_of!($var)) }
}; };
} }