nordisk/facett

facet-wrapped/examples/browser_bench.rs

//! Run the browser bench harness (`facet_wrapped::browser_bench`) from the command line.
//!
//! ```text
//! cargo run --release -p facet-wrapped --example browser_bench -- \
//!     --dist facet-wrapped/dist --component graphnav --nodes 100000 --power high [--port 8701] [--headless]
//! ```
//!
//! Prints the page's JSON result on stdout; `--out FILE` also appends it as one line.

use std::path::PathBuf;
use std::time::Duration;

use facet_wrapped::browser_bench::{self, BrowserRun, Power};

fn main() {
    let mut args = std::env::args().skip(1);
    let mut dist = PathBuf::from("facet-wrapped/dist");
    let mut component = "graphnav".to_string();
    let mut nodes = 10_000usize;
    let mut power = Power::HighPerformance;
    let mut drag_ms = 3000u32;
    let mut timeout = 300u64;
    let mut out: Option<PathBuf> = None;
    // 0 = not given: take the first free port of 8701..=8719, the bench lane's range on
    // a shared box (loki, the t14s), rather than whatever the OS hands out.
    let mut port = 0u16;
    // Headless Chrome on the GPU render node (a box someone is working on); default is a
    // headful window on the desktop session.
    let mut headless = false;
    while let Some(a) = args.next() {
        let mut val = || args.next().unwrap_or_else(|| panic!("{a} needs a value"));
        match a.as_str() {
            "--dist" => dist = PathBuf::from(val()),
            "--component" => component = val(),
            "--nodes" => nodes = val().parse().expect("--nodes N"),
            "--power" => {
                power = match val().as_str() {
                    "low" | "low-power" => Power::LowPower,
                    _ => Power::HighPerformance,
                }
            }
            "--drag-ms" => drag_ms = val().parse().expect("--drag-ms N"),
            "--timeout-s" => timeout = val().parse().expect("--timeout-s N"),
            "--out" => out = Some(PathBuf::from(val())),
            "--port" => port = val().parse().expect("--port N"),
            "--headless" => headless = true,
            other => panic!("unknown argument {other}"),
        }
    }
    if port == 0 {
        port = (8701..=8719)
            .find(|p| std::net::TcpListener::bind(("127.0.0.1", *p)).is_ok())
            .expect("every port of 8701..=8719 is taken; pass --port");
    }
    let chrome = browser_bench::find_chrome().expect("no Chrome on PATH (set CHROME=)");
    let scratch = std::env::var_os("TMPDIR").map_or_else(std::env::temp_dir, PathBuf::from);
    let run = BrowserRun {
        dist,
        component,
        nodes,
        power,
        drag_ms,
        timeout: Duration::from_secs(timeout),
        chrome,
        scratch,
        port,
        headless,
    };
    match browser_bench::run(&run) {
        Ok(v) => {
            let line = v.to_string();
            println!(
                "{}",
                serde_json::to_string_pretty(&v).unwrap_or(line.clone())
            );
            if let Some(p) = out {
                use std::io::Write;
                let mut f = std::fs::OpenOptions::new()
                    .create(true)
                    .append(true)
                    .open(&p)
                    .expect("open --out");
                writeln!(f, "{line}").expect("write --out");
            }
        }
        Err(e) => {
            eprintln!("browser_bench: {e}");
            std::process::exit(1);
        }
    }
}