volatile_cell replayer is now thread-safe

Author: farcaller

src/hal/lpc11xx/syscon.rs

@@ -78,22 +78,25 @@ mod test {
 
   #[test]
   fn returns_isr_location() {
-    let mut replayer = VolatileCellReplayer::new();
-    set_replayer(&mut replayer);
+    init_replayer!();
 
-    expect_volatile_read!(replayer, 0x4004_8000, 0b10);
+    expect_volatile_read!(0x4004_8000, 0b10);
 
     expect!(get_isr_location()).to(be_equal_to(ISRLocation::Flash));
 
-    expect_replayer_valid!(replayer);
+    expect_replayer_valid!();
   }
 
   #[test]
   fn sets_isr_location() {
-    let mut replayer = VolatileCellReplayer::new();
-    set_replayer(&mut replayer);
+    init_replayer!();
+
+    expect_volatile_write!(0x4004_8000, 2);
 
-    expect_volatile_write!(replayer, 0x4004_8000, 0b00);
+    set_isr_location(ISRLocation::Flash);
+
+    expect_replayer_valid!();
+  }
 
     set_isr_location(ISRLocation::Bootloader);
 
@@ -102,33 +105,32 @@ mod test {
 
   #[test]
   fn initialize_system_clock() {
-    let mut replayer = VolatileCellReplayer::new();
-    set_replayer(&mut replayer);
+    init_replayer!();
 
     // read PDRUNCFG, returns reset value
-    expect_volatile_read!(replayer,  0x4004_8238, 0x0000_EDF0);
+    expect_volatile_read!( 0x4004_8238, 0x0000_EDF0);
     // write PDRUNCFG, set SYSOSC_PD to POWERED
-    expect_volatile_write!(replayer, 0x4004_8238, 0x0000_EDD0);
+    expect_volatile_write!(0x4004_8238, 0x0000_EDD0);
 
     // write SYSOSCCTRL, set BYPASS to off, FREQRANGE 1-20MHz
-    expect_volatile_write!(replayer, 0x4004_8020, 0x0000_0000);
+    expect_volatile_write!(0x4004_8020, 0x0000_0000);
 
     // write SYSPLLCLKSEL, set SEL to system oscillator
-    expect_volatile_write!(replayer, 0x4004_8040, 0x0000_0001);
+    expect_volatile_write!(0x4004_8040, 0x0000_0001);
 
     // write SYSPLLCLKUEN, set update/no change/update
-    expect_volatile_write!(replayer, 0x4004_8044, 0x0000_0001);
-    expect_volatile_write!(replayer, 0x4004_8044, 0x0000_0000);
-    expect_volatile_write!(replayer, 0x4004_8044, 0x0000_0001);
+    expect_volatile_write!(0x4004_8044, 0x0000_0001);
+    expect_volatile_write!(0x4004_8044, 0x0000_0000);
+    expect_volatile_write!(0x4004_8044, 0x0000_0001);
 
     // poll-read SYSPLLCLKUEN until returns update
-    expect_volatile_read!(replayer,  0x4004_8044, 0x0000_0000);
-    expect_volatile_read!(replayer,  0x4004_8044, 0x0000_0000);
-    expect_volatile_read!(replayer,  0x4004_8044, 0x0000_0000);
-    expect_volatile_read!(replayer,  0x4004_8044, 0x0000_0001);
+    expect_volatile_read!( 0x4004_8044, 0x0000_0000);
+    expect_volatile_read!( 0x4004_8044, 0x0000_0000);
+    expect_volatile_read!( 0x4004_8044, 0x0000_0000);
+    expect_volatile_read!( 0x4004_8044, 0x0000_0001);
 
     init_system_clock();
 
-    expect_replayer_valid!(replayer);
+    expect_replayer_valid!();
   }
 }

volatile_cell/lib.rs

@@ -29,6 +29,7 @@ extern crate core;
 #[cfg(feature="replayer")] use std::fmt;
 #[cfg(feature="replayer")] use core::cmp::PartialEq;
 #[cfg(feature="replayer")] use core::clone::Clone;
+#[cfg(feature="replayer")] use core::cell::RefCell;
 
 #[cfg(not(feature="replayer"))] use core::intrinsics::{volatile_load, volatile_store};
 #[cfg(feature="replayer")] use core::intrinsics::transmute;
@@ -72,13 +73,13 @@ impl<T> VolatileCell<T> {
 impl VolatileCell<u32> {
   pub fn get(&self) -> u32 {
     unsafe {
-      (*GlobalReplayer).get_cell(transmute(&self.value))
+      GLOBAL_REPLAYER.with(|gr| { gr.borrow_mut().get_cell(transmute(&self.value)) })
     }
   }
 
   pub fn set(&self, value: u32) {
     unsafe {
-      (*GlobalReplayer).set_cell(transmute(&self.value), value)
+      GLOBAL_REPLAYER.with(|gr| { gr.borrow_mut().set_cell(transmute(&self.value), value) })
     }
   }
 }
@@ -87,13 +88,13 @@ impl VolatileCell<u32> {
 impl VolatileCell<u16> {
   pub fn get(&self) -> u16 {
     unsafe {
-      (*GlobalReplayer).get_cell(transmute(&self.value)) as u16
+      GLOBAL_REPLAYER.with(|gr| { gr.borrow_mut().get_cell(transmute(&self.value)) }) as u16
     }
   }
 
   pub fn set(&self, value: u16) {
     unsafe {
-      (*GlobalReplayer).set_cell(transmute(&self.value), value as u32)
+      GLOBAL_REPLAYER.with(|gr| { gr.borrow_mut().set_cell(transmute(&self.value), value as u32) })
     }
   }
 }
@@ -102,13 +103,13 @@ impl VolatileCell<u16> {
 impl VolatileCell<u8> {
   pub fn get(&self) -> u8 {
     unsafe {
-      (*GlobalReplayer).get_cell(transmute(&self.value)) as u8
+      GLOBAL_REPLAYER.with(|gr| { gr.borrow_mut().get_cell(transmute(&self.value)) }) as u8
     }
   }
 
   pub fn set(&self, value: u8) {
     unsafe {
-      (*GlobalReplayer).set_cell(transmute(&self.value), value as u32)
+      GLOBAL_REPLAYER.with(|gr| { gr.borrow_mut().set_cell(transmute(&self.value), value as u32) })
     }
   }
 }
@@ -234,13 +235,22 @@ impl VolatileCellReplayer {
 }
 
 #[cfg(feature="replayer")]
-static mut GlobalReplayer: *mut VolatileCellReplayer = 0 as *mut VolatileCellReplayer;
+thread_local!(static GLOBAL_REPLAYER: RefCell<VolatileCellReplayer> = RefCell::new(VolatileCellReplayer::new()));
 
 #[cfg(feature="replayer")]
-pub fn set_replayer(replayer: &mut VolatileCellReplayer) {
-  unsafe {
-    GlobalReplayer = replayer;
-  }
+pub fn set_replayer(replayer: VolatileCellReplayer) {
+  GLOBAL_REPLAYER.with(|gr| {
+    let mut bm = gr.borrow_mut();
+    *bm = replayer;
+  });
+}
+
+#[cfg(feature="replayer")]
+pub fn with_mut_replayer<F>(f: F) where F: core::ops::FnOnce(&mut VolatileCellReplayer) {
+  GLOBAL_REPLAYER.with(|gr| {
+    let mut bm = gr.borrow_mut();
+    f(&mut *bm);
+  });
 }
 
 struct BeEqualToWithContext<E> {
@@ -271,23 +281,34 @@ impl<A, E> Matcher<A, E> for BeEqualToWithContext<E>
 
 #[macro_export]
 macro_rules! expect_volatile_read {
-    ($replayer: ident, $addr: expr, $val: expr) => (
-        $replayer.expect_read($addr, $val,
-          expectest::core::SourceLocation::new(file!(), line!()))
-    );
+  ($addr: expr, $val: expr) => (
+    $crate::with_mut_replayer(|r| {
+      r.expect_read($addr, $val, expectest::core::SourceLocation::new(file!(), line!()));
+    })
+  );
 }
 
 #[macro_export]
 macro_rules! expect_volatile_write {
-    ($replayer: ident, $addr: expr, $val: expr) => (
-        $replayer.expect_write($addr, $val,
-          expectest::core::SourceLocation::new(file!(), line!()))
-    );
+  ($addr: expr, $val: expr) => (
+    $crate::with_mut_replayer(|r| {
+      r.expect_write($addr, $val, expectest::core::SourceLocation::new(file!(), line!()));
+    })
+  );
 }
 
 #[macro_export]
 macro_rules! expect_replayer_valid {
-    ($replayer: ident) => (
-      $replayer.verify(expectest::core::SourceLocation::new(file!(), line!()))
-    );
+  () => (
+    $crate::with_mut_replayer(|r| {
+      r.verify(expectest::core::SourceLocation::new(file!(), line!()));
+    })
+  );
+}
+
+#[macro_export]
+macro_rules! init_replayer {
+  () => (
+    set_replayer(VolatileCellReplayer::new());
+  );
 }