samples: philosophers: Create

This is an initial version of the dining philosophers problem,
implemented in Rust.  This version is intended to be flexible, allowing
for different sycnronization methods to be tested.  This contains the
only method implemented so far, sys::Mutex.

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

Author: d3zd3z

samples/philosophers/CMakeLists.txt

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.20.0)
+
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(philosophers)
+
+rust_cargo_application()

samples/philosophers/Cargo.toml

@@ -0,0 +1,16 @@
+# Copyright (c) 2024 Linaro LTD
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+# This must be rustapp for now.
+name = "rustapp"
+version = "3.7.0"
+edition = "2021"
+description = "A sample hello world application in Rust"
+license = "Apache-2.0 or MIT"
+
+[lib]
+crate-type = ["staticlib"]
+
+[dependencies]
+zephyr = "3.7.0"

samples/philosophers/boards/rpi_pico.conf

@@ -0,0 +1,7 @@
+# Copyright (c) 2024 Linaro LTD
+# SPDX-License-Identifier: Apache-2.0
+
+# This board doesn't have a serial console, so use RTT.
+CONFIG_UART_CONSOLE=n
+CONFIG_RTT_CONSOLE=y
+CONFIG_USE_SEGGER_RTT=y

samples/philosophers/prj.conf

@@ -0,0 +1,17 @@
+# Copyright (c) 2024 Linaro LTD
+# SPDX-License-Identifier: Apache-2.0
+
+CONFIG_RUST=y
+CONFIG_RUST_ALLOC=y
+CONFIG_MAIN_STACK_SIZE=8192
+
+# CONFIG_USERSPACE=y
+
+# Some debugging
+CONFIG_THREAD_MONITOR=y
+CONFIG_THREAD_ANALYZER=y
+CONFIG_THREAD_ANALYZER_USE_PRINTK=y
+CONFIG_THREAD_ANALYZER_AUTO=n
+CONFIG_THREAD_ANALYZER_AUTO_INTERVAL=15
+
+CONFIG_RUST_CHECK_KOBJ_INIT=y

samples/philosophers/sample.yaml

@@ -0,0 +1,15 @@
+sample:
+  description: Philosphers, in Rust
+  name: philosophers rust
+common:
+  harness: console
+  harness_config:
+    type: one_line
+    regex:
+      - "Child 5 thinking"
+  tags: rust
+  filter: CONFIG_RUST_SUPPORTED
+tests:
+  sample.rust.philosopher.sysmutex:
+    tags: introduction
+    min_ram: 32

samples/philosophers/src/lib.rs

@@ -0,0 +1,144 @@
+// Copyright (c) 2023 Linaro LTD
+// SPDX-License-Identifier: Apache-2.0
+
+#![no_std]
+
+extern crate alloc;
+
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use zephyr::time::{Duration, sleep, Tick};
+use zephyr::{
+    printkln,
+    kobj_define,
+    sys::uptime_get,
+    sync::Arc,
+};
+
+use crate::sysmutex::SysMutexSync;
+
+mod sysmutex;
+
+/// How many philosophers.  There will be the same number of forks.
+const NUM_PHIL: usize = 6;
+
+/// How much stack should each philosopher thread get.  Worst case I've seen is riscv64, with 3336
+/// bytes, when printing messages.  Make a bit larger to work.
+const PHIL_STACK_SIZE: usize = 4096;
+
+// The dining philosophers problem is a simple example of cooperation between multiple threads.
+// This implementation use one of several different underlying mechanism to support this cooperation.
+
+// This example uses dynamic dispatch to allow multiple implementations.  The intent is to be able
+// to periodically shut down all of the philosphers and start them up with a differernt sync
+// mechanism.  This isn't implemented yet.
+
+/// The philosophers use a fork synchronization mechanism.  Essentially, this is 6 locks, and will be
+/// implemented in a few different ways to demonstrate/test different mechanmism in Rust.  All of
+/// them implement The ForkSync trait which provides this mechanism.
+trait ForkSync: core::fmt::Debug + Sync + Send {
+    /// Take the given fork.  The are indexed the same as the philosopher index number.  This will
+    /// block until the fork is released.
+    fn take(&self, index: usize);
+
+    /// Release the given fork.  Index is the same as take.
+    fn release(&self, index: usize);
+}
+
+#[no_mangle]
+extern "C" fn rust_main() {
+    printkln!("Hello world from Rust on {}",
+              zephyr::kconfig::CONFIG_BOARD);
+    printkln!("Time tick: {}", zephyr::time::SYS_FREQUENCY);
+
+    let syncers = get_syncer();
+
+    printkln!("Pre fork");
+    for (i, syncer) in (0..PHIL_THREAD.len()).zip(syncers.into_iter()) {
+        /*
+        let child_syncer = syncer.clone();
+        */
+        // The Rust borrow checker doesn't seem quite smart enough to realize that we are moving
+        // these out individually.  Best would be to rewrite this to iterate over the queue, but for
+        // now, the clone isn't terribly costly.
+        /*
+        let child_syncer = ChannelSync::new(cq_send.clone(), reply_queues[i].clone());
+        let child_syncer = Arc::new(child_syncer);
+        */
+        // let child_stat = stats.clone();
+        let thread = PHIL_THREAD[i].spawn(PHIL_STACK[i].token(), move || {
+            phil_thread(i, syncer /*, child_stat*/);
+        });
+        thread.start();
+    }
+
+    let delay = Duration::secs_at_least(10);
+    loop {
+        // Periodically, printout the stats.
+        zephyr::time::sleep(delay);
+        // stats.lock().unwrap().show();
+    }
+}
+
+fn get_syncer() -> Vec<Arc<dyn ForkSync>> {
+    // Simple mutex version.
+    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> /*, stats: Arc<Mutex<Stats>>*/) {
+    printkln!("Child {} started: {:?}", n, syncer);
+
+    // Determine our two forks.
+    let forks = if n == NUM_PHIL - 1 {
+        // Per Dijkstra, the last phyilosopher needs to reverse forks, or we deadlock.
+        (0, n)
+    } else {
+        (n, n+1)
+    };
+
+    loop {
+        {
+            // printkln!("Child {} hungry", n);
+            // printkln!("Child {} take left fork", n);
+            syncer.take(forks.0);
+            // printkln!("Child {} take right fork", n);
+            syncer.take(forks.1);
+
+            let delay = get_random_delay(n, 25);
+            printkln!("Child {} eating ({} ms)", n, delay);
+            sleep(delay);
+            // stats.lock().unwrap().record_eat(n, delay);
+
+            // Release the forks.
+            // printkln!("Child {} giving up forks", n);
+            syncer.release(forks.1);
+            syncer.release(forks.0);
+
+            let delay = get_random_delay(n, 25);
+            printkln!("Child {} thinking ({} ms)", n, delay);
+            sleep(delay);
+            // stats.lock().unwrap().record_think(n, delay);
+        }
+    }
+}
+
+/// Get a random delay, based on the ID of this user, and the current uptime.
+fn get_random_delay(id: usize, period: usize) -> Duration {
+    let tick = (uptime_get() & (usize::MAX as i64)) as usize;
+    let delay = (tick / 100 * (id + 1)) & 0x1f;
+
+    // Use one greater to be sure to never get a delay of zerp.
+    Duration::millis_at_least(((delay + 1) * period) as Tick)
+}
+
+kobj_define! {
+    static PHIL_THREAD: [StaticThread; NUM_PHIL];
+    static PHIL_STACK: [ThreadStack<PHIL_STACK_SIZE>; NUM_PHIL];
+}

samples/philosophers/src/sysmutex.rs

@@ -0,0 +1,52 @@
+// 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::object::KobjInit;
+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 {
+    pub fn new() -> SysMutexSync  {
+        let locks = MUTEXES.each_ref().map(|m| {
+            m.init();
+            m.get()
+        });
+        SysMutexSync { locks }
+    }
+}
+
+impl ForkSync for SysMutexSync {
+    fn take(&self, index: usize) {
+        self.locks[index].lock(Forever).unwrap();
+    }
+
+    fn release(&self, index: usize) {
+        self.locks[index].unlock().unwrap();
+    }
+}
+
+kobj_define! {
+    static MUTEXES: [StaticMutex; NUM_PHIL];
+}

zephyr/module.yml

@@ -4,6 +4,6 @@ build:
   cmake: .
   kconfig: Kconfig
 samples:
-  - samples/hello_world
+  - samples
 tests:
   - tests