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