src/libstd/collections/hash/bench.rs

   1 // Copyright 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 #![cfg(test)]
  12
  13 extern crate test;
  14
  15 use self::test::Bencher;
  16
  17 #[bench]
  18 fn new_drop(b: &mut Bencher) {
  19     use super::map::HashMap;
  20
  21     b.iter(|| {
  22         let m: HashMap<i32, i32> = HashMap::new();
  23         assert_eq!(m.len(), 0);
  24     })
  25 }
  26
  27 #[bench]
  28 fn new_insert_drop(b: &mut Bencher) {
  29     use super::map::HashMap;
  30
  31     b.iter(|| {
  32         let mut m = HashMap::new();
  33         m.insert(0, 0);
  34         assert_eq!(m.len(), 1);
  35     })
  36 }
  37
  38 #[bench]
  39 fn grow_by_insertion(b: &mut Bencher) {
  40     use super::map::HashMap;
  41
  42     let mut m = HashMap::new();
  43
  44     for i in 1..1001 {
  45         m.insert(i, i);
  46     }
  47
  48     let mut k = 1001;
  49
  50     b.iter(|| {
  51         m.insert(k, k);
  52         k += 1;
  53     });
  54 }
  55
  56 #[bench]
  57 fn find_existing(b: &mut Bencher) {
  58     use super::map::HashMap;
  59
  60     let mut m = HashMap::new();
  61
  62     for i in 1..1001 {
  63         m.insert(i, i);
  64     }
  65
  66     b.iter(|| {
  67         for i in 1..1001 {
  68             m.contains_key(&i);
  69         }
  70     });
  71 }
  72
  73 #[bench]
  74 fn find_nonexisting(b: &mut Bencher) {
  75     use super::map::HashMap;
  76
  77     let mut m = HashMap::new();
  78
  79     for i in 1..1001 {
  80         m.insert(i, i);
  81     }
  82
  83     b.iter(|| {
  84         for i in 1001..2001 {
  85             m.contains_key(&i);
  86         }
  87     });
  88 }
  89
  90 #[bench]
  91 fn hashmap_as_queue(b: &mut Bencher) {
  92     use super::map::HashMap;
  93
  94     let mut m = HashMap::new();
  95
  96     for i in 1..1001 {
  97         m.insert(i, i);
  98     }
  99
 100     let mut k = 1;
 101
 102     b.iter(|| {
 103         m.remove(&k);
 104         m.insert(k + 1000, k + 1000);
 105         k += 1;
 106     });
 107 }
 108
 109 #[bench]
 110 fn get_remove_insert(b: &mut Bencher) {
 111     use super::map::HashMap;
 112
 113     let mut m = HashMap::new();
 114
 115     for i in 1..1001 {
 116         m.insert(i, i);
 117     }
 118
 119     let mut k = 1;
 120
 121     b.iter(|| {
 122         m.get(&(k + 400));
 123         m.get(&(k + 2000));
 124         m.remove(&k);
 125         m.insert(k + 1000, k + 1000);
 126         k += 1;
 127     })
 128 }