collections: flesh out Vec benchmarks
This commit is contained in:
Erick Tryzelaar
parent
aaff4e05e1
commit
065b98d577
1 changed files with 370 additions and 60 deletions
|
|
@ -1857,107 +1857,417 @@ mod tests {
|
|||
#[bench]
|
||||
fn bench_new(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<int> = Vec::new();
|
||||
let v: Vec<uint> = Vec::new();
|
||||
assert_eq!(v.len(), 0);
|
||||
assert_eq!(v.capacity(), 0);
|
||||
assert!(v.as_slice() == []);
|
||||
})
|
||||
}
|
||||
|
||||
fn do_bench_with_capacity(b: &mut Bencher, src_len: uint) {
|
||||
b.bytes = src_len as u64;
|
||||
|
||||
b.iter(|| {
|
||||
let v: Vec<uint> = Vec::with_capacity(src_len);
|
||||
assert_eq!(v.len(), 0);
|
||||
assert_eq!(v.capacity(), src_len);
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_with_capacity_0(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<int> = Vec::with_capacity(0);
|
||||
assert_eq!(v.capacity(), 0);
|
||||
assert!(v.as_slice() == []);
|
||||
})
|
||||
fn bench_with_capacity_0000(b: &mut Bencher) {
|
||||
do_bench_with_capacity(b, 0)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_with_capacity_0010(b: &mut Bencher) {
|
||||
do_bench_with_capacity(b, 10)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_with_capacity_5(b: &mut Bencher) {
|
||||
fn bench_with_capacity_0100(b: &mut Bencher) {
|
||||
do_bench_with_capacity(b, 100)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_with_capacity_1000(b: &mut Bencher) {
|
||||
do_bench_with_capacity(b, 1000)
|
||||
}
|
||||
|
||||
fn do_bench_from_fn(b: &mut Bencher, src_len: uint) {
|
||||
b.bytes = src_len as u64;
|
||||
|
||||
b.iter(|| {
|
||||
let v: Vec<int> = Vec::with_capacity(5);
|
||||
assert_eq!(v.capacity(), 5);
|
||||
assert!(v.as_slice() == []);
|
||||
let dst = Vec::from_fn(src_len, |i| i);
|
||||
assert_eq!(dst.len(), src_len);
|
||||
assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_with_capacity_100(b: &mut Bencher) {
|
||||
fn bench_from_fn_0000(b: &mut Bencher) {
|
||||
do_bench_from_fn(b, 0)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_from_fn_0010(b: &mut Bencher) {
|
||||
do_bench_from_fn(b, 10)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_from_fn_0100(b: &mut Bencher) {
|
||||
do_bench_from_fn(b, 100)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_from_fn_1000(b: &mut Bencher) {
|
||||
do_bench_from_fn(b, 1000)
|
||||
}
|
||||
|
||||
fn do_bench_from_elem(b: &mut Bencher, src_len: uint) {
|
||||
b.bytes = src_len as u64;
|
||||
|
||||
b.iter(|| {
|
||||
let v: Vec<int> = Vec::with_capacity(100);
|
||||
assert_eq!(v.capacity(), 100);
|
||||
assert!(v.as_slice() == []);
|
||||
let dst: Vec<uint> = Vec::from_elem(src_len, 5);
|
||||
assert_eq!(dst.len(), src_len);
|
||||
assert!(dst.iter().all(|x| *x == 5));
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_from_fn_0(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<int> = Vec::from_fn(0, |_| 5);
|
||||
assert!(v.as_slice() == []);
|
||||
})
|
||||
fn bench_from_elem_0000(b: &mut Bencher) {
|
||||
do_bench_from_elem(b, 0)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_from_fn_5(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<int> = Vec::from_fn(5, |_| 5);
|
||||
assert!(v.as_slice() == [5, 5, 5, 5, 5]);
|
||||
})
|
||||
fn bench_from_elem_0010(b: &mut Bencher) {
|
||||
do_bench_from_elem(b, 10)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_from_slice_0(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<int> = Vec::from_slice([]);
|
||||
assert!(v.as_slice() == []);
|
||||
})
|
||||
fn bench_from_elem_0100(b: &mut Bencher) {
|
||||
do_bench_from_elem(b, 100)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_from_slice_5(b: &mut Bencher) {
|
||||
fn bench_from_elem_1000(b: &mut Bencher) {
|
||||
do_bench_from_elem(b, 1000)
|
||||
}
|
||||
|
||||
fn do_bench_from_slice(b: &mut Bencher, src_len: uint) {
|
||||
let src: Vec<uint> = FromIterator::from_iter(range(0, src_len));
|
||||
|
||||
b.bytes = src_len as u64;
|
||||
|
||||
b.iter(|| {
|
||||
let v: Vec<int> = Vec::from_slice([1i, 2, 3, 4, 5]);
|
||||
assert!(v.as_slice() == [1, 2, 3, 4, 5]);
|
||||
})
|
||||
let dst = Vec::from_slice(src.clone().as_slice());
|
||||
assert_eq!(dst.len(), src_len);
|
||||
assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
|
||||
});
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_from_iter_0(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v0: Vec<int> = vec!();
|
||||
let v1: Vec<int> = FromIterator::from_iter(v0.move_iter());
|
||||
assert!(v1.as_slice() == []);
|
||||
})
|
||||
fn bench_from_slice_0000(b: &mut Bencher) {
|
||||
do_bench_from_slice(b, 0)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_from_iter_5(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v0: Vec<int> = vec!(1, 2, 3, 4, 5);
|
||||
let v1: Vec<int> = FromIterator::from_iter(v0.move_iter());
|
||||
assert!(v1.as_slice() == [1, 2, 3, 4, 5]);
|
||||
})
|
||||
fn bench_from_slice_0010(b: &mut Bencher) {
|
||||
do_bench_from_slice(b, 10)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_extend_0(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v0: Vec<int> = vec!();
|
||||
let mut v1: Vec<int> = vec!(1, 2, 3, 4, 5);
|
||||
v1.extend(v0.move_iter());
|
||||
assert!(v1.as_slice() == [1, 2, 3, 4, 5]);
|
||||
})
|
||||
fn bench_from_slice_0100(b: &mut Bencher) {
|
||||
do_bench_from_slice(b, 100)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_extend_5(b: &mut Bencher) {
|
||||
fn bench_from_slice_1000(b: &mut Bencher) {
|
||||
do_bench_from_slice(b, 1000)
|
||||
}
|
||||
|
||||
fn do_bench_from_iter(b: &mut Bencher, src_len: uint) {
|
||||
let src: Vec<uint> = FromIterator::from_iter(range(0, src_len));
|
||||
|
||||
b.bytes = src_len as u64;
|
||||
|
||||
b.iter(|| {
|
||||
let v0: Vec<int> = vec!(1, 2, 3, 4, 5);
|
||||
let mut v1: Vec<int> = vec!(1, 2, 3, 4, 5);
|
||||
v1.extend(v0.move_iter());
|
||||
assert!(v1.as_slice() == [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]);
|
||||
})
|
||||
let dst: Vec<uint> = FromIterator::from_iter(src.clone().move_iter());
|
||||
assert_eq!(dst.len(), src_len);
|
||||
assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
|
||||
});
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_from_iter_0000(b: &mut Bencher) {
|
||||
do_bench_from_iter(b, 0)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_from_iter_0010(b: &mut Bencher) {
|
||||
do_bench_from_iter(b, 10)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_from_iter_0100(b: &mut Bencher) {
|
||||
do_bench_from_iter(b, 100)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_from_iter_1000(b: &mut Bencher) {
|
||||
do_bench_from_iter(b, 1000)
|
||||
}
|
||||
|
||||
fn do_bench_extend(b: &mut Bencher, dst_len: uint, src_len: uint) {
|
||||
let dst: Vec<uint> = FromIterator::from_iter(range(0, dst_len));
|
||||
let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
|
||||
|
||||
b.bytes = src_len as u64;
|
||||
|
||||
b.iter(|| {
|
||||
let mut dst = dst.clone();
|
||||
dst.extend(src.clone().move_iter());
|
||||
assert_eq!(dst.len(), dst_len + src_len);
|
||||
assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
|
||||
});
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_extend_0000_0000(b: &mut Bencher) {
|
||||
do_bench_extend(b, 0, 0)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_extend_0000_0010(b: &mut Bencher) {
|
||||
do_bench_extend(b, 0, 10)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_extend_0000_0100(b: &mut Bencher) {
|
||||
do_bench_extend(b, 0, 100)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_extend_0000_1000(b: &mut Bencher) {
|
||||
do_bench_extend(b, 0, 1000)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_extend_0010_0010(b: &mut Bencher) {
|
||||
do_bench_extend(b, 10, 10)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_extend_0100_0100(b: &mut Bencher) {
|
||||
do_bench_extend(b, 100, 100)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_extend_1000_1000(b: &mut Bencher) {
|
||||
do_bench_extend(b, 1000, 1000)
|
||||
}
|
||||
|
||||
fn do_bench_push_all(b: &mut Bencher, dst_len: uint, src_len: uint) {
|
||||
let dst: Vec<uint> = FromIterator::from_iter(range(0, dst_len));
|
||||
let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
|
||||
|
||||
b.bytes = src_len as u64;
|
||||
|
||||
b.iter(|| {
|
||||
let mut dst = dst.clone();
|
||||
dst.push_all(src.as_slice());
|
||||
assert_eq!(dst.len(), dst_len + src_len);
|
||||
assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
|
||||
});
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_push_all_0000_0000(b: &mut Bencher) {
|
||||
do_bench_push_all(b, 0, 0)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_push_all_0000_0010(b: &mut Bencher) {
|
||||
do_bench_push_all(b, 0, 10)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_push_all_0000_0100(b: &mut Bencher) {
|
||||
do_bench_push_all(b, 0, 100)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_push_all_0000_1000(b: &mut Bencher) {
|
||||
do_bench_push_all(b, 0, 1000)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_push_all_0010_0010(b: &mut Bencher) {
|
||||
do_bench_push_all(b, 10, 10)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_push_all_0100_0100(b: &mut Bencher) {
|
||||
do_bench_push_all(b, 100, 100)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_push_all_1000_1000(b: &mut Bencher) {
|
||||
do_bench_push_all(b, 1000, 1000)
|
||||
}
|
||||
|
||||
fn do_bench_push_all_move(b: &mut Bencher, dst_len: uint, src_len: uint) {
|
||||
let dst: Vec<uint> = FromIterator::from_iter(range(0u, dst_len));
|
||||
let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
|
||||
|
||||
b.bytes = src_len as u64;
|
||||
|
||||
b.iter(|| {
|
||||
let mut dst = dst.clone();
|
||||
dst.push_all_move(src.clone());
|
||||
assert_eq!(dst.len(), dst_len + src_len);
|
||||
assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
|
||||
});
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_push_all_move_0000_0000(b: &mut Bencher) {
|
||||
do_bench_push_all_move(b, 0, 0)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_push_all_move_0000_0010(b: &mut Bencher) {
|
||||
do_bench_push_all_move(b, 0, 10)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_push_all_move_0000_0100(b: &mut Bencher) {
|
||||
do_bench_push_all_move(b, 0, 100)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_push_all_move_0000_1000(b: &mut Bencher) {
|
||||
do_bench_push_all_move(b, 0, 1000)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_push_all_move_0010_0010(b: &mut Bencher) {
|
||||
do_bench_push_all_move(b, 10, 10)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_push_all_move_0100_0100(b: &mut Bencher) {
|
||||
do_bench_push_all_move(b, 100, 100)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_push_all_move_1000_1000(b: &mut Bencher) {
|
||||
do_bench_push_all_move(b, 1000, 1000)
|
||||
}
|
||||
|
||||
fn do_bench_clone(b: &mut Bencher, src_len: uint) {
|
||||
let src: Vec<uint> = FromIterator::from_iter(range(0, src_len));
|
||||
|
||||
b.bytes = src_len as u64;
|
||||
|
||||
b.iter(|| {
|
||||
let dst = src.clone();
|
||||
assert_eq!(dst.len(), src_len);
|
||||
assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
|
||||
});
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_0000(b: &mut Bencher) {
|
||||
do_bench_clone(b, 0)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_0010(b: &mut Bencher) {
|
||||
do_bench_clone(b, 10)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_0100(b: &mut Bencher) {
|
||||
do_bench_clone(b, 100)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_1000(b: &mut Bencher) {
|
||||
do_bench_clone(b, 1000)
|
||||
}
|
||||
|
||||
fn do_bench_clone_from(b: &mut Bencher, dst_len: uint, src_len: uint) {
|
||||
let dst: Vec<uint> = FromIterator::from_iter(range(0, src_len));
|
||||
let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
|
||||
|
||||
b.bytes = src_len as u64;
|
||||
|
||||
b.iter(|| {
|
||||
let mut dst = dst.clone();
|
||||
let src = src.clone();
|
||||
dst.clone_from(&src);
|
||||
assert_eq!(dst.len(), src_len);
|
||||
assert!(dst.iter().enumerate().all(|(i, x)| dst_len + i == *x));
|
||||
});
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_from_0000_0000(b: &mut Bencher) {
|
||||
do_bench_clone_from(b, 0, 0)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_from_0000_0010(b: &mut Bencher) {
|
||||
do_bench_clone_from(b, 0, 10)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_from_0000_0100(b: &mut Bencher) {
|
||||
do_bench_clone_from(b, 0, 100)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_from_0000_1000(b: &mut Bencher) {
|
||||
do_bench_clone_from(b, 0, 1000)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_from_0010_0010(b: &mut Bencher) {
|
||||
do_bench_clone_from(b, 10, 10)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_from_0100_0100(b: &mut Bencher) {
|
||||
do_bench_clone_from(b, 100, 100)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_from_1000_1000(b: &mut Bencher) {
|
||||
do_bench_clone_from(b, 1000, 1000)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_from_0010_0100(b: &mut Bencher) {
|
||||
do_bench_clone_from(b, 10, 100)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_from_0100_1000(b: &mut Bencher) {
|
||||
do_bench_clone_from(b, 100, 1000)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_from_0010_0000(b: &mut Bencher) {
|
||||
do_bench_clone_from(b, 10, 0)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_from_0100_0010(b: &mut Bencher) {
|
||||
do_bench_clone_from(b, 100, 10)
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_clone_from_1000_0100(b: &mut Bencher) {
|
||||
do_bench_clone_from(b, 1000, 100)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue