command-line.txt

$ rustup run nightly rustc -Copt-level=3 --test sort.rs 
$ ./sort --bench

running 6 tests
test bench_insert_sort                 ... bench:         571 ns/iter (+/- 22)
test bench_insert_sort_asserted        ... bench:         547 ns/iter (+/- 47)
test bench_insert_sort_clone           ... bench:         440 ns/iter (+/- 28)
test bench_insert_sort_clone_asserted  ... bench:         428 ns/iter (+/- 16)
test bench_insert_sort_unsafe          ... bench:         239 ns/iter (+/- 15)
test bench_insert_sort_unsafe_improved ... bench:         255 ns/iter (+/- 23)

test result: ok. 0 passed; 0 failed; 0 ignored; 6 measured; 0 filtered out

sort.rs

#![feature(test)]
// codes are from http://qiita.com/chalharu/items/3fe582b2fde39f45bf1e
// (rustup run nightly) rustc sort.rs -Copt-level=3 --test
// ./sort --bench

extern crate test;
use std::mem;
use std::ptr;
use test::Bencher;

fn insert_sort<T: PartialOrd>(source: &mut [T]) {
    for i in 1..source.len() {
        let mut j = i;
        while 0 < j && source[j - 1] > source[j] {
            source.swap(j - 1, j);
            j -= 1;
        }
    }
}

fn insert_sort_asserted<T: PartialOrd>(source: &mut [T]) {
    for i in 1..source.len() {
        let mut j = i;
        while 0 < j && source[j - 1] > source[j] {
            assert!(j < source.len());
            assert!(0 < j);
            source.swap(j - 1, j);
            j -= 1;
        }
    }
}

fn insert_sort_clone<T: PartialOrd + Clone>(source: &mut [T]) {
    for i in 1..source.len() {
        let mut j = i;
        let t = source[j].clone();
        while 0 < j && source[j - 1] > t {
            source[j] = source[j - 1].clone();
            j -= 1;
        }
        source[j] = t;
    }
}

fn insert_sort_clone_asserted<T: PartialOrd + Clone>(source: &mut [T]) {
    for i in 1..source.len() {
        let mut j = i;
        assert!(j < source.len());
        assert!(0 < j);
        let t = source[j].clone();
        while 0 < j && source[j - 1] > t {
            assert!(j < source.len());
            assert!(0 < j);
            source[j] = source[j - 1].clone();
            j -= 1;
        }
        source[j] = t;
    }
}

fn insert_sort_unsafe<T: PartialOrd + Clone>(source: &mut [T]) {
    for i in 1..source.len() {
        let mut j = i;
        unsafe {
            let t = (*source.get_unchecked(j)).clone();
            while 0 < j && *source.get_unchecked(j - 1) > t {
                *source.get_unchecked_mut(j) = (*source.get_unchecked(j - 1)).clone();
                j -= 1;
            }
            *source.get_unchecked_mut(j) = t;
        }
    }
}

fn insert_sort_unsafe_improved<T: PartialOrd>(source: &mut [T]) {
    let len = source.len();
    let ptr = source.as_mut_ptr();
    for i in 1..len {
        unsafe {
            let mut j = i;
            let mut t: T = mem::uninitialized();
            ptr::copy_nonoverlapping(ptr.offset(j as isize), &mut t, 1);
            while 0 < j && *(ptr.offset((j - 1) as isize)) > t {
                ptr::copy_nonoverlapping(ptr.offset((j - 1) as isize), ptr.offset(j as isize), 1);
                j -= 1;
            }
            ptr::copy_nonoverlapping(&t, ptr.offset(j as isize), 1);
            mem::forget(t);
        }
    }
}

fn data() -> Vec<i32> {
    vec![
        3,
        3,
        6,
        2,
        1,
        5,
        7,
        3,
        1,
        2,
        3,
        3,
        6,
        2,
        1,
        5,
        7,
        3,
        1,
        2,
        8,
        4,
        9,
        13,
        25,
        3,
        3,
        6,
        2,
        1,
        5,
        7,
        3,
        1,
        2,
        3,
        3,
        6,
        2,
        1,
        5,
        7,
        3,
        1,
        2,
        8,
        4,
        9,
        13,
        25,
    ]
}

#[bench]
fn bench_insert_sort(b: &mut Bencher) {
    b.iter(|| {
        let mut data = data();
        insert_sort(&mut data);
    })
}

#[bench]
fn bench_insert_sort_asserted(b: &mut Bencher) {
    b.iter(|| {
        let mut data = data();
        insert_sort_asserted(&mut data);
    })
}

#[bench]
fn bench_insert_sort_clone(b: &mut Bencher) {
    b.iter(|| {
        let mut data = data();
        insert_sort_clone(&mut data);
    })
}

#[bench]
fn bench_insert_sort_clone_asserted(b: &mut Bencher) {
    b.iter(|| {
        let mut data = data();
        insert_sort_clone_asserted(&mut data);
    })
}

#[bench]
fn bench_insert_sort_unsafe(b: &mut Bencher) {
    b.iter(|| {
        let mut data = data();
        insert_sort_unsafe(&mut data);
    })
}

#[bench]
fn bench_insert_sort_unsafe_improved(b: &mut Bencher) {
    b.iter(|| {
        let mut data = data();
        insert_sort_unsafe_improved(&mut data);
    })
}