feat: remove the uses of CAS atomics

It's not supported by the Armv6-M architecture. Load/store atomics is
fine.

Author: yvt

src/constance_port_arm_m_test_driver/src/logger_semihosting.rs

@@ -19,6 +19,10 @@ impl log::Log for Logger {
 }
 
 pub fn init() {
-    log::set_logger(&Logger).unwrap();
+    // Note: Some targets don't support CAS atomics. This is why we need to use
+    //       `set_logger_racy` here.
+    // Safety: There are no other threads calling `set_logger_racy` at the
+    //         same time.
+    unsafe { log::set_logger_racy(&Logger).unwrap() };
     log::set_max_level(log::LevelFilter::Trace);
 }

src/constance_test_suite/src/kernel_tests/compute_round_robin.rs

@@ -137,6 +137,8 @@ fn worker_body<System: Kernel, D: Driver<App<System>>>(worker_id: usize) {
     // Safety: A mutable reference to `ref_output` doesn't exist at this point
     let ref_output = unsafe { &*state.ref_output.get() };
 
+    let run_count = &state.run_count[worker_id];
+
     let mut i = 0;
 
     while !state.stop.load(Ordering::Relaxed) {
@@ -156,7 +158,10 @@ fn worker_body<System: Kernel, D: Driver<App<System>>>(worker_id: usize) {
         }
 
         log::trace!("[{}] Iteration {}: complete", worker_id, i);
-        state.run_count[worker_id].fetch_add(1, Ordering::Relaxed);
+
+        // Note: Some targets don't support CAS atomics. Non-atomic load/store
+        //       suffices because `run_count` is only written by this task.
+        run_count.store(run_count.load(Ordering::Relaxed) + 1, Ordering::Relaxed);
     }
 }
 

src/constance_test_suite/src/utils.rs

@@ -30,13 +30,10 @@ impl SeqTracker {
     /// `new`.
     #[track_caller]
     pub(crate) fn expect_and_replace(&self, old: usize, new: usize) {
-        log::debug!(
-            "{} (expected: {}) → {}",
-            self.counter.load(Ordering::Relaxed),
-            old,
-            new
-        );
-        let got = self.counter.compare_and_swap(old, new, Ordering::Relaxed);
+        // Note: Some targets don't support CAS atomics
+        let got = self.counter.load(Ordering::Relaxed);
+        log::debug!("{} (expected: {}) → {}", got, old, new);
         assert_eq!(got, old, "expected {}, got {}", old, got);
+        self.counter.store(new, Ordering::Relaxed);
     }
 }