Benching write!, write_fmt, fmt::Write::write_str, and io::Write::write

vec_string_write_benches.rs

#![allow(unused_must_use)]
#![feature(test)]

extern crate test;

use std::fmt::Write as FmtWrite;
use std::io::Write as IoWrite;
use std::vec::Vec;

use test::Bencher;

#[bench]
fn vec_write_value(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem: Vec<u8> = Vec::new();
        for _ in 0..1000 {
            mem.write("abc".as_bytes());
        }
    });
}

#[bench]
fn vec_write_ref(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem: Vec<u8> = Vec::new();
        let wr = &mut mem as &mut dyn IoWrite;
        for _ in 0..1000 {
            wr.write("abc".as_bytes());
        }
    });
}

#[bench]
fn vec_write_macro1(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem: Vec<u8> = Vec::new();
        let wr = &mut mem as &mut dyn IoWrite;
        for _ in 0..1000 {
            write!(wr, "abc");
        }
    });
}

#[bench]
fn vec_write_macro2(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem: Vec<u8> = Vec::new();
        let wr = &mut mem as &mut dyn IoWrite;
        for _ in 0..1000 {
            write!(wr, "{}", "abc");
        }
    });
}

#[bench]
fn vec_write_fmt(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem: Vec<u8> = Vec::new();
        let wr = &mut mem as &mut dyn IoWrite;
        for _ in 0..1000 {
            wr.write_fmt(format_args!("abc"));
        }
    });
}

#[bench]
fn string_write_value(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem = String::new();
        for _ in 0..1000 {
            mem.write_str("abc");
        }
    });
}

#[bench]
fn string_write_ref(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem = String::new();
        let wr = &mut mem as &mut dyn FmtWrite;
        for _ in 0..1000 {
            wr.write_str("abc");
        }
    });
}

#[bench]
fn string_write_macro1(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem = String::new();
        let wr = &mut mem as &mut dyn FmtWrite;
        for _ in 0..1000 {
            write!(wr, "abc");
        }
    });
}

#[bench]
fn string_write_macro2(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem = String::new();
        let wr = &mut mem as &mut dyn FmtWrite;
        for _ in 0..1000 {
            write!(wr, "{}", "abc");
        }
    });
}

#[bench]
fn string_write_fmt(bh: &mut Bencher) {
    bh.iter(|| {
        let mut mem = String::new();
        let wr = &mut mem as &mut dyn FmtWrite;
        for _ in 0..1000 {
            wr.write_fmt(format_args!("abc"));
        }
    });
}