serde_macros 0.6.5

#![feature(test)]

extern crate test;

use std::env;
use std::mem;
use std::str::FromStr;

#[repr(i8)]
enum State {
    X0,
    X1,
    X2,
    X3,
    X4,
    X5,
    X6,
    X7,
    X8,
    X9,
}

fn range() -> i32 {
    i32::from_str(&env::var("COUNT").unwrap()).unwrap()
}

#[inline(never)]
fn do_uninit(i: i32) -> (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32) {
    let mut state = State::X0;
    let mut x0 = unsafe { mem::uninitialized() };
    let mut x1 = unsafe { mem::uninitialized() };
    let mut x2 = unsafe { mem::uninitialized() };
    let mut x3 = unsafe { mem::uninitialized() };
    let mut x4 = unsafe { mem::uninitialized() };
    let mut x5 = unsafe { mem::uninitialized() };
    let mut x6 = unsafe { mem::uninitialized() };
    let mut x7 = unsafe { mem::uninitialized() };
    let mut x8 = unsafe { mem::uninitialized() };
    let x9;

    let mut j = 0;
    loop {
        match state {
            State::X0 => { x0 = i + j; j += 1; state = State::X1; }
            State::X1 => { x1 = i + j; j += 1; state = State::X2; }
            State::X2 => { x2 = i + j; j += 1; state = State::X3; }
            State::X3 => { x3 = i + j; j += 1; state = State::X4; }
            State::X4 => { x4 = i + j; j += 1; state = State::X5; }
            State::X5 => { x5 = i + j; j += 1; state = State::X6; }
            State::X6 => { x6 = i + j; j += 1; state = State::X7; }
            State::X7 => { x7 = i + j; j += 1; state = State::X8; }
            State::X8 => { x8 = i + j; j += 1; state = State::X9; }
            State::X9 => {
                x9 = i + j;
                return (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
            }
        }
    }
}

#[bench]
fn bench_uninit(b: &mut test::Bencher) {
    b.iter(|| {
        for i in 0 .. range() {
            let tuple = do_uninit(i);
            assert_eq!(tuple, (i + 0, i + 1, i + 2, i + 3, i + 4, i + 5, i + 6, i + 7, i + 8, i + 9));

            test::black_box(tuple);
        }
    })
}

struct UninitStruct {
    state: State,
    x0: i32,
    x1: i32,
    x2: i32,
    x3: i32,
    x4: i32,
    x5: i32,
    x6: i32,
    x7: i32,
    x8: i32,
    x9: i32,
}

#[inline(never)]
fn do_uninit_struct(i: i32) -> (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32) {
    let mut uninit = UninitStruct {
        state: State::X0,
        x0: unsafe { mem::uninitialized() },
        x1: unsafe { mem::uninitialized() },
        x2: unsafe { mem::uninitialized() },
        x3: unsafe { mem::uninitialized() },
        x4: unsafe { mem::uninitialized() },
        x5: unsafe { mem::uninitialized() },
        x6: unsafe { mem::uninitialized() },
        x7: unsafe { mem::uninitialized() },
        x8: unsafe { mem::uninitialized() },
        x9: unsafe { mem::uninitialized() },
    };

    let mut j = 0;
    loop {
        match uninit.state {
            State::X0 => { uninit.x0 = i + j; j += 1; uninit.state = State::X1; }
            State::X1 => { uninit.x1 = i + j; j += 1; uninit.state = State::X2; }
            State::X2 => { uninit.x2 = i + j; j += 1; uninit.state = State::X3; }
            State::X3 => { uninit.x3 = i + j; j += 1; uninit.state = State::X4; }
            State::X4 => { uninit.x4 = i + j; j += 1; uninit.state = State::X5; }
            State::X5 => { uninit.x5 = i + j; j += 1; uninit.state = State::X6; }
            State::X6 => { uninit.x6 = i + j; j += 1; uninit.state = State::X7; }
            State::X7 => { uninit.x7 = i + j; j += 1; uninit.state = State::X8; }
            State::X8 => { uninit.x8 = i + j; j += 1; uninit.state = State::X9; }
            State::X9 => { uninit.x9 = i + j; break; }
        }
    }

    (uninit.x0, uninit.x1, uninit.x2, uninit.x3, uninit.x4, uninit.x5, uninit.x6, uninit.x7, uninit.x8, uninit.x9)
}

#[bench]
fn bench_uninit_struct(b: &mut test::Bencher) {
    b.iter(|| {
        for i in 0 .. range() {
            let tuple = do_uninit_struct(i);
            assert_eq!(tuple, (i + 0, i + 1, i + 2, i + 3, i + 4, i + 5, i + 6, i + 7, i + 8, i + 9));

            test::black_box(tuple);
        }
    })
}

#[inline(never)]
fn do_init(i: i32) -> (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32) {
    let mut state = State::X0;
    let mut x0 = 0;
    let mut x1 = 0;
    let mut x2 = 0;
    let mut x3 = 0;
    let mut x4 = 0;
    let mut x5 = 0;
    let mut x6 = 0;
    let mut x7 = 0;
    let mut x8 = 0;
    let x9;

    let mut j = 0;
    loop {
        match state {
            State::X0 => { x0 = i + j; j += 1; state = State::X1; }
            State::X1 => { x1 = i + j; j += 1; state = State::X2; }
            State::X2 => { x2 = i + j; j += 1; state = State::X3; }
            State::X3 => { x3 = i + j; j += 1; state = State::X4; }
            State::X4 => { x4 = i + j; j += 1; state = State::X5; }
            State::X5 => { x5 = i + j; j += 1; state = State::X6; }
            State::X6 => { x6 = i + j; j += 1; state = State::X7; }
            State::X7 => { x7 = i + j; j += 1; state = State::X8; }
            State::X8 => { x8 = i + j; j += 1; state = State::X9; }
            State::X9 => { x9 = i + j; break; }
        }
    }

    (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)
}

#[bench]
fn bench_init(b: &mut test::Bencher) {
    b.iter(|| {
        for i in 0 .. range() {
            let tuple = do_init(i);
            assert_eq!(tuple, (i + 0, i + 1, i + 2, i + 3, i + 4, i + 5, i + 6, i + 7, i + 8, i + 9));

            test::black_box(tuple);
        }
    })
}

#[inline(never)]
fn do_option(i: i32) -> (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32) {
    let mut state = State::X0;
    let mut x0 = None;
    let mut x1 = None;
    let mut x2 = None;
    let mut x3 = None;
    let mut x4 = None;
    let mut x5 = None;
    let mut x6 = None;
    let mut x7 = None;
    let mut x8 = None;
    let x9;

    let mut j = 0;
    loop {
        match state {
            State::X0 => { x0 = Some(i + j); j += 1; state = State::X1; }
            State::X1 => { x1 = Some(i + j); j += 1; state = State::X2; }
            State::X2 => { x2 = Some(i + j); j += 1; state = State::X3; }
            State::X3 => { x3 = Some(i + j); j += 1; state = State::X4; }
            State::X4 => { x4 = Some(i + j); j += 1; state = State::X5; }
            State::X5 => { x5 = Some(i + j); j += 1; state = State::X6; }
            State::X6 => { x6 = Some(i + j); j += 1; state = State::X7; }
            State::X7 => { x7 = Some(i + j); j += 1; state = State::X8; }
            State::X8 => { x8 = Some(i + j); j += 1; state = State::X9; }
            State::X9 => { x9 = i + j; break; }
        }
    }

    match (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) {
        (
            Some(x0),
            Some(x1),
            Some(x2),
            Some(x3),
            Some(x4),
            Some(x5),
            Some(x6),
            Some(x7),
            Some(x8),
            x9,
        ) => (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9),
        _ => panic!()
    }
}

#[bench]
fn bench_option(b: &mut test::Bencher) {
    b.iter(|| {
        for i in 0 .. range() {
            let tuple = do_option(i);
            assert_eq!(tuple, (i + 0, i + 1, i + 2, i + 3, i + 4, i + 5, i + 6, i + 7, i + 8, i + 9));

            test::black_box(tuple);
        }
    })
}

enum Enum {
    X,
    X0(i32,),
    X1(i32, i32),
    X2(i32, i32, i32),
    X3(i32, i32, i32, i32),
    X4(i32, i32, i32, i32, i32),
    X5(i32, i32, i32, i32, i32, i32),
    X6(i32, i32, i32, i32, i32, i32, i32),
    X7(i32, i32, i32, i32, i32, i32, i32, i32),
    X8(i32, i32, i32, i32, i32, i32, i32, i32, i32),
}

#[inline(never)]
fn do_enum(i: i32) -> (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32) {
    let mut x = Enum::X;

    let mut j = 0;
    loop {
        match x {
            Enum::X => {
                let x0 = i + j; j += 1;
                x = Enum::X0(x0,);
            }
            Enum::X0(x0,) => {
                let x1 = i + j; j += 1;
                x = Enum::X1(x0, x1);
            }
            Enum::X1(x0, x1) => {
                let x2 = i + j; j += 1;
                x = Enum::X2(x0, x1, x2);
            }
            Enum::X2(x0, x1, x2) => {
                let x3 = i + j; j += 1;
                x = Enum::X3(x0, x1, x2, x3);
            }
            Enum::X3(x0, x1, x2, x3) => {
                let x4 = i + j; j += 1;
                x = Enum::X4(x0, x1, x2, x3, x4);
            }
            Enum::X4(x0, x1, x2, x3, x4) => {
                let x5 = i + j; j += 1;
                x = Enum::X5(x0, x1, x2, x3, x4, x5);
            }
            Enum::X5(x0, x1, x2, x3, x4, x5) => {
                let x6 = i + j; j += 1;
                x = Enum::X6(x0, x1, x2, x3, x4, x5, x6);
            }
            Enum::X6(x0, x1, x2, x3, x4, x5, x6) => {
                let x7 = i + j; j += 1;
                x = Enum::X7(x0, x1, x2, x3, x4, x5, x6, x7);
            }
            Enum::X7(x0, x1, x2, x3, x4, x5, x6, x7) => {
                let x8 = i + j; j += 1;
                x = Enum::X8(x0, x1, x2, x3, x4, x5, x6, x7, x8);
            }
            Enum::X8(x0, x1, x2, x3, x4, x5, x6, x7, x8) => {
                let x9 = i + j;
                return (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
            }
        }
    }
}

#[bench]
fn bench_enum(b: &mut test::Bencher) {
    b.iter(|| {
        for i in 0 .. range() {
            let tuple = do_enum(i);
            assert_eq!(tuple, (i + 0, i + 1, i + 2, i + 3, i + 4, i + 5, i + 6, i + 7, i + 8, i + 9));

            test::black_box(tuple);
        }
    })
}