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 // ignore-lexer-test FIXME #15679
  12 // Microbenchmarks for various functions in std and extra
  13
  14 #![feature(macro_rules)]
  15 #![feature(unboxed_closures)]
  16
  17 use std::io::File;
  18 use std::iter::repeat;
  19 use std::mem::swap;
  20 use std::os;
  21 use std::rand::Rng;
  22 use std::rand;
  23 use std::str;
  24 use std::time::Duration;
  25 use std::vec;
  26
  27 fn main() {
  28     let argv = os::args();
  29     let _tests = argv.slice(1, argv.len());
  30
  31     macro_rules! bench (
  32         ($id:ident) =>
  33             (maybe_run_test(argv.as_slice(),
  34                             stringify!($id).to_string(),
  35                             $id)));
  36
  37     bench!(shift_push);
  38     bench!(read_line);
  39     bench!(vec_plus);
  40     bench!(vec_append);
  41     bench!(vec_push_all);
  42     bench!(is_utf8_ascii);
  43     bench!(is_utf8_multibyte);
  44 }
  45
  46 fn maybe_run_test<F>(argv: &[String], name: String, test: F) where F: FnOnce() {
  47     let mut run_test = false;
  48
  49     if os::getenv("RUST_BENCH").is_some() {
  50         run_test = true
  51     } else if argv.len() > 0 {
  52         run_test = argv.iter().any(|x| x == &"all".to_string()) || argv.iter().any(|x| x == &name)
  53     }
  54
  55     if !run_test {
  56         return
  57     }
  58
  59     let dur = Duration::span(test);
  60
  61     println!("{}:\t\t{} ms", name, dur.num_milliseconds());
  62 }
  63
  64 fn shift_push() {
  65     let mut v1 = repeat(1i).take(30000).collect::<Vec<_>>();
  66     let mut v2 = Vec::new();
  67
  68     while v1.len() > 0 {
  69         v2.push(v1.remove(0));
  70     }
  71 }
  72
  73 fn read_line() {
  74     use std::io::BufferedReader;
  75
  76     let mut path = Path::new(env!("CFG_SRC_DIR"));
  77     path.push("src/test/bench/shootout-k-nucleotide.data");
  78
  79     for _ in range(0u, 3) {
  80         let mut reader = BufferedReader::new(File::open(&path).unwrap());
  81         for _line in reader.lines() {
  82         }
  83     }
  84 }
  85
  86 fn vec_plus() {
  87     let mut r = rand::thread_rng();
  88
  89     let mut v = Vec::new();
  90     let mut i = 0;
  91     while i < 1500 {
  92         let rv = repeat(i).take(r.gen_range(0u, i + 1)).collect::<Vec<_>>();
  93         if r.gen() {
  94             v.extend(rv.into_iter());
  95         } else {
  96             let mut rv = rv.clone();
  97             rv.push_all(v.as_slice());
  98             v = rv;
  99         }
 100         i += 1;
 101     }
 102 }
 103
 104 fn vec_append() {
 105     let mut r = rand::thread_rng();
 106
 107     let mut v = Vec::new();
 108     let mut i = 0;
 109     while i < 1500 {
 110         let rv = repeat(i).take(r.gen_range(0u, i + 1)).collect::<Vec<_>>();
 111         if r.gen() {
 112             let mut t = v.clone();
 113             t.push_all(rv.as_slice());
 114             v = t;
 115         }
 116         else {
 117             let mut t = rv.clone();
 118             t.push_all(v.as_slice());
 119             v = t;
 120         }
 121         i += 1;
 122     }
 123 }
 124
 125 fn vec_push_all() {
 126     let mut r = rand::thread_rng();
 127
 128     let mut v = Vec::new();
 129     for i in range(0u, 1500) {
 130         let mut rv = repeat(i).take(r.gen_range(0u, i + 1)).collect::<Vec<_>>();
 131         if r.gen() {
 132             v.push_all(rv.as_slice());
 133         }
 134         else {
 135             swap(&mut v, &mut rv);
 136             v.push_all(rv.as_slice());
 137         }
 138     }
 139 }
 140
 141 fn is_utf8_ascii() {
 142     let mut v : Vec<u8> = Vec::new();
 143     for _ in range(0u, 20000) {
 144         v.push('b' as u8);
 145         if str::from_utf8(v.as_slice()).is_err() {
 146             panic!("from_utf8 panicked");
 147         }
 148     }
 149 }
 150
 151 fn is_utf8_multibyte() {
 152     let s = "b¢€𤭢";
 153     let mut v : Vec<u8> = Vec::new();
 154     for _ in range(0u, 5000) {
 155         v.push_all(s.as_bytes());
 156         if str::from_utf8(v.as_slice()).is_err() {
 157             panic!("from_utf8 panicked");
 158         }
 159     }
 160 }