samples: philosopher: Add Condvar based sync

Add an implementation of the fork synchronizer build around a single
array of flags, protected by a mutex, and coordinated with a condition
variable.

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

Author: d3zd3z

samples/philosophers/src/condsync.rs

@@ -0,0 +1,62 @@
+// Copyright (c) 2024 Linaro LTD
+// SPDX-License-Identifier: Apache-2.0
+
+//! # sync::Mutex/sync::Condvar implementation of ForkSync
+//!
+//! This implementation of the Fork synchronizer uses a single data object, protected by a
+//! `sync::Mutex`, and coordinated by a `sync::Condvar`.
+
+use crate::{
+    ForkSync,
+    NUM_PHIL,
+};
+use zephyr::{
+    kobj_define,
+};
+use zephyr::object::KobjInit;
+use zephyr::sync::Mutex;
+use zephyr::sync::Condvar;
+// use zephyr::time::Forever;
+
+#[derive(Debug)]
+pub struct CondSync {
+    /// The lock that holds the flag for each philosopher.
+    lock: Mutex<[bool; NUM_PHIL]>,
+    /// Condition variable to wake other threads.
+    cond: Condvar,
+}
+
+impl CondSync {
+    pub fn new() -> CondSync  {
+        MUTEX.init();
+        CONDVAR.init();
+        let sys_mutex = MUTEX.get();
+        let sys_condvar = CONDVAR.get();
+
+        let lock = Mutex::new_from([false; NUM_PHIL], sys_mutex);
+        let cond = Condvar::new_from(sys_condvar);
+        CondSync { lock, cond }
+    }
+}
+
+impl ForkSync for CondSync {
+    fn take(&self, index: usize) {
+        let mut lock = self.lock.lock().unwrap();
+        while lock[index] {
+            lock = self.cond.wait(lock).unwrap();
+        }
+        lock[index] = true;
+    }
+
+    fn release(&self, index: usize) {
+        let mut lock = self.lock.lock().unwrap();
+        lock[index] = false;
+        // No predictible waiter, so must wake everyone.
+        self.cond.notify_all();
+    }
+}
+
+kobj_define! {
+    static MUTEX: StaticMutex;
+    static CONDVAR: StaticCondvar;
+}

samples/philosophers/src/lib.rs

@@ -16,8 +16,10 @@ use zephyr::{
     sync::{Arc, Mutex},
 };
 
+use crate::condsync::CondSync;
 use crate::sysmutex::SysMutexSync;
 
+mod condsync;
 mod sysmutex;
 
 /// How many philosophers.  There will be the same number of forks.
@@ -84,7 +86,8 @@ extern "C" fn rust_main() {
     }
 }
 
-fn get_syncer() -> Vec<Arc<dyn ForkSync>> {
+#[allow(dead_code)]
+fn get_syncerb() -> Vec<Arc<dyn ForkSync>> {
     // Simple mutex version.
     let syncer = Box::new(SysMutexSync::new())
         as Box<dyn ForkSync>;
@@ -96,6 +99,18 @@ fn get_syncer() -> Vec<Arc<dyn ForkSync>> {
     result
 }
 
+fn get_syncer() -> Vec<Arc<dyn ForkSync>> {
+    // Condvar version
+    let syncer = Box::new(CondSync::new())
+        as Box<dyn ForkSync>;
+    let syncer: Arc<dyn ForkSync> = Arc::from(syncer);
+    let mut result = Vec::new();
+    for _ in 0..NUM_PHIL {
+        result.push(syncer.clone());
+    }
+    result
+}
+
 fn phil_thread(n: usize, syncer: Arc<dyn ForkSync>, stats: Arc<Mutex<Stats>>) {
     printkln!("Child {} started: {:?}", n, syncer);