chore: rename `mpsc::sync` to `mpsc::blocking` (#40)

* chore: rename `mpsc::sync` to `mpsc::blocking`

This naming scheme should be a bit less ambiguous.

Signed-off-by: Eliza Weisman <eliza@buoyant.io>

bench/benches/sync_spsc.rs

@@ -20,8 +20,8 @@ aaaaaaaaaaaaaa";
         group.throughput(Throughput::Elements(size));
         group.bench_with_input(BenchmarkId::new("ThingBuf", size), &size, |b, &i| {
             b.iter(|| {
-                use thingbuf::mpsc::{sync, TrySendError};
-                let (tx, rx) = sync::channel::<String>(100);
+                use thingbuf::mpsc::{blocking, TrySendError};
+                let (tx, rx) = blocking::channel::<String>(100);
                 let producer = thread::spawn(move || loop {
                     match tx.try_send_ref() {
                         Ok(mut slot) => {
@@ -103,8 +103,8 @@ aaaaaaaaaaaaaa";
         group.throughput(Throughput::Elements(size));
         group.bench_with_input(BenchmarkId::new("ThingBuf", size), &size, |b, &i| {
             b.iter(|| {
-                use thingbuf::mpsc::sync;
-                let (tx, rx) = sync::channel::<String>(100);
+                use thingbuf::mpsc::blocking;
+                let (tx, rx) = blocking::channel::<String>(100);
                 let producer = thread::spawn(move || {
                     while let Ok(mut slot) = tx.send_ref() {
                         slot.clear();

src/mpsc.rs

@@ -5,10 +5,10 @@
 //! receiving task willwait when there are no messages in the channel.
 //!
 //! If the "std" feature flag is enabled, this module also provides a
-//! synchronous channel, in the [`sync`] module. The synchronous  receiver will
-//! instead wait for new messages by blocking the current thread. Naturally,
-//! this requires the Rust standard library. A synchronous channel
-//! can be constructed using the [`sync::channel`] function.
+//! synchronous channel, in the [`blocking`] module. The synchronous receiver
+//! will instead wait for new messages by blocking the current thread.
+//! Naturally, this requires the Rust standard library. A synchronous channel
+//! can be constructed using the [`blocking::channel`] function.
 
 use crate::{
     loom::{atomic::AtomicUsize, hint},
@@ -405,7 +405,7 @@ pub use self::async_impl::*;
 
 feature! {
     #![feature = "std"]
-    pub mod sync;
+    pub mod blocking;
 }
 
 #[cfg(all(loom, test))]

src/mpsc/sync.rs → src/mpsc/blocking.rs

@@ -97,7 +97,7 @@ feature! {
     /// # Examples
     ///
     /// ```
-    /// use thingbuf::mpsc::sync::StaticChannel;
+    /// use thingbuf::mpsc::blocking::StaticChannel;
     ///
     /// // Construct a statically-allocated channel of `usize`s with a capacity
     /// // of 16 messages.
@@ -260,7 +260,7 @@ feature! {
         /// Sending formatted strings by writing them directly to channel slots,
         /// in place:
         /// ```
-        /// use thingbuf::mpsc::sync::StaticChannel;
+        /// use thingbuf::mpsc::blocking::StaticChannel;
         /// use std::{fmt::Write, thread};
         ///
         /// static CHANNEL: StaticChannel<String, 8> = StaticChannel::new();
@@ -313,7 +313,7 @@ feature! {
         /// # Examples
         ///
         /// ```
-        /// use thingbuf::mpsc::sync::StaticChannel;
+        /// use thingbuf::mpsc::blocking::StaticChannel;
         /// use std::{fmt::Write, thread};
         ///
         /// static CHANNEL: StaticChannel<i32, 8> = StaticChannel::new();
@@ -468,7 +468,7 @@ feature! {
         /// # Examples
         ///
         /// ```
-        /// use thingbuf::mpsc::sync::StaticChannel;
+        /// use thingbuf::mpsc::blocking::StaticChannel;
         /// use std::{thread, fmt::Write};
         ///
         /// static CHANNEL: StaticChannel<String, 100> = StaticChannel::new();
@@ -487,7 +487,7 @@ feature! {
         /// Values are buffered:
         ///
         /// ```
-        /// use thingbuf::mpsc::sync::StaticChannel;
+        /// use thingbuf::mpsc::blocking::StaticChannel;
         /// use std::fmt::Write;
         ///
         /// static CHANNEL: StaticChannel<String, 100> = StaticChannel::new();
@@ -527,7 +527,7 @@ feature! {
         /// # Examples
         ///
         /// ```
-        /// use thingbuf::mpsc::sync::StaticChannel;
+        /// use thingbuf::mpsc::blocking::StaticChannel;
         /// use std::thread;
         ///
         /// static CHANNEL: StaticChannel<i32, 100> = StaticChannel::new();
@@ -544,7 +544,7 @@ feature! {
         /// Values are buffered:
         ///
         /// ```
-        /// use thingbuf::mpsc::sync::StaticChannel;
+        /// use thingbuf::mpsc::blocking::StaticChannel;
         ///
         /// static CHANNEL: StaticChannel<i32, 100> = StaticChannel::new();
         /// let (tx, rx) = CHANNEL.split();
@@ -663,10 +663,10 @@ where
     /// Sending formatted strings by writing them directly to channel slots,
     /// in place:
     /// ```
-    /// use thingbuf::mpsc::sync;
+    /// use thingbuf::mpsc::blocking;
     /// use std::{fmt::Write, thread};
     ///
-    /// let (tx, rx) = sync::channel::<String>(8);
+    /// let (tx, rx) = blocking::channel::<String>(8);
     ///
     /// // Spawn a thread that prints each message received from the channel:
     /// thread::spawn(move || {
@@ -718,10 +718,10 @@ where
     /// # Examples
     ///
     /// ```
-    /// use thingbuf::mpsc::sync;
+    /// use thingbuf::mpsc::blocking;
     /// use std::thread;
     ///
-    /// let (tx, rx) = sync::channel(8);
+    /// let (tx, rx) = blocking::channel(8);
     ///
     /// // Spawn a thread that prints each message received from the channel:
     /// thread::spawn(move || {
@@ -863,10 +863,10 @@ impl<T, R> Receiver<T, R> {
     /// # Examples
     ///
     /// ```
-    /// use thingbuf::mpsc::sync;
+    /// use thingbuf::mpsc::blocking;
     /// use std::{thread, fmt::Write};
     ///
-    /// let (tx, rx) = sync::channel::<String>(100);
+    /// let (tx, rx) = blocking::channel::<String>(100);
     ///
     /// thread::spawn(move || {
     ///     let mut value = tx.send_ref().unwrap();
@@ -881,10 +881,10 @@ impl<T, R> Receiver<T, R> {
     /// Values are buffered:
     ///
     /// ```
-    /// use thingbuf::mpsc::sync;
+    /// use thingbuf::mpsc::blocking;
     /// use std::fmt::Write;
     ///
-    /// let (tx, rx) = sync::channel::<String>(100);
+    /// let (tx, rx) = blocking::channel::<String>(100);
     ///
     /// write!(tx.send_ref().unwrap(), "hello").unwrap();
     /// write!(tx.send_ref().unwrap(), "world").unwrap();
@@ -920,10 +920,10 @@ impl<T, R> Receiver<T, R> {
     /// # Examples
     ///
     /// ```
-    /// use thingbuf::mpsc::sync;
+    /// use thingbuf::mpsc::blocking;
     /// use std::{thread, fmt::Write};
     ///
-    /// let (tx, rx) = sync::channel(100);
+    /// let (tx, rx) = blocking::channel(100);
     ///
     /// thread::spawn(move || {
     ///    tx.send(1).unwrap();
@@ -936,9 +936,9 @@ impl<T, R> Receiver<T, R> {
     /// Values are buffered:
     ///
     /// ```
-    /// use thingbuf::mpsc::sync;
+    /// use thingbuf::mpsc::blocking;
     ///
-    /// let (tx, rx) = sync::channel(100);
+    /// let (tx, rx) = blocking::channel(100);
     ///
     /// tx.send(1).unwrap();
     /// tx.send(2).unwrap();

src/mpsc/tests.rs

@@ -2,4 +2,4 @@ use super::*;
 
 mod mpsc_async;
 #[cfg(feature = "std")]
-mod mpsc_sync;
+mod mpsc_blocking;

src/mpsc/tests/mpsc_sync.rs → src/mpsc/tests/mpsc_blocking.rs

@@ -13,7 +13,7 @@ use crate::loom::{self, alloc::Track, thread};
 #[ignore]
 fn mpsc_try_send_recv() {
     loom::model(|| {
-        let (tx, rx) = sync::channel(3);
+        let (tx, rx) = blocking::channel(3);
 
         let p1 = {
             let tx = tx.clone();
@@ -44,7 +44,7 @@ fn mpsc_try_send_recv() {
 fn rx_closes() {
     const ITERATIONS: usize = 6;
     loom::model(|| {
-        let (tx, rx) = sync::channel(ITERATIONS / 2);
+        let (tx, rx) = blocking::channel(ITERATIONS / 2);
 
         let producer = thread::spawn(move || {
             'iters: for i in 0..=ITERATIONS {
@@ -82,7 +82,7 @@ fn rx_close_unconsumed_spsc() {
     const MESSAGES: usize = 4;
 
     loom::model(|| {
-        let (tx, rx) = sync::channel(MESSAGES);
+        let (tx, rx) = blocking::channel(MESSAGES);
 
         let consumer = thread::spawn(move || {
             // recieve one message
@@ -109,7 +109,7 @@ fn rx_close_unconsumed_spsc() {
 fn rx_close_unconsumed_mpsc() {
     const MESSAGES: usize = 2;
 
-    fn do_producer(tx: sync::Sender<Track<i32>>, n: usize) -> impl FnOnce() + Send + Sync {
+    fn do_producer(tx: blocking::Sender<Track<i32>>, n: usize) -> impl FnOnce() + Send + Sync {
         move || {
             let mut i = 1;
             while let Ok(mut slot) = tx.send_ref() {
@@ -121,7 +121,7 @@ fn rx_close_unconsumed_mpsc() {
     }
 
     loom::model(|| {
-        let (tx, rx) = sync::channel(MESSAGES);
+        let (tx, rx) = blocking::channel(MESSAGES);
 
         let consumer = thread::spawn(move || {
             // recieve one message
@@ -143,7 +143,7 @@ fn rx_close_unconsumed_mpsc() {
 #[test]
 fn spsc_recv_then_try_send() {
     loom::model(|| {
-        let (tx, rx) = sync::channel::<i32>(4);
+        let (tx, rx) = blocking::channel::<i32>(4);
         let consumer = thread::spawn(move || {
             assert_eq_dbg!(rx.recv().unwrap(), 10);
         });
@@ -156,7 +156,7 @@ fn spsc_recv_then_try_send() {
 #[test]
 fn spsc_recv_then_close() {
     loom::model(|| {
-        let (tx, rx) = sync::channel::<i32>(4);
+        let (tx, rx) = blocking::channel::<i32>(4);
         let producer = thread::spawn(move || {
             drop(tx);
         });
@@ -170,7 +170,7 @@ fn spsc_recv_then_close() {
 #[test]
 fn spsc_recv_then_try_send_then_close() {
     loom::model(|| {
-        let (tx, rx) = sync::channel::<i32>(2);
+        let (tx, rx) = blocking::channel::<i32>(2);
         let consumer = thread::spawn(move || {
             assert_eq_dbg!(rx.recv().unwrap(), 10);
             assert_eq_dbg!(rx.recv().unwrap(), 20);
@@ -196,7 +196,7 @@ fn spsc_recv_then_try_send_then_close() {
 #[ignore]
 fn mpsc_send_recv_wrap() {
     loom::model(|| {
-        let (tx, rx) = sync::channel::<usize>(1);
+        let (tx, rx) = blocking::channel::<usize>(1);
         let producer1 = do_producer(tx.clone(), 10);
         let producer2 = do_producer(tx, 20);
 
@@ -227,7 +227,7 @@ fn mpsc_send_recv_wrap() {
 #[test]
 fn mpsc_send_recv_no_wrap() {
     loom::model(|| {
-        let (tx, rx) = sync::channel::<usize>(2);
+        let (tx, rx) = blocking::channel::<usize>(2);
         let producer1 = do_producer(tx.clone(), 10);
         let producer2 = do_producer(tx, 20);
 
@@ -255,7 +255,7 @@ fn mpsc_send_recv_no_wrap() {
     })
 }
 
-fn do_producer(tx: sync::Sender<usize>, tag: usize) -> thread::JoinHandle<()> {
+fn do_producer(tx: blocking::Sender<usize>, tag: usize) -> thread::JoinHandle<()> {
     thread::spawn(move || {
         test_println!("SENDING {:?}", tag);
         tx.send(tag).unwrap();
@@ -267,7 +267,7 @@ fn do_producer(tx: sync::Sender<usize>, tag: usize) -> thread::JoinHandle<()> {
 fn spsc_send_recv_in_order_no_wrap() {
     const N_SENDS: usize = 4;
     loom::model(|| {
-        let (tx, rx) = sync::channel::<usize>(N_SENDS);
+        let (tx, rx) = blocking::channel::<usize>(N_SENDS);
         let consumer = thread::spawn(move || {
             for i in 1..=N_SENDS {
                 assert_eq_dbg!(rx.recv(), Some(i));
@@ -296,7 +296,7 @@ fn spsc_send_recv_in_order_no_wrap() {
 fn spsc_send_recv_in_order_wrap() {
     const N_SENDS: usize = 2;
     loom::model(|| {
-        let (tx, rx) = sync::channel::<usize>(N_SENDS / 2);
+        let (tx, rx) = blocking::channel::<usize>(N_SENDS / 2);
         let consumer = thread::spawn(move || {
             for i in 1..=N_SENDS {
                 assert_eq_dbg!(rx.recv(), Some(i));
@@ -315,7 +315,7 @@ fn spsc_send_recv_in_order_wrap() {
 #[test]
 fn tx_close_wakes() {
     loom::model(|| {
-        let (tx, rx) = sync::channel::<i32>(2);
+        let (tx, rx) = blocking::channel::<i32>(2);
         let consumer = thread::spawn(move || {
             assert_eq_dbg!(rx.recv(), None);
         });
@@ -328,7 +328,7 @@ fn tx_close_wakes() {
 fn tx_close_drains_queue() {
     const LEN: usize = 4;
     loom::model(|| {
-        let (tx, rx) = sync::channel(LEN);
+        let (tx, rx) = blocking::channel(LEN);
         let producer = thread::spawn(move || {
             for i in 0..LEN {
                 tx.send(i).unwrap();

tests/mpsc_sync.rs → tests/mpsc_blocking.rs

@@ -1,5 +1,5 @@
 use std::thread;
-use thingbuf::mpsc::sync;
+use thingbuf::mpsc::blocking;
 
 #[test]
 fn basically_works() {
@@ -8,7 +8,7 @@ fn basically_works() {
     const N_SENDS: usize = 10;
     const N_PRODUCERS: usize = 10;
 
-    fn start_producer(tx: sync::Sender<usize>, n: usize) -> thread::JoinHandle<()> {
+    fn start_producer(tx: blocking::Sender<usize>, n: usize) -> thread::JoinHandle<()> {
         let tag = n * N_SENDS;
         thread::Builder::new()
             .name(format!("producer {}", n))
@@ -24,7 +24,7 @@ fn basically_works() {
             .expect("spawning threads should succeed")
     }
 
-    let (tx, rx) = sync::channel(N_SENDS / 2);
+    let (tx, rx) = blocking::channel(N_SENDS / 2);
     for n in 0..N_PRODUCERS {
         start_producer(tx.clone(), n);
     }
@@ -56,7 +56,7 @@ fn tx_close_drains_queue() {
     for i in 0..10000 {
         println!("\n\n--- iteration {} ---\n\n", i);
 
-        let (tx, rx) = sync::channel(LEN);
+        let (tx, rx) = blocking::channel(LEN);
         let producer = thread::spawn(move || {
             for i in 0..LEN {
                 tx.send(i).unwrap();

tests/static_storage.rs

@@ -145,16 +145,16 @@ async fn static_async_channel() {
 }
 
 #[test]
-fn static_sync_channel() {
+fn static_blocking_channel() {
     use std::collections::HashSet;
-    use thingbuf::mpsc::sync;
+    use thingbuf::mpsc::blocking;
 
     const N_PRODUCERS: usize = 8;
     const N_SENDS: usize = N_PRODUCERS * 2;
 
-    static CHANNEL: sync::StaticChannel<usize, N_PRODUCERS> = sync::StaticChannel::new();
+    static CHANNEL: blocking::StaticChannel<usize, N_PRODUCERS> = blocking::StaticChannel::new();
 
-    fn do_producer(tx: sync::StaticSender<usize>, n: usize) -> impl FnOnce() {
+    fn do_producer(tx: blocking::StaticSender<usize>, n: usize) -> impl FnOnce() {
         move || {
             let tag = n * N_SENDS;
             for i in 0..N_SENDS {