samples: philosophers: Add sync using Mutex/Condvar

Build a syncer that coordinates the forks using a single Mutex/Condvar
pair, where the Mutex protects the data, and Condvar is used to
coordinate.  This is a common paradigm for shared synchronization.

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

Author: d3zd3z

samples/philosophers/Kconfig

@@ -7,7 +7,7 @@ source "Kconfig.zephyr"
 
 choice
 	prompt "Select Synchronization implementation"
-	default SYNC_SYS_MUTEX
+	default SYNC_CONDVAR
 
 	config SYNC_SYS_SEMAPHORE
 		bool "Use sys::Semaphore to synchronize forks"
@@ -21,4 +21,10 @@ choice
 		  Use to have the dining philosophers sample use sys::Mutex, with one per fork, to
 		  synchronize.
 
+	config SYNC_CONDVAR
+		bool "Use sync::Condvar and sync::Mutex to synchronize forks"
+		help
+		  Use to have the dining philosophers sample use a single data structure, protected
+		  by a sync::Mutex and coordinated with a sync::Condvar, to synchronize.
+
 endchoice

samples/philosophers/sample.yaml

@@ -25,3 +25,8 @@ tests:
     min_ram: 32
     extra_configs:
       - CONFIG_SYNC_SYS_MUTEX=y
+  sample.rust.philosopher.condvar:
+    tags: introduction
+    min_ram: 32
+    extra_configs:
+      - CONFIG_SYNC_CONDVAR=y

samples/philosophers/src/condsync.rs

@@ -0,0 +1,58 @@
+// 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::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 {
+    #[allow(dead_code)]
+    pub fn new() -> CondSync  {
+        let sys_mutex = MUTEX.init_once(()).unwrap();
+        let sys_condvar = CONDVAR.init_once(()).unwrap();
+
+        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

@@ -23,10 +23,13 @@ use zephyr::{
 
 // These are optional, based on Kconfig, so allow them to be unused.
 #[allow(unused_imports)]
+use crate::condsync::CondSync;
+#[allow(unused_imports)]
 use crate::sysmutex::SysMutexSync;
 #[allow(unused_imports)]
 use crate::semsync::semaphore_sync;
 
+mod condsync;
 mod sysmutex;
 mod semsync;
 
@@ -97,6 +100,19 @@ fn get_syncer() -> Vec<Arc<dyn ForkSync>> {
     result
 }
 
+#[cfg(CONFIG_SYNC_CONDVAR)]
+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>) {
     printkln!("Child {} started: {:?}", n, syncer);