#![feature(test)]
extern crate im;
extern crate test;
use std::iter::FromIterator;
use test::Bencher;
use im::vector::Vector;
fn vector_push_front_mut(b: &mut Bencher, count: usize) {
b.iter(|| {
let mut l = Vector::new();
for i in 0..count {
l.push_front(i);
}
})
}
#[bench]
fn vector_push_front_mut_10(b: &mut Bencher) {
vector_push_front_mut(b, 10)
}
#[bench]
fn vector_push_front_mut_100(b: &mut Bencher) {
vector_push_front_mut(b, 100)
}
#[bench]
fn vector_push_front_mut_1000(b: &mut Bencher) {
vector_push_front_mut(b, 1000)
}
#[bench]
fn vector_push_front_mut_100000(b: &mut Bencher) {
vector_push_front_mut(b, 100_000)
}
fn vector_push_back_mut(b: &mut Bencher, count: usize) {
b.iter(|| {
let mut l = Vector::new();
for i in 0..count {
l.push_back(i);
}
})
}
#[bench]
fn vector_push_back_mut_10(b: &mut Bencher) {
vector_push_back_mut(b, 10)
}
#[bench]
fn vector_push_back_mut_100(b: &mut Bencher) {
vector_push_back_mut(b, 100)
}
#[bench]
fn vector_push_back_mut_1000(b: &mut Bencher) {
vector_push_back_mut(b, 1000)
}
#[bench]
fn vector_push_back_mut_100000(b: &mut Bencher) {
vector_push_back_mut(b, 100_000)
}
fn vector_pop_front_mut(b: &mut Bencher, count: usize) {
let l = Vector::from_iter(0..count);
b.iter(|| {
let mut p = l.clone();
for _ in 0..count {
p.pop_front();
}
})
}
#[bench]
fn vector_pop_front_mut_10(b: &mut Bencher) {
vector_pop_front_mut(b, 10)
}
#[bench]
fn vector_pop_front_mut_100(b: &mut Bencher) {
vector_pop_front_mut(b, 100)
}
#[bench]
fn vector_pop_front_mut_1000(b: &mut Bencher) {
vector_pop_front_mut(b, 1000)
}
#[bench]
fn vector_pop_front_mut_100000(b: &mut Bencher) {
vector_pop_front_mut(b, 100_000)
}
fn vector_pop_back_mut(b: &mut Bencher, count: usize) {
let l = Vector::from_iter(0..count);
b.iter(|| {
let mut p = l.clone();
for _ in 0..count {
p.pop_back();
}
})
}
#[bench]
fn vector_pop_back_mut_10(b: &mut Bencher) {
vector_pop_back_mut(b, 10)
}
#[bench]
fn vector_pop_back_mut_100(b: &mut Bencher) {
vector_pop_back_mut(b, 100)
}
#[bench]
fn vector_pop_back_mut_1000(b: &mut Bencher) {
vector_pop_back_mut(b, 1000)
}
#[bench]
fn vector_pop_back_mut_100000(b: &mut Bencher) {
vector_pop_back_mut(b, 100_000)
}
fn vector_split(b: &mut Bencher, count: usize) {
let vec = Vector::from_iter(0..count);
b.iter(|| vec.clone().split_off(count / 2))
}
#[bench]
fn vector_split_10(b: &mut Bencher) {
vector_split(b, 10)
}
#[bench]
fn vector_split_100(b: &mut Bencher) {
vector_split(b, 100)
}
#[bench]
fn vector_split_1000(b: &mut Bencher) {
vector_split(b, 1000)
}
#[bench]
fn vector_split_100000(b: &mut Bencher) {
vector_split(b, 100_000)
}
fn vector_append(b: &mut Bencher, count: usize) {
let vec1 = Vector::from_iter(0..count / 2);
let vec2 = Vector::from_iter(count / 2..count);
b.iter(|| {
let mut vec = vec1.clone();
vec.append(vec2.clone());
})
}
#[bench]
fn vector_append_10(b: &mut Bencher) {
vector_append(b, 10)
}
#[bench]
fn vector_append_100(b: &mut Bencher) {
vector_append(b, 100)
}
#[bench]
fn vector_append_1000(b: &mut Bencher) {
vector_append(b, 1000)
}
#[bench]
fn vector_append_100000(b: &mut Bencher) {
vector_append(b, 100_000)
}