#[macro_export]
macro_rules! bench_func {
($name: ident, $desc: expr, op => $func: ident, from => $from: expr) => {
pub(crate) fn $name(c: &mut Criterion) {
const SIZE: usize = 1 << 13;
let mut rng = support::PCG32::default();
let inputs =
criterion::black_box((0..SIZE).map(|_| $from(&mut rng)).collect::<Vec<_>>());
let mut outputs = vec![$func($from(&mut rng)); SIZE];
let mut i = 0;
c.bench_function($desc, |b| {
b.iter(|| {
i = (i + 1) & (SIZE - 1);
unsafe {
*outputs.get_unchecked_mut(i) = $func(*inputs.get_unchecked(i));
}
})
});
criterion::black_box(outputs);
}
};
}
#[macro_export]
macro_rules! bench_unop {
($name: ident, $desc: expr, op => $unop: ident, from => $from: expr) => {
pub(crate) fn $name(c: &mut Criterion) {
const SIZE: usize = 1 << 13;
let mut rng = support::PCG32::default();
let inputs =
criterion::black_box((0..SIZE).map(|_| $from(&mut rng)).collect::<Vec<_>>());
let mut outputs = vec![$from(&mut rng).$unop(); SIZE];
let mut i = 0;
c.bench_function($desc, |b| {
b.iter(|| {
i = (i + 1) & (SIZE - 1);
unsafe {
*outputs.get_unchecked_mut(i) = inputs.get_unchecked(i).$unop();
}
})
});
criterion::black_box(outputs);
}
};
}
#[macro_export]
macro_rules! bench_binop {
($name: ident, $desc: expr, op => $binop: ident, from1 => $from1:expr, from2 => $from2:expr) => {
pub(crate) fn $name(c: &mut Criterion) {
const SIZE: usize = 1 << 13;
let mut rng = support::PCG32::default();
let inputs1 =
criterion::black_box((0..SIZE).map(|_| $from1(&mut rng)).collect::<Vec<_>>());
let inputs2 =
criterion::black_box((0..SIZE).map(|_| $from2(&mut rng)).collect::<Vec<_>>());
let mut outputs = vec![$from1(&mut rng).$binop($from2(&mut rng)); SIZE];
let mut i = 0;
c.bench_function($desc, |b| {
b.iter(|| {
i = (i + 1) & (SIZE - 1);
unsafe {
*outputs.get_unchecked_mut(i) = inputs1.get_unchecked(i).$binop(*inputs2.get_unchecked(i));
}
})
});
criterion::black_box(outputs);
}
};
($name: ident, $desc: expr, op => $binop: ident, from => $from: expr) => {
bench_binop!($name, $desc, op => $binop, from1 => $from, from2 => $from);
};
}
#[macro_export]
macro_rules! bench_trinop {
($name: ident, $desc: expr, op => $trinop: ident, from1 => $from1:expr, from2 => $from2:expr, from3 => $from3:expr) => {
pub(crate) fn $name(c: &mut Criterion) {
const SIZE: usize = 1 << 13;
let mut rng = support::PCG32::default();
let inputs1 =
criterion::black_box((0..SIZE).map(|_| $from1(&mut rng)).collect::<Vec<_>>());
let inputs2 =
criterion::black_box((0..SIZE).map(|_| $from2(&mut rng)).collect::<Vec<_>>());
let inputs3 =
criterion::black_box((0..SIZE).map(|_| $from3(&mut rng)).collect::<Vec<_>>());
let mut outputs =
vec![$from1(&mut rng).$trinop($from2(&mut rng), $from3(&mut rng)); SIZE];
let mut i = 0;
c.bench_function($desc, |b| {
b.iter(|| {
i = (i + 1) & (SIZE - 1);
unsafe {
*outputs.get_unchecked_mut(i) = inputs1
.get_unchecked(i)
.$trinop(*inputs2.get_unchecked(i), *inputs3.get_unchecked(i));
}
})
});
criterion::black_box(outputs);
}
};
}
#[macro_export]
macro_rules! bench_select {
($name:ident, $desc:expr, ty => $ty: ident, op => $op: ident, from => $from:expr) => {
pub(crate) fn $name(c: &mut Criterion) {
const SIZE: usize = 1 << 13;
let mut rng = support::PCG32::default();
let inputs1 =
criterion::black_box((0..SIZE).map(|_| $from(&mut rng)).collect::<Vec<_>>());
let inputs2 =
criterion::black_box((0..SIZE).map(|_| $from(&mut rng)).collect::<Vec<_>>());
let masks = vec![$from(&mut rng).$op($from(&mut rng)); SIZE];
let mut outputs = vec![$from(&mut rng); SIZE];
let mut i = 0;
c.bench_function($desc, |b| {
b.iter(|| {
i = (i + 1) & (SIZE - 1);
unsafe {
*outputs.get_unchecked_mut(i) = $ty::select(
*masks.get_unchecked(i),
*inputs1.get_unchecked(i),
*inputs2.get_unchecked(i),
);
}
})
});
criterion::black_box(outputs);
}
};
}
#[macro_export]
macro_rules! bench_from_ypr {
($name: ident, $desc: expr, ty => $ty:ty) => {
pub(crate) fn $name(c: &mut Criterion) {
const SIZE: usize = 1 << 13;
let mut rng = support::PCG32::default();
let inputs = criterion::black_box(
(0..SIZE)
.map(|_| {
(
random_radians(&mut rng),
random_radians(&mut rng),
random_radians(&mut rng),
)
})
.collect::<Vec<_>>(),
);
let mut outputs = vec![<$ty>::default(); SIZE];
let mut i = 0;
c.bench_function($desc, |b| {
b.iter(|| {
i = (i + 1) & (SIZE - 1);
unsafe {
let data = inputs.get_unchecked(i);
*outputs.get_unchecked_mut(i) =
<$ty>::from_euler(glam::EulerRot::YXZ, data.0, data.1, data.2)
}
})
});
}
};
}
#[macro_export]
macro_rules! euler {
($name: ident, $desc: expr, ty => $t: ty, storage => $storage: ty, zero => $zero: expr, rand => $rand: ident) => {
pub(crate) fn $name(c: &mut Criterion) {
const UPDATE_RATE: f32 = 1.0 / 60.0;
const NUM_OBJECTS: usize = 10000;
struct TestData {
acc: Vec<$storage>,
vel: Vec<$storage>,
pos: Vec<$storage>,
}
let mut rng = support::PCG32::default();
let mut data = TestData {
acc: vec![$rand(&mut rng); NUM_OBJECTS],
vel: vec![$zero; NUM_OBJECTS],
pos: vec![$zero; NUM_OBJECTS],
};
let dt = <$t>::splat(UPDATE_RATE);
c.bench_function($desc, |b| {
b.iter(|| {
for ((position, acceleration), velocity) in
data.pos.iter_mut().zip(&data.acc).zip(&mut data.vel)
{
let local_acc: $t = (*acceleration).into();
let mut local_pos: $t = (*position).into();
let mut local_vel: $t = (*velocity).into();
local_vel += local_acc * dt;
local_pos += local_vel * dt;
*velocity = local_vel.into();
*position = local_pos.into();
}
})
});
}
};
}