nordisk/facett

facett-simview/tests/frame_time.rs

//! **Measured: the native frame time of the whole window at 110 000 persons**, on the
//! lane a host without a GPU renderer gets (the CPU painter's depth-strided sample).
//! Each frame orbits the camera, so the projection is really recomputed.
//!
//! `cargo test --release -p facett-simview --test frame_time -- --ignored --nocapture`

use std::time::Instant;

use facett_core::Facet;
use facett_graph3d::Msg as G3Msg;
use facett_simview::SimView;
use facett_simview::mock::{MockBackend, MockServer};

#[test]
#[ignore = "a measurement: run in --release"]
fn frame_time_at_110k_persons() {
    let persons = 110_000;
    let t0 = Instant::now();
    let mut v = SimView::new(Box::new(MockBackend::new(MockServer::new(persons))));
    v.step(0.0);
    let load = t0.elapsed();
    assert_eq!(v.state_json()["nodes"], persons);

    let ctx = egui::Context::default();
    let mut times = Vec::new();
    let mut verts = 0;
    for f in 0..60 {
        let _ = v.graph_mut().update(G3Msg::DragYaw(4.0));
        let input = egui::RawInput {
            screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1600.0, 900.0))),
            time: Some(f as f64 / 60.0),
            ..Default::default()
        };
        let t = Instant::now();
        let mut out = ctx.run_ui(input, |ui| {
            egui::CentralPanel::default().show(ui, |ui| v.ui(ui));
        });
        out.textures_delta.clear();
        let prims = ctx.tessellate(out.shapes, out.pixels_per_point);
        verts = prims.iter().map(|p| match &p.primitive { egui::epaint::Primitive::Mesh(m) => m.vertices.len(), _ => 0 }).sum::<usize>();
        times.push(t.elapsed().as_secs_f64() * 1e3);
    }
    let warm = &mut times[5..];
    warm.sort_by(f64::total_cmp);
    let (med, p95) = (warm[warm.len() / 2], warm[warm.len() * 95 / 100]);
    let st = v.state_json();
    println!(
        "simview frame @ {persons} persons, lane {}, cpu stride {}: median {med:.2} ms ({:.0} fps), p95 {p95:.2} ms, {verts} vertices/frame; load+decode+place {:.0} ms",
        st["render_lane"],
        st["cpu_paint_stride"],
        1e3 / med,
        load.as_secs_f64() * 1e3
    );
    assert_eq!(st["render_lane"], "cpu-strided");
    assert!(verts > 10_000, "the strided sample really paints: {verts} vertices");
}