Use once_cell in rayon-demo

Author: cuviper

ci/compat-Cargo.lock

@@ -12,7 +12,7 @@ cgmath = "0.18"
 docopt = "1"
 fixedbitset = "0.4"
 glium = "0.32"
-lazy_static = "1"
+once_cell = "1.17.1"
 rand = "0.8"
 rand_xorshift = "0.3"
 regex = "1"

rayon-demo/Cargo.toml

@@ -3,24 +3,23 @@
 macro_rules! make_tests {
     ($n:expr, $m:ident) => {
         mod $m {
+            use once_cell::sync::Lazy;
             use rand::distributions::Standard;
             use rand::Rng;
             use rayon::prelude::*;
             use test::Bencher;
 
-            lazy_static::lazy_static! {
-                static ref HAYSTACK: Vec<[u32; $n]> = {
-                    let rng = crate::seeded_rng();
-                    rng.sample_iter(&Standard)
-                        .map(|x| {
-                            let mut result: [u32; $n] = [0; $n];
-                            result[0] = x;
-                            result
-                        })
-                        .take(10_000_000)
-                        .collect()
-                };
-            }
+            static HAYSTACK: Lazy<Box<[[u32; $n]]>> = Lazy::new(|| {
+                let rng = crate::seeded_rng();
+                rng.sample_iter(&Standard)
+                    .map(|x| {
+                        let mut result: [u32; $n] = [0; $n];
+                        result[0] = x;
+                        result
+                    })
+                    .take(10_000_000)
+                    .collect()
+            });
 
             #[bench]
             fn parallel_find_first(b: &mut Bencher) {

rayon-demo/src/find/mod.rs

@@ -1,18 +1,18 @@
 //! Some microbenchmarks for splitting strings
 
+use once_cell::sync::Lazy;
 use rand::seq::SliceRandom;
 use rayon::prelude::*;
 use test::Bencher;
 
-lazy_static::lazy_static! {
-    static ref HAYSTACK: String = {
-        let mut rng = crate::seeded_rng();
-        let mut bytes: Vec<u8> = "abcdefg ".bytes().cycle().take(1_000_000).collect();
-        bytes.shuffle(&mut rng);
-        String::from_utf8(bytes).unwrap()
-    };
-    static ref COUNT: usize = HAYSTACK.split(' ').count();
-}
+static HAYSTACK: Lazy<String> = Lazy::new(|| {
+    let mut rng = crate::seeded_rng();
+    let mut bytes: Vec<u8> = "abcdefg ".bytes().cycle().take(1_000_000).collect();
+    bytes.shuffle(&mut rng);
+    String::from_utf8(bytes).unwrap()
+});
+
+static COUNT: Lazy<usize> = Lazy::new(|| HAYSTACK.split(' ').count());
 
 // Try multiple kinds of whitespace, but HAYSTACK only contains plain spaces.
 const WHITESPACE: &[char] = &['\r', '\n', ' ', '\t'];

rayon-demo/src/str_split.rs

@@ -1,3 +1,4 @@
+use once_cell::sync::Lazy;
 use regex::Regex;
 use std::collections::HashMap;
 use std::str::{FromStr, Lines};
@@ -23,13 +24,9 @@ use super::weight::Weight;
 // NODE_COORD_SECTION
 // 1 11003.611100 42102.500000
 
-lazy_static::lazy_static! {
-    static ref HEADER: Regex = Regex::new(r"([A-Z_]+)\s*:(.*)").unwrap();
-}
+static HEADER: Lazy<Regex> = Lazy::new(|| Regex::new(r"([A-Z_]+)\s*:(.*)").unwrap());
 
-lazy_static::lazy_static! {
-    static ref COORD: Regex = Regex::new(r"([0-9]+) ([0-9.]+) ([0-9.]+)").unwrap();
-}
+static COORD: Lazy<Regex> = Lazy::new(|| Regex::new(r"([0-9]+) ([0-9.]+) ([0-9.]+)").unwrap());
 
 pub fn parse_tsp_data(text: &str) -> Result<Graph, String> {
     let mut data = Data::new(text);