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