#![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);
}
})
}