Work Queue support with Async

CMakeLists.txt

@@ -57,7 +57,7 @@ endfunction()
 function(get_include_dirs target dirs)
   get_target_property(include_dirs ${target} INTERFACE_INCLUDE_DIRECTORIES)
   if(include_dirs)
-    set(${dirs} ${include_dirs} PARENT_SCOPE)
+    set(${dirs} "${include_dirs}" PARENT_SCOPE)
   else()
     set(${dirs} "" PARENT_SCOPE)
   endif()

samples/bench/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(bench)
+
+rust_cargo_application()

samples/bench/Cargo.toml

@@ -0,0 +1,33 @@
+# Copyright (c) 2024 Linaro LTD
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+# This must be rustapp for now.
+name = "rustapp"
+version = "0.1.0"
+edition = "2021"
+description = "A sample hello world application in Rust"
+license = "Apache-2.0 or MIT"
+
+[lib]
+crate-type = ["staticlib"]
+
+[dependencies]
+zephyr = "0.1.0"
+critical-section = "1.1.2"
+
+# Dependencies that are used by build.rs.
+[build-dependencies]
+zephyr-build = "0.1.0"
+
+[profile.release]
+debug-assertions = true
+overflow-checks = true
+debug = true
+opt-level = "z"
+lto = true
+
+[profile.dev]
+debug = 2
+lto = true
+opt-level = "z"

samples/bench/Kconfig

@@ -0,0 +1,51 @@
+# 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_CHANNEL
+
+	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 fork, to
+		  synchronize.
+
+	config SYNC_SYS_DYNAMIC_SEMAPHORE
+		bool "Use a dynamic sys::Semaphore to synchronize forks"
+		help
+		  Use to have the dining philosophers sample use sys::Semaphore, with one per fork, to
+		  synchronize.  The Semaphores will be dynamically allocated.
+
+	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.
+
+	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.
+
+	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
+
+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/bench/boards/pimoroni_tiny_2040.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/bench/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/bench/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/bench/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_POLL=y
+
+# 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

samples/bench/sample.yaml

@@ -0,0 +1,24 @@
+sample:
+  description: Philosphers, in Rust
+  name: philosophers rust
+common:
+  harness: console
+  harness_config:
+    type: one_line
+    regex:
+      # Match message printed at the end.
+      - "Done with all tests"
+  tags: rust
+  filter: CONFIG_RUST_SUPPORTED
+  platform_allow:
+    - qemu_cortex_m0
+    - qemu_cortex_m3
+    - qemu_riscv32
+    - qemu_riscv32/qemu_virt_riscv32/smp
+    - qemu_riscv64
+    - qemu_riscv64/qemu_virt_riscv64/smp
+    - nrf52840dk/nrf52840
+tests:
+  sample.rust/bench.plain:
+    tags: benchmark
+    min_ram: 256

samples/bench/src/basesem.rs

@@ -0,0 +1,117 @@
+//! Base Semaphore
+//!
+//! This is an experiment into a different approach to Zephyr kernel objects.
+//!
+//! Currently, these kernel objects are directed through "Fixed", which is an enum referencing with
+//! a pointer to something static declared, or to a `Pin<Box<UnsafeCell<T>>>`.  This was done in an
+//! attempt to keep things performant, but we actually always still end up with both an enum
+//! discriminant, as well as an extra indirection for the static one.
+//!
+//! The deep issue here is that Zephyr objects inherently cannot be moved.  Zephyr uses a `dlist`
+//! structure in most objects that has a pointer back to itself to indicate the empty list.
+//!
+//! To work around this, we will implement objects as a pairing of an `AtomicUsize` and a
+//! `UnsafeCell<k_sem>` (for whatever underlying type).  The atomic will go through a small number
+//! of states:
+//!
+//! - 0: indicates that this object is uninitialized.
+//! - ptr: where ptr is the address of Self for an initialized object.
+//!
+//! On each use, the atomic value can be read (Relaxed is fine here), and if a 0 is seen, perform an
+//! initialization.  The initialization will lock a simple critical section, checking the atomic
+//! again, to make sure it didn't get initialized by something intercepting it.  If the check sees a
+//! 'ptr' value that is not the same as Self, it indicates the object has been moved after
+//! initialization, and will simply panic.
+
+// To measure performance, this module implements this for `k_sem` without abstractions around it.
+// The idea is to compare performance with the above `Fixed` implementation.
+
+use core::{cell::UnsafeCell, ffi::c_uint, mem, sync::atomic::Ordering};
+
+use zephyr::Result;
+use zephyr::{
+    error::to_result_void,
+    raw::{k_sem, k_sem_give, k_sem_init, k_sem_take},
+    sync::atomic::AtomicUsize,
+    time::Timeout,
+};
+
+pub struct Semaphore {
+    state: AtomicUsize,
+    item: UnsafeCell<k_sem>,
+}
+
+// SAFETY: These are both Send and Sync. The semaphore itself is safe, and the atomic+critical
+// section protects the state.
+unsafe impl Send for Semaphore {}
+unsafe impl Sync for Semaphore {}
+
+impl Semaphore {
+    /// Construct a new semaphore, with the given initial_count and limit.  There is a bit of
+    /// trickery to pass the initial values through to the initializer, but otherwise this is just a
+    /// basic initialization.
+    pub fn new(initial_count: c_uint, limit: c_uint) -> Semaphore {
+        let this = Self {
+            state: AtomicUsize::new(0),
+            item: unsafe { UnsafeCell::new(mem::zeroed()) },
+        };
+
+        // Set the initial count and limit in the semaphore to use for later initialization.
+        unsafe {
+            let ptr = this.item.get();
+            (*ptr).count = initial_count;
+            (*ptr).limit = limit;
+        }
+
+        this
+    }
+
+    /// Get the raw pointer, initializing the `k_sem` if needed.
+    fn get(&self) -> *mut k_sem {
+        // First load can be relaxed, for performance reasons.  If it is seen as uninitialized, the
+        // below Acquire load will see the correct value.
+        let state = self.state.load(Ordering::Relaxed);
+        if state == self as *const Self as usize {
+            return self.item.get();
+        } else if state != 0 {
+            panic!("Semaphore was moved after first use");
+        }
+
+        critical_section::with(|_| {
+            // Reload, with Acquire ordering to see a determined value.
+            let state = self.state.load(Ordering::Acquire);
+            if state == self as *const Self as usize {
+                return self.item.get();
+            } else if state != 0 {
+                panic!("Semaphore was moved after first use");
+            }
+
+            // Perform the initialization.  We're within the critical section, and know that nobody
+            // could be using this.
+            unsafe {
+                let ptr = self.item.get();
+                let initial_count = (*ptr).count;
+                let limit = (*ptr).limit;
+
+                k_sem_init(ptr, initial_count, limit);
+            }
+
+            self.state
+                .store(self as *const Self as usize, Ordering::Release);
+            self.item.get()
+        })
+    }
+
+    /// Synchronous take.
+    pub fn take(&self, timeout: impl Into<Timeout>) -> Result<()> {
+        let timeout: Timeout = timeout.into();
+        let ptr = self.get();
+        let ret = unsafe { k_sem_take(ptr, timeout.0) };
+        to_result_void(ret)
+    }
+
+    pub fn give(&self) {
+        let ptr = self.get();
+        unsafe { k_sem_give(ptr) };
+    }
+}