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(macro_rules)]
  14
  15 extern crate rand;
  16 extern crate time;
  17
  18 use time::precise_time_s;
  19 use rand::Rng;
  20 use std::mem::swap;
  21 use std::os;
  22 use std::str;
  23 use std::vec;
  24 use std::io::File;
  25
  26 macro_rules! bench (
  27     ($argv:expr, $id:ident) => (maybe_run_test($argv, stringify!($id).to_owned(), $id))
  28 )
  29
  30 fn main() {
  31     let argv = os::args();
  32     let _tests = argv.slice(1, argv.len());
  33
  34     bench!(argv, shift_push);
  35     bench!(argv, read_line);
  36     bench!(argv, vec_plus);
  37     bench!(argv, vec_append);
  38     bench!(argv, vec_push_all);
  39     bench!(argv, is_utf8_ascii);
  40     bench!(argv, is_utf8_multibyte);
  41 }
  42
  43 fn maybe_run_test(argv: &[~str], name: ~str, test: ||) {
  44     let mut run_test = false;
  45
  46     if os::getenv("RUST_BENCH").is_some() {
  47         run_test = true
  48     } else if argv.len() > 0 {
  49         run_test = argv.iter().any(|x| x == &~"all") || argv.iter().any(|x| x == &name)
  50     }
  51
  52     if !run_test {
  53         return
  54     }
  55
  56     let start = precise_time_s();
  57     test();
  58     let stop = precise_time_s();
  59
  60     println!("{}:\t\t{} ms", name, (stop - start) * 1000.0);
  61 }
  62
  63 fn shift_push() {
  64     let mut v1 = Vec::from_elem(30000, 1);
  65     let mut v2 = Vec::new();
  66
  67     while v1.len() > 0 {
  68         v2.push(v1.shift().unwrap());
  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(0, 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::task_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.push_all_move(rv);
  94         } else {
  95             v = rv.clone().append(v.as_slice());
  96         }
  97         i += 1;
  98     }
  99 }
 100
 101 fn vec_append() {
 102     let mut r = rand::task_rng();
 103
 104     let mut v = Vec::new();
 105     let mut i = 0;
 106     while i < 1500 {
 107         let rv = Vec::from_elem(r.gen_range(0u, i + 1), i);
 108         if r.gen() {
 109             v = v.clone().append(rv.as_slice());
 110         }
 111         else {
 112             v = rv.clone().append(v.as_slice());
 113         }
 114         i += 1;
 115     }
 116 }
 117
 118 fn vec_push_all() {
 119     let mut r = rand::task_rng();
 120
 121     let mut v = Vec::new();
 122     for i in range(0u, 1500) {
 123         let mut rv = Vec::from_elem(r.gen_range(0u, i + 1), i);
 124         if r.gen() {
 125             v.push_all(rv.as_slice());
 126         }
 127         else {
 128             swap(&mut v, &mut rv);
 129             v.push_all(rv.as_slice());
 130         }
 131     }
 132 }
 133
 134 fn is_utf8_ascii() {
 135     let mut v : Vec<u8> = Vec::new();
 136     for _ in range(0u, 20000) {
 137         v.push('b' as u8);
 138         if !str::is_utf8(v.as_slice()) {
 139             fail!("is_utf8 failed");
 140         }
 141     }
 142 }
 143
 144 fn is_utf8_multibyte() {
 145     let s = "b¢€𤭢";
 146     let mut v : Vec<u8> = Vec::new();
 147     for _ in range(0u, 5000) {
 148         v.push_all(s.as_bytes());
 149         if !str::is_utf8(v.as_slice()) {
 150             fail!("is_utf8 failed");
 151         }
 152     }
 153 }