// except according to those terms. extern mod std; <del> use std::oldmap; use std::treemap::TreeMap; use core::hashmap::linear::*; use core::io::WriterUtil; struct Results { sequential_ints: float, random_ints: float, delete_ints: float, sequential_strings: float, random_strings: float, delete_strings: float } fn timed(result: &mut float, op: &fn()) { let start = std::time::precise_time_s(); op(); let end = std::time::precise_time_s(); *result = (end - start); </del> <ins> use core::io; use std::time; use std::treemap::TreeMap; use core::hashmap::linear::{LinearMap, LinearSet}; use core::trie::TrieMap; fn timed(label: &str, f: &fn()) { let start = time::precise_time_s(); f(); let end = time::precise_time_s(); io::println(fmt!("  %s: %f", label, end - start)); </ins> } <del> fn old_int_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) { { let map = oldmap::HashMap(); do timed(&mut results.sequential_ints) { for uint::range(0, num_keys) |i| { map.insert(i, i+1); } </del> <ins> fn ascending<M: Map<uint, uint>>(map: &mut M, n_keys: uint) { io::println(" Ascending integers:"); </ins> <del> for uint::range(0, num_keys) |i| { fail_unless!(map.get(&i) == i+1); } </del> <ins> do timed("insert") { for uint::range(0, n_keys) |i| { map.insert(i, i + 1); </ins> } } <del> { let map = oldmap::HashMap(); do timed(&mut results.random_ints) { for uint::range(0, num_keys) |i| { map.insert(rng.next() as uint, i); } </del> <ins> do timed("search") { for uint::range(0, n_keys) |i| { fail_unless!(map.find(&i).unwrap() == &(i + 1)); </ins> } } <del> { let map = oldmap::HashMap(); for uint::range(0, num_keys) |i| { map.insert(i, i);; } do timed(&mut results.delete_ints) { for uint::range(0, num_keys) |i| { fail_unless!(map.remove(&i)); } </del> <ins> do timed("remove") { for uint::range(0, n_keys) |i| { fail_unless!(map.remove(&i)); </ins> } } } <del> fn old_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) { { let map = oldmap::HashMap(); do timed(&mut results.sequential_strings) { for uint::range(0, num_keys) |i| { let s = uint::to_str(i); map.insert(s, i); } </del> <ins> fn descending<M: Map<uint, uint>>(map: &mut M, n_keys: uint) { io::println(" Descending integers:"); </ins> <del> for uint::range(0, num_keys) |i| { let s = uint::to_str(i); fail_unless!(map.get(&s) == i); } </del> <ins> do timed("insert") { for uint::range(0, n_keys) |i| { map.insert(i, i + 1); </ins> } } <del> { let map = oldmap::HashMap(); do timed(&mut results.random_strings) { for uint::range(0, num_keys) |i| { let s = uint::to_str(rng.next() as uint); map.insert(s, i); } </del> <ins> do timed("search") { for uint::range(0, n_keys) |i| { fail_unless!(map.find(&i).unwrap() == &(i + 1)); </ins> } } <del> { let map = oldmap::HashMap(); for uint::range(0, num_keys) |i| { map.insert(uint::to_str(i), i); } do timed(&mut results.delete_strings) { for uint::range(0, num_keys) |i| { fail_unless!(map.remove(&uint::to_str(i))); } </del> <ins> do timed("remove") { for uint::range(0, n_keys) |i| { fail_unless!(map.remove(&i)); </ins> } } } <del> fn linear_int_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) { { let mut map = LinearMap::new(); do timed(&mut results.sequential_ints) { for uint::range(0, num_keys) |i| { map.insert(i, i+1); } </del> <ins> fn vector<M: Map<uint, uint>>(map: &mut M, n_keys: uint, dist: &[uint]) { </ins> <del> for uint::range(0, num_keys) |i| { fail_unless!(map.find(&i).unwrap() == &(i+1)); } </del> <ins> do timed("insert") { for uint::range(0, n_keys) |i| { map.insert(dist[i], i + 1); </ins> } } <del> { let mut map = LinearMap::new(); do timed(&mut results.random_ints) { for uint::range(0, num_keys) |i| { map.insert(rng.next() as uint, i); } </del> <ins> do timed("search") { for uint::range(0, n_keys) |i| { fail_unless!(map.find(&dist[i]).unwrap() == &(i + 1)); </ins> } } <del> { let mut map = LinearMap::new(); for uint::range(0, num_keys) |i| { map.insert(i, i);; } do timed(&mut results.delete_ints) { for uint::range(0, num_keys) |i| { fail_unless!(map.remove(&i)); } </del> <ins> do timed("remove") { for uint::range(0, n_keys) |i| { fail_unless!(map.remove(&dist[i])); </ins> } } } <del> fn linear_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) { { let mut map = LinearMap::new(); do timed(&mut results.sequential_strings) { for uint::range(0, num_keys) |i| { let s = uint::to_str(i); map.insert(s, i); } for uint::range(0, num_keys) |i| { let s = uint::to_str(i); fail_unless!(map.find(&s).unwrap() == &i); } </del> <ins> fn main() { let args = os::args(); let n_keys = { if args.len() == 2 { uint::from_str(args[1]).get() } else { 1000000 </ins> } <del> } </del> <ins> }; </ins> <del> { let mut map = LinearMap::new(); do timed(&mut results.random_strings) { for uint::range(0, num_keys) |i| { let s = uint::to_str(rng.next() as uint); map.insert(s, i); } } } </del> <ins> let mut rand = vec::with_capacity(n_keys); </ins> { <del> let mut map = LinearMap::new(); for uint::range(0, num_keys) |i| { map.insert(uint::to_str(i), i); } do timed(&mut results.delete_strings) { for uint::range(0, num_keys) |i| { fail_unless!(map.remove(&uint::to_str(i))); </del> <ins> let rng = core::rand::seeded_rng([1, 1, 1, 1, 1, 1, 1]); let mut set = LinearSet::new(); while set.len() != n_keys { let next = rng.next() as uint; if set.insert(next) { rand.push(next); </ins> } } } <del> } fn tree_int_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) { { let mut map = TreeMap::new(); do timed(&mut results.sequential_ints) { for uint::range(0, num_keys) |i| { map.insert(i, i+1); } </del> <ins> io::println(fmt!("%? keys", n_keys)); </ins> <del> for uint::range(0, num_keys) |i| { fail_unless!(map.find(&i).unwrap() == &(i+1)); } } } </del> <ins> io::println("nTreeMap:"); </ins> { <del> let mut map = TreeMap::new(); do timed(&mut results.random_ints) { for uint::range(0, num_keys) |i| { map.insert(rng.next() as uint, i); } } </del> <ins> let mut map = TreeMap::new::<uint, uint>(); ascending(&mut map, n_keys); </ins> } { <del> let mut map = TreeMap::new(); for uint::range(0, num_keys) |i| { map.insert(i, i);; } do timed(&mut results.delete_ints) { for uint::range(0, num_keys) |i| { fail_unless!(map.remove(&i)); } } </del> <ins> let mut map = TreeMap::new::<uint, uint>(); descending(&mut map, n_keys); </ins> } <del> } fn tree_str_benchmarks(rng: @rand::Rng, num_keys: uint, results: &mut Results) { </del> { <del> let mut map = TreeMap::new(); do timed(&mut results.sequential_strings) { for uint::range(0, num_keys) |i| { let s = uint::to_str(i); map.insert(s, i); } for uint::range(0, num_keys) |i| { let s = uint::to_str(i); fail_unless!(map.find(&s).unwrap() == &i); } } </del> <ins> io::println(" Random integers:"); let mut map = TreeMap::new::<uint, uint>(); vector(&mut map, n_keys, rand); </ins> } <ins> io::println("nLinearMap:"); </ins> { <del> let mut map = TreeMap::new(); do timed(&mut results.random_strings) { for uint::range(0, num_keys) |i| { let s = uint::to_str(rng.next() as uint); map.insert(s, i); } } </del> <ins> let mut map = LinearMap::new::<uint, uint>(); ascending(&mut map, n_keys); </ins> } { <del> let mut map = TreeMap::new(); for uint::range(0, num_keys) |i| { map.insert(uint::to_str(i), i); } do timed(&mut results.delete_strings) { for uint::range(0, num_keys) |i| { fail_unless!(map.remove(&uint::to_str(i))); } } </del> <ins> let mut map = LinearMap::new::<uint, uint>(); descending(&mut map, n_keys); </ins> } <del> } fn write_header(header: &str) { io::stdout().write_str(header); io::stdout().write_str("n"); } fn write_row(label: &str, value: float) { io::stdout().write_str(fmt!("%30s %f sn", label, value)); } fn write_results(label: &str, results: &Results) { write_header(label); write_row("sequential_ints", results.sequential_ints); write_row("random_ints", results.random_ints); write_row("delete_ints", results.delete_ints); write_row("sequential_strings", results.sequential_strings); write_row("random_strings", results.random_strings); write_row("delete_strings", results.delete_strings); } fn empty_results() -> Results { Results { sequential_ints: 0f, random_ints: 0f, delete_ints: 0f, sequential_strings: 0f, random_strings: 0f, delete_strings: 0f, </del> <ins> { io::println(" Random integers:"); let mut map = LinearMap::new::<uint, uint>(); vector(&mut map, n_keys, rand); </ins> } <del> } fn main() { let args = os::args(); let num_keys = { if args.len() == 2 { uint::from_str(args[1]).get() } else { 100 // woefully inadequate for any real measurement } }; let seed = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; </del> <ins> io::println("nTrieMap:"); </ins> { <del> let rng = rand::seeded_rng(seed); let mut results = empty_results(); old_int_benchmarks(rng, num_keys, &mut results); old_str_benchmarks(rng, num_keys, &mut results); write_results("std::oldmap::HashMap", &results); </del> <ins> let mut map = TrieMap::new::<uint>(); ascending(&mut map, n_keys); </ins> } { <del> let rng = rand::seeded_rng(seed); let mut results = empty_results(); linear_int_benchmarks(rng, num_keys, &mut results); linear_str_benchmarks(rng, num_keys, &mut results); write_results("core::hashmap::linear::LinearMap", &results); </del> <ins> let mut map = TrieMap::new::<uint>(); descending(&mut map, n_keys); </ins> } { <del> let rng = rand::seeded_rng(seed); let mut results = empty_results(); tree_int_benchmarks(rng, num_keys, &mut results); tree_str_benchmarks(rng, num_keys, &mut results); write_results("std::treemap::TreeMap", &results); </del> <ins> io::println(" Random integers:"); let mut map = TrieMap::new::<uint>(); vector(&mut map, n_keys, rand); </ins> } }