disk IO bench

bench.rs

#![feature(test)]
extern crate memmap;
extern crate test;
extern crate rand;
extern crate vecio;

use std::env;
use std::io::{self, Read, Write, Cursor, Seek, SeekFrom};
use std::fs::{File, OpenOptions};
use rand::Rng;
use memmap::{Mmap, Protection};
use test::Bencher;
use vecio::Rawv;

#[bench]
fn read_mmap(b: &mut Bencher) {
    let mmap = unsafe { Mmap::open_path("a.iso", Protection::Read) }
            .expect("failed to map the file");
    let mut buf = vec![0; 4096];
    let mut rng = rand::thread_rng();

    b.iter(|| {
        unsafe {
            let mut s = mmap.as_slice();
            for i in 0..100 {
                let beg = rng.gen_range(0, s.len() - 4096);
                (&s[beg..beg+4096]).read(&mut buf).unwrap();
            }
        }
    })
}

#[bench]
fn read_mmap_seq(b: &mut Bencher) {
    let mmap = unsafe { Mmap::open_path("a.iso", Protection::Read) }
            .expect("failed to map the file");
    let mut buf = vec![0; 4096];

    b.iter(|| {
        unsafe {
            let mut s = mmap.as_slice();
            let mut beg = 0;
            for i in 0..100 {
                (&s[beg..beg+4096]).read(&mut buf).unwrap();
                beg += 4096;
            }
        }
    })
}

#[bench]
fn read_io(b: &mut Bencher) {
    let mut f = File::open("a.iso").unwrap();
    let mut buf = vec![0; 4096];
    let mut rng = rand::thread_rng();

    b.iter(|| {
        unsafe {
            for i in 0..100 {
                let beg = rng.gen_range(0, f.metadata().unwrap().len() - 4096);
                f.seek(SeekFrom::Start(beg)).unwrap();
                f.read_exact(&mut buf).unwrap();
            }
        }
    })
}

#[bench]
fn read_io_seq(b: &mut Bencher) {
    let mut f = File::open("a.iso").unwrap();
    let mut buf = vec![0; 4096];

    b.iter(|| {
        unsafe {
            f.seek(SeekFrom::Start(0)).unwrap();
            for i in 0..100 {
                f.read_exact(&mut buf).unwrap();
            }
        }
    })
}

#[bench]
fn read_iov_seq(b: &mut Bencher) {
    let mut f = File::open("a.iso").unwrap();
    let mut buf = vec![vec![0; 4096]; 100];
    let v: Vec<_> = buf.iter_mut().map(|v| v.as_mut_slice()).collect();

    b.iter(|| {
        unsafe {
            f.seek(SeekFrom::Start(0)).unwrap();
            f.readv(&v).unwrap();
        }
    })
}

#[bench]
fn write_mmap(b: &mut Bencher) {
    let mut mmap = unsafe { Mmap::open_path("a.iso", Protection::ReadWrite) }
            .expect("failed to map the file");
    let mut buf = vec![0xFF; 4096];
    let mut rng = rand::thread_rng();

    b.iter(|| {
        unsafe {
            let mut s = mmap.as_mut_slice();
            for i in 0..100 {
                let beg = rng.gen_range(0, s.len() - 4096);
                (&mut s[beg..beg+4096]).write(&buf).unwrap();
            }
        }
        mmap.flush_async().unwrap();
    })
}

#[bench]
fn write_mmap_seq(b: &mut Bencher) {
    let mut mmap = unsafe { Mmap::open_path("a.iso", Protection::ReadWrite) }
            .expect("failed to map the file");
    let mut buf = vec![0xFF; 4096];

    b.iter(|| {
        unsafe {
            let mut s = mmap.as_mut_slice();
            let mut beg = 0;
            for i in 0..100 {
                (&mut s[beg..beg+4096]).write(&buf).unwrap();
                beg += 4096;
            }
        }
        mmap.flush_async().unwrap();
    })
}

#[bench]
fn write_io(b: &mut Bencher) {
    let mut f = OpenOptions::new().write(true).open("a.iso").unwrap();
    let mut buf = vec![0xFF; 4096];
    let mut rng = rand::thread_rng();

    b.iter(|| {
        unsafe {
            for i in 0..100 {
                let beg = rng.gen_range(0, f.metadata().unwrap().len() - 4096);
                f.seek(SeekFrom::Start(beg)).unwrap();
                f.write_all(&buf).unwrap();
            }
        }
    })
}

#[bench]
fn write_io_seq(b: &mut Bencher) {
    let mut f = OpenOptions::new().write(true).open("a.iso").unwrap();
    let mut buf = vec![0xFF; 4096];

    b.iter(|| {
        unsafe {
            f.seek(SeekFrom::Start(0)).unwrap();
            for i in 0..100 {
                f.write_all(&buf).unwrap();
            }
        }
    })
}

#[bench]
fn write_iov_seq(b: &mut Bencher) {
    let mut f = OpenOptions::new().write(true).open("a.iso").unwrap();
    let mut buf = vec![vec![0xFF; 4096]; 100];
    let v: Vec<_> = buf.iter().map(|v| v.as_slice()).collect();

    b.iter(|| {
        unsafe {
            f.seek(SeekFrom::Start(0)).unwrap();
            f.writev(&v).unwrap();
        }
    })
}

results.txt

running 10 tests
test read_io        ... bench:     110,065 ns/iter (+/- 10,931)
test read_io_seq    ... bench:      23,903 ns/iter (+/- 11,306)
test read_iov_seq   ... bench:      19,346 ns/iter (+/- 233)
test read_mmap      ... bench:      56,262 ns/iter (+/- 11,579)
test read_mmap_seq  ... bench:       6,900 ns/iter (+/- 1,023)
test write_io       ... bench:     149,528 ns/iter (+/- 8,158)
test write_io_seq   ... bench:      48,695 ns/iter (+/- 2,552)
test write_iov_seq  ... bench:      42,746 ns/iter (+/- 974)
test write_mmap     ... bench:      33,903 ns/iter (+/- 2,913)
test write_mmap_seq ... bench:       9,708 ns/iter (+/- 358)

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