#[cfg(test)]
mod bench {
- use test::Bencher;
+ use std::prelude::*;
+ use std::rand::{weak_rng, Rng};
+ use test::{Bencher, black_box};
use super::BTreeMap;
+ use MutableMap;
use deque::bench::{insert_rand_n, insert_seq_n, find_rand_n, find_seq_n};
#[bench]
let mut m : BTreeMap<uint,uint> = BTreeMap::new();
find_seq_n(10_000, &mut m, b);
}
+
+ fn bench_iter(b: &mut Bencher, size: uint) {
+ let mut map = BTreeMap::<uint, uint>::new();
+ let mut rng = weak_rng();
+
+ for _ in range(0, size) {
+ map.swap(rng.gen(), rng.gen());
+ }
+
+ b.iter(|| {
+ for entry in map.iter() {
+ black_box(entry);
+ }
+ });
+ }
+
+ #[bench]
+ pub fn iter_20(b: &mut Bencher) {
+ bench_iter(b, 20);
+ }
+
+ #[bench]
+ pub fn iter_1000(b: &mut Bencher) {
+ bench_iter(b, 1000);
+ }
+
+ #[bench]
+ pub fn iter_100000(b: &mut Bencher) {
+ bench_iter(b, 100000);
+ }
}
#[cfg(test)]
mod bench {
- use test::Bencher;
+ use std::prelude::*;
+ use std::rand::{weak_rng, Rng};
+ use test::{Bencher, black_box};
use super::TreeMap;
+ use MutableMap;
use deque::bench::{insert_rand_n, insert_seq_n, find_rand_n, find_seq_n};
// Find seq
let mut m : TreeMap<uint,uint> = TreeMap::new();
find_seq_n(10_000, &mut m, b);
}
+
+ fn bench_iter(b: &mut Bencher, size: uint) {
+ let mut map = TreeMap::<uint, uint>::new();
+ let mut rng = weak_rng();
+
+ for _ in range(0, size) {
+ map.swap(rng.gen(), rng.gen());
+ }
+
+ b.iter(|| {
+ for entry in map.iter() {
+ black_box(entry);
+ }
+ });
+ }
+
+ #[bench]
+ pub fn iter_20(b: &mut Bencher) {
+ bench_iter(b, 20);
+ }
+
+ #[bench]
+ pub fn iter_1000(b: &mut Bencher) {
+ bench_iter(b, 1000);
+ }
+
+ #[bench]
+ pub fn iter_100000(b: &mut Bencher) {
+ bench_iter(b, 100000);
+ }
}
#[cfg(test)]
// rules, and are just manipulating raw pointers like there's no
// such thing as invalid pointers and memory unsafety. The
// reason is performance, without doing this we can get the
- // bench_iter_large microbenchmark down to about 30000 ns/iter
- // (using .unsafe_get to index self.stack directly, 38000
+ // (now replaced) bench_iter_large microbenchmark down to about
+ // 30000 ns/iter (using .unsafe_get to index self.stack directly, 38000
// ns/iter with [] checked indexing), but this smashes that down
// to 13500 ns/iter.
//
mod bench_map {
use std::prelude::*;
use std::rand::{weak_rng, Rng};
- use test::Bencher;
+ use test::{Bencher, black_box};
use MutableMap;
use super::TrieMap;
- #[bench]
- fn bench_iter_small(b: &mut Bencher) {
- let mut m = TrieMap::<uint>::new();
+ fn bench_iter(b: &mut Bencher, size: uint) {
+ let mut map = TrieMap::<uint>::new();
let mut rng = weak_rng();
- for _ in range(0u, 20) {
- m.insert(rng.gen(), rng.gen());
+
+ for _ in range(0, size) {
+ map.swap(rng.gen(), rng.gen());
}
- b.iter(|| for _ in m.iter() {})
+ b.iter(|| {
+ for entry in map.iter() {
+ black_box(entry);
+ }
+ });
}
#[bench]
- fn bench_iter_large(b: &mut Bencher) {
- let mut m = TrieMap::<uint>::new();
- let mut rng = weak_rng();
- for _ in range(0u, 1000) {
- m.insert(rng.gen(), rng.gen());
- }
+ pub fn iter_20(b: &mut Bencher) {
+ bench_iter(b, 20);
+ }
- b.iter(|| for _ in m.iter() {})
+ #[bench]
+ pub fn iter_1000(b: &mut Bencher) {
+ bench_iter(b, 1000);
+ }
+
+ #[bench]
+ pub fn iter_100000(b: &mut Bencher) {
+ bench_iter(b, 100000);
}
#[bench]