Use std::hint::black_box in benchmarks, upgrade rand usage

Author: mgeier

benches/single_thread_single_byte.rs

@@ -3,7 +3,9 @@
 //! This is *not* a typical use case but it should nevertheless be useful
 //! for comparing the overhead of different methods.
 
-use criterion::{black_box, criterion_group, criterion_main};
+use std::hint::black_box;
+
+use criterion::{criterion_group, criterion_main};
 use criterion::{AxisScale, PlotConfiguration};
 
 use rtrb::RingBuffer;
@@ -15,6 +17,7 @@ where
 {
     group.bench_function(id, |b| {
         let mut i = 0;
+        #[allow(clippy::incompatible_msrv)]
         b.iter(|| {
             assert_eq!(f(black_box(i)), black_box(i));
             i = i.wrapping_add(1);

benches/single_thread_two_bytes.rs

@@ -5,9 +5,10 @@
 //! Writing two elements to a three-element queue makes sure
 //! that there is a ring buffer wrap-around every second time.
 
+use std::hint::black_box;
 use std::io::{Read, Write};
 
-use criterion::{black_box, criterion_group, criterion_main};
+use criterion::{criterion_group, criterion_main};
 use criterion::{AxisScale, PlotConfiguration};
 
 use rtrb::{CopyToUninit, RingBuffer};
@@ -19,6 +20,7 @@ where
 {
     group.bench_function(id, |b| {
         let mut i: u8 = 0;
+        #[allow(clippy::incompatible_msrv)]
         b.iter_batched(
             || {
                 let mut data = [i, 0];

benches/single_thread_with_chunks.rs

@@ -2,9 +2,10 @@
 //!
 //! Single-threaded usage is *not* a typical use case!
 
+use std::hint::black_box;
 use std::io::{Read, Write};
 
-use criterion::{black_box, criterion_group, criterion_main};
+use criterion::{criterion_group, criterion_main};
 use criterion::{AxisScale, PlotConfiguration};
 
 use rtrb::{CopyToUninit, RingBuffer};
@@ -16,6 +17,7 @@ where
     F: FnMut(&[u8]) -> [u8; CHUNK_SIZE],
     M: criterion::measurement::Measurement,
 {
+    #[allow(clippy::incompatible_msrv)]
     group.bench_function(id, |b| {
         let mut data = [0; CHUNK_SIZE];
         let mut i: u8 = 0;

benches/two_threads.rs

@@ -2,9 +2,10 @@ macro_rules! create_two_threads_benchmark {
     ($($id:literal, $create:expr, $push:expr, $pop:expr,::)+) => {
 
 use std::convert::TryInto as _;
+use std::hint::black_box;
 use std::sync::{Arc, Barrier};
 
-use criterion::{black_box, criterion_group, criterion_main};
+use criterion::{criterion_group, criterion_main};
 
 fn help_with_type_inference<P, C, Create, Push, Pop>(create: Create, push: Push, pop: Pop) -> (Create, Push, Pop)
 where
@@ -69,6 +70,7 @@ $(
             barrier.wait();
             let start_popping = std::time::Instant::now();
             for _ in 0..iters {
+                #[allow(clippy::incompatible_msrv)]
                 black_box(pop(&mut c));
             }
             let stop_popping = std::time::Instant::now();

tests/lib.rs

@@ -68,7 +68,7 @@ fn parallel() {
 
 #[test]
 fn drops() {
-    use rand::{thread_rng, Rng};
+    use rand::prelude::*;
     use std::sync::atomic::{AtomicUsize, Ordering};
 
     const RUNS: usize = if cfg!(miri) { 10 } else { 100 };
@@ -84,11 +84,11 @@ fn drops() {
         }
     }
 
-    let mut rng = thread_rng();
+    let mut rng = rand::rng();
 
     for _ in 0..RUNS {
-        let steps = rng.gen_range(0..if cfg!(miri) { 100 } else { 10_000 });
-        let additional = rng.gen_range(0..50);
+        let steps = rng.random_range(0..if cfg!(miri) { 100 } else { 10_000 });
+        let additional = rng.random_range(0..50);
 
         DROPS.store(0, Ordering::SeqCst);
         let (mut p, mut c) = RingBuffer::new(50);