library/core/benches/fmt.rs

   1 use std::fmt::{self, Write as FmtWrite};
   2 use std::io::{self, Write as IoWrite};
   3 use test::Bencher;
   4
   5 #[bench]
   6 fn write_vec_value(bh: &mut Bencher) {
   7     bh.iter(|| {
   8         let mut mem = Vec::new();
   9         for _ in 0..1000 {
  10             mem.write_all("abc".as_bytes()).unwrap();
  11         }
  12     });
  13 }
  14
  15 #[bench]
  16 fn write_vec_ref(bh: &mut Bencher) {
  17     bh.iter(|| {
  18         let mut mem = Vec::new();
  19         let wr = &mut mem as &mut dyn io::Write;
  20         for _ in 0..1000 {
  21             wr.write_all("abc".as_bytes()).unwrap();
  22         }
  23     });
  24 }
  25
  26 #[bench]
  27 fn write_vec_macro1(bh: &mut Bencher) {
  28     bh.iter(|| {
  29         let mut mem = Vec::new();
  30         let wr = &mut mem as &mut dyn io::Write;
  31         for _ in 0..1000 {
  32             write!(wr, "abc").unwrap();
  33         }
  34     });
  35 }
  36
  37 #[bench]
  38 fn write_vec_macro2(bh: &mut Bencher) {
  39     bh.iter(|| {
  40         let mut mem = Vec::new();
  41         let wr = &mut mem as &mut dyn io::Write;
  42         for _ in 0..1000 {
  43             write!(wr, "{}", "abc").unwrap();
  44         }
  45     });
  46 }
  47
  48 #[bench]
  49 fn write_vec_macro_debug(bh: &mut Bencher) {
  50     bh.iter(|| {
  51         let mut mem = Vec::new();
  52         let wr = &mut mem as &mut dyn io::Write;
  53         for _ in 0..1000 {
  54             write!(wr, "{:?}", "☃").unwrap();
  55         }
  56     });
  57 }
  58
  59 #[bench]
  60 fn write_str_value(bh: &mut Bencher) {
  61     bh.iter(|| {
  62         let mut mem = String::new();
  63         for _ in 0..1000 {
  64             mem.write_str("abc").unwrap();
  65         }
  66     });
  67 }
  68
  69 #[bench]
  70 fn write_str_ref(bh: &mut Bencher) {
  71     bh.iter(|| {
  72         let mut mem = String::new();
  73         let wr = &mut mem as &mut dyn fmt::Write;
  74         for _ in 0..1000 {
  75             wr.write_str("abc").unwrap();
  76         }
  77     });
  78 }
  79
  80 #[bench]
  81 fn write_str_macro1(bh: &mut Bencher) {
  82     bh.iter(|| {
  83         let mut mem = String::new();
  84         for _ in 0..1000 {
  85             write!(mem, "abc").unwrap();
  86         }
  87     });
  88 }
  89
  90 #[bench]
  91 fn write_str_macro2(bh: &mut Bencher) {
  92     bh.iter(|| {
  93         let mut mem = String::new();
  94         let wr = &mut mem as &mut dyn fmt::Write;
  95         for _ in 0..1000 {
  96             write!(wr, "{}", "abc").unwrap();
  97         }
  98     });
  99 }
 100
 101 #[bench]
 102 fn write_str_macro_debug(bh: &mut Bencher) {
 103     bh.iter(|| {
 104         let mut mem = String::new();
 105         let wr = &mut mem as &mut dyn fmt::Write;
 106         for _ in 0..1000 {
 107             write!(wr, "{:?}", "☃").unwrap();
 108         }
 109     });
 110 }
 111
 112 #[bench]
 113 fn write_u128_max(bh: &mut Bencher) {
 114     bh.iter(|| {
 115         std::hint::black_box(format!("{}", u128::MAX));
 116     });
 117 }
 118
 119 #[bench]
 120 fn write_u128_min(bh: &mut Bencher) {
 121     bh.iter(|| {
 122         let s = format!("{}", 0u128);
 123         std::hint::black_box(s);
 124     });
 125 }
 126
 127 #[bench]
 128 fn write_u64_max(bh: &mut Bencher) {
 129     bh.iter(|| {
 130         std::hint::black_box(format!("{}", u64::MAX));
 131     });
 132 }
 133
 134 #[bench]
 135 fn write_u64_min(bh: &mut Bencher) {
 136     bh.iter(|| {
 137         std::hint::black_box(format!("{}", 0u64));
 138     });
 139 }