vendor/ordermap/benches/faststring.rs

   1 #![feature(test)]
   2 extern crate test;
   3 extern crate rand;
   4 extern crate lazy_static;
   5
   6 use test::Bencher;
   7
   8 extern crate ordermap;
   9
  10 use ordermap::OrderMap;
  11
  12 use std::collections::HashMap;
  13 use std::iter::FromIterator;
  14
  15 use rand::{weak_rng, Rng};
  16
  17 use std::hash::{Hash, Hasher};
  18
  19 use std::borrow::Borrow;
  20 use std::ops::Deref;
  21 use std::mem;
  22
  23 #[derive(PartialEq, Eq, Copy, Clone)]
  24 pub struct OneShot<T: ?Sized>(pub T);
  25
  26 impl Hash for OneShot<str>
  27 {
  28     fn hash<H: Hasher>(&self, h: &mut H) {
  29         h.write(self.0.as_bytes())
  30     }
  31 }
  32
  33 impl<'a, S> From<&'a S> for &'a OneShot<str>
  34     where S: AsRef<str>
  35 {
  36     fn from(s: &'a S) -> Self {
  37         let s: &str = s.as_ref();
  38         unsafe {
  39             mem::transmute(s)
  40         }
  41     }
  42 }
  43
  44 impl Hash for OneShot<String>
  45 {
  46     fn hash<H: Hasher>(&self, h: &mut H) {
  47         h.write(self.0.as_bytes())
  48     }
  49 }
  50
  51 impl Borrow<OneShot<str>> for OneShot<String>
  52 {
  53     fn borrow(&self) -> &OneShot<str> {
  54         <&OneShot<str>>::from(&self.0)
  55     }
  56 }
  57
  58 impl<T> Deref for OneShot<T>
  59 {
  60     type Target = T;
  61     fn deref(&self) -> &T {
  62         &self.0
  63     }
  64 }
  65
  66
  67 fn shuffled_keys<I>(iter: I) -> Vec<I::Item>
  68     where I: IntoIterator
  69 {
  70     let mut v = Vec::from_iter(iter);
  71     let mut rng = weak_rng();
  72     rng.shuffle(&mut v);
  73     v
  74 }
  75
  76
  77 #[bench]
  78 fn insert_hashmap_string_10_000(b: &mut Bencher) {
  79     let c = 10_000;
  80     b.iter(|| {
  81         let mut map = HashMap::with_capacity(c);
  82         for x in 0..c {
  83             map.insert(x.to_string(), ());
  84         }
  85         map
  86     });
  87 }
  88
  89 #[bench]
  90 fn insert_hashmap_string_oneshot_10_000(b: &mut Bencher) {
  91     let c = 10_000;
  92     b.iter(|| {
  93         let mut map = HashMap::with_capacity(c);
  94         for x in 0..c {
  95             map.insert(OneShot(x.to_string()), ());
  96         }
  97         map
  98     });
  99 }
 100
 101 #[bench]
 102 fn insert_orderedmap_string_10_000(b: &mut Bencher) {
 103     let c = 10_000;
 104     b.iter(|| {
 105         let mut map = OrderMap::with_capacity(c);
 106         for x in 0..c {
 107             map.insert(x.to_string(), ());
 108         }
 109         map
 110     });
 111 }
 112
 113 #[bench]
 114 fn lookup_hashmap_10_000_exist_string(b: &mut Bencher) {
 115     let c = 10_000;
 116     let mut map = HashMap::with_capacity(c);
 117     let keys = shuffled_keys(0..c);
 118     for &key in &keys {
 119         map.insert(key.to_string(), 1);
 120     }
 121     let lookups = (5000..c).map(|x| x.to_string()).collect::<Vec<_>>();
 122     b.iter(|| {
 123         let mut found = 0;
 124         for key in &lookups {
 125             found += map.get(key).is_some() as i32;
 126         }
 127         found
 128     });
 129 }
 130
 131 #[bench]
 132 fn lookup_hashmap_10_000_exist_string_oneshot(b: &mut Bencher) {
 133     let c = 10_000;
 134     let mut map = HashMap::with_capacity(c);
 135     let keys = shuffled_keys(0..c);
 136     for &key in &keys {
 137         map.insert(OneShot(key.to_string()), 1);
 138     }
 139     let lookups = (5000..c).map(|x| OneShot(x.to_string())).collect::<Vec<_>>();
 140     b.iter(|| {
 141         let mut found = 0;
 142         for key in &lookups {
 143             found += map.get(key).is_some() as i32;
 144         }
 145         found
 146     });
 147 }
 148
 149 #[bench]
 150 fn lookup_ordermap_10_000_exist_string(b: &mut Bencher) {
 151     let c = 10_000;
 152     let mut map = OrderMap::with_capacity(c);
 153     let keys = shuffled_keys(0..c);
 154     for &key in &keys {
 155         map.insert(key.to_string(), 1);
 156     }
 157     let lookups = (5000..c).map(|x| x.to_string()).collect::<Vec<_>>();
 158     b.iter(|| {
 159         let mut found = 0;
 160         for key in &lookups {
 161             found += map.get(key).is_some() as i32;
 162         }
 163         found
 164     });
 165 }
 166
 167 #[bench]
 168 fn lookup_ordermap_10_000_exist_string_oneshot(b: &mut Bencher) {
 169     let c = 10_000;
 170     let mut map = OrderMap::with_capacity(c);
 171     let keys = shuffled_keys(0..c);
 172     for &key in &keys {
 173         map.insert(OneShot(key.to_string()), 1);
 174     }
 175     let lookups = (5000..c).map(|x| OneShot(x.to_string())).collect::<Vec<_>>();
 176     b.iter(|| {
 177         let mut found = 0;
 178         for key in &lookups {
 179             found += map.get(key).is_some() as i32;
 180         }
 181         found
 182     });
 183 }