add more special examples

Author: smallnest

special/Cargo.toml

@@ -9,6 +9,7 @@ edition = "2021"
 async-lock = "2.5.0"
 async-oneshot = "0.5.0"
 atomic_float = "0.1.0"
+awaitgroup = "0.6.0"
 catty = "0.1.5"
 concurrent-queue = "1.2.4"
 dashmap = "5.4.0"
@@ -18,11 +19,13 @@ flurry = "0.4.0"
 oneshot = "0.1.5"
 portable-atomic = { version = "0.3", features=["float"] }
 process_lock = "0.1.0"
+scc = "0.11.1"
 sharded-slab = "0.1.4"
 simple-mutex = "1.1.5"
 slab = "0.4.7"
 smol = "1.2.5"
 triggered = "0.1.2"
+triple_buffer = "6.2.0"
 try-lock = "0.2.3"
 waitgroup = "0.1.2"
 wg = "0.3.1"

special/src/lib.rs

@@ -1,13 +1,15 @@
-pub mod oslock;
-pub mod oneshots;
-pub mod map;
-pub mod primitive;
-pub mod notify;
-pub mod queue;
+mod oslock;
+mod oneshots;
+mod map;
+mod primitive;
+mod notify;
+mod queue;
+mod scc_examples;
 
 pub use oslock::*;
 pub use oneshots::*;
 pub use map::*;
 pub use primitive::*;
 pub use notify::*;
-pub use queue::*;
+pub use queue::*;
+pub use scc_examples::*;

special/src/main.rs

@@ -39,6 +39,13 @@ fn main() {
 
     waitgroup_example();
     wg_example();
+    awaitgroup_example();
+
+    scc_hashmap();
+    scc_hashindex();
+    scc_treeindex();
+    scc_hashset();
+    scc_queue();
 
 }
 

special/src/primitive/waitgroup_examples.rs

@@ -41,3 +41,25 @@ pub fn wg_example() {
     wg.wait();
     assert_eq!(ctr.load(Ordering::Relaxed), 5);
 }
+
+pub fn awaitgroup_example() {
+    use awaitgroup::WaitGroup;
+
+    smol::block_on(async {
+        let mut wg = WaitGroup::new();
+        for _ in 0..5 {
+            // Create a new worker.
+            let worker = wg.worker();
+
+            let _ = smol::spawn(async {
+                // Do some work...
+
+                // This task is done all of its work.
+                worker.done();
+            });
+        }
+
+        // Block until all other tasks have finished their work.
+        wg.wait().await;
+    });
+}

special/src/scc.rs

@@ -0,0 +1,61 @@
+use scc::*;
+use std::collections::hash_map::RandomState;
+
+pub fn scc_hashmap() {
+    let hashmap: HashMap<usize, usize, RandomState> = HashMap::with_capacity(1000);
+    assert_eq!(hashmap.capacity(), 1024);
+
+    let ticket = hashmap.reserve(10000);
+    assert!(ticket.is_some());
+    assert_eq!(hashmap.capacity(), 16384);
+    for i in 0..16 {
+        assert!(hashmap.insert(i, i).is_ok());
+    }
+    drop(ticket);
+
+    assert_eq!(hashmap.capacity(), 1024);
+}
+
+pub fn scc_hashindex() {
+    let hashindex: HashIndex<u64, u32> = HashIndex::default();
+
+    assert!(!hashindex.remove(&1));
+    assert!(hashindex.insert(1, 0).is_ok());
+    assert!(hashindex.remove(&1));
+}
+
+pub fn scc_treeindex() {
+    let treeindex: TreeIndex<u64, u32> = TreeIndex::new();
+
+    assert!(treeindex.insert(1, 10).is_ok());
+    assert_eq!(treeindex.insert(1, 11).err().unwrap(), (1, 11));
+    assert_eq!(treeindex.read(&1, |_k, v| *v).unwrap(), 10);
+}
+
+pub fn scc_hashset() {
+    let hashset: HashSet<usize, RandomState> = HashSet::with_capacity(1000);
+    assert_eq!(hashset.capacity(), 1024);
+
+    let ticket = hashset.reserve(10000);
+    assert!(ticket.is_some());
+    assert_eq!(hashset.capacity(), 16384);
+    for i in 0..16 {
+        assert!(hashset.insert(i).is_ok());
+    }
+    drop(ticket);
+
+    assert_eq!(hashset.capacity(), 1024);
+}
+
+pub fn scc_queue() {
+    let queue: Queue<usize> = Queue::default();
+
+    queue.push(37);
+    queue.push(3);
+    queue.push(1);
+
+    assert_eq!(queue.pop().map(|e| **e), Some(37));
+    assert_eq!(queue.pop().map(|e| **e), Some(3));
+    assert_eq!(queue.pop().map(|e| **e), Some(1));
+    assert!(queue.pop().is_none());
+}