Skip to content

Instantly share code, notes, and snippets.

@erickt

erickt/test.rs

Last active December 31, 2015 09:49
Show Gist options
  • Save erickt/7969451 to your computer and use it in GitHub Desktop.
Save erickt/7969451 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
gistfile1.txt
running 18 tests
test bench_extendable__clone_iter2 ... bench: 2961 ns/iter (+/- 248)
test bench_extendable__move_iter ... bench: 3067 ns/iter (+/- 123)
test bench_push___iter__clone ... bench: 2903 ns/iter (+/- 233)
test bench_push__clone_iter2 ... bench: 2932 ns/iter (+/- 276)
test bench_push__iter_deref ... bench: 2903 ns/iter (+/- 68)
test bench_push__move_iter ... bench: 2897 ns/iter (+/- 96)
test bench_push_all ... bench: 2930 ns/iter (+/- 240)
test bench_push_all_clone ... bench: 2914 ns/iter (+/- 683)
test bench_push_all_iter1__clone_iter2 ... bench: 2915 ns/iter (+/- 191)
test bench_push_all_iter1__move_iter ... bench: 3018 ns/iter (+/- 279)
test bench_push_all_iter2__clone_iter2 ... bench: 1139 ns/iter (+/- 110)
test bench_push_all_iter2__move_iter ... bench: 1674 ns/iter (+/- 145)
test bench_push_all_iter3__clone_iter2 ... bench: 1921 ns/iter (+/- 236)
test bench_push_all_iter3__move_iter ... bench: 1968 ns/iter (+/- 377)
test bench_push_all_move ... bench: 1139 ns/iter (+/- 58)
test bench_push_all_move2 ... bench: 1135 ns/iter (+/- 53)
test bench_unsafe_set__iter ... bench: 1155 ns/iter (+/- 112)
test bench_unsafe_set__unsafe_get ... bench: 1132 ns/iter (+/- 57)
test result: ok. 0 passed; 0 failed; 0 ignored; 18 measured
Raw
test.rs
extern mod extra;
use std::ptr;
use std::vec;
use extra::test::BenchHarness;
pub trait Methods<T> {
fn push_all_iter1<Iter: Iterator<T>>(&mut self, mut iter: Iter);
fn push_all_iter2<Iter: Iterator<T>>(&mut self, mut iter: Iter);
fn push_all_iter3<Iter: Iterator<T>>(&mut self, mut iter: Iter);
fn push_all_move2(&mut self, mut rhs: ~[T]);
}
impl<T> Methods<T> for ~[T] {
#[inline]
fn push_all_iter1<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
let (len, _) = iter.size_hint();
self.reserve_additional(len);
for elt in iter {
self.push(elt)
}
}
#[inline]
fn push_all_iter2<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
unsafe {
let self_len = self.len();
let (iter_len, _) = iter.size_hint();
let new_len = self_len + iter_len;
self.reserve(new_len);
let mut i = self_len;
for elt in iter {
vec::raw::init_elem(*self, i, elt);
i += 1;
}
self.set_len(i);
}
}
#[inline]
fn push_all_iter3<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
unsafe {
let self_len = self.len();
let (iter_len, _) = iter.size_hint();
let new_len = self_len + iter_len;
self.reserve(new_len);
let mut i = self_len;
while i < new_len {
match iter.next() {
Some(elt) => {
vec::raw::init_elem(*self, i, elt);
}
None => {
self.set_len(i);
return;
}
}
i += 1;
}
self.set_len(i);
for elt in iter {
self.push(elt)
}
}
}
#[inline]
fn push_all_move2(&mut self, mut rhs: ~[T]) {
let self_len = self.len();
let rhs_len = rhs.len();
let new_len = self_len + rhs_len;
self.reserve_additional(rhs.len());
unsafe { // Note: infallible.
let self_p = self.as_mut_ptr();
let rhs_p = rhs.as_ptr();
ptr::copy_memory(ptr::mut_offset(self_p, self_len as int), rhs_p, rhs_len);
self.set_len(new_len);
rhs.set_len(0);
}
}
}
///////////////////////////////////////////////////////////////////////////////
pub trait CloneIter2<'a, T> {
fn clone_iter2(self) -> CloneIterator2<'a, T>;
}
impl<'a, T: Clone> CloneIter2<'a, T> for &'a [T] {
#[inline]
fn clone_iter2(self) -> CloneIterator2<'a, T> {
CloneIterator2 {
iter: self.iter(),
}
}
}
///////////////////////////////////////////////////////////////////////////////
pub struct CloneIterator2<'a, T> {
priv iter: vec::VecIterator<'a, T>,
}
impl<'a, T: Clone> Iterator<T> for CloneIterator2<'a, T> {
#[inline]
fn next(&mut self) -> Option<T> {
match self.iter.next() {
Some(value) => Some(value.clone()),
None => None,
}
}
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
self.iter.size_hint()
}
}
///////////////////////////////////////////////////////////////////////////////
trait PushAllClone<T: Clone> {
fn push_all_clone(&mut self, rhs: &[T]);
}
impl<T: Clone> PushAllClone<T> for ~[T] {
#[inline]
fn push_all_clone(&mut self, rhs: &[T]) {
self.reserve_additional(rhs.len());
for elt in rhs.iter() {
self.push((*elt).clone())
}
}
}
///////////////////////////////////////////////////////////////////////////////
#[bench]
fn bench_push__iter_deref(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.reserve_additional(y.len());
for z in y.iter() {
x.push(*z);
}
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_push___iter__clone(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.reserve_additional(y.len());
for z in y.iter() {
x.push(z.clone());
}
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_push__clone_iter2(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.reserve_additional(y.len());
for z in y.clone_iter2() {
x.push(z);
}
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_push__move_iter(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.reserve_additional(y.len());
for z in y.move_iter() {
x.push(z);
}
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_push_all_iter1__clone_iter2(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.push_all_iter1(y.clone_iter2());
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_push_all_iter2__clone_iter2(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.push_all_iter2(y.clone_iter2());
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_push_all_iter3__clone_iter2(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.push_all_iter3(y.clone_iter2());
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_push_all_iter1__move_iter(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.push_all_iter1(y.move_iter());
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_push_all_iter2__move_iter(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.push_all_iter2(y.move_iter());
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_push_all_iter3__move_iter(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.push_all_iter3(y.move_iter());
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_push_all(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.push_all(y);
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_push_all_clone(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.push_all_clone(y);
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_push_all_move(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.push_all_move(y);
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_push_all_move2(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.push_all_move2(y);
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_extendable__clone_iter2(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.extend(&mut y.clone_iter2());
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_extendable__move_iter(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let y = vec::from_elem(1000, 5);
x.extend(&mut y.move_iter());
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_unsafe_set__unsafe_get(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let mut y = vec::from_elem(1000, 5);
x.reserve_additional(y.len());
unsafe {
let x_len = x.len();
let y_len = y.len();
let new_len = x_len + y_len;
for i in range(0u, 1000u) {
let valptr = y.unsafe_ref(i);
vec::raw::init_elem(x, 1000 + i, ptr::read_ptr(valptr));
}
x.set_len(new_len);
y.set_len(0);
}
//assert_eq!(_a, x);
});
}
#[bench]
fn bench_unsafe_set__iter(bh: &mut BenchHarness) {
let _a = vec::from_elem(2000, 5);
bh.iter(|| {
let mut x = vec::from_elem(1000, 5);
let mut y = vec::from_elem(1000, 5);
x.reserve_additional(y.len());
unsafe {
let x_len = x.len();
let y_len = y.len();
let new_len = x_len + y_len;
let mut i = 1000;
for z in y.iter() {
vec::raw::init_elem(x, i, *z);
i += 1;
}
x.set_len(new_len);
y.set_len(0);
}
//assert_eq!(_a, x);
});
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment