src/libcollectionstest/bench.rs

   1 // Copyright 2013-2014 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 macro_rules! map_insert_rand_bench {
  12     ($name: ident, $n: expr, $map: ident) => (
  13         #[bench]
  14         pub fn $name(b: &mut ::test::Bencher) {
  15             use std::__rand::{thread_rng, Rng};
  16             use test::black_box;
  17
  18             let n: usize = $n;
  19             let mut map = $map::new();
  20             // setup
  21             let mut rng = thread_rng();
  22
  23             for _ in 0..n {
  24                 let i = rng.gen::<usize>() % n;
  25                 map.insert(i, i);
  26             }
  27
  28             // measure
  29             b.iter(|| {
  30                 let k = rng.gen::<usize>() % n;
  31                 map.insert(k, k);
  32                 map.remove(&k);
  33             });
  34             black_box(map);
  35         }
  36     )
  37 }
  38
  39 macro_rules! map_insert_seq_bench {
  40     ($name: ident, $n: expr, $map: ident) => (
  41         #[bench]
  42         pub fn $name(b: &mut ::test::Bencher) {
  43             use test::black_box;
  44
  45             let mut map = $map::new();
  46             let n: usize = $n;
  47             // setup
  48             for i in 0..n {
  49                 map.insert(i * 2, i * 2);
  50             }
  51
  52             // measure
  53             let mut i = 1;
  54             b.iter(|| {
  55                 map.insert(i, i);
  56                 map.remove(&i);
  57                 i = (i + 2) % n;
  58             });
  59             black_box(map);
  60         }
  61     )
  62 }
  63
  64 macro_rules! map_find_rand_bench {
  65     ($name: ident, $n: expr, $map: ident) => (
  66         #[bench]
  67         pub fn $name(b: &mut ::test::Bencher) {
  68             use std::iter::Iterator;
  69             use std::__rand::{thread_rng, Rng};
  70             use std::vec::Vec;
  71             use test::black_box;
  72
  73             let mut map = $map::new();
  74             let n: usize = $n;
  75
  76             // setup
  77             let mut rng = thread_rng();
  78             let mut keys: Vec<_> = (0..n).map(|_| rng.gen::<usize>() % n).collect();
  79
  80             for &k in &keys {
  81                 map.insert(k, k);
  82             }
  83
  84             rng.shuffle(&mut keys);
  85
  86             // measure
  87             let mut i = 0;
  88             b.iter(|| {
  89                 let t = map.get(&keys[i]);
  90                 i = (i + 1) % n;
  91                 black_box(t);
  92             })
  93         }
  94     )
  95 }
  96
  97 macro_rules! map_find_seq_bench {
  98     ($name: ident, $n: expr, $map: ident) => (
  99         #[bench]
 100         pub fn $name(b: &mut ::test::Bencher) {
 101             use test::black_box;
 102
 103             let mut map = $map::new();
 104             let n: usize = $n;
 105
 106             // setup
 107             for i in 0..n {
 108                 map.insert(i, i);
 109             }
 110
 111             // measure
 112             let mut i = 0;
 113             b.iter(|| {
 114                 let x = map.get(&i);
 115                 i = (i + 1) % n;
 116                 black_box(x);
 117             })
 118         }
 119     )
 120 }