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_str_macro_debug_ascii(bh: &mut Bencher) {
 114     bh.iter(|| {
 115         let mut mem = String::new();
 116         let wr = &mut mem as &mut dyn fmt::Write;
 117         for _ in 0..1000 {
 118             write!(wr, "{:?}", "Hello, World!").unwrap();
 119         }
 120     });
 121 }
 122
 123 #[bench]
 124 fn write_u128_max(bh: &mut Bencher) {
 125     bh.iter(|| {
 126         test::black_box(format!("{}", u128::MAX));
 127     });
 128 }
 129
 130 #[bench]
 131 fn write_u128_min(bh: &mut Bencher) {
 132     bh.iter(|| {
 133         let s = format!("{}", 0u128);
 134         test::black_box(s);
 135     });
 136 }
 137
 138 #[bench]
 139 fn write_u64_max(bh: &mut Bencher) {
 140     bh.iter(|| {
 141         test::black_box(format!("{}", u64::MAX));
 142     });
 143 }
 144
 145 #[bench]
 146 fn write_u64_min(bh: &mut Bencher) {
 147     bh.iter(|| {
 148         test::black_box(format!("{}", 0u64));
 149     });
 150 }