WIP

Cargo.toml

@@ -83,6 +83,9 @@ windows=["weresocool_error/windows", "weresocool_core/windows", "weresocool_pars
 wasm = ["weresocool_core/wasm", "weresocool_ast/wasm", "weresocool_instrument/wasm", "weresocool_parser/wasm", "weresocool_error/wasm"]
 
 
+[[bench]]
+name = "render_manager_read_bench"
+harness = false
 [[bench]]
 name = "render_op_render_bench"
 harness = false

benches/render_batch_bench.rs

@@ -9,8 +9,11 @@ use weresocool_instrument::{
     StereoWaveform,
 };
 
+use weresocool_shared::Settings;
+
 fn render_batch_bench(c: &mut Criterion) {
-    let filename = "songs/test/render_op_get_batch.socool".to_string();
+    Settings::init_default();
+    let filename = "simple.socool".to_string();
     c.bench_function("render_batch", |b| {
         b.iter(|| {
             let (nf, basis, mut table) = match Filename(&filename)

benches/render_manager_read_bench.rs

@@ -0,0 +1,54 @@
+mod perf;
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use weresocool_core::manager::RenderManager;
+
+use weresocool::{
+    generation::{RenderReturn, RenderType},
+    interpretable::{InputType::Filename, Interpretable},
+};
+use weresocool_instrument::renderable::{
+    nf_to_vec_renderable, render_voice::renderables_to_render_voices,
+};
+
+use weresocool_shared::Settings;
+
+fn setup_render_manager() -> RenderManager {
+    let filename = "simple.socool";
+    let mut rm = RenderManager::init(None, None, true, None);
+    let (nf, basis, mut table) = match Filename(&filename)
+        .make(RenderType::NfBasisAndTable, None)
+        .unwrap()
+    {
+        RenderReturn::NfBasisAndTable(nf, basis, table) => (nf, basis, table),
+        _ => {
+            panic!();
+        }
+    };
+
+    let renderables = nf_to_vec_renderable(&nf, &mut table, &basis).unwrap();
+    let voices = renderables_to_render_voices(renderables);
+
+    rm.push_render(voices, true);
+
+    rm
+}
+
+fn read_benchmark(c: &mut Criterion) {
+    Settings::init_default();
+    let mut manager = setup_render_manager();
+    let buffer_size = 1024 * 12;
+
+    c.bench_function("render_manager_read_bench", |b| {
+        b.iter(|| {
+            let manager = black_box(&mut manager);
+            manager.read(buffer_size)
+        })
+    });
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default().with_profiler(perf::FlamegraphProfiler::new(100));
+    targets = read_benchmark
+}
+criterion_main!(benches);

benches/render_op_render_bench.rs

@@ -9,7 +9,7 @@ use weresocool_shared::Settings;
 pub fn render_op_render_bench(c: &mut Criterion) {
     Settings::init_default();
     let mut oscillator = Oscillator::init();
-    let mut render_op = RenderOp::init_fglp(400.0, (1.0, 1.0), 10.0, 0.0, Settings::global());
+    let render_op = RenderOp::init_fglp(400.0, (1.0, 1.0), 10.0, 0.0, Settings::global());
 
     let offset = Offset {
         freq: 1.0,

instrument/src/stereo_waveform.rs

@@ -80,6 +80,38 @@ impl StereoWaveform {
             None
         }
     }
+
+    /// Sum a vec of StereoWaveform to a single stereo_waveform.
+    pub fn sum_many(mut vec_wav: Vec<Self>) -> StereoWaveform {
+        // Sort the vectors by length
+        StereoWaveform::sort_vecs(&mut vec_wav);
+
+        // Get the length of the longest vector
+        let max_len = vec_wav[0].l_buffer.len();
+
+        let mut result = StereoWaveform::new(max_len);
+
+        for wav in vec_wav {
+            StereoWaveform::sum_vec(&mut result.l_buffer, &wav.l_buffer[..]);
+            StereoWaveform::sum_vec(&mut result.r_buffer, &wav.r_buffer[..])
+        }
+
+        result
+    }
+
+    /// Sort a vec of StereoWaveform by length. Assumes both channels have the same
+    /// buffer length
+    fn sort_vecs(vec_wav: &mut [StereoWaveform]) {
+        vec_wav.sort_unstable_by(|a, b| b.l_buffer.len().cmp(&a.l_buffer.len()));
+    }
+
+    /// Sum two vectors. Assumes vector a is longer than or of the same length
+    /// as vector b.
+    pub fn sum_vec(a: &mut [f64], b: &[f64]) {
+        for (ai, bi) in a.iter_mut().zip(b) {
+            *ai += *bi;
+        }
+    }
 }
 
 impl Normalize for StereoWaveform {

simple.socool

@@ -0,0 +1,29 @@
+{ f: 311.127, l: 1, g: 1/3, p: 0 }
+
+thing1 = {
+    Overlay [
+        {1/1, 2, 1, 1},
+        {1/1, 0, 1, -1},
+    ]
+    | Seq [
+        Fm 1, Fm 9/8, Fm 5/4
+   ]
+}
+
+thing2 = {
+    Overlay [
+        {1/1, 3, 1, 1},
+        {1/1, 0, 1, -1},
+    ]
+    | Seq [
+        Fm 3/4
+    ]
+    | FitLength thing1
+}
+
+main = {
+    Overlay [
+        thing1,
+        thing2
+    ]
+}

src/lib.rs

@@ -9,9 +9,14 @@
 )]
 
 pub use weresocool_ast as ast;
+pub use weresocool_core::generation::*;
+pub use weresocool_core::interpretable::*;
 pub use weresocool_core::*;
 pub use weresocool_error as error;
 pub use weresocool_instrument as instrument;
+pub use weresocool_instrument::renderable::*;
+pub use weresocool_instrument::StereoWaveform;
 pub use weresocool_parser as parser;
 pub use weresocool_shared as shared;
+pub use weresocool_shared::Settings;
 pub mod testing;