fix more benchmark test with black_box

chenyukang · chenyukang · commit 62cfd8a123e2 · 2023-02-21T03:26:40.000Z
diff --git a/library/core/benches/fmt.rs b/library/core/benches/fmt.rs
@@ -1,13 +1,13 @@
 use std::fmt::{self, Write as FmtWrite};
 use std::io::{self, Write as IoWrite};
-use test::Bencher;
+use test::{black_box, Bencher};
 
 #[bench]
 fn write_vec_value(bh: &mut Bencher) {
     bh.iter(|| {
         let mut mem = Vec::new();
         for _ in 0..1000 {
-            mem.write_all("abc".as_bytes()).unwrap();
+            mem.write_all(black_box("abc").as_bytes()).unwrap();
         }
     });
 }
@@ -18,7 +18,7 @@ fn write_vec_ref(bh: &mut Bencher) {
         let mut mem = Vec::new();
         let wr = &mut mem as &mut dyn io::Write;
         for _ in 0..1000 {
-            wr.write_all("abc".as_bytes()).unwrap();
+            wr.write_all(black_box("abc").as_bytes()).unwrap();
         }
     });
 }
@@ -29,7 +29,7 @@ fn write_vec_macro1(bh: &mut Bencher) {
         let mut mem = Vec::new();
         let wr = &mut mem as &mut dyn io::Write;
         for _ in 0..1000 {
-            write!(wr, "abc").unwrap();
+            write!(wr, "{}", black_box("abc")).unwrap();
         }
     });
 }
@@ -40,7 +40,7 @@ fn write_vec_macro2(bh: &mut Bencher) {
         let mut mem = Vec::new();
         let wr = &mut mem as &mut dyn io::Write;
         for _ in 0..1000 {
-            write!(wr, "{}", "abc").unwrap();
+            write!(wr, "{}", black_box("abc")).unwrap();
         }
     });
 }
@@ -51,7 +51,7 @@ fn write_vec_macro_debug(bh: &mut Bencher) {
         let mut mem = Vec::new();
         let wr = &mut mem as &mut dyn io::Write;
         for _ in 0..1000 {
-            write!(wr, "{:?}", "☃").unwrap();
+            write!(wr, "{:?}", black_box("☃")).unwrap();
         }
     });
 }
@@ -61,7 +61,7 @@ fn write_str_value(bh: &mut Bencher) {
     bh.iter(|| {
         let mut mem = String::new();
         for _ in 0..1000 {
-            mem.write_str("abc").unwrap();
+            mem.write_str(black_box("abc")).unwrap();
         }
     });
 }
@@ -72,7 +72,7 @@ fn write_str_ref(bh: &mut Bencher) {
         let mut mem = String::new();
         let wr = &mut mem as &mut dyn fmt::Write;
         for _ in 0..1000 {
-            wr.write_str("abc").unwrap();
+            wr.write_str(black_box("abc")).unwrap();
         }
     });
 }
@@ -82,7 +82,7 @@ fn write_str_macro1(bh: &mut Bencher) {
     bh.iter(|| {
         let mut mem = String::new();
         for _ in 0..1000 {
-            write!(mem, "abc").unwrap();
+            write!(mem, "{}", black_box("abc")).unwrap();
         }
     });
 }
@@ -93,7 +93,7 @@ fn write_str_macro2(bh: &mut Bencher) {
         let mut mem = String::new();
         let wr = &mut mem as &mut dyn fmt::Write;
         for _ in 0..1000 {
-            write!(wr, "{}", "abc").unwrap();
+            write!(wr, "{}", black_box("abc")).unwrap();
         }
     });
 }
@@ -104,7 +104,7 @@ fn write_str_macro_debug(bh: &mut Bencher) {
         let mut mem = String::new();
         let wr = &mut mem as &mut dyn fmt::Write;
         for _ in 0..1000 {
-            write!(wr, "{:?}", "☃").unwrap();
+            write!(wr, "{:?}", black_box("☃")).unwrap();
         }
     });
 }
@@ -115,7 +115,7 @@ fn write_str_macro_debug_ascii(bh: &mut Bencher) {
         let mut mem = String::new();
         let wr = &mut mem as &mut dyn fmt::Write;
         for _ in 0..1000 {
-            write!(wr, "{:?}", "Hello, World!").unwrap();
+            write!(wr, "{:?}", black_box("Hello, World!")).unwrap();
         }
     });
 }
diff --git a/library/core/benches/num/dec2flt/mod.rs b/library/core/benches/num/dec2flt/mod.rs
@@ -1,57 +1,57 @@
-use test::Bencher;
+use test::{black_box, Bencher};
 
 #[bench]
 fn bench_0(b: &mut Bencher) {
-    b.iter(|| "0.0".parse::<f64>());
+    b.iter(|| black_box("0.0").parse::<f64>());
 }
 
 #[bench]
 fn bench_42(b: &mut Bencher) {
-    b.iter(|| "42".parse::<f64>());
+    b.iter(|| black_box("42").parse::<f64>());
 }
 
 #[bench]
 fn bench_huge_int(b: &mut Bencher) {
     // 2^128 - 1
-    b.iter(|| "170141183460469231731687303715884105727".parse::<f64>());
+    b.iter(|| black_box("170141183460469231731687303715884105727").parse::<f64>());
 }
 
 #[bench]
 fn bench_short_decimal(b: &mut Bencher) {
-    b.iter(|| "1234.5678".parse::<f64>());
+    b.iter(|| black_box("1234.5678").parse::<f64>());
 }
 
 #[bench]
 fn bench_pi_long(b: &mut Bencher) {
-    b.iter(|| "3.14159265358979323846264338327950288".parse::<f64>());
+    b.iter(|| black_box("3.14159265358979323846264338327950288").parse::<f64>());
 }
 
 #[bench]
 fn bench_pi_short(b: &mut Bencher) {
-    b.iter(|| "3.141592653589793".parse::<f64>())
+    b.iter(|| black_box("3.141592653589793").parse::<f64>())
 }
 
 #[bench]
 fn bench_1e150(b: &mut Bencher) {
-    b.iter(|| "1e150".parse::<f64>());
+    b.iter(|| black_box("1e150").parse::<f64>());
 }
 
 #[bench]
 fn bench_long_decimal_and_exp(b: &mut Bencher) {
-    b.iter(|| "727501488517303786137132964064381141071e-123".parse::<f64>());
+    b.iter(|| black_box("727501488517303786137132964064381141071e-123").parse::<f64>());
 }
 
 #[bench]
 fn bench_min_subnormal(b: &mut Bencher) {
-    b.iter(|| "5e-324".parse::<f64>());
+    b.iter(|| black_box("5e-324").parse::<f64>());
 }
 
 #[bench]
 fn bench_min_normal(b: &mut Bencher) {
-    b.iter(|| "2.2250738585072014e-308".parse::<f64>());
+    b.iter(|| black_box("2.2250738585072014e-308").parse::<f64>());
 }
 
 #[bench]
 fn bench_max(b: &mut Bencher) {
-    b.iter(|| "1.7976931348623157e308".parse::<f64>());
+    b.iter(|| black_box("1.7976931348623157e308").parse::<f64>());
 }
diff --git a/library/core/benches/num/flt2dec/mod.rs b/library/core/benches/num/flt2dec/mod.rs
@@ -7,7 +7,7 @@ use core::num::flt2dec::MAX_SIG_DIGITS;
 use core::num::flt2dec::{decode, DecodableFloat, Decoded, FullDecoded};
 use std::io::Write;
 use std::vec::Vec;
-use test::Bencher;
+use test::{black_box, Bencher};
 
 pub fn decode_finite<T: DecodableFloat>(v: T) -> Decoded {
     match decode(v).1 {
@@ -22,7 +22,7 @@ fn bench_small_shortest(b: &mut Bencher) {
 
     b.iter(|| {
         buf.clear();
-        write!(&mut buf, "{}", 3.1415926f64).unwrap()
+        write!(black_box(&mut buf), "{}", black_box(3.1415926f64)).unwrap()
     });
 }
 
@@ -32,6 +32,6 @@ fn bench_big_shortest(b: &mut Bencher) {
 
     b.iter(|| {
         buf.clear();
-        write!(&mut buf, "{}", f64::MAX).unwrap()
+        write!(black_box(&mut buf), "{}", black_box(f64::MAX)).unwrap()
     });
 }
diff --git a/library/core/benches/num/mod.rs b/library/core/benches/num/mod.rs
@@ -3,7 +3,7 @@ mod flt2dec;
 mod int_log;
 
 use std::str::FromStr;
-use test::Bencher;
+use test::{black_box, Bencher};
 
 const ASCII_NUMBERS: [&str; 19] = [
     "0",
@@ -36,7 +36,7 @@ macro_rules! from_str_bench {
                     .iter()
                     .cycle()
                     .take(5_000)
-                    .filter_map(|s| <$t>::from_str(s).ok())
+                    .filter_map(|s| <$t>::from_str(black_box(s)).ok())
                     .max()
             })
         }
@@ -52,7 +52,7 @@ macro_rules! from_str_radix_bench {
                     .iter()
                     .cycle()
                     .take(5_000)
-                    .filter_map(|s| <$t>::from_str_radix(s, $radix).ok())
+                    .filter_map(|s| <$t>::from_str_radix(black_box(s), $radix).ok())
                     .max()
             })
         }

Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,13 @@`
`1`	`1`	`use std::fmt::{self, Write as FmtWrite};`
`2`	`2`	`use std::io::{self, Write as IoWrite};`
`3`		`-use test::Bencher;`
	`3`	`+use test::{black_box, Bencher};`
`4`	`4`
`5`	`5`	`#[bench]`
`6`	`6`	`fn write_vec_value(bh: &mut Bencher) {`
`7`	`7`	`bh.iter(\|\| {`
`8`	`8`	`let mut mem = Vec::new();`
`9`	`9`	`for _ in 0..1000 {`
`10`		`- mem.write_all("abc".as_bytes()).unwrap();`
	`10`	`+ mem.write_all(black_box("abc").as_bytes()).unwrap();`
`11`	`11`	`}`
`12`	`12`	`});`
`13`	`13`	`}`
`@@ -18,7 +18,7 @@ fn write_vec_ref(bh: &mut Bencher) {`
`18`	`18`	`let mut mem = Vec::new();`
`19`	`19`	`let wr = &mut mem as &mut dyn io::Write;`
`20`	`20`	`for _ in 0..1000 {`
`21`		`- wr.write_all("abc".as_bytes()).unwrap();`
	`21`	`+ wr.write_all(black_box("abc").as_bytes()).unwrap();`
`22`	`22`	`}`
`23`	`23`	`});`
`24`	`24`	`}`
`@@ -29,7 +29,7 @@ fn write_vec_macro1(bh: &mut Bencher) {`
`29`	`29`	`let mut mem = Vec::new();`
`30`	`30`	`let wr = &mut mem as &mut dyn io::Write;`
`31`	`31`	`for _ in 0..1000 {`
`32`		`- write!(wr, "abc").unwrap();`
	`32`	`+ write!(wr, "{}", black_box("abc")).unwrap();`
`33`	`33`	`}`
`34`	`34`	`});`
`35`	`35`	`}`
`@@ -40,7 +40,7 @@ fn write_vec_macro2(bh: &mut Bencher) {`
`40`	`40`	`let mut mem = Vec::new();`
`41`	`41`	`let wr = &mut mem as &mut dyn io::Write;`
`42`	`42`	`for _ in 0..1000 {`
`43`		`- write!(wr, "{}", "abc").unwrap();`
	`43`	`+ write!(wr, "{}", black_box("abc")).unwrap();`
`44`	`44`	`}`
`45`	`45`	`});`
`46`	`46`	`}`
`@@ -51,7 +51,7 @@ fn write_vec_macro_debug(bh: &mut Bencher) {`
`51`	`51`	`let mut mem = Vec::new();`
`52`	`52`	`let wr = &mut mem as &mut dyn io::Write;`
`53`	`53`	`for _ in 0..1000 {`
`54`		`- write!(wr, "{:?}", "☃").unwrap();`
	`54`	`+ write!(wr, "{:?}", black_box("☃")).unwrap();`
`55`	`55`	`}`
`56`	`56`	`});`
`57`	`57`	`}`
`@@ -61,7 +61,7 @@ fn write_str_value(bh: &mut Bencher) {`
`61`	`61`	`bh.iter(\|\| {`
`62`	`62`	`let mut mem = String::new();`
`63`	`63`	`for _ in 0..1000 {`
`64`		`- mem.write_str("abc").unwrap();`
	`64`	`+ mem.write_str(black_box("abc")).unwrap();`
`65`	`65`	`}`
`66`	`66`	`});`
`67`	`67`	`}`
`@@ -72,7 +72,7 @@ fn write_str_ref(bh: &mut Bencher) {`
`72`	`72`	`let mut mem = String::new();`
`73`	`73`	`let wr = &mut mem as &mut dyn fmt::Write;`
`74`	`74`	`for _ in 0..1000 {`
`75`		`- wr.write_str("abc").unwrap();`
	`75`	`+ wr.write_str(black_box("abc")).unwrap();`
`76`	`76`	`}`
`77`	`77`	`});`
`78`	`78`	`}`
`@@ -82,7 +82,7 @@ fn write_str_macro1(bh: &mut Bencher) {`
`82`	`82`	`bh.iter(\|\| {`
`83`	`83`	`let mut mem = String::new();`
`84`	`84`	`for _ in 0..1000 {`
`85`		`- write!(mem, "abc").unwrap();`
	`85`	`+ write!(mem, "{}", black_box("abc")).unwrap();`
`86`	`86`	`}`
`87`	`87`	`});`
`88`	`88`	`}`
`@@ -93,7 +93,7 @@ fn write_str_macro2(bh: &mut Bencher) {`
`93`	`93`	`let mut mem = String::new();`
`94`	`94`	`let wr = &mut mem as &mut dyn fmt::Write;`
`95`	`95`	`for _ in 0..1000 {`
`96`		`- write!(wr, "{}", "abc").unwrap();`
	`96`	`+ write!(wr, "{}", black_box("abc")).unwrap();`
`97`	`97`	`}`
`98`	`98`	`});`
`99`	`99`	`}`
`@@ -104,7 +104,7 @@ fn write_str_macro_debug(bh: &mut Bencher) {`
`104`	`104`	`let mut mem = String::new();`
`105`	`105`	`let wr = &mut mem as &mut dyn fmt::Write;`
`106`	`106`	`for _ in 0..1000 {`
`107`		`- write!(wr, "{:?}", "☃").unwrap();`
	`107`	`+ write!(wr, "{:?}", black_box("☃")).unwrap();`
`108`	`108`	`}`
`109`	`109`	`});`
`110`	`110`	`}`
`@@ -115,7 +115,7 @@ fn write_str_macro_debug_ascii(bh: &mut Bencher) {`
`115`	`115`	`let mut mem = String::new();`
`116`	`116`	`let wr = &mut mem as &mut dyn fmt::Write;`
`117`	`117`	`for _ in 0..1000 {`
`118`		`- write!(wr, "{:?}", "Hello, World!").unwrap();`
	`118`	`+ write!(wr, "{:?}", black_box("Hello, World!")).unwrap();`
`119`	`119`	`}`
`120`	`120`	`});`
`121`	`121`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,57 +1,57 @@`
`1`		`-use test::Bencher;`
	`1`	`+use test::{black_box, Bencher};`
`2`	`2`
`3`	`3`	`#[bench]`
`4`	`4`	`fn bench_0(b: &mut Bencher) {`
`5`		`- b.iter(\|\| "0.0".parse::<f64>());`
	`5`	`+ b.iter(\|\| black_box("0.0").parse::<f64>());`
`6`	`6`	`}`
`7`	`7`
`8`	`8`	`#[bench]`
`9`	`9`	`fn bench_42(b: &mut Bencher) {`
`10`		`- b.iter(\|\| "42".parse::<f64>());`
	`10`	`+ b.iter(\|\| black_box("42").parse::<f64>());`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`#[bench]`
`14`	`14`	`fn bench_huge_int(b: &mut Bencher) {`
`15`	`15`	`// 2^128 - 1`
`16`		`- b.iter(\|\| "170141183460469231731687303715884105727".parse::<f64>());`
	`16`	`+ b.iter(\|\| black_box("170141183460469231731687303715884105727").parse::<f64>());`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`#[bench]`
`20`	`20`	`fn bench_short_decimal(b: &mut Bencher) {`
`21`		`- b.iter(\|\| "1234.5678".parse::<f64>());`
	`21`	`+ b.iter(\|\| black_box("1234.5678").parse::<f64>());`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`#[bench]`
`25`	`25`	`fn bench_pi_long(b: &mut Bencher) {`
`26`		`- b.iter(\|\| "3.14159265358979323846264338327950288".parse::<f64>());`
	`26`	`+ b.iter(\|\| black_box("3.14159265358979323846264338327950288").parse::<f64>());`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`#[bench]`
`30`	`30`	`fn bench_pi_short(b: &mut Bencher) {`
`31`		`- b.iter(\|\| "3.141592653589793".parse::<f64>())`
	`31`	`+ b.iter(\|\| black_box("3.141592653589793").parse::<f64>())`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`#[bench]`
`35`	`35`	`fn bench_1e150(b: &mut Bencher) {`
`36`		`- b.iter(\|\| "1e150".parse::<f64>());`
	`36`	`+ b.iter(\|\| black_box("1e150").parse::<f64>());`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`#[bench]`
`40`	`40`	`fn bench_long_decimal_and_exp(b: &mut Bencher) {`
`41`		`- b.iter(\|\| "727501488517303786137132964064381141071e-123".parse::<f64>());`
	`41`	`+ b.iter(\|\| black_box("727501488517303786137132964064381141071e-123").parse::<f64>());`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`#[bench]`
`45`	`45`	`fn bench_min_subnormal(b: &mut Bencher) {`
`46`		`- b.iter(\|\| "5e-324".parse::<f64>());`
	`46`	`+ b.iter(\|\| black_box("5e-324").parse::<f64>());`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`#[bench]`
`50`	`50`	`fn bench_min_normal(b: &mut Bencher) {`
`51`		`- b.iter(\|\| "2.2250738585072014e-308".parse::<f64>());`
	`51`	`+ b.iter(\|\| black_box("2.2250738585072014e-308").parse::<f64>());`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`#[bench]`
`55`	`55`	`fn bench_max(b: &mut Bencher) {`
`56`		`- b.iter(\|\| "1.7976931348623157e308".parse::<f64>());`
	`56`	`+ b.iter(\|\| black_box("1.7976931348623157e308").parse::<f64>());`
`57`	`57`	`}`