add more special examples

Author: smallnest

special/Cargo.toml

@@ -7,11 +7,22 @@ edition = "2021"
 
 [dependencies]
 async-lock = "2.5.0"
+async-oneshot = "0.5.0"
+atomic_float = "0.1.0"
+catty = "0.1.5"
 concurrent-queue = "1.2.4"
 dashmap = "5.4.0"
 event-listener = "2.5.3"
+evmap = "10.0.2"
+flurry = "0.4.0"
+oneshot = "0.1.5"
+portable-atomic = { version = "0.3", features=["float"] }
 process_lock = "0.1.0"
 sharded-slab = "0.1.4"
+simple-mutex = "1.1.5"
 slab = "0.4.7"
 smol = "1.2.5"
+triggered = "0.1.2"
 try-lock = "0.2.3"
+waitgroup = "0.1.2"
+wg = "0.3.1"

special/src/lib.rs

@@ -1,12 +1,12 @@
 pub mod oslock;
-pub mod oneshot;
+pub mod oneshots;
 pub mod map;
 pub mod primitive;
 pub mod notify;
 pub mod queue;
 
 pub use oslock::*;
-pub use oneshot::*;
+pub use oneshots::*;
 pub use map::*;
 pub use primitive::*;
 pub use notify::*;

special/src/main.rs

@@ -12,9 +12,35 @@ fn main() {
     slab_example();
 
     event_listener_example();
+    triggered_example();
 
     hashmap_example();
+    flurry_hashmap();
+    flurry_hashset();
+    evmap_example();
+
     concurrent_queue_example();
 
     async_lock_mutex();
+    async_lock_rwlock();
+    async_lock_barrier();
+    async_lock_semaphore();
+
+    portable_atomic_i128();
+    portable_atomic_u128();
+    portable_atomic_f64();
+    atomic_float_example();
+
+    simple_mutex_example();
+
+    oneshot_example();
+    async_oneshot_example();
+    catty_example();
+
+    waitgroup_example();
+    wg_example();
+
 }
+
+
+// lockfree

special/src/map.rs

@@ -1,6 +1,6 @@
+use dashmap::DashMap;
 use std::sync::Arc;
 use std::thread;
-use dashmap::DashMap;
 
 pub fn hashmap_example() {
     let map = Arc::new(DashMap::new());
@@ -11,26 +11,97 @@ pub fn hashmap_example() {
         map1.insert(2, 3);
     });
 
-
     let map2 = map.clone();
     let rhandle = thread::spawn(move || {
-        
         loop {
             if let Some(v) = map2.get(&1) {
                 println!("get value {} for key 1", *v);
                 break;
-            } 
+            }
         }
 
         loop {
             if let Some(v) = map2.get(&2) {
                 println!("get value {} for key 2", *v);
                 break;
-            } 
+            }
         }
     });
 
     whandle.join().unwrap();
     rhandle.join().unwrap();
+}
+
+pub fn flurry_hashmap() {
+    let map = flurry::HashMap::new();
+
+    assert_eq!(map.pin().insert(37, "a"), None);
+    assert_eq!(map.pin().is_empty(), false);
+}
+
+pub fn flurry_hashset() {
+    // Initialize a new hash set.
+    let books = flurry::HashSet::new();
+    let guard = books.guard();
+
+    // Add some books
+    books.insert("Fight Club", &guard);
+    books.insert("Three Men In A Raft", &guard);
+    books.insert("The Book of Dust", &guard);
+    books.insert("The Dry", &guard);
+
+    // Check for a specific one.
+    if !books.contains(&"The Drunken Botanist", &guard) {
+        println!("We don't have The Drunken Botanist.");
+    }
+
+    // Remove a book.
+    books.remove(&"Three Men In A Raft", &guard);
+
+    // Iterate over everything.
+    for book in books.iter(&guard) {
+        println!("{}", book);
+    }
+}
+
+pub fn evmap_example() {
+    let (book_reviews_r, mut book_reviews_w) = evmap::new();
 
+    let readers: Vec<_> = (0..4)
+        .map(|_| {
+            let r = book_reviews_r.clone();
+            thread::spawn(move || {
+                loop {
+                    let l = r.len();
+                    if l == 0 {
+                        thread::yield_now();
+                    } else {
+                        // the reader will either see all the reviews,
+                        // or none of them, since refresh() is atomic.
+                        assert_eq!(l, 4);
+                        break;
+                    }
+                }
+            })
+        })
+        .collect();
+
+    // do some writes
+    book_reviews_w.insert("Adventures of Huckleberry Finn", "My favorite book.");
+    book_reviews_w.insert("Grimms' Fairy Tales", "Masterpiece.");
+    book_reviews_w.insert("Pride and Prejudice", "Very enjoyable.");
+    book_reviews_w.insert("The Adventures of Sherlock Holmes", "Eye lyked it alot.");
+    // expose the writes
+    book_reviews_w.refresh();
+
+    // you can read through the write handle
+    assert_eq!(book_reviews_w.len(), 4);
+
+    // the original read handle still works too
+    assert_eq!(book_reviews_r.len(), 4);
+
+    // all the threads should eventually see .len() == 4
+    for r in readers.into_iter() {
+        assert!(r.join().is_ok());
+    }
 }

special/src/notify.rs

@@ -45,3 +45,22 @@ pub fn event_listener_example() {
 
     println!("flag is set");
 }
+
+pub fn triggered_example() {
+    smol::block_on(async {
+        let (trigger, listener) = triggered::trigger();
+
+        let task = smol::spawn(async {
+            // Blocks until `trigger.trigger()` below
+            listener.await;
+
+            println!("Triggered async task");
+        });
+
+        // This will make any thread blocked in `Listener::wait()` or async task awaiting the
+        // listener continue execution again.
+        trigger.trigger();
+
+        let _ = task.await;
+    })
+}

special/src/oneshot.rs

@@ -0,0 +1,42 @@
+use std::thread;
+
+pub fn oneshot_example() {
+    let (sender, receiver) = oneshot::channel::<i32>();
+    let sender = thread::spawn(move || {
+        sender.send(1).unwrap();
+    });
+    let receiver = thread::spawn(move || {
+        let v = receiver.recv().unwrap();
+        println!("get value {}", v);
+    });
+    sender.join().unwrap();
+    receiver.join().unwrap();
+}
+
+pub fn async_oneshot_example() {
+    let (mut sender, receiver) = async_oneshot::oneshot();
+    smol::block_on(async {
+        sender.send(1).unwrap();
+    });
+
+    smol::block_on(async {
+        let v = receiver.try_recv().unwrap();
+        println!("get value {}", v);
+    });   
+}
+
+pub fn catty_example() {
+    let (sender, mut receiver) = catty::oneshot();
+    let sender = thread::spawn(move || {
+        sender.send(1).unwrap();
+    });
+    let receiver = thread::spawn(move || {
+        let v = receiver.try_recv().unwrap();
+        if v.is_some() {
+            println!("get value {}", v.unwrap());
+        }
+       
+    });
+    sender.join().unwrap();
+    receiver.join().unwrap();
+}

special/src/oneshots.rs

@@ -0,0 +1,63 @@
+use async_lock::*;
+use std::sync::Arc;
+use std::thread;
+
+pub fn async_lock_mutex() {
+    let lock = Arc::new(Mutex::new(0));
+
+    let lock1 = lock.clone();
+    smol::block_on(async {
+        let mut guard = lock1.lock().await;
+        *guard += 1;
+    });
+
+    let lock2 = lock.clone();
+    smol::block_on(async {
+        let guard = lock2.lock().await;
+        println!("lock2 {}", *guard);
+    });
+}
+
+pub fn async_lock_rwlock() {
+    let lock = Arc::new(RwLock::new(0));
+
+    let lock1 = lock.clone();
+    smol::block_on(async {
+        let mut guard = lock1.write().await;
+        *guard += 1;
+    });
+
+    let lock2 = lock.clone();
+    smol::block_on(async {
+        let guard = lock2.read().await;
+        println!("lock2 {}", *guard);
+    });
+}
+
+pub fn async_lock_barrier() {
+    let barrier = Arc::new(Barrier::new(5));
+
+    thread::scope(|s| {
+        for _ in 0..5 {
+            let barrier = barrier.clone();
+            s.spawn(move || {
+                smol::block_on(async {
+                    println!("before wait");
+                    barrier.wait().await;
+                    println!("after wait");
+                });
+            });
+        }
+    });
+}
+
+pub fn async_lock_semaphore() {
+    let s = Arc::new(Semaphore::new(2));
+
+    let _g1 = s.try_acquire_arc().unwrap();
+    let g2 = s.try_acquire_arc().unwrap();
+
+    assert!(s.try_acquire_arc().is_none());
+    drop(g2);
+    assert!(s.try_acquire_arc().is_some());
+}

special/src/primitive/async_lock_example.rs

@@ -0,0 +1,54 @@
+use portable_atomic::*;
+use std::sync::atomic::Ordering::Relaxed;
+
+pub fn portable_atomic_i128() {
+    let mut some_var = AtomicI128::new(10);
+    assert_eq!(*some_var.get_mut(), 10);
+    *some_var.get_mut() = 5;
+    assert_eq!(some_var.load(Ordering::SeqCst), 5);
+
+    assert_eq!(some_var.load(Ordering::Relaxed), 5);
+}
+
+pub fn portable_atomic_u128() {
+    let mut some_var = AtomicU128::new(10);
+    assert_eq!(*some_var.get_mut(), 10);
+    *some_var.get_mut() = 5;
+    assert_eq!(some_var.load(Ordering::SeqCst), 5);
+
+    assert_eq!(some_var.load(Ordering::Relaxed), 5);
+}
+
+pub fn portable_atomic_f32() {
+    let mut some_var = AtomicF32::new(10.0);
+    assert_eq!(*some_var.get_mut(), 10.0);
+    *some_var.get_mut() = 5.0;
+    assert_eq!(some_var.load(Ordering::SeqCst), 5.0);
+
+    assert_eq!(some_var.load(Ordering::Relaxed), 5.0);
+}
+
+pub fn portable_atomic_f64() {
+    let mut some_var = AtomicF64::new(10.0f64);
+    assert_eq!(*some_var.get_mut(), 10.0);
+    *some_var.get_mut() = 5.0;
+    assert_eq!(some_var.load(Ordering::SeqCst), 5.0);
+
+    assert_eq!(some_var.load(Ordering::Relaxed), 5.0);
+}
+
+pub fn atomic_float_example() {
+    let some_var = atomic_float::AtomicF32::new(800.0f32);
+    some_var.fetch_add(30.0, Relaxed);
+    some_var.fetch_sub(-55.0, Relaxed);
+    some_var.fetch_neg(Relaxed);
+
+    assert_eq!(some_var.load(Relaxed), -885.0);
+
+    let some_var = atomic_float::AtomicF64::new(800.0f64);
+    some_var.fetch_add(30.0, Relaxed);
+    some_var.fetch_sub(-55.0, Relaxed);
+    some_var.fetch_neg(Relaxed);
+
+    assert_eq!(some_var.load(Relaxed), -885.0);
+}