ai-app/iris/android-app/src/bench_client.rs

//! P0's iris half (docs/RUST.md's P0 box, docs/AGENTS.md's "The rigs"):
//! the same fixture, scroll loop and streaming phase the Compose `bench`
//! build type's `BenchRun.kt`/`BenchFixture.kt` drive, run here against
//! `transcript-ui`'s real screen with no server -- a frame-time comparison
//! that measures the renderer rather than the data or the network.
//!
//! **Reuses `transcript_client.rs`'s shape** (folded items, the same
//! `TranscriptScreen::apply` incremental update on every event) with the
//! network half replaced by the checked-in fixture, embedded with
//! `include_str!` -- `app/bench-fixture/assets/transcript.jsonl`,
//! 1,915,760 bytes, generated by `app/bench-fixture/generate.py` and never
//! a real transcript (that file's own README). The first 3,200 lines are
//! the opening backlog, folded once through
//! `client_core::transcript_fold::fold_page` exactly as a real
//! `/transcript` page would be (then a full `transcript_ui::build_tree`,
//! same as any first load); the remaining ~400 are the streaming tail,
//! replayed one at a time through `fold_event` -- the same fold path a
//! live SSE reply arrives on -- by the "Run benchmark" control below.
//! Streaming through `apply` rather than a full rebuild per event is what
//! this file exists to measure -- see docs/RUST.md's P0 box for the
//! before/after report.

use crate::bench_jni::PlatformHandle;
use android_view::jni::{JavaVM, objects::GlobalRef};
use client_core::transcript_fold::{TranscriptItem, fold_event, fold_page, group_tool_runs};
use event_model::SeqEvent;
use iris::android::{AndroidAppState, AndroidRsc, AndroidUiState, HasAndroidUiState};
use iris::prelude::*;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;

/// bench-fixture/README.md: the first `BACKLOG_COUNT` non-blank lines are
/// the opening window; the rest are the streaming tail. Kept in sync with
/// `BenchFixture.kt`'s identical constant by hand -- both read the same
/// checked-in file, so a mismatch would only mean the two apps' bench
/// builds open a different split of it, not a wrong-vs-right answer.
const BACKLOG_COUNT: usize = 3200;

/// `BenchRun.kt`'s own constants -- kept identical so the two apps' bench
/// runs are the same gesture and the same load, which is the entire point
/// of a shared fixture and a shared scripted loop (P0's pass condition).
const CYCLES: usize = 6;
const SWIPE_PX: f32 = 900.0;
const SWIPE_MS: u64 = 200;
const SWIPE_PAUSE_MS: u64 = 500;
const STREAM_EVENTS_PER_SEC: u64 = 20;
const STREAM_SECONDS: u64 = 20;
/// One animation step's target cadence -- close enough to 60Hz that a
/// `List::scroll` swipe is many small moves rather than one jump, so
/// frames are actually rendered along the way (the point of animating it
/// at all rather than calling `scroll` once per swipe).
const ANIM_STEP_MS: u64 = 16;

const FIXTURE_JSONL: &str = include_str!("../../../app/bench-fixture/assets/transcript.jsonl");

pub struct BenchClient {
    ui_state: AndroidUiState,
    content: WeakWidget<WidgetPtr>,
    report_display: WeakWidget<TextEdit>,
    screen: Option<transcript_ui::TranscriptScreen>,
    items: Vec<TranscriptItem>,
    /// The events not yet streamed -- consumed by `start_benchmark`'s own
    /// clone, kept here only as the source a second run would need (the
    /// button can be pressed more than once; `running` just stops overlap,
    /// not repeat).
    stream_tail: Vec<SeqEvent>,
    platform: Option<Arc<PlatformHandle>>,
    last_report: Option<String>,
    running: bool,
}

impl HasAndroidUiState for BenchClient {
    fn android_state(&self) -> &AndroidUiState {
        &self.ui_state
    }
    fn android_state_mut(&mut self) -> &mut AndroidUiState {
        &mut self.ui_state
    }
}

/// Parses the fixture once: `serde_json::Value`s for the backlog
/// (`fold_page` takes a page of raw wire JSON, same as a real
/// `/transcript` response) and folded `SeqEvent`s for the tail (`fold_event`
/// takes one live wire event at a time, same as a real SSE frame).
fn parse_fixture() -> (Vec<serde_json::Value>, Vec<SeqEvent>) {
    let lines: Vec<&str> = FIXTURE_JSONL
        .lines()
        .filter(|line| !line.trim().is_empty())
        .collect();
    let mut backlog = Vec::with_capacity(BACKLOG_COUNT.min(lines.len()));
    let mut stream_tail = Vec::new();
    for (i, line) in lines.iter().enumerate() {
        let value: serde_json::Value =
            serde_json::from_str(line).expect("bench fixture is generated JSON, always valid");
        if i < BACKLOG_COUNT {
            backlog.push(value);
        } else {
            let event: SeqEvent = serde_json::from_value(value)
                .expect("bench fixture event matches event-model's SeqEvent");
            stream_tail.push(event);
        }
    }
    (backlog, stream_tail)
}

fn placeholder<Rsc: HasEvents>(rsc: &mut Rsc, message: &str) -> StrongWidget {
    wtext(message.to_string())
        .color(Color::WHITE)
        .wrap(true)
        .pad(16)
        .add_strong(rsc)
        .any()
}

/// `getrusage(RUSAGE_SELF)`'s user+system time, in ms -- `None` only if
/// the syscall itself fails, which UI_RULES.md's "never present an
/// inferred value as a measured one" says to keep apart from a real (and
/// here, impossible) zero.
fn process_cpu_ms() -> Option<u64> {
    // SAFETY: `rusage` is a plain-old-data struct `getrusage` fully
    // initialises on success; on failure it is never read.
    unsafe {
        let mut usage: libc::rusage = std::mem::zeroed();
        if libc::getrusage(libc::RUSAGE_SELF, &mut usage) != 0 {
            return None;
        }
        let user_ms = usage.ru_utime.tv_sec as u64 * 1000 + usage.ru_utime.tv_usec as u64 / 1000;
        let sys_ms = usage.ru_stime.tv_sec as u64 * 1000 + usage.ru_stime.tv_usec as u64 / 1000;
        Some(user_ms + sys_ms)
    }
}

/// `VmHWM` from `/proc/self/status` -- the process's peak RSS since it
/// started, in kB. Same source `BenchRun.kt`'s `peakRssLine` reads, so the
/// two reports' numbers mean the same thing.
fn peak_rss_kb() -> Option<u64> {
    std::fs::read_to_string("/proc/self/status")
        .ok()?
        .lines()
        .find_map(|line| line.strip_prefix("VmHWM:"))
        .and_then(|rest| rest.trim().strip_suffix("kB"))
        .and_then(|n| n.trim().parse().ok())
}

fn battery_line(samples: &[i32]) -> String {
    if samples.is_empty() {
        return "  battery current: unavailable on this device".to_string();
    }
    let mean = samples.iter().map(|&v| v as i64).sum::<i64>() / samples.len() as i64;
    let min = samples.iter().min().unwrap();
    let max = samples.iter().max().unwrap();
    format!(
        "  battery current: mean {mean}\u{b5}A over {} samples (min {min}, max {max})",
        samples.len()
    )
}

impl AndroidAppState for BenchClient {
    fn new(mut ui_state: AndroidUiState, rsc: &mut AndroidRsc<Self>) -> Self {
        let content = WidgetPtr::new().add(rsc);
        let loading = placeholder(rsc, "Loading fixture...");
        content(rsc).set(loading);

        let report_display = wtext("")
            .editable(EditMode::MultiLine)
            .text_align(Align::LEFT)
            .wrap(true)
            .size(14)
            .color(Color::WHITE)
            .attr::<Selectable>(())
            .label("Benchmark report")
            .add(rsc);

        let controls = bench_controls(rsc);
        let tree = (
            controls,
            content.height(rest(2)),
            report_display.height(rest(1)).pad(8),
        )
            .span(Dir::DOWN)
            .add_strong(rsc)
            .any();
        ui_state.set_root(tree);

        let mut client = Self {
            ui_state,
            content,
            report_display,
            screen: None,
            items: Vec::new(),
            stream_tail: Vec::new(),
            platform: None,
            last_report: None,
            running: false,
        };

        let (backlog, stream_tail) = parse_fixture();
        client.stream_tail = stream_tail;
        match fold_page(&backlog) {
            Ok(items) => {
                client.items = items;
                client.rebuild_transcript(rsc);
            }
            Err(message) => {
                client.show_message(rsc, &format!("Couldn't fold the bench fixture: {message}"))
            }
        }
        client
    }

    fn platform_ready(&mut self, _rsc: &mut AndroidRsc<Self>, vm: JavaVM, view: GlobalRef) {
        self.platform = Some(Arc::new(PlatformHandle::new(vm, view)));
    }

    fn back_pressed(&mut self, _rsc: &mut AndroidRsc<Self>, _render: &mut UiRenderState) -> bool {
        false
    }
}

type Rsc = AndroidRsc<BenchClient>;

fn bench_controls(rsc: &mut Rsc) -> WeakWidget {
    let run_rect = rect(Color::rgb(40, 70, 40))
        .on(
            CursorSense::click(),
            |ctx: EventIdCtx<'_, Rsc, _, _>, rsc: &mut Rsc| {
                ctx.state.start_benchmark(rsc);
            },
        )
        .label("Run benchmark");
    let run = (
        run_rect,
        wtext("Run benchmark").size(18).text_align(Align::CENTER),
    )
        .stack()
        .pad(8)
        .add(rsc);

    let copy_rect = rect(Color::rgb(50, 50, 60))
        .on(
            CursorSense::click(),
            |ctx: EventIdCtx<'_, Rsc, _, _>, _rsc: &mut Rsc| {
                ctx.state.copy_report();
            },
        )
        .label("Copy report");
    let copy = (
        copy_rect,
        wtext("Copy report").size(18).text_align(Align::CENTER),
    )
        .stack()
        .pad(8)
        .add(rsc);

    (run, copy).span(Dir::RIGHT).height(56).add(rsc)
}

impl BenchClient {
    fn show_message(&mut self, rsc: &mut Rsc, message: &str) {
        let widget = placeholder(rsc, message);
        (self.content)(rsc).set(widget);
        self.screen = None;
    }

    fn rebuild_transcript(&mut self, rsc: &mut Rsc) {
        let rows = group_tool_runs(&self.items);
        let (screen, tree) = transcript_ui::build_tree(rsc, rows);
        (self.content)(rsc).set(tree);
        self.screen = Some(screen);
    }

    fn copy_report(&mut self) {
        let Some(report) = &self.last_report else {
            log::info!("iris bench report: nothing to copy -- run the benchmark first");
            return;
        };
        let Some(platform) = &self.platform else {
            log::info!("iris bench report: no platform handle, can't reach the clipboard");
            return;
        };
        if platform.copy_to_clipboard("iris bench report", report) {
            log::info!("iris bench report: copied to clipboard");
        } else {
            log::info!("iris bench report: clipboard copy failed");
        }
    }

    /// P0's scripted run: `BenchRun.kt`'s scroll loop, then its streaming
    /// phase, then the report -- run in-process for the same reason that
    /// file's own doc gives (no usable system tracing on a real phone, no
    /// agent that can drive one).
    fn start_benchmark(&mut self, rsc: &mut Rsc) {
        if self.running {
            log::info!("iris bench report: already running");
            return;
        }
        self.running = true;
        self.android_state_mut().frame_report.reset();
        self.report_display.edit(rsc).set("Running benchmark...");

        let redraw = rsc.tasks.redraw_handle();
        let platform = self.platform.clone();
        let stream_tail = self.stream_tail.clone();
        let cpu_start = process_cpu_ms();

        rsc.spawn_task(async move |mut ctx| {
            // The swipe loop: two drags toward newer content, two back --
            // a cycle returns to where it started, so the whole loop
            // measures steady-state scrolling. `BenchRun.kt`'s own
            // comment on this shape.
            for _ in 0..CYCLES {
                for delta in [SWIPE_PX, SWIPE_PX, -SWIPE_PX, -SWIPE_PX] {
                    animate_scroll(&mut ctx, &redraw, delta, SWIPE_MS).await;
                    tokio::time::sleep(Duration::from_millis(SWIPE_PAUSE_MS)).await;
                }
            }

            // Pinned to the newest end before streaming starts, matching
            // `stream-bench.sh`'s "Jump to latest" tap.
            ctx.update(|state: &mut BenchClient, rsc| {
                if let Some(screen) = &state.screen {
                    (screen.list)(rsc).jump_to_end();
                }
            });
            redraw.request_redraw();

            // The battery sampler runs concurrently with the streaming
            // phase, once a second, the same cadence `BatterySampler` uses
            // on the Compose side -- via its own JNI-attached thread, not
            // `ctx.update`, since a sample needs no widget-tree access.
            let sampler_done = Arc::new(AtomicBool::new(false));
            let samples = Arc::new(std::sync::Mutex::new(Vec::<i32>::new()));
            let sampler = platform.clone().map(|platform| {
                let done = sampler_done.clone();
                let samples = samples.clone();
                tokio::spawn(async move {
                    while !done.load(Ordering::Relaxed) {
                        if let Some(value) = platform.battery_current_ua() {
                            samples.lock().unwrap().push(value);
                        }
                        tokio::time::sleep(Duration::from_secs(1)).await;
                    }
                })
            });

            let total = (STREAM_EVENTS_PER_SEC * STREAM_SECONDS) as usize;
            let mut sent = 0usize;
            for event in stream_tail.into_iter().take(total) {
                ctx.update(move |state: &mut BenchClient, rsc| {
                    let old_items = state.items.clone();
                    state.items = fold_event(&state.items, &event);
                    match &state.screen {
                        // The path P0 asked to measure: update only the
                        // row(s) that changed instead of rebuilding all
                        // ~3,200 of them per event.
                        Some(screen) => screen.apply(rsc, &old_items, &state.items),
                        None => state.rebuild_transcript(rsc),
                    }
                });
                redraw.request_redraw();
                sent += 1;
                tokio::time::sleep(Duration::from_millis(1000 / STREAM_EVENTS_PER_SEC)).await;
            }
            // Lets the last few deltas land and draw before the report is
            // read -- `BenchRun.kt`'s own closing delay.
            tokio::time::sleep(Duration::from_millis(300)).await;

            sampler_done.store(true, Ordering::Relaxed);
            if let Some(sampler) = sampler {
                let _ = sampler.await;
            }
            let battery = battery_line(&samples.lock().unwrap());
            let cpu_line = match (cpu_start, process_cpu_ms()) {
                (Some(start), Some(end)) => {
                    format!("  process CPU time over this run: {}ms", end.saturating_sub(start))
                }
                _ => "  process CPU time over this run: unavailable".to_string(),
            };
            let rss_line = match peak_rss_kb() {
                Some(kb) => format!("  peak RSS: {kb}kB"),
                None => "  peak RSS: unavailable (/proc/self/status unreadable)".to_string(),
            };

            ctx.update(move |state: &mut BenchClient, rsc| {
                state.running = false;
                let scroll_line = format!(
                    "  scroll: {CYCLES} cycles ({} swipes), streamed {sent}/{total} fixture events",
                    CYCLES * 4
                );
                let frames_line = match state.android_state().frame_report.report() {
                    Some(stats) => format!("{stats}"),
                    None => "no frames recorded".to_string(),
                };
                let report = format!(
                    "iris bench report\n{frames_line}\n{scroll_line}\n{cpu_line}\n{rss_line}\n{battery}"
                );
                log::info!("iris bench report: {report}");
                state.report_display.edit(rsc).set(&report);
                state.last_report = Some(report);
            });
            redraw.request_redraw();
        });
    }
}

/// Moves `List::scroll` by `total_px` over `duration_ms`, in ~60Hz steps,
/// so the swipe is many rendered frames rather than one jump -- the same
/// shape `animateScrollBy(SWIPE_PX, tween(SWIPE_MS))` gives on the Compose
/// side, in the one place the two backends have to differ (iris's `List`
/// has no built-in tween, so this drives it by hand).
async fn animate_scroll(
    ctx: &mut iris::task::TaskCtx<Rsc>,
    redraw: &Arc<dyn iris::task::RequestRedraw>,
    total_px: f32,
    duration_ms: u64,
) {
    let steps = (duration_ms / ANIM_STEP_MS).max(1);
    let step_px = total_px / steps as f32;
    for _ in 0..steps {
        ctx.update(move |state: &mut BenchClient, rsc| {
            if let Some(screen) = &state.screen {
                (screen.list)(rsc).scroll(step_px);
            }
        });
        redraw.request_redraw();
        tokio::time::sleep(Duration::from_millis(ANIM_STEP_MS)).await;
    }
}