Merge pull request #40 from orxfun/Use-of-Collection-constrained-PinnedVecs

Use-of-Collection-constrained-PinnedVecs

Author: orxfun

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "orx-concurrent-vec"
-version = "3.2.0"
+version = "3.3.0"
 edition = "2021"
 authors = ["orxfun <[email protected]>"]
 description = "A thread-safe, efficient and lock-free vector allowing concurrent grow, read and update operations."
@@ -11,22 +11,23 @@ categories = ["data-structures", "concurrency", "rust-patterns", "no-std"]
 
 [dependencies]
 orx-pseudo-default = { version = "1.4", default-features = false }
-orx-pinned-vec = "3.11"
-orx-fixed-vec = "3.11"
-orx-split-vec = "3.11"
-orx-pinned-concurrent-col = "2.9"
+orx-pinned-vec = "3.12"
+orx-fixed-vec = "3.12"
+orx-split-vec = "3.12"
+orx-pinned-concurrent-col = "2.10"
 orx-concurrent-option = "1.3"
 serde = { version = "1.0.217", optional = true, default-features = false }
 
 [dev-dependencies]
-append-only-vec = "0.1.5"
-boxcar = "0.2.5"
-clap = { version = "4.5.17", features = ["derive"] }
+append-only-vec = "0.1.7"
+boxcar = "0.2.8"
+clap = { version = "4.5.27", features = ["derive"] }
 criterion = "0.5.1"
-rand = "0.8"
-rand_chacha = "0.3"
-rayon = "1.9.0"
-serde_json = { version = "1.0.135", default-features = false, features = [
+orx-iterable = "1.1.1"
+rand = "0.9.0"
+rand_chacha = "0.9.0"
+rayon = "1.10.0"
+serde_json = { version = "1.0.138", default-features = false, features = [
     "std",
 ] }
 test-case = "3.3.1"

examples/concurrent_grow_read_noupdate.rs

@@ -1,5 +1,6 @@
 use clap::Parser;
 use orx_concurrent_vec::*;
+use orx_iterable::*;
 use rand::prelude::*;
 use rand_chacha::ChaCha8Rng;
 
@@ -105,7 +106,7 @@ fn read(vec: &ConcurrentVec<String>, final_len: usize, lag: u64) {
         for _ in 0..1000 {
             std::thread::sleep(std::time::Duration::from_micros(lag));
 
-            let idx = rng.gen_range(0..slice.len());
+            let idx = rng.random_range(0..slice.len());
 
             // direct access to the reference
             // SAFETY: safe in this scenario since we know that no update on the element happens.

examples/concurrent_grow_read_update.rs

@@ -1,11 +1,12 @@
 use clap::Parser;
 use orx_concurrent_vec::*;
+use orx_iterable::*;
 use rand::prelude::*;
 use rand_chacha::ChaCha8Rng;
 
 /// Randomly draws an element from the `candidates.`
 fn draw<'a, T>(r: &mut ChaCha8Rng, candidates: &'a [T]) -> &'a T {
-    &candidates[r.gen_range(0..candidates.len())]
+    &candidates[r.random_range(0..candidates.len())]
 }
 
 /// Note that [`vec.push(value)`] could also be used, which returns the position
@@ -87,7 +88,7 @@ fn read(vec: &ConcurrentVec<String>, final_len: usize, lag: u64) {
         for _ in 0..1000 {
             std::thread::sleep(std::time::Duration::from_micros(lag));
 
-            let idx = rng.gen_range(0..slice.len());
+            let idx = rng.random_range(0..slice.len());
 
             match draw(&mut rng, &READ_OPS) {
                 Read::Map => {
@@ -168,7 +169,7 @@ fn update(vec: &ConcurrentVec<String>, final_len: usize, lag: u64) {
         for _ in 0..1000 {
             std::thread::sleep(std::time::Duration::from_micros(lag));
 
-            let idx = rng.gen_range(0..slice.len());
+            let idx = rng.random_range(0..slice.len());
 
             match draw(&mut rng, &UPDATE_OPS) {
                 Update::Update => {

examples/random_actions.rs

@@ -30,15 +30,15 @@ enum ConAction {
 
 impl ConAction {
     fn new(r: &mut ChaCha8Rng, vec_len: usize) -> Self {
-        let idx = |r: &mut ChaCha8Rng| r.gen_range(0..vec_len);
-        let str = |r: &mut ChaCha8Rng| r.gen_range(0..1000).to_string();
+        let idx = |r: &mut ChaCha8Rng| r.random_range(0..vec_len);
+        let str = |r: &mut ChaCha8Rng| r.random_range(0..1000).to_string();
 
         if vec_len == 0 {
-            // to avoid gen_range panicking when vec_len = 0
+            // to avoid random_range panicking when vec_len = 0
             return ConAction::Push(str(r));
         }
 
-        match r.gen_range(0..10) {
+        match r.random_range(0..10) {
             0 => ConAction::Push(str(r)),
             1 => ConAction::Extend((0..64).map(|_| str(r)).collect()),
             2 => ConAction::Map(idx(r)),
@@ -49,7 +49,7 @@ impl ConAction {
             7 => ConAction::IterMapReduce,
             8 => {
                 let i = idx(r);
-                let j = r.gen_range(i..vec_len);
+                let j = r.random_range(i..vec_len);
                 ConAction::IterCloned(i..j)
             }
             9 => ConAction::IterMutate,

examples/updater_reader.rs

@@ -26,7 +26,7 @@ fn run_with_con_vec(len: usize, num_readers: usize, num_updaters: usize, duratio
 
         let instant = Instant::now();
         while instant.elapsed().as_millis() < duration_seconds * 1000 {
-            let i = r.gen_range(1..vec.len());
+            let i = r.random_range(1..vec.len());
             vec[i].set((i as u64 + 1) % 1000);
             num_updates += 1;
         }
@@ -41,7 +41,7 @@ fn run_with_con_vec(len: usize, num_readers: usize, num_updaters: usize, duratio
         let len = vec.len();
         let instant = Instant::now();
         while instant.elapsed().as_millis() < duration_seconds * 1000 {
-            let i = r.gen_range(1..len);
+            let i = r.random_range(1..len);
             let value = vec.get_cloned(i).unwrap();
             assert!(value < len as u64);
 
@@ -102,7 +102,7 @@ fn run_with_arc_mutex_vec(
 
         let instant = Instant::now();
         while instant.elapsed().as_millis() < duration_seconds * 1000 {
-            let i = r.gen_range(1..vec_len);
+            let i = r.random_range(1..vec_len);
             vec.lock().unwrap()[i] = (i as u64 + 1) % 1000;
             num_updates += 1;
         }
@@ -116,7 +116,7 @@ fn run_with_arc_mutex_vec(
         let len = vec.lock().unwrap().len();
         let instant = Instant::now();
         while instant.elapsed().as_millis() < duration_seconds * 1000 {
-            let i = r.gen_range(1..len);
+            let i = r.random_range(1..len);
             let value = vec.lock().unwrap()[i];
             assert!(value < len as u64);