Merge crates into a single repo

Author: Stjepan Glavina

.github/workflows/build-and-test.yaml

@@ -49,3 +49,4 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: test
+          args: --all

.gitignore

@@ -1,2 +1,2 @@
-/target
+target/
 Cargo.lock

Cargo.toml

@@ -17,3 +17,12 @@ async-barrier = "1.0.1"
 async-mutex = "1.3.0"
 async-rwlock = "1.1.0"
 async-semaphore = "1.1.0"
+
+[workspace]
+members = [
+  ".",
+  "async-barrier",
+  "async-mutex",
+  "async-rwlock",
+  "async-semaphore",
+]

async-barrier/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "async-barrier"
+version = "1.0.1"
+authors = ["Stjepan Glavina <stjepang@gmail.com>"]
+edition = "2018"
+description = "An async barrier"
+license = "Apache-2.0 OR MIT"
+repository = "https://github.com/stjepang/async-lock"
+homepage = "https://github.com/stjepang/async-lock"
+documentation = "https://docs.rs/async-barrier"
+keywords = ["rendezvous", "sync", "async", "synchronize", "synchronization"]
+categories = ["asynchronous", "concurrency"]
+readme = "../README.md"
+
+[dependencies]
+async-mutex = "1.1.5"
+event-listener = "2.4.0"
+
+[dev-dependencies]
+async-channel = "1.4.1"
+futures-lite = "1.0.0"

async-barrier/src/lib.rs

@@ -0,0 +1,139 @@
+//! An async barrier.
+//!
+//! This crate is an async version of [`std::sync::Barrier`].
+
+#![forbid(unsafe_code)]
+#![warn(missing_docs, missing_debug_implementations, rust_2018_idioms)]
+
+use async_mutex::Mutex;
+use event_listener::Event;
+
+/// A counter to synchronize multiple tasks at the same time.
+#[derive(Debug)]
+pub struct Barrier {
+    n: usize,
+    state: Mutex<State>,
+    event: Event,
+}
+
+#[derive(Debug)]
+struct State {
+    count: usize,
+    generation_id: u64,
+}
+
+impl Barrier {
+    /// Creates a barrier that can block the given number of tasks.
+    ///
+    /// A barrier will block `n`-1 tasks which call [`wait()`] and then wake up all tasks
+    /// at once when the `n`th task calls [`wait()`].
+    ///
+    /// [`wait()`]: `Barrier::wait()`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use async_barrier::Barrier;
+    ///
+    /// let barrier = Barrier::new(5);
+    /// ```
+    pub fn new(n: usize) -> Barrier {
+        Barrier {
+            n,
+            state: Mutex::new(State {
+                count: 0,
+                generation_id: 0,
+            }),
+            event: Event::new(),
+        }
+    }
+
+    /// Blocks the current task until all tasks reach this point.
+    ///
+    /// Barriers are reusable after all tasks have synchronized, and can be used continuously.
+    ///
+    /// Returns a [`BarrierWaitResult`] indicating whether this task is the "leader", meaning the
+    /// last task to call this method.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use async_barrier::Barrier;
+    /// use futures_lite::future;
+    /// use std::sync::Arc;
+    /// use std::thread;
+    ///
+    /// let barrier = Arc::new(Barrier::new(5));
+    ///
+    /// for _ in 0..5 {
+    ///     let b = barrier.clone();
+    ///     thread::spawn(move || {
+    ///         future::block_on(async {
+    ///             // The same messages will be printed together.
+    ///             // There will NOT be interleaving of "before" and "after".
+    ///             println!("before wait");
+    ///             b.wait().await;
+    ///             println!("after wait");
+    ///         });
+    ///     });
+    /// }
+    /// ```
+    pub async fn wait(&self) -> BarrierWaitResult {
+        let mut state = self.state.lock().await;
+        let local_gen = state.generation_id;
+        state.count += 1;
+
+        if state.count < self.n {
+            while local_gen == state.generation_id && state.count < self.n {
+                let listener = self.event.listen();
+                drop(state);
+                listener.await;
+                state = self.state.lock().await;
+            }
+            BarrierWaitResult { is_leader: false }
+        } else {
+            state.count = 0;
+            state.generation_id = state.generation_id.wrapping_add(1);
+            self.event.notify(std::usize::MAX);
+            BarrierWaitResult { is_leader: true }
+        }
+    }
+}
+
+/// Returned by [`Barrier::wait()`] when all tasks have called it.
+///
+/// # Examples
+///
+/// ```
+/// # futures_lite::future::block_on(async {
+/// use async_barrier::Barrier;
+///
+/// let barrier = Barrier::new(1);
+/// let barrier_wait_result = barrier.wait().await;
+/// # });
+/// ```
+#[derive(Debug, Clone)]
+pub struct BarrierWaitResult {
+    is_leader: bool,
+}
+
+impl BarrierWaitResult {
+    /// Returns `true` if this task was the last to call to [`Barrier::wait()`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # futures_lite::future::block_on(async {
+    /// use async_barrier::Barrier;
+    /// use futures_lite::future;
+    ///
+    /// let barrier = Barrier::new(2);
+    /// let (a, b) = future::zip(barrier.wait(), barrier.wait()).await;
+    /// assert_eq!(a.is_leader(), false);
+    /// assert_eq!(b.is_leader(), true);
+    /// # });
+    /// ```
+    pub fn is_leader(&self) -> bool {
+        self.is_leader
+    }
+}

async-barrier/tests/smoke.rs

@@ -0,0 +1,49 @@
+use std::sync::Arc;
+use std::thread;
+
+use async_barrier::Barrier;
+use futures_lite::future;
+
+#[test]
+fn smoke() {
+    future::block_on(async move {
+        const N: usize = 10;
+
+        let barrier = Arc::new(Barrier::new(N));
+
+        for _ in 0..10 {
+            let (tx, rx) = async_channel::unbounded();
+
+            for _ in 0..N - 1 {
+                let c = barrier.clone();
+                let tx = tx.clone();
+
+                thread::spawn(move || {
+                    future::block_on(async move {
+                        let res = c.wait().await;
+                        tx.send(res.is_leader()).await.unwrap();
+                    })
+                });
+            }
+
+            // At this point, all spawned threads should be blocked,
+            // so we shouldn't get anything from the cahnnel.
+            let res = rx.try_recv();
+            assert!(match res {
+                Err(_err) => true,
+                _ => false,
+            });
+
+            let mut leader_found = barrier.wait().await.is_leader();
+
+            // Now, the barrier is cleared and we should get data.
+            for _ in 0..N - 1 {
+                if rx.recv().await.unwrap() {
+                    assert!(!leader_found);
+                    leader_found = true;
+                }
+            }
+            assert!(leader_found);
+        }
+    });
+}

async-mutex/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "async-mutex"
+version = "1.3.0"
+authors = ["Stjepan Glavina <stjepang@gmail.com>"]
+edition = "2018"
+description = "Async mutex"
+license = "Apache-2.0 OR MIT"
+repository = "https://github.com/stjepang/async-lock"
+homepage = "https://github.com/stjepang/async-lock"
+documentation = "https://docs.rs/async-mutex"
+keywords = ["asynchronous", "mutex", "lock", "synchronization"]
+categories = ["asynchronous", "concurrency"]
+readme = "../README.md"
+
+[dependencies]
+event-listener = "2.0.0"
+
+[dev-dependencies]
+async-std = "1.6.2"
+futures = "0.3.5"
+futures-intrusive = "0.3.1"
+futures-lite = "1.0.0"
+smol = "0.1.18"
+tokio = { version = "0.2.21", features = ["sync", "parking_lot"] }

async-mutex/benches/async-mutex.rs

@@ -0,0 +1,42 @@
+#![feature(test)]
+
+extern crate test;
+
+use std::sync::Arc;
+
+use async_mutex::Mutex;
+use async_std::task;
+use test::Bencher;
+
+#[bench]
+fn create(b: &mut Bencher) {
+    b.iter(|| Mutex::new(()));
+}
+
+#[bench]
+fn contention(b: &mut Bencher) {
+    b.iter(|| task::block_on(run(10, 1000)));
+}
+
+#[bench]
+fn no_contention(b: &mut Bencher) {
+    b.iter(|| task::block_on(run(1, 10000)));
+}
+
+async fn run(task: usize, iter: usize) {
+    let m = Arc::new(Mutex::new(()));
+    let mut tasks = Vec::new();
+
+    for _ in 0..task {
+        let m = m.clone();
+        tasks.push(task::spawn(async move {
+            for _ in 0..iter {
+                let _ = m.lock().await;
+            }
+        }));
+    }
+
+    for t in tasks {
+        t.await;
+    }
+}

async-mutex/benches/async-std.rs

@@ -0,0 +1,42 @@
+#![feature(test)]
+
+extern crate test;
+
+use std::sync::Arc;
+
+use async_std::sync::Mutex;
+use async_std::task;
+use test::Bencher;
+
+#[bench]
+fn create(b: &mut Bencher) {
+    b.iter(|| Mutex::new(()));
+}
+
+#[bench]
+fn contention(b: &mut Bencher) {
+    b.iter(|| task::block_on(run(10, 1000)));
+}
+
+#[bench]
+fn no_contention(b: &mut Bencher) {
+    b.iter(|| task::block_on(run(1, 10000)));
+}
+
+async fn run(task: usize, iter: usize) {
+    let m = Arc::new(Mutex::new(()));
+    let mut tasks = Vec::new();
+
+    for _ in 0..task {
+        let m = m.clone();
+        tasks.push(task::spawn(async move {
+            for _ in 0..iter {
+                let _ = m.lock().await;
+            }
+        }));
+    }
+
+    for t in tasks {
+        t.await;
+    }
+}

async-mutex/benches/futures-intrusive.rs

@@ -0,0 +1,42 @@
+#![feature(test)]
+
+extern crate test;
+
+use std::sync::Arc;
+
+use async_std::task;
+use futures_intrusive::sync::Mutex;
+use test::Bencher;
+
+#[bench]
+fn create(b: &mut Bencher) {
+    b.iter(|| Mutex::new((), true));
+}
+
+#[bench]
+fn contention(b: &mut Bencher) {
+    b.iter(|| task::block_on(run(10, 1000)));
+}
+
+#[bench]
+fn no_contention(b: &mut Bencher) {
+    b.iter(|| task::block_on(run(1, 10000)));
+}
+
+async fn run(task: usize, iter: usize) {
+    let m = Arc::new(Mutex::new((), true));
+    let mut tasks = Vec::new();
+
+    for _ in 0..task {
+        let m = m.clone();
+        tasks.push(task::spawn(async move {
+            for _ in 0..iter {
+                let _ = m.lock().await;
+            }
+        }));
+    }
+
+    for t in tasks {
+        t.await;
+    }
+}