use iterpipes::*;
use time::Instant;
mod piped {
use iterpipes::Pipe;
struct Envelope {
attack_len: usize,
decay_len: usize,
}
impl Envelope {
pub fn new(attack_len: usize, decay_len: usize) -> Self {
Self {
attack_len,
decay_len,
}
}
}
impl Pipe for Envelope {
type InputItem = usize;
type OutputItem = f32;
fn next(&mut self, index: usize) -> f32 {
if index < self.attack_len {
index as f32 / self.attack_len as f32
} else if index < self.attack_len + self.decay_len {
1.0 - ((index - self.attack_len) as f32 / self.decay_len as f32)
} else {
0.0
}
}
}
struct SineWave {
wave_length: usize,
}
impl SineWave {
pub fn new(wave_length: usize) -> Self {
SineWave { wave_length }
}
}
impl Pipe for SineWave {
type InputItem = usize;
type OutputItem = f32;
fn next(&mut self, index: usize) -> f32 {
let index = index % self.wave_length;
let progress = index as f32 / self.wave_length as f32;
(progress * 2.0 * std::f32::consts::PI).sin()
}
}
pub struct Metronome {
env: Envelope,
sine: SineWave,
pulse_distance: usize,
}
impl Metronome {
pub fn new(
attack_len: usize,
decay_len: usize,
wave_length: usize,
pulse_distance: usize,
) -> Self {
Self {
env: Envelope::new(attack_len, decay_len),
sine: SineWave::new(wave_length),
pulse_distance,
}
}
}
impl Pipe for Metronome {
type InputItem = usize;
type OutputItem = f32;
fn next(&mut self, index: usize) -> f32 {
self.sine.next(index) * self.env.next(index % self.pulse_distance)
}
}
}
mod manual {
use iterpipes::Pipe;
pub struct Metronome {
attack_len: usize,
decay_len: usize,
wave_length: usize,
pulse_distance: usize,
}
impl Metronome {
pub fn new(
attack_len: usize,
decay_len: usize,
wave_length: usize,
pulse_distance: usize,
) -> Self {
Self {
attack_len,
decay_len,
wave_length,
pulse_distance,
}
}
}
impl Pipe for Metronome {
type InputItem = usize;
type OutputItem = f32;
fn next(&mut self, index: usize) -> f32 {
let wave_index = index % self.wave_length;
let wave_progress = wave_index as f32 / self.wave_length as f32;
let wave_frame = (wave_progress * 2.0 * std::f32::consts::PI).sin();
let env_index = index % self.pulse_distance;
let env_frame = if env_index < self.attack_len {
index as f32 / self.attack_len as f32
} else if env_index < self.attack_len + self.decay_len {
1.0 - ((env_index - self.attack_len) as f32 / self.decay_len as f32)
} else {
0.0
};
wave_frame * env_frame
}
}
}
fn benchmark_pipe<P, F>(length: usize, runs: usize, mut factory: F) -> Vec<f32>
where
P: Pipe<InputItem = usize, OutputItem = f32>,
F: FnMut() -> P,
{
use std::io::Write;
let mut signal_buffer = vec![0.0; length].into_boxed_slice();
let mut durations: Vec<f32> = Vec::with_capacity(runs);
for _ in 0..runs {
let mut pipe = factory();
let start = Instant::now();
for i in 0..length {
signal_buffer[i] = pipe.next(i);
}
let end = Instant::now();
let duration = (end - start).as_seconds_f32();
print!("{}, ", duration);
std::io::stdout().flush().unwrap();
durations.push(duration);
}
println!();
durations
}
const INFO: &str = "# This program benchmarks pipes by rendering a simple metronome signal.
# The signal is calculated by a pipes-based implementation first and by a manually implementated one
# afterwards. Both implementations are executed 200 times each, which will take about 15 minutes,
# depending on your system. The runtime of each execution is printed in a CSV-style format, which
# can parsed and analyzed.
#
# This benchmark shows that pipes-based implementations is exactly as fast as a manual
# implementation if it was compiled with the lto flag.
#
";
fn main() {
const LEN: usize = 200_000_000;
const RUNS: usize = 200;
print!("{}", INFO);
println!("# Runtimes of the piped version:");
let mut counter: usize = 0;
let piped_durations: Vec<f32> = benchmark_pipe(LEN, RUNS, move || {
counter += 1;
piped::Metronome::new(500, 500, 100 * counter, 1_000)
});
println!("# Runtimes of the manual version:");
let mut counter: usize = 0;
let manual_durations: Vec<f32> = benchmark_pipe(LEN, RUNS, move || {
counter += 1;
manual::Metronome::new(500, 500, 100 * counter, 1_000)
});
let mean_duration_piped: f32 =
piped_durations.iter().sum::<f32>() / piped_durations.len() as f32;
let mean_duration_manual: f32 =
manual_durations.iter().sum::<f32>() / manual_durations.len() as f32;
let combined: Vec<(f32, f32)> = Iterator::zip(piped_durations.iter(), manual_durations.iter())
.map(|(piped, manual)| (piped - manual, piped / manual))
.collect();
let (
mean_difference,
mean_relation,
min_difference,
max_difference,
min_relation,
max_relation,
) = combined.iter().cloned().fold(
(
0.0,
0.0,
combined[0].0,
combined[0].0,
combined[0].1,
combined[0].1,
),
|(diff_sum, rel_sum, min_diff, max_diff, min_rel, max_rel), (diff, rel)| {
(
diff_sum + diff,
rel_sum + rel,
f32::min(min_diff, diff),
f32::max(max_diff, diff),
f32::min(min_rel, rel),
f32::max(max_rel, rel),
)
},
);
let (mean_difference, mean_relation) = (
mean_difference / combined.len() as f32,
mean_relation / combined.len() as f32,
);
println!(
"# Mean duration of a piped execution: {}s",
mean_duration_piped
);
println!(
"# Mean duration of a manual execution: {}s",
mean_duration_manual
);
println!(
"# Minimal, Mean, and Maximal difference between a piped and a manual execution: {}s, {}s, {}s",
min_difference, mean_difference, max_difference
);
println!(
"# Minimal, Mean, and Maximal relation between a piped and a manual exection: {}, {}, {}",
min_relation, mean_relation, max_relation
);
}