samples: philosopher: Allow sync type as Kconfig

Add Kconfig entries to the sample that allow a selection of which
synchronization algorithm to use.  This demonstrates how an app can have
conditional compilation, which requires a `build.rs` script to invoke
the kconfig value exporter.

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

Author: d3zd3z

samples/philosophers/Cargo.toml

@@ -15,6 +15,10 @@ crate-type = ["staticlib"]
 [dependencies]
 zephyr = "3.7.0"
 
+# Dependencies that are used by build.rs.
+[build-dependencies]
+zephyr-build = "3.7.0"
+
 [profile.release]
 debug-assertions = true
 overflow-checks = true

samples/philosophers/Kconfig

@@ -0,0 +1,23 @@
+# Copyright (c) 2024 Linaro LTD
+# SPDX-License-Identifier: Apache-2.0
+
+mainmenu "Rust Dining Philosphers"
+
+source "Kconfig.zephyr"
+
+choice
+	prompt "Select Synchronization implementation"
+	default SYNC_CONDVAR
+
+	config SYNC_SYS_MUTEX
+		bool "Use sys::Mutex to synchronize forks"
+		help
+		  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/build.rs

@@ -0,0 +1,9 @@
+// Copyright (c) 2023 Linaro LTD
+// SPDX-License-Identifier: Apache-2.0
+
+// This crate needs access to kconfig variables.  This is an example of how to do that.  The
+// zephyr-build must be a build dependency.
+
+fn main() {
+    zephyr_build::export_bool_kconfig();
+}

samples/philosophers/src/condsync.rs

@@ -27,6 +27,7 @@ pub struct CondSync {
 }
 
 impl CondSync {
+    #[allow(dead_code)]
     pub fn new() -> CondSync  {
         MUTEX.init();
         CONDVAR.init();

samples/philosophers/src/lib.rs

@@ -3,6 +3,11 @@
 
 #![no_std]
 
+// Cargo tries to detect configs that have typos in them.  Unfortunately, the Zephyr Kconfig system
+// uses a large number of Kconfigs and there is no easy way to know which ones might conceivably be
+// valid.  This prevents a warning about each cfg that is used.
+#![allow(unexpected_cfgs)]
+
 extern crate alloc;
 
 use alloc::boxed::Box;
@@ -16,7 +21,10 @@ use zephyr::{
     sync::{Arc, Mutex},
 };
 
+// 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;
 
 mod condsync;
@@ -86,8 +94,8 @@ extern "C" fn rust_main() {
     }
 }
 
-#[allow(dead_code)]
-fn get_syncerb() -> Vec<Arc<dyn ForkSync>> {
+#[cfg(CONFIG_SYNC_SYS_MUTEX)]
+fn get_syncer() -> Vec<Arc<dyn ForkSync>> {
     // Simple mutex version.
     let syncer = Box::new(SysMutexSync::new())
         as Box<dyn ForkSync>;
@@ -99,6 +107,7 @@ fn get_syncerb() -> Vec<Arc<dyn ForkSync>> {
     result
 }
 
+#[cfg(CONFIG_SYNC_CONDVAR)]
 fn get_syncer() -> Vec<Arc<dyn ForkSync>> {
     // Condvar version
     let syncer = Box::new(CondSync::new())

samples/philosophers/src/sysmutex.rs

@@ -28,6 +28,7 @@ pub struct SysMutexSync {
 }
 
 impl SysMutexSync {
+    #[allow(dead_code)]
     pub fn new() -> SysMutexSync  {
         let locks = MUTEXES.each_ref().map(|m| {
             m.init();