samples: philosophers: Add sysmutex version

Add a version of the philosopher's demo that is built around sys::Mutex,
in it's simplest use case.

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

Author: d3zd3z

samples/philosophers/Kconfig

@@ -7,12 +7,18 @@ source "Kconfig.zephyr"
 
 choice
 	prompt "Select Synchronization implementation"
-	default SYNC_SYS_SEMAPHORE
+	default SYNC_SYS_MUTEX
 
 	config SYNC_SYS_SEMAPHORE
 		bool "Use sys::Semaphore to synchronize forks"
 		help
-		  Use to have the dining philosophers sample use sys::Semaphore, with one per form,
-		  to synchronize.
+		  Use to have the dining philosophers sample use sys::Mutex, with one per fork, to
+		  synchronize.
+
+	config SYNC_SYS_MUTEX
+		bool "Use sys::Semaphore to synchronize forks"
+		help
+		  Use to have the dining philosophers sample use sys::Mutex, with one per fork, to
+		  synchronize.
 
 endchoice

samples/philosophers/sample.yaml

@@ -20,3 +20,8 @@ tests:
     min_ram: 32
     extra_configs:
       - CONFIG_SYNC_SYS_SEMAPHORE=y
+  sample.rust.philosopher.sysmutex:
+    tags: introduction
+    min_ram: 32
+    extra_configs:
+      - CONFIG_SYNC_SYS_MUTEX=y

samples/philosophers/src/lib.rs

@@ -23,8 +23,11 @@ use zephyr::{
 
 // These are optional, based on Kconfig, so allow them to be unused.
 #[allow(unused_imports)]
+use crate::sysmutex::SysMutexSync;
+#[allow(unused_imports)]
 use crate::semsync::semaphore_sync;
 
+mod sysmutex;
 mod semsync;
 
 /// How many philosophers.  There will be the same number of forks.
@@ -82,6 +85,18 @@ fn get_syncer() -> Vec<Arc<dyn ForkSync>> {
     semaphore_sync()
 }
 
+#[cfg(CONFIG_SYNC_SYS_MUTEX)]
+fn get_syncer() -> Vec<Arc<dyn ForkSync>> {
+    let syncer = Box::new(SysMutexSync::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);
 

samples/philosophers/src/sysmutex.rs

@@ -0,0 +1,51 @@
+// Copyright (c) 2024 Linaro LTD
+// SPDX-License-Identifier: Apache-2.0
+
+//! # sys::Mutex implementation of ForkSync
+//!
+//! This is a simple implementation of the Fork synchronizer that uses underlying Zephyr `k_mutex`
+//! wrapped in `sys::Mutex`.  The ForkSync semantics map simply to these.
+
+use crate::{
+    ForkSync,
+    NUM_PHIL,
+};
+use zephyr::kobj_define;
+use zephyr::sys::sync::Mutex;
+use zephyr::time::Forever;
+
+type SysMutexes = [Mutex; NUM_PHIL];
+
+/// A simple implementation of ForkSync based on underlying Zephyr sys::Mutex, which uses explicit
+/// lock and release semantics.
+
+#[derive(Debug)]
+pub struct SysMutexSync {
+    locks: SysMutexes,
+}
+
+impl SysMutexSync {
+    #[allow(dead_code)]
+    pub fn new() -> SysMutexSync  {
+        let locks = MUTEXES.each_ref().map(|m| {
+            m.init_once(()).unwrap()
+        });
+        SysMutexSync { locks }
+    }
+}
+
+impl ForkSync for SysMutexSync {
+    fn take(&self, index: usize) {
+        self.locks[index].lock(Forever).unwrap();
+    }
+
+    fn release(&self, index: usize) {
+        unsafe {
+            self.locks[index].unlock().unwrap();
+        }
+    }
+}
+
+kobj_define! {
+    static MUTEXES: [StaticMutex; NUM_PHIL];
+}