src/test/bench/core-std.rs

   1 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 // Microbenchmarks for various functions in std and extra
  12
  13 #![feature(rand, vec_push_all, duration, duration_span)]
  14
  15 use std::iter::repeat;
  16 use std::mem::swap;
  17 use std::env;
  18 use std::__rand::{thread_rng, Rng};
  19 use std::str;
  20 use std::time::Duration;
  21
  22 fn main() {
  23     let argv: Vec<String> = env::args().collect();
  24
  25     macro_rules! bench {
  26         ($id:ident) =>
  27             (maybe_run_test(&argv,
  28                             stringify!($id).to_string(),
  29                             $id))
  30     }
  31
  32     bench!(shift_push);
  33     bench!(vec_plus);
  34     bench!(vec_append);
  35     bench!(vec_push_all);
  36     bench!(is_utf8_ascii);
  37     bench!(is_utf8_multibyte);
  38 }
  39
  40 fn maybe_run_test<F>(argv: &[String], name: String, test: F) where F: FnOnce() {
  41     let mut run_test = false;
  42
  43     if env::var_os("RUST_BENCH").is_some() {
  44         run_test = true
  45     } else if !argv.is_empty() {
  46         run_test = argv.iter().any(|x| x == &"all".to_string()) || argv.iter().any(|x| x == &name)
  47     }
  48
  49     if !run_test {
  50         return
  51     }
  52
  53     let dur = Duration::span(test);
  54
  55     println!("{}:\t\t{}", name, dur);
  56 }
  57
  58 fn shift_push() {
  59     let mut v1 = repeat(1).take(30000).collect::<Vec<_>>();
  60     let mut v2 = Vec::new();
  61
  62     while !v1.is_empty() {
  63         v2.push(v1.remove(0));
  64     }
  65 }
  66
  67 fn vec_plus() {
  68     let mut r = thread_rng();
  69
  70     let mut v = Vec::new();
  71     let mut i = 0;
  72     while i < 1500 {
  73         let rv = repeat(i).take(r.gen_range(0, i + 1)).collect::<Vec<_>>();
  74         if r.gen() {
  75             v.extend(rv);
  76         } else {
  77             let mut rv = rv.clone();
  78             rv.push_all(&v);
  79             v = rv;
  80         }
  81         i += 1;
  82     }
  83 }
  84
  85 fn vec_append() {
  86     let mut r = thread_rng();
  87
  88     let mut v = Vec::new();
  89     let mut i = 0;
  90     while i < 1500 {
  91         let rv = repeat(i).take(r.gen_range(0, i + 1)).collect::<Vec<_>>();
  92         if r.gen() {
  93             let mut t = v.clone();
  94             t.push_all(&rv);
  95             v = t;
  96         }
  97         else {
  98             let mut t = rv.clone();
  99             t.push_all(&v);
 100             v = t;
 101         }
 102         i += 1;
 103     }
 104 }
 105
 106 fn vec_push_all() {
 107     let mut r = thread_rng();
 108
 109     let mut v = Vec::new();
 110     for i in 0..1500 {
 111         let mut rv = repeat(i).take(r.gen_range(0, i + 1)).collect::<Vec<_>>();
 112         if r.gen() {
 113             v.push_all(&rv);
 114         }
 115         else {
 116             swap(&mut v, &mut rv);
 117             v.push_all(&rv);
 118         }
 119     }
 120 }
 121
 122 fn is_utf8_ascii() {
 123     let mut v : Vec<u8> = Vec::new();
 124     for _ in 0..20000 {
 125         v.push('b' as u8);
 126         if str::from_utf8(&v).is_err() {
 127             panic!("from_utf8 panicked");
 128         }
 129     }
 130 }
 131
 132 fn is_utf8_multibyte() {
 133     let s = "b¢€𤭢";
 134     let mut v : Vec<u8> = Vec::new();
 135     for _ in 0..5000 {
 136         v.push_all(s.as_bytes());
 137         if str::from_utf8(&v).is_err() {
 138             panic!("from_utf8 panicked");
 139         }
 140     }
 141 }