tmp: Hand semaphore version

Author: d3zd3z

samples/work-philosophers/src/hand_sem.rs

@@ -0,0 +1,89 @@
+//! Hand-written semaphore solution
+//!
+//! Implements the semaphore solution to the dining philosopher problem, but with all Futures
+//! written by hand.
+//!
+//! For this particular case, we will use Arc with the Semaphores instead of Rc, and not try to be
+//! thread-local.
+
+use core::{future::Future, task::Poll};
+
+use alloc::vec::Vec;
+use zephyr::{kio::{spawn, sync::Mutex}, sync::Arc, sys::sync::Semaphore, work::{futures::JoinHandle, WorkQueue}};
+
+use crate::{Stats, NUM_PHIL};
+
+/// Number of iterations for each philospher.
+const EAT_COUNT: usize = 10;
+
+pub fn phil(wqueue: &WorkQueue) -> impl Future<Output = Arc<Mutex<Stats>>> + Send {
+    let stats = Arc::new(Mutex::new(Stats::default()));
+
+    // One fork for each philospher.
+    let forks: Vec<_> = (0..NUM_PHIL)
+        .map(|_| Arc::new(Semaphore::new(1, 1).unwrap()))
+        .collect();
+
+    // Create all of the philosphers.
+    let phils: Vec<_> = (0..NUM_PHIL)
+        .map(|i| {
+            // Determine the two forks.
+            let forks = if i == NUM_PHIL - 1 {
+                [forks[0].clone(), forks[i].clone()]
+            } else {
+                [forks[i].clone(), forks[i + 1].clone()]
+            };
+
+            spawn(one_phil(forks, i, stats.clone()), wqueue, c"phil")
+        })
+        .collect();
+
+    Phil {
+        stats, phils,
+    }
+}
+
+struct Phil<F>
+where
+    F: Future<Output = ()> + Send,
+{
+    stats: Arc<Mutex<Stats>>,
+    phils: Vec<JoinHandle<F>>,
+}
+
+impl<F> Future for Phil<F>
+where
+    F: Future<Output = ()> + Send,
+{
+    type Output = Arc<Mutex<Stats>>;
+
+    fn poll(self: core::pin::Pin<&mut Self>, cx: &mut core::task::Context<'_>) -> core::task::Poll<Self::Output> {
+        if self.phils.is_empty() {
+            return Poll::Ready(self.stats.clone());
+        }
+        let _ = cx;
+        todo!()
+    }
+}
+
+/// Simulate a single philospher
+fn one_phil(forks: [Arc<Semaphore>; 2], n: usize, stats: Arc<Mutex<Stats>>) -> impl Future<Output = ()> + Send {
+    OnePhil {
+        forks, n, stats,
+    }
+}
+
+struct OnePhil {
+    forks: [Arc<Semaphore>; 2],
+    n: usize,
+    stats: Arc<Mutex<Stats>>,
+}
+
+impl Future for OnePhil {
+    type Output = ();
+
+    fn poll(self: core::pin::Pin<&mut Self>, cx: &mut core::task::Context<'_>) -> core::task::Poll<Self::Output> {
+        let _ = cx;
+        todo!()
+    }
+}

samples/work-philosophers/src/lib.rs

@@ -19,6 +19,7 @@ use zephyr::{
 };
 
 mod async_sem;
+mod hand_sem;
 
 /// How many philosophers.  There will be the same number of forks.
 const NUM_PHIL: usize = 6;
@@ -57,6 +58,13 @@ extern "C" fn rust_main() {
     let _ = Arc::into_raw(lower_worker.clone());
     let _ = Arc::into_raw(worker.clone());
 
+    // Run the hand-written semaphore one.
+    printkln!("Running 'hand-sem' test");
+    let handle = spawn(hand_sem::phil(&worker), &worker, c"hand-sem");
+    let stats = handle.join();
+    printkln!("Done with hand-sem test");
+    stats.show();
+
     // First run the async semaphore based one.
     printkln!("Running 'async-sem' test");
     let handle = spawn(async_sem::phil(), &worker, c"async-sem");