Let's test that spin-lock CS too

Author: jonathanpallant

examples/mps3-an536/Cargo.toml

@@ -16,6 +16,7 @@ cortex-ar = { path = "../../cortex-ar", features = ["critical-section-multi-core
 cortex-r-rt = { path = "../../cortex-r-rt" }
 semihosting = { version = "0.1.18", features = ["stdio"] }
 arm-gic = { git = "https://github.com/google/arm-gic.git", rev = "46a8fc1720f5c28fccf4dfb5953b88dab7012e9c", optional = true }
+critical-section = "1.2.0"
 
 [build-dependencies]
 arm-targets = {version = "0.1.0", path = "../../arm-targets"}

examples/mps3-an536/src/bin/smp_test.rs

@@ -10,8 +10,8 @@
 #![no_std]
 #![no_main]
 
-use core::cell::UnsafeCell;
-use core::sync::atomic::{AtomicU32, Ordering};
+use core::cell::{RefCell, UnsafeCell};
+use core::sync::atomic::{AtomicBool, AtomicU32, Ordering};
 
 // pull in our start-up code
 use mps3_an536 as _;
@@ -40,8 +40,22 @@ unsafe impl<const LEN_BYTES: usize> Sync for Stack<LEN_BYTES> {}
 
 static CORE1_STACK: Stack<65536> = Stack::new();
 
+static CORE1_BOOTED: AtomicBool = AtomicBool::new(false);
+
 static SHARED_VARIABLE: AtomicU32 = AtomicU32::new(0);
 
+static SHARED_VARIABLE_2: critical_section::Mutex<RefCell<u32>> =
+    critical_section::Mutex::new(RefCell::new(0));
+
+/// How long core 0 waits for core 1
+const CORE0_WILL_WAIT: usize = 1_000_000;
+
+/// How many CAS loops to run?
+const CAS_LOOPS: u32 = 1000;
+
+/// How many CS Mutex loops to run?
+const CS_MUTEX_LOOPS: u32 = 1000;
+
 /// The entry-point to the Rust application.
 ///
 /// It is called by the start-up code in `cortex-m-rt`.
@@ -62,25 +76,50 @@ pub extern "C" fn kmain() {
     }
 
     // wait some time for core 1 to start
-    for counter in 0..1000 {
-        if SHARED_VARIABLE.load(Ordering::SeqCst) != 0 {
+    for counter in 0..=CORE0_WILL_WAIT {
+        if CORE1_BOOTED.load(Ordering::SeqCst) {
             break;
         }
-        if counter == 999 {
+        if counter == CORE0_WILL_WAIT {
             println!("CPU 1 is missing?!");
 
             semihosting::process::exit(0);
         }
     }
 
-    for _ in 0..1000 {
+    for _ in 0..CAS_LOOPS {
         SHARED_VARIABLE.fetch_add(1, Ordering::Relaxed);
     }
 
-    println!(
-        "Total is {} (is it 2001?)",
-        SHARED_VARIABLE.load(Ordering::Relaxed)
-    );
+    for _ in 0..CS_MUTEX_LOOPS {
+        critical_section::with(|cs| {
+            let mut value_ref = SHARED_VARIABLE_2.borrow_ref_mut(cs);
+            *value_ref += 1;
+        })
+    }
+
+    // let the other core finish
+    for _ in 0..CORE0_WILL_WAIT {
+        cortex_ar::asm::nop();
+    }
+
+    let total_a = SHARED_VARIABLE.load(Ordering::Relaxed);
+    if total_a == CAS_LOOPS * 2 {
+        println!("CAS test passed");
+    } else {
+        println!("CAS test failed, got {} not 2000", total_a);
+    }
+
+    let total_b = critical_section::with(|cs| {
+        let value_ref = SHARED_VARIABLE_2.borrow_ref(cs);
+        *value_ref
+    });
+
+    if total_b == CS_MUTEX_LOOPS * 2 {
+        println!("CS Mutex test passed");
+    } else {
+        println!("CS Mutex test failed, got {} not 2000", total_b);
+    }
 
     semihosting::process::exit(0);
 }
@@ -90,10 +129,19 @@ pub extern "C" fn kmain() {
 /// It is called by the start-up code below, on Core 1.
 #[no_mangle]
 pub extern "C" fn kmain2() {
-    SHARED_VARIABLE.store(1, Ordering::SeqCst);
-    for _ in 0..1000 {
+    CORE1_BOOTED.store(true, Ordering::SeqCst);
+
+    for _ in 0..CAS_LOOPS {
         SHARED_VARIABLE.fetch_add(1, Ordering::Relaxed);
     }
+
+    for _ in 0..CS_MUTEX_LOOPS {
+        critical_section::with(|cs| {
+            let mut value_ref = SHARED_VARIABLE_2.borrow_ref_mut(cs);
+            *value_ref += 1;
+        })
+    }
+
     loop {
         core::hint::spin_loop();
     }