preserves/implementations/rust/oo/benches/codec.rs

use criterion::{criterion_group, criterion_main, Criterion};
use oo::BinarySource;
use oo::BytesBinarySource;
use oo::Domain;
use oo::IOBinarySource;
use oo::IOValueDomainCodec;
use oo::IOValues;
use oo::PackedWriter;
use oo::PlainValue;
use oo::Reader;
use oo::ValueImpl;
use oo::packed::annotated_iovalue_from_bytes;
use oo::packed::view::ViewIterator;
use std::fs::File;
use std::io::Read;
use std::io::Seek;
use std::io;

fn deep_standalone_copy<D: Domain, V: ValueImpl<D>>(v: V) -> PlainValue<'static, D> {
    oo::copy_via(&v, &mut |d| Ok::<_, ()>(oo::owned(oo::Embedded::new(d.clone())))).unwrap()
}

pub fn bench_decoder_bytes(c: &mut Criterion) {
    let mut fh = File::open("../../../tests/samples.bin").unwrap();
    let mut bs = vec![];
    fh.read_to_end(&mut bs).ok();
    c.bench_function("(oo) decode samples.bin via bytes", |b| b.iter_with_large_drop(
        || annotated_iovalue_from_bytes(&bs[..]).unwrap()));
}

pub fn bench_decoder_file(c: &mut Criterion) {
    let mut fh = File::open("../../../tests/samples.bin").unwrap();
    c.bench_function("(oo) decode samples.bin via file", |b| b.iter_with_large_drop(|| {
        fh.seek(io::SeekFrom::Start(0)).ok();
        IOBinarySource::new(&mut fh).packed().next_iovalue(true).unwrap()
    }));
}

pub fn bench_decoder_buffered_file(c: &mut Criterion) {
    let mut fh = io::BufReader::new(File::open("../../../tests/samples.bin").unwrap());
    c.bench_function("(oo) decode samples.bin via buffered file", |b| b.iter_with_large_drop(|| {
        fh.seek(io::SeekFrom::Start(0)).ok();
        IOBinarySource::new(&mut fh).packed().next_iovalue(true).unwrap()
    }));
}

pub fn bench_encoder(c: &mut Criterion) {
    let mut fh = File::open("../../../tests/samples.bin").unwrap();
    let v = IOBinarySource::new(&mut fh).packed().next_iovalue(true).unwrap();
    c.bench_function("(oo) encode samples.bin", |b| b.iter_with_large_drop(
        || PackedWriter::encode_iovalue(&v).unwrap()));
}

pub fn large_testdata_decoder_with_ann(c: &mut Criterion) {
    c.bench_function("(oo) decode testdata.bin with annotations", |b| {
        let mut fh = File::open("benches/testdata.bin").unwrap();
        let mut bs = vec![];
        fh.read_to_end(&mut bs).ok();
        b.iter(|| {
            let src = BytesBinarySource::new(&bs[..]);
            let mut r = IOValues::new(src.packed()).read_annotations(true);
            while let Some(Ok(_)) = r.next() {}
        })
    });
}

pub fn large_testdata_decoder_without_ann(c: &mut Criterion) {
    c.bench_function("(oo) decode testdata.bin without annotations", |b| {
        let mut fh = File::open("benches/testdata.bin").unwrap();
        let mut bs = vec![];
        fh.read_to_end(&mut bs).ok();
        b.iter(|| {
            let src = BytesBinarySource::new(&bs[..]);
            let mut r = IOValues::new(src.packed()).read_annotations(false);
            while let Some(Ok(_)) = r.next() {}
        })
    });
}

pub fn large_testdata_encoder(c: &mut Criterion) {
    c.bench_function("(oo) encode testdata.bin", |b| {
        let mut fh = io::BufReader::new(File::open("benches/testdata.bin").unwrap());
        let src = IOBinarySource::new(&mut fh);
        let vs = IOValues::new(src.packed()).read_annotations(true).collect::<Result<Vec<_>, _>>().unwrap();
        b.iter_with_large_drop(|| {
            let mut bs = vec![];
            let mut w = PackedWriter::new(&mut bs);
            let mut enc = IOValueDomainCodec;
            for v in &vs {
                v.write(&mut w, &mut enc).unwrap();
            }
            bs
        })
    });
}

pub fn large_testdata_decoder_view(c: &mut Criterion) {
    c.bench_function("(oo) view-decode testdata.bin", |b| {
        let mut fh = File::open("benches/testdata.bin").unwrap();
        let mut bs = vec![];
        fh.read_to_end(&mut bs).ok();
        b.iter(|| {
            let mut r = ViewIterator::new(&bs);
            while let Some(_) = r.next() {}
        })
    });
}

pub fn large_testdata_decoder_view_clone(c: &mut Criterion) {
    c.bench_function("(oo) view-decode testdata.bin with cloning", |b| {
        let mut fh = File::open("benches/testdata.bin").unwrap();
        let mut bs = vec![];
        fh.read_to_end(&mut bs).ok();
        b.iter(|| {
            let mut r = ViewIterator::new(&bs);
            while let Some(v) = r.next() {
                v.value_clone();
            }
        })
    });
}

pub fn large_testdata_decoder_view_deepcopy(c: &mut Criterion) {
    c.bench_function("(oo) view-decode testdata.bin with deep copy", |b| {
        let mut fh = File::open("benches/testdata.bin").unwrap();
        let mut bs = vec![];
        fh.read_to_end(&mut bs).ok();
        b.iter(|| {
            let mut r = ViewIterator::new(&bs);
            while let Some(v) = r.next() {
                deep_standalone_copy(&*v);
            }
        })
    });
}

pub fn large_testdata_encoder_view(c: &mut Criterion) {
    c.bench_function("(oo) view-encode testdata.bin", |b| {
        let mut fh = io::BufReader::new(File::open("benches/testdata.bin").unwrap());
        let mut bs = vec![];
        fh.read_to_end(&mut bs).ok();
        let vs = ViewIterator::new(&bs).collect::<Vec<_>>();
        b.iter_with_large_drop(|| {
            let mut bs = vec![];
            let mut w = PackedWriter::new(&mut bs);
            let mut enc = IOValueDomainCodec;
            for v in &vs {
                v.write(&mut w, &mut enc).unwrap();
            }
            bs
        })
    });
}

pub fn large_testdata_encoder_view_clone(c: &mut Criterion) {
    c.bench_function("(oo) view-encode testdata.bin with cloning", |b| {
        let mut fh = io::BufReader::new(File::open("benches/testdata.bin").unwrap());
        let mut bs = vec![];
        fh.read_to_end(&mut bs).ok();
        let vs = ViewIterator::new(&bs).map(|v| v.value_clone()).collect::<Vec<_>>();
        b.iter_with_large_drop(|| {
            let mut bs = vec![];
            let mut w = PackedWriter::new(&mut bs);
            let mut enc = IOValueDomainCodec;
            for v in &vs {
                v.write(&mut w, &mut enc).unwrap();
            }
            bs
        })
    });
}

pub fn large_testdata_encoder_view_deepcopy(c: &mut Criterion) {
    c.bench_function("(oo) view-encode testdata.bin with deep copy", |b| {
        let mut fh = io::BufReader::new(File::open("benches/testdata.bin").unwrap());
        let mut bs = vec![];
        fh.read_to_end(&mut bs).ok();
        let vs = ViewIterator::new(&bs).map(|v| deep_standalone_copy(&*v)).collect::<Vec<_>>();
        b.iter_with_large_drop(|| {
            let mut bs = vec![];
            let mut w = PackedWriter::new(&mut bs);
            let mut enc = IOValueDomainCodec;
            for v in &vs {
                v.write(&mut w, &mut enc).unwrap();
            }
            bs
        })
    });
}

criterion_group!(codec,
                 bench_decoder_bytes, bench_decoder_file, bench_decoder_buffered_file,
                 bench_encoder);
criterion_group!{
    name = large_testdata;
    config = Criterion::default().sample_size(10);
    targets =
        large_testdata_decoder_with_ann, large_testdata_decoder_without_ann, large_testdata_encoder,
        large_testdata_decoder_view, large_testdata_decoder_view_clone, large_testdata_decoder_view_deepcopy,
        large_testdata_encoder_view, large_testdata_encoder_view_clone, large_testdata_encoder_view_deepcopy
}
criterion_main!(codec, large_testdata);