#![feature(test)]
extern crate basic_dsp;
extern crate test;
pub mod tools;
#[cfg(test)]
mod real {
use crate::test::Bencher;
use crate::tools::*;
use basic_dsp::*;
#[inline(never)]
pub fn add_offset_reference32(mut array: Vec<f32>, offset: f32) -> Vec<f32> {
let mut i = 0;
while i < array.len() {
array[i] = array[i] + offset;
i += 1;
}
array
}
#[inline(never)]
pub fn add_offset_reference64(mut array: Vec<f64>, offset: f64) -> Vec<f64> {
let mut i = 0;
while i < array.len() {
array[i] = array[i] + offset;
i += 1;
}
array
}
#[bench]
fn real_offset_32s_reference(b: &mut Bencher) {
let mut vector = VectorBox::<Vec<f32>, f32>::new(Size::Small);
b.iter(|| vector.execute(|v, _| add_offset_reference32(v, 100.0)));
}
#[bench]
fn real_offset_64s_reference(b: &mut Bencher) {
let mut vector = VectorBox::<Vec<f64>, f64>::new(Size::Small);
b.iter(|| vector.execute(|v, _| add_offset_reference64(v, 100.0)))
}
#[inline(never)]
pub fn real_logn_reference32(mut array: Vec<f32>) -> Vec<f32> {
let mut i = 0;
while i < array.len() {
array[i] = array[i].ln();
i += 1;
}
array
}
#[bench]
fn vector_creation_32_benchmark(b: &mut Bencher) {
b.iter(|| {
let data = vec![0.0; DEFAULT_DATA_SIZE];
data.to_real_time_vec();
});
}
#[bench]
fn real_offset_32s_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.offset(100.0);
v
})
});
}
#[bench]
fn real_offset_32m_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Medium);
b.iter(|| {
vector.execute(|mut v, _| {
v.offset(100.0);
v
})
});
}
#[bench]
fn real_offset_32l_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Large);
b.iter(|| {
vector.execute(|mut v, _| {
v.offset(100.0);
v
})
});
}
#[bench]
fn real_offset_64s_benchmark(b: &mut Bencher) {
let mut vector = RealTime64Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.offset(100.0);
v
})
});
}
#[bench]
fn real_scale_32m_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.scale(10.0);
v
})
});
}
#[bench]
fn real_scale_with_mapping_32m_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Medium);
b.iter(|| {
vector.execute(|mut v, _| {
v.map_inplace((), &|v, _, _| 2.0 * v);
v
})
});
}
#[bench]
fn real_abs_32s_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.abs();
v
})
});
}
#[bench]
fn real_square_32s_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.square();
v
})
});
}
#[bench]
fn real_root_32s_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.root(3.0);
v
})
});
}
#[bench]
fn real_power_32s_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.powf(3.0);
v
})
});
}
#[bench]
fn real_log_32s_reference(b: &mut Bencher) {
let mut vector = VectorBox::<Vec<f32>, f32>::new(Size::Small);
b.iter(|| vector.execute(|v, _| real_logn_reference32(v)));
}
#[bench]
fn real_log_32s_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.ln();
v
})
});
}
#[bench]
fn real_log_32m_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Medium);
b.iter(|| {
vector.execute(|mut v, _| {
v.ln();
v
})
});
}
#[bench]
fn real_log_32l_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Large);
b.iter(|| {
vector.execute(|mut v, _| {
v.ln();
v
})
});
}
#[bench]
fn real_log_approx_32s_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.ln_approx();
v
})
});
}
#[bench]
fn real_exp_32s_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.exp();
v
})
});
}
#[bench]
fn real_exp_approx_32s_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.exp_approx();
v
})
});
}
#[bench]
fn wrap_32s_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.wrap(10.0);
v
})
});
}
#[bench]
fn unwrap_32s_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.unwrap(10.0);
v
})
});
}
#[bench]
fn diff_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.diff_with_start();
v
})
});
}
#[bench]
fn cum_sum_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.cum_sum();
v
})
});
}
#[bench]
fn real_vector_multiplication_32s_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute_with_arg(|mut v, o, _| {
v.mul(&o).unwrap();
(v, o)
})
});
}
#[bench]
fn real_sin_32s_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.sin();
v
})
});
}
#[bench]
fn real_sin_approx_32s_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.sin_approx();
v
})
});
}
#[bench]
fn real_sin_32m_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Medium);
b.iter(|| {
vector.execute(|mut v, _| {
v.sin();
v
})
});
}
#[bench]
fn real_sin_64s_benchmark(b: &mut Bencher) {
let mut vector = RealTime64Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.sin();
v
})
});
}
#[bench]
fn swap_halves_32m_even_benchmark(b: &mut Bencher) {
let mut vector = Gen32Box::with_size(10000);
b.iter(|| {
vector.execute(|mut v, _| {
v.swap_halves();
v
})
});
}
#[bench]
fn swap_halves_32m_odd_benchmark(b: &mut Bencher) {
let mut vector = Gen32Box::with_size(10000);
b.iter(|| {
vector.execute(|mut v, _| {
v.swap_halves();
v
})
});
}
#[bench]
fn reverse_32s_benchmark(b: &mut Bencher) {
let mut vector = RealTime32Box::new(Size::Small);
b.iter(|| {
vector.execute(|mut v, _| {
v.reverse();
v
})
});
}
}