Implement Bounded channels

.github/workflows/build.yml

@@ -77,6 +77,6 @@ jobs:
           lscpu
           df -h
 
-          west twister -M all -T samples -T tests -v --inline-logs --integration -j 4 \
+          ../zephyr/scripts/twister -M all -T samples -T tests -v --inline-logs --integration -j 4 \
              --timeout-multiplier 2 \
              $(cat etc/platforms.txt)

samples/philosophers/Kconfig

@@ -40,3 +40,12 @@ choice
 		  channels to synchronize.
 
 endchoice
+
+if SYNC_CHANNEL
+	config USE_BOUNDED_CHANNELS
+	bool "Should channel sync use bounded channels?"
+	default y
+	help
+	  If set, the channel-based communication will use bounded channels with bounds calculated
+	  to not ever block.
+endif

samples/philosophers/sample.yaml

@@ -32,8 +32,15 @@ tests:
     min_ram: 32
     extra_configs:
       - CONFIG_SYNC_CONDVAR=y
-  sample.rust.philosopher.channel:
+  sample.rust.philosopher.channel_bounded:
     tags: introduction
     min_ram: 32
     extra_configs:
       - CONFIG_SYNC_CHANNEL=y
+      - CONFIG_USE_BOUNDED_CHANNELS=y
+  sample.rust.philosopher.channel_unbounded:
+    tags: introduction
+    min_ram: 32
+    extra_configs:
+      - CONFIG_SYNC_CHANNEL=y
+      - CONFIG_USE_BOUNDED_CHANNELS=n

samples/philosophers/src/channel.rs

@@ -112,10 +112,22 @@ impl ChannelSync {
 /// Generate a syncer out of a ChannelSync.
 #[allow(dead_code)]
 pub fn get_channel_syncer() -> Vec<Arc<dyn ForkSync>> {
-    let (cq_send, cq_recv) = channel::unbounded();
-    let reply_queues = [(); NUM_PHIL].each_ref().map(|()| {
-        channel::unbounded()
-    });
+    let (cq_send, cq_recv);
+    let reply_queues;
+
+    if cfg!(CONFIG_USE_BOUNDED_CHANNELS) {
+        // Use only one message, so that send will block, to ensure that works.
+        (cq_send, cq_recv) = channel::bounded(1);
+        reply_queues = [(); NUM_PHIL].each_ref().map(|()| {
+            channel::bounded(1)
+        });
+    } else {
+        (cq_send, cq_recv) = channel::unbounded();
+        reply_queues = [(); NUM_PHIL].each_ref().map(|()| {
+            channel::unbounded()
+        });
+    }
+
     let syncer = reply_queues.into_iter().map(|rqueue| {
         let item = Box::new(ChannelSync::new(cq_send.clone(), rqueue))
             as Box<dyn ForkSync>;