gistfile1.rs

/*
    test elem_000001   ... bench:        37 ns/iter (+/- 1)
    test elem_000010   ... bench:        44 ns/iter (+/- 2)
    test elem_000100   ... bench:        66 ns/iter (+/- 2)
    test elem_001000   ... bench:       332 ns/iter (+/- 5)
    test elem_010000   ... bench:     26077 ns/iter (+/- 386)
    test elem_100000   ... bench:    237744 ns/iter (+/- 15692)
    test iter_000001   ... bench:        42 ns/iter (+/- 0)
    test iter_000010   ... bench:        62 ns/iter (+/- 1)
    test iter_000100   ... bench:       264 ns/iter (+/- 1)
    test iter_001000   ... bench:      2202 ns/iter (+/- 17)
    test iter_010000   ... bench:     44173 ns/iter (+/- 616)
    test iter_100000   ... bench:    417574 ns/iter (+/- 2167)
    test unsafe_000001 ... bench:        42 ns/iter (+/- 1)
    test unsafe_000010 ... bench:        63 ns/iter (+/- 3)
    test unsafe_000100 ... bench:       264 ns/iter (+/- 2)
    test unsafe_001000 ... bench:      2133 ns/iter (+/- 14)
    test unsafe_010000 ... bench:     44622 ns/iter (+/- 801)
    test unsafe_100000 ... bench:    421455 ns/iter (+/- 10473)
*/


    extern crate test;
    use test::Bencher;
    use std::iter::repeat;
    use std::ptr;

    pub trait UnsafeVec<A> {
        fn from_unsafe<I: Iterator<Item=A>>(I) -> Self;
    }

    impl<A> UnsafeVec<A> for Vec<A> {
        fn from_unsafe<I: Iterator<Item=A>>(mut iter: I) -> Vec<A> {
            let len = iter.size_hint().0;
            let mut v = Vec::with_capacity(len);
            let mut ptr = v.as_mut_ptr();
            unsafe {
                for elem in iter {
                    ptr::write(ptr, elem);
                    ptr = ptr.offset(1);
                }
                v.set_len(len);
            }
            v
        }
    }

    fn iter_n(b: &mut Bencher, n: usize) {
        b.iter(||{
            let v: Vec<u32> = repeat(7).take(n).collect();
            v
        });
    }

    fn elem_n(b: &mut Bencher, length: usize) {
        let value = 7;
        b.iter(||{
            unsafe {
                let mut xs: Vec<u32> = Vec::with_capacity(length);
                while xs.len() < length {
                    let len = xs.len();
                    ptr::write(xs.as_mut_slice().get_unchecked_mut(len),
                               value.clone());
                    xs.set_len(len + 1);
                }
                xs
            }
        });
    }

    fn unsafe_n(b: &mut Bencher, n: usize) {
        b.iter(||{
            let v: Vec<u32> = UnsafeVec::from_unsafe(repeat(7).take(n));
            v
        });
    }

    #[bench] fn iter_000001(b: &mut Bencher) { iter_n(b, 1) }
    #[bench] fn iter_000010(b: &mut Bencher) { iter_n(b, 10) }
    #[bench] fn iter_000100(b: &mut Bencher) { iter_n(b, 100) }
    #[bench] fn iter_001000(b: &mut Bencher) { iter_n(b, 1000) }
    #[bench] fn iter_010000(b: &mut Bencher) { iter_n(b, 10000) }
    #[bench] fn iter_100000(b: &mut Bencher) { iter_n(b, 100000) }

    #[bench] fn elem_000001(b: &mut Bencher) { elem_n(b, 1) }
    #[bench] fn elem_000010(b: &mut Bencher) { elem_n(b, 10) }
    #[bench] fn elem_000100(b: &mut Bencher) { elem_n(b, 100) }
    #[bench] fn elem_001000(b: &mut Bencher) { elem_n(b, 1000) }
    #[bench] fn elem_010000(b: &mut Bencher) { elem_n(b, 10000) }
    #[bench] fn elem_100000(b: &mut Bencher) { elem_n(b, 100000) }

    #[bench] fn unsafe_000001(b: &mut Bencher) { unsafe_n(b, 1) }
    #[bench] fn unsafe_000010(b: &mut Bencher) { unsafe_n(b, 10) }
    #[bench] fn unsafe_000100(b: &mut Bencher) { unsafe_n(b, 100) }
    #[bench] fn unsafe_001000(b: &mut Bencher) { unsafe_n(b, 1000) }
    #[bench] fn unsafe_010000(b: &mut Bencher) { unsafe_n(b, 10000) }
    #[bench] fn unsafe_100000(b: &mut Bencher) { unsafe_n(b, 100000) }