samples: philosophers: Migrate Mutex to const constructor

With Mutex having a const constructor, simplify the initializaion, and
use a simple static for the Stats container.

Signed-off-by: David Brown <[email protected]>

Author: d3zd3z

samples/philosophers/src/lib.rs

@@ -68,22 +68,18 @@ extern "C" fn rust_main() {
     printkln!("Hello world from Rust on {}", zephyr::kconfig::CONFIG_BOARD);
     printkln!("Time tick: {}", zephyr::time::SYS_FREQUENCY);
 
-    let stats = Arc::new(Mutex::new_from(
-        Stats::default(),
-        STAT_MUTEX.init_once(()).unwrap(),
-    ));
+    let stats = &STAT_MUTEX;
 
     let syncers = get_syncer();
 
     printkln!("Pre fork");
 
     for (i, syncer) in (0..NUM_PHIL).zip(syncers.into_iter()) {
-        let child_stat = stats.clone();
         let thread = PHIL_THREADS[i]
             .init_once(PHIL_STACKS[i].init_once(()).unwrap())
             .unwrap();
         thread.spawn(move || {
-            phil_thread(i, syncer, child_stat);
+            phil_thread(i, syncer, stats);
         });
     }
 
@@ -133,7 +129,7 @@ fn get_syncer() -> Vec<Arc<dyn ForkSync>> {
     get_channel_syncer()
 }
 
-fn phil_thread(n: usize, syncer: Arc<dyn ForkSync>, stats: Arc<Mutex<Stats>>) {
+fn phil_thread(n: usize, syncer: Arc<dyn ForkSync>, stats: &'static Mutex<Stats>) {
     printkln!("Child {} started: {:?}", n, syncer);
 
     // Determine our two forks.
@@ -191,6 +187,17 @@ struct Stats {
     thinking: [u64; NUM_PHIL],
 }
 
+impl Stats {
+    /// Const constructor to allow for static initializaion.
+    pub const fn new() -> Self {
+        Self {
+            count: [0; NUM_PHIL],
+            eating: [0; NUM_PHIL],
+            thinking: [0; NUM_PHIL],
+        }
+    }
+}
+
 impl Stats {
     fn record_eat(&mut self, index: usize, time: Duration) {
         self.eating[index] += time.to_millis();
@@ -211,9 +218,9 @@ impl Stats {
     }
 }
 
+static STAT_MUTEX: Mutex<Stats> = Mutex::new(Stats::new());
+
 kobj_define! {
     static PHIL_THREADS: [StaticThread; NUM_PHIL];
     static PHIL_STACKS: [ThreadStack<PHIL_STACK_SIZE>; NUM_PHIL];
-
-    static STAT_MUTEX: StaticMutex;
 }

samples/philosophers/src/sysmutex.rs

@@ -23,7 +23,7 @@ pub struct SysMutexSync {
 impl SysMutexSync {
     #[allow(dead_code)]
     pub fn new() -> SysMutexSync {
-        let locks = [(); NUM_PHIL].each_ref().map(|()| Mutex::new().unwrap());
+        let locks = [(); NUM_PHIL].each_ref().map(|()| Mutex::new());
         SysMutexSync { locks }
     }
 }