slice reverse benchmark

lib.rs

#![feature(test)]

extern crate test;

use std::ptr;
use test::Bencher;

pub fn reverse_slice_orig<T>(s: &mut [T]) {
    let mut i: usize = 0;
    let ln = s.len();
    while i < ln / 2 {
        unsafe {
            let pa: *mut T = s.get_unchecked_mut(i);
            let pb: *mut T = s.get_unchecked_mut(ln - i - 1);
            ptr::swap(pa, pb);
        }
        i += 1;
    }
}

pub fn reverse_slice_nonoverlapping<T>(s: &mut [T]) {
    let mut i: usize = 0;
    let ln = s.len();
    while i < ln / 2 {
        unsafe {
            let pa: *mut T = s.get_unchecked_mut(i);
            let pb: *mut T = s.get_unchecked_mut(ln - i - 1);
            ptr::swap_nonoverlapping(pa, pb, 1);
        }
        i += 1;
    }
}

const SIZE: usize = 1_000_000;

#[bench]
fn bench_bytes_orig(b: &mut Bencher) {
    let mut s = vec![1u8; SIZE];
    b.iter(|| {
        test::black_box(&mut s);
        reverse_slice_orig(&mut s);
    });
}

#[bench]
fn bench_bytes_nonoverlapping(b: &mut Bencher) {
    let mut s = vec![1u8; SIZE];
    b.iter(|| {
        test::black_box(&mut s);
        reverse_slice_nonoverlapping(&mut s);
    });
}

#[bench]
fn bench_u64_orig(b: &mut Bencher) {
    let mut s = vec![1u64; SIZE / 8];
    b.iter(|| {
        test::black_box(&mut s);
        reverse_slice_orig(&mut s);
    });
}

#[bench]
fn bench_u64_nonoverlapping(b: &mut Bencher) {
    let mut s = vec![1u64; SIZE / 8];
    b.iter(|| {
        test::black_box(&mut s);
        reverse_slice_nonoverlapping(&mut s);
    });
}

#[bench]
fn bench_irregular_size_obj_orig(b: &mut Bencher) {
    const ARRAY_SIZE: usize = 15;
    let mut s = vec![[1u8; ARRAY_SIZE]; SIZE / ARRAY_SIZE];
    b.iter(|| {
        test::black_box(&mut s);
        reverse_slice_orig(&mut s);
    });
}

#[bench]
fn bench_irregular_size_obj_nonoverlapping(b: &mut Bencher) {
    const ARRAY_SIZE: usize = 15;
    let mut s = vec![[1u8; ARRAY_SIZE]; SIZE / ARRAY_SIZE];
    b.iter(|| {
        test::black_box(&mut s);
        reverse_slice_nonoverlapping(&mut s);
    });
}

#[bench]
fn bench_simd_size_obj_orig(b: &mut Bencher) {
    const ARRAY_SIZE: usize = 32;
    let mut s = vec![[1u8; ARRAY_SIZE]; SIZE / ARRAY_SIZE];
    b.iter(|| {
        test::black_box(&mut s);
        reverse_slice_orig(&mut s);
    });
}

#[bench]
fn bench_simd_size_obj_nonoverlapping(b: &mut Bencher) {
    const ARRAY_SIZE: usize = 32;
    let mut s = vec![[1u8; ARRAY_SIZE]; SIZE / ARRAY_SIZE];
    b.iter(|| {
        test::black_box(&mut s);
        reverse_slice_nonoverlapping(&mut s);
    });
}

#[bench]
fn bench_giant_obj_orig(b: &mut Bencher) {
    const ARRAY_SIZE: usize = 10_000;
    let mut s = vec![[1u8; ARRAY_SIZE]; SIZE / ARRAY_SIZE];
    b.iter(|| {
        test::black_box(&mut s);
        reverse_slice_orig(&mut s);
    });
}

#[bench]
fn bench_giant_obj_nonoverlapping(b: &mut Bencher) {
    const ARRAY_SIZE: usize = 10_000;
    let mut s = vec![[1u8; ARRAY_SIZE]; SIZE / ARRAY_SIZE];
    b.iter(|| {
        test::black_box(&mut s);
        reverse_slice_nonoverlapping(&mut s);
    });
}

my_reuslts.txt

test bench_bytes_nonoverlapping              ... bench:     651,573 ns/iter (+/- 1,277)
test bench_bytes_orig                        ... bench:     651,663 ns/iter (+/- 2,202)
test bench_giant_obj_nonoverlapping          ... bench:      64,622 ns/iter (+/- 651)
test bench_giant_obj_orig                    ... bench:      78,483 ns/iter (+/- 496)
test bench_irregular_size_obj_nonoverlapping ... bench:     385,827 ns/iter (+/- 1,360)
test bench_irregular_size_obj_orig           ... bench:     365,499 ns/iter (+/- 938)
test bench_simd_size_obj_nonoverlapping      ... bench:      63,660 ns/iter (+/- 263)
test bench_simd_size_obj_orig                ... bench:      84,770 ns/iter (+/- 183)
test bench_u64_nonoverlapping                ... bench:     103,898 ns/iter (+/- 736)
test bench_u64_orig                          ... bench:     103,919 ns/iter (+/- 2,119)