samples: philosophers: Add implementation for channels

Add a synchronizer for forks based on sending messages over channels to
a worker thread.

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_CONDVAR
+	default SYNC_CHANNEL
 
 	config SYNC_SYS_SEMAPHORE
 		bool "Use sys::Semaphore to synchronize forks"
@@ -27,4 +27,10 @@ choice
 		  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.
 
+	config SYNC_CHANNEL
+		bool "Use sync::channel to synchronize forks"
+		help
+		  Use to have the dining philosophers sample use a worker thread, communicating via
+		  channels to synchronize.
+
 endchoice

samples/philosophers/sample.yaml

@@ -30,3 +30,8 @@ tests:
     min_ram: 32
     extra_configs:
       - CONFIG_SYNC_CONDVAR=y
+  sample.rust.philosopher.channel:
+    tags: introduction
+    min_ram: 32
+    extra_configs:
+      - CONFIG_SYNC_CHANNEL=y

samples/philosophers/src/channel.rs

@@ -16,7 +16,6 @@ use zephyr::{
     kobj_define,
     sync::Arc,
 };
-use zephyr::object::KobjInit;
 
 use crate::{NUM_PHIL, ForkSync};
 
@@ -113,23 +112,21 @@ impl ChannelSync {
 /// Generate a syncer out of a ChannelSync.
 #[allow(dead_code)]
 pub fn get_channel_syncer() -> Vec<Arc<dyn ForkSync>> {
-    COMMAND_QUEUE.init();
-    let command_queue = COMMAND_QUEUE.get();
+    let command_queue = COMMAND_QUEUE.init_once(()).unwrap();
     let (cq_send, cq_recv) = channel::unbounded_from(command_queue);
     let reply_queues = REPLY_QUEUES.each_ref().map(|m| {
-        m.init();
-        channel::unbounded_from(m.get())
+        channel::unbounded_from(m.init_once(()).unwrap())
     });
     let syncer = reply_queues.into_iter().map(|rqueue| {
         let item = Box::new(ChannelSync::new(cq_send.clone(), rqueue))
             as Box<dyn ForkSync>;
         Arc::from(item)
     });
 
-    let channel_thread = CHANNEL_THREAD.spawn(CHANNEL_STACK.token(), move || {
+    let channel_child = CHANNEL_THREAD.init_once(CHANNEL_STACK.init_once(()).unwrap()).unwrap();
+    channel_child.spawn(move || {
         channel_thread(cq_recv);
     });
-    channel_thread.start();
 
     syncer.collect()
 }

samples/philosophers/src/lib.rs

@@ -27,8 +27,11 @@ use crate::condsync::CondSync;
 #[allow(unused_imports)]
 use crate::sysmutex::SysMutexSync;
 #[allow(unused_imports)]
+use crate::channel::get_channel_syncer;
+#[allow(unused_imports)]
 use crate::semsync::semaphore_sync;
 
+mod channel;
 mod condsync;
 mod sysmutex;
 mod semsync;
@@ -113,6 +116,11 @@ fn get_syncer() -> Vec<Arc<dyn ForkSync>> {
     result
 }
 
+#[cfg(CONFIG_SYNC_CHANNEL)]
+fn get_syncer() -> Vec<Arc<dyn ForkSync>> {
+    get_channel_syncer()
+}
+
 fn phil_thread(n: usize, syncer: Arc<dyn ForkSync>) {
     printkln!("Child {} started: {:?}", n, syncer);
 

zephyr/src/object.rs

@@ -309,6 +309,19 @@ macro_rules! _kobj_rule {
     ($v:vis, $name:ident, [ThreadStack<{$size:expr}>; $asize:expr]) => {
         $crate::_kobj_stack!($v, $name, $size, $asize);
     };
+
+    // Queues.
+    ($v:vis, $name: ident, StaticQueue) => {
+        #[link_section = concat!("._k_queue.static.", stringify!($name), ".", file!(), line!())]
+        $v static $name: $crate::sys::queue::StaticQueue =
+            unsafe { ::core::mem::zeroed() };
+    };
+
+    ($v:vis, $name: ident, [StaticQueue; $size:expr]) => {
+        #[link_section = concat!("._k_queue.static.", stringify!($name), ".", file!(), line!())]
+        $v static $name: [$crate::sys::queue::StaticQueue; $size] =
+            unsafe { ::core::mem::zeroed() };
+    };
 }
 
 #[doc(hidden)]