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::mem::swap;
  16 use std::env;
  17 use std::__rand::{thread_rng, Rng};
  18 use std::str;
  19 use std::time::Duration;
  20
  21 fn main() {
  22     let argv: Vec<String> = env::args().collect();
  23
  24     macro_rules! bench {
  25         ($id:ident) =>
  26             (maybe_run_test(&argv,
  27                             stringify!($id).to_string(),
  28                             $id))
  29     }
  30
  31     bench!(shift_push);
  32     bench!(vec_plus);
  33     bench!(vec_append);
  34     bench!(vec_push_all);
  35     bench!(is_utf8_ascii);
  36     bench!(is_utf8_multibyte);
  37 }
  38
  39 fn maybe_run_test<F>(argv: &[String], name: String, test: F) where F: FnOnce() {
  40     let mut run_test = false;
  41
  42     if env::var_os("RUST_BENCH").is_some() {
  43         run_test = true
  44     } else if !argv.is_empty() {
  45         run_test = argv.iter().any(|x| x == &"all".to_string()) || argv.iter().any(|x| x == &name)
  46     }
  47
  48     if !run_test {
  49         return
  50     }
  51
  52     let dur = Duration::span(test);
  53
  54     println!("{}:\t\t{:?}", name, dur);
  55 }
  56
  57 fn shift_push() {
  58     let mut v1 = vec![1; 30000];
  59     let mut v2 = Vec::new();
  60
  61     while !v1.is_empty() {
  62         v2.push(v1.remove(0));
  63     }
  64 }
  65
  66 fn vec_plus() {
  67     let mut r = thread_rng();
  68
  69     let mut v = Vec::new();
  70     let mut i = 0;
  71     while i < 1500 {
  72         let rv = vec![i; r.gen_range(0, i + 1)];
  73         if r.gen() {
  74             v.extend(rv);
  75         } else {
  76             let mut rv = rv.clone();
  77             rv.push_all(&v);
  78             v = rv;
  79         }
  80         i += 1;
  81     }
  82 }
  83
  84 fn vec_append() {
  85     let mut r = thread_rng();
  86
  87     let mut v = Vec::new();
  88     let mut i = 0;
  89     while i < 1500 {
  90         let rv = vec![i; r.gen_range(0, i + 1)];
  91         if r.gen() {
  92             let mut t = v.clone();
  93             t.push_all(&rv);
  94             v = t;
  95         }
  96         else {
  97             let mut t = rv.clone();
  98             t.push_all(&v);
  99             v = t;
 100         }
 101         i += 1;
 102     }
 103 }
 104
 105 fn vec_push_all() {
 106     let mut r = thread_rng();
 107
 108     let mut v = Vec::new();
 109     for i in 0..1500 {
 110         let mut rv = vec![i; r.gen_range(0, i + 1)];
 111         if r.gen() {
 112             v.push_all(&rv);
 113         }
 114         else {
 115             swap(&mut v, &mut rv);
 116             v.push_all(&rv);
 117         }
 118     }
 119 }
 120
 121 fn is_utf8_ascii() {
 122     let mut v : Vec<u8> = Vec::new();
 123     for _ in 0..20000 {
 124         v.push('b' as u8);
 125         if str::from_utf8(&v).is_err() {
 126             panic!("from_utf8 panicked");
 127         }
 128     }
 129 }
 130
 131 fn is_utf8_multibyte() {
 132     let s = "b¢€𤭢";
 133     let mut v : Vec<u8> = Vec::new();
 134     for _ in 0..5000 {
 135         v.push_all(s.as_bytes());
 136         if str::from_utf8(&v).is_err() {
 137             panic!("from_utf8 panicked");
 138         }
 139     }
 140 }