improvise/benches/reshape_observation.rs

//! What a model batch costs on the keypress path, which is where the reshape
//! observation sits (improvise-ni6k). Run with
//! `cargo bench --bench reshape_observation`.

use std::time::{Duration, Instant};

use improvise::model::cell::{CellKey, CellValue};
use improvise::view::Axis;
use improvise::workbook::Workbook;
use improvise_command::ui::app::App;
use improvise_command::ui::effect::{Effect, SetCell};

/// The fixture `grid_projection` uses, so the two numbers are comparable.
fn dense_app(regions: usize, products: usize, measures: usize) -> App {
    let mut wb = Workbook::new("Bench");
    wb.add_category("Region").unwrap();
    wb.add_category("Product").unwrap();
    let regions: Vec<String> = (0..regions).map(|i| format!("Region{i}")).collect();
    let products: Vec<String> = (0..products).map(|i| format!("Product{i}")).collect();
    let measures: Vec<String> = (0..measures).map(|i| format!("Measure{i}")).collect();
    for r in &regions {
        wb.add_item("Region", r.clone()).unwrap();
    }
    for p in &products {
        wb.add_item("Product", p.clone()).unwrap();
    }
    for m in &measures {
        wb.add_item("_Measure", m.clone()).unwrap();
    }
    {
        let v = wb.active_view_mut();
        v.set_axis("Region", Axis::Row);
        v.set_axis("Product", Axis::Row);
        v.set_axis("_Measure", Axis::Column);
    }
    let mut n = 0.0f64;
    for r in &regions {
        for p in &products {
            for m in &measures {
                n += 1.0;
                let key = CellKey::new(vec![
                    ("Region".to_string(), r.clone()),
                    ("Product".to_string(), p.clone()),
                    ("_Measure".to_string(), m.clone()),
                ]);
                wb.model.set_cell(key, CellValue::Number(n));
            }
        }
    }
    // More than one view, because the observation runs over all of them.
    wb.create_view("Second");
    wb.switch_view("Default").unwrap();
    let mut app = App::new(wb, None);
    app.rebuild_layout();
    app
}

/// Min-of-N for the reason `grid_projection` says: a mean over a few runs
/// measures the machine, not the code.
fn time_batch(iters: u32, app: &mut App, key: &CellKey) -> Duration {
    let mut best = Duration::MAX;
    for i in 0..iters.max(3) {
        let effects: Vec<Box<dyn Effect>> = vec![Box::new(SetCell(
            key.clone(),
            CellValue::Number(i as f64 + 1.0),
        ))];
        let start = Instant::now();
        std::hint::black_box(app.apply_effects(effects));
        best = best.min(start.elapsed());
    }
    best
}

fn case(label: &str, regions: usize, products: usize, measures: usize, iters: u32) {
    let mut app = dense_app(regions, products, measures);
    let (rows, cols) = (app.layout.row_count(), app.layout.col_count());
    let key = CellKey::new(vec![
        ("Region".to_string(), "Region0".to_string()),
        ("Product".to_string(), "Product0".to_string()),
        ("_Measure".to_string(), "Measure0".to_string()),
    ]);
    let batch = time_batch(iters, &mut app, &key);
    println!(
        "{label:<22} {rows:>5} x {cols:>3} = {:>7} cells  one SetCell batch {batch:>11.3?}",
        rows * cols
    );
}

fn main() {
    println!("App::apply_effects, one model batch = one keypress that writes a cell");
    println!("a 60fps frame budget is 16.7ms\n");
    case("typical", 20, 5, 4, 200);
    case("large", 60, 20, 8, 50);
    case("18k cells (gotcha 41)", 150, 20, 6, 20);
    case("pathological", 300, 30, 10, 5);
}