improvise/benches/scale_bisect.rs

//! One configuration per process: build a sparse document, time the real paths.
//! `scale_bisect k=1000 n=100000 cats=3 prune=1 mode=grid`; see context/test-evidence/scale-bisect.md.

use std::collections::{HashMap, HashSet};
use std::io::Write;
use std::time::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::{self, ViewTarget};
use improvise_command::ui::host::Host;
use improvise_command::ui::project::{self, Viewport};
use improvise_command::ui::reduce::caught_up;
use improvise_io::persistence::{format_md, parse_md, save_to};
use improvise_io::storage::MemoryFs;
use improvise_protocol::{
    ClientFrame, KeyCode, KeyEvent, KeyModifiers, ModelCommand, RecordHash, render::RecordCell,
};

fn lcg(s: &mut u64, n: usize) -> usize {
    *s = s
        .wrapping_mul(6_364_136_223_846_793_005)
        .wrapping_add(1_442_695_040_888_963_407);
    (*s >> 33) as usize % n
}

struct Cfg {
    k: usize,
    n: usize,
    cats: usize,
    prune: bool,
    mode: String,
    groups: bool,
    ops: String,
}

fn arg(args: &HashMap<String, String>, k: &str, d: &str) -> String {
    args.get(k).cloned().unwrap_or_else(|| d.to_string())
}

fn document(c: &Cfg) -> (Workbook, Vec<CellKey>) {
    let mut wb = Workbook::new("bench");
    for ci in 0..c.cats {
        let cat = format!("C{ci}");
        wb.add_category(cat.clone()).expect("under the limit");
        for i in 0..c.k {
            if c.groups && ci == 0 {
                wb.add_item_in_group(&cat, format!("i{i}"), format!("G{}", i / 10))
                    .expect("added");
            } else {
                wb.add_item(&cat, format!("i{i}")).expect("added");
            }
        }
    }
    for m in ["Cost", "Rev"] {
        wb.add_item("_Measure", m).expect("virtual");
    }
    let space = (c.k as f64).powi(c.cats as i32);
    let wanted = c.n.min((space / 2.0).max(1.0) as usize);
    let (mut s, mut seen, mut recs) = (0x9E37_79B9_7F4A_7C15u64, HashSet::new(), Vec::new());
    while seen.len() < wanted {
        let d: Vec<usize> = (0..c.cats).map(|_| lcg(&mut s, c.k)).collect();
        if !seen.insert(d.clone()) {
            continue;
        }
        let coords: Vec<(String, String)> = d
            .iter()
            .enumerate()
            .map(|(ci, x)| (format!("C{ci}"), format!("i{x}")))
            .collect();
        recs.push(CellKey::new(coords.clone()));
        for (m, v) in [("Cost", 3.0), ("Rev", 5.0)] {
            let mut key = coords.clone();
            key.push(("_Measure".to_string(), m.to_string()));
            wb.model.set_cell(CellKey::new(key), CellValue::Number(v));
        }
    }
    let view = wb.active_view_mut();
    for ci in 0..c.cats {
        let axis = if c.mode == "records" || c.mode == "none" {
            Axis::None
        } else {
            Axis::Row
        };
        view.set_axis(&format!("C{ci}"), axis);
    }
    if c.mode == "records" {
        view.set_axis("_Index", Axis::Row);
        view.set_axis("_Dim", Axis::Column);
    } else {
        view.set_axis("_Measure", Axis::Column);
    }
    view.prune_empty = c.prune;
    (wb, recs)
}

fn maxrss_mb() -> f64 {
    let mut u: libc::rusage = unsafe { std::mem::zeroed() };
    unsafe { libc::getrusage(libc::RUSAGE_SELF, &mut u) };
    u.ru_maxrss as f64 / 1048576.0
}

fn rss_mb() -> f64 {
    let out = std::process::Command::new("ps")
        .args(["-o", "rss=", "-p", &std::process::id().to_string()])
        .output()
        .expect("ps");
    String::from_utf8_lossy(&out.stdout)
        .trim()
        .parse::<f64>()
        .unwrap_or(0.0)
        / 1024.0
}

/// Sample `f` up to `reps` times, stopping once `budget_ms` is spent (one sample minimum).
fn sample(name: &str, reps: usize, budget_ms: f64, mut f: impl FnMut(usize)) {
    let mut v = Vec::new();
    let start = Instant::now();
    for r in 0..reps {
        let t = Instant::now();
        f(r);
        v.push(t.elapsed().as_secs_f64() * 1000.0);
        if start.elapsed().as_secs_f64() * 1000.0 > budget_ms {
            break;
        }
    }
    v.sort_by(|a, b| a.partial_cmp(b).expect("finite"));
    println!(
        "{name} min={:.3} med={:.3} max={:.3} reps={}",
        v[0],
        v[v.len() / 2],
        v[v.len() - 1],
        v.len()
    );
    std::io::stdout().flush().ok();
}

fn once<T>(name: &str, f: impl FnOnce() -> T) -> T {
    let t = Instant::now();
    let v = f();
    println!(
        "{name} min={0:.3} med={0:.3} max={0:.3} reps=1",
        t.elapsed().as_secs_f64() * 1000.0
    );
    std::io::stdout().flush().ok();
    v
}

fn key(code: KeyCode) -> KeyEvent {
    KeyEvent::new(code, KeyModifiers::NONE)
}

fn main() {
    let args: HashMap<String, String> = std::env::args()
        .skip(1)
        .filter_map(|a| {
            a.split_once('=')
                .map(|(k, v)| (k.to_string(), v.to_string()))
        })
        .collect();
    let c = Cfg {
        k: arg(&args, "k", "1000").parse().expect("k"),
        n: arg(&args, "n", "100000").parse().expect("n"),
        cats: arg(&args, "cats", "3").parse().expect("cats"),
        prune: arg(&args, "prune", "1") == "1",
        mode: arg(&args, "mode", "grid"),
        groups: arg(&args, "groups", "0") == "1",
        ops: arg(
            &args,
            "ops",
            "open,key,frame,window,setcell,host,reshape,io",
        ),
    };
    let rows_cap: f64 = arg(&args, "rows_cap", "30000000").parse().expect("cap");
    let product = (c.k as f64).powi(c.cats as i32);
    if c.mode == "grid" && product > rows_cap {
        println!(
            "REFUSED product_rows={product:.3e} (> {rows_cap:.0}: layout would materialize it)"
        );
        return;
    }
    let want = |o: &str| c.ops.split(',').any(|x| x == o);
    let (wb, recs) = document(&c);
    println!(
        "cells={} records={} base_rss_mb={:.0}",
        wb.model.data.iter_cells().count(),
        recs.len(),
        rss_mb()
    );
    let mut app = once("open", || App::new(wb, None));
    println!(
        "rows={} cols={} rss_after_open_mb={:.0}",
        app.layout.row_count(),
        app.layout.col_count(),
        rss_mb()
    );
    app.term_width = 200;
    app.term_height = 50;
    let name = app.view_name().to_string();

    if want("key") {
        sample("keypress_down", 8, 6000.0, |_| {
            app.dispatch_key(key(KeyCode::Down));
        });
    }
    if want("frame") {
        let whole = |app: &App| Viewport {
            row_offset: 0,
            col_offset: 0,
            rows: app.layout.row_count(),
            cols: app.layout.col_count(),
        };
        sample("tui_frame_grid_of_whole", 3, 8000.0, |_| {
            std::hint::black_box(project::grid_of(&app, whole(&app)));
        });
        let cache = project::grid_of(&app, whole(&app));
        let area = ratatui::layout::Rect::new(0, 0, 200, 50);
        sample("tui_render_gridwidget_buffer", 5, 4000.0, |_| {
            let mut buf = ratatui::buffer::Buffer::empty(area);
            let w = improvise::ui::grid::GridWidget::new(
                &cache,
                app.cursor(),
                &app.view_state.active_view,
                &app.layout,
                &app.view_state.mode,
                &app.view_state.search_query,
                &app.view_state.buffers,
                app.drill_state.as_ref(),
            );
            ratatui::widgets::Widget::render(w, area, &mut buf);
            std::hint::black_box(buf);
        });
    }
    if want("window") {
        let mid = app.layout.row_count() / 2;
        for (label, off) in [("top", 0), ("mid", mid)] {
            let vp = Viewport {
                row_offset: off,
                col_offset: 0,
                rows: 45,
                cols: 12,
            };
            sample(&format!("browser_grid_of_{label}"), 5, 6000.0, |_| {
                std::hint::black_box(project::grid_of(&app, vp));
            });
        }
    }
    if want("setcell") && !recs.is_empty() {
        let existing = recs[recs.len() / 2].clone().with("_Measure", "Rev");
        sample("setcell_existing", 5, 6000.0, |r| {
            app.apply_effects(vec![Box::new(effect::SetCell(
                existing.clone(),
                CellValue::Number(10.0 + r as f64),
            ))]);
        });
        let mut s = 99u64;
        sample("setcell_new_record", 5, 6000.0, |_| {
            let mut coords: Vec<(String, String)> = (0..c.cats)
                .map(|ci| (format!("C{ci}"), format!("i{}", lcg(&mut s, c.k))))
                .collect();
            coords.push(("_Measure".into(), "Rev".into()));
            app.apply_effects(vec![Box::new(effect::SetCell(
                CellKey::new(coords),
                CellValue::Number(1.0),
            ))]);
        });
    }
    if want("reshape") && c.mode == "grid" {
        let v = || ViewTarget::Active;
        sample("reshape_hide_item", 3, 6000.0, |r| {
            app.apply_effects(vec![Box::new(effect::HideItem {
                view: v(),
                category: "C1".into(),
                item: format!("i{r}"),
            })]);
        });
        if c.groups {
            sample("reshape_toggle_group", 3, 6000.0, |_| {
                app.apply_effects(vec![Box::new(effect::ToggleGroup {
                    view: v(),
                    category: "C0".into(),
                    group: "G0".into(),
                })]);
            });
        }
        let last = format!("C{}", c.cats - 1);
        sample("reshape_set_axis", 4, 6000.0, |r| {
            let axis = if r % 2 == 0 { Axis::Page } else { Axis::Row };
            app.apply_effects(vec![Box::new(effect::SetAxis {
                view: v(),
                category: last.clone(),
                axis,
            })]);
        });
        sample("reshape_toggle_prune", 2, 6000.0, |_| {
            app.apply_effects(vec![Box::new(effect::TogglePruneEmpty(v()))]);
        });
    }
    if want("io") {
        let wbr = &app.model_state.workbook;
        let text = once("format_md", || format_md(wbr));
        println!("improv_mb={:.2}", text.len() as f64 / 1048576.0);
        once("parse_md", || parse_md(&text).expect("parses"));
        let fs = MemoryFs::new();
        sample("persist_per_command_save_to", 3, 6000.0, |_| {
            save_to(&fs, wbr, std::path::Path::new("d.improv")).expect("write");
        });
    }
    if want("host") && !recs.is_empty() {
        let mut host = Host::new(app);
        let (id, snap) = once("host_connect_snapshot", || host.connect(45, 12));
        sample("json_encode_snapshot", 3, 4000.0, |_| {
            std::hint::black_box(serde_json::to_vec(&snap.msg).expect("json"));
        });
        println!(
            "snapshot_kb={:.1}",
            serde_json::to_vec(&snap.msg).expect("json").len() as f64 / 1024.0
        );
        let rec = recs[recs.len() / 2].clone();
        let cell = RecordCell {
            record: RecordHash::of(&rec),
            measure: Some("Rev".into()),
        };
        let mut enc: Vec<(f64, usize)> = Vec::new();
        sample("host_handle_setcell_and_project", 4, 8000.0, |r| {
            let wire = caught_up(
                host.app(),
                ModelCommand::SetCell {
                    view: name.clone(),
                    cell: cell.clone(),
                    value: CellValue::Number(50.0 + r as f64),
                },
            );
            let out = host.handle(id, ClientFrame::command(wire));
            let t = Instant::now();
            let bytes: usize = out
                .iter()
                .map(|a| serde_json::to_vec(&a.msg).expect("json").len())
                .sum();
            enc.push((t.elapsed().as_secs_f64() * 1000.0, bytes));
        });
        println!("json_encode_setcell_updates ms={:?}", enc);
    }
    println!("maxrss_mb={:.0}", maxrss_mb());
}