pref: large diff improvements (#58)

* improvements

* stable, before imara

* imara

* imara pref 1

* imara pref 2

* imara diff pref 3

* ui and loading improvements

* fix(view): correct no-step extent markers and add debug logging

* fix(view): rebuild immediately on hunk jumps

* test: stabilize diff size settings and drop window debug

* feat(profile): add idle filtering for report

* perf: make lazy syntax cache incremental

* feat: improve syntax warmup and profiling tools

* test: cover syntax warmup scheduling

* fix: clamp scroll in large no-step windowed view

* fix: honor deferred view scroll in split jumps

* fix: refresh hunk scope after no-step jumps

* fix: fmt

* fix: lint issues

* fix: test

* fix: lint issues

* fix(views): avoid end-scroll bounce

* fix(views): keep blame end-scroll stable

* feat(cli): add single-file HEAD diff

Author: ahkohd

Cargo.lock

@@ -18,7 +18,8 @@ thiserror = "2.0"
 anyhow = "1.0"
 
 # Diff engine
-similar = { version = "2.6", features = ["unicode"] }
+imara-diff = "0.1"
+rustc-hash = "1.1"
 
 # TUI
 ratatui = "0.29"
@@ -30,6 +31,7 @@ tokio = { version = "1.0", features = ["full"] }
 
 # CLI
 clap = { version = "4.0", features = ["derive"] }
+flate2 = "1.0"
 
 # Config
 toml = "0.8"

Cargo.toml

@@ -0,0 +1,75 @@
+# Profiling
+
+This repo includes a small Rust helper, `oy-profile`, to summarize samply/Firefox
+JSON profiles.
+
+## Record with samply
+
+Build a release binary and record a profile:
+
+```bash
+cargo build -p oyo --release
+samply record --save-only -o profile.json.gz -- ./target/release/oy --range HEAD...HEAD
+```
+
+Notes:
+- Use a `.json.gz` output name to keep files small.
+- If you need perf permissions on Linux:
+
+```bash
+sudo sysctl -w kernel.perf_event_paranoid=1
+```
+
+Reset it when you are done:
+
+```bash
+sudo sysctl -w kernel.perf_event_paranoid=2
+```
+
+## Summarize profiles
+
+Quick report (hot threads/paths/spots/modules):
+
+```bash
+cargo run -p oyo --bin oy-profile -- profile.json.gz --report --top 15
+```
+
+Add `--verbose` to include the full ranked function table with `--report`.
+By default the report includes idle samples (percent columns are total). To
+exclude idle samples (poll/sleep/etc), pass `--no-idle`. Customize the idle
+matcher with:
+
+```bash
+cargo run -p oyo --bin oy-profile -- profile.json.gz --report --no-idle
+cargo run -p oyo --bin oy-profile -- profile.json.gz --report --idle-pattern "my_idle_fn"
+```
+
+List threads:
+
+```bash
+cargo run -p oyo --bin oy-profile -- profile.json.gz --list-threads
+```
+
+Pick a thread and mode (inclusive = hot paths, leaf = self time):
+
+```bash
+cargo run -p oyo --bin oy-profile -- profile.json.gz --thread 0 --mode inclusive
+cargo run -p oyo --bin oy-profile -- profile.json.gz --thread oy --mode leaf --top 30
+```
+
+By default the tool selects the hottest thread (based on the chosen metric) and
+prints a short thread summary. Control the metric and summary size with:
+
+```bash
+cargo run -p oyo --bin oy-profile -- profile.json.gz --metric weight
+cargo run -p oyo --bin oy-profile -- profile.json.gz --metric time --top-threads 0
+```
+
+Interpretation notes:
+- CPU% is per-thread (threadCPUDelta / thread lifetime), not whole-system CPU.
+- Short-lived threads can show near-100% CPU even with few samples.
+- If `threadCPUDelta` or timing data is missing, CPU% is omitted.
+
+## Debug logs
+
+For diff UI debug logs (extent markers, navigation, etc.), see `docs/DEBUG.md`.

PROFILING.md

@@ -106,6 +106,14 @@ oy
 oy old.rs new.rs
 ```
 
+### Compare a file against HEAD
+
+```bash
+oy path/to/file.rs
+```
+
+Runs a working-tree vs `HEAD` diff for that file (like `git diff path/to/file.rs`).
+
 ### Commit picker
 
 ```bash
@@ -262,8 +270,13 @@ hunk = "none"               # "none" | "hunk" | "file"
 # bg = false                # Full-line diff background (true/false)
 # fg = "theme"              # "theme" or "syntax"
 # highlight = "text"        # "text" | "word" | "none"
+# max_bytes = 16777216      # Defer diffing above this size (bytes)
+# full_context_max_bytes = 2097152  # Full-context render up to this size (bytes)
+# defer = true              # Defer large diffs and compute in background
+# idle_ms = 250             # Idle time before background diff compute
 # extent_marker = "neutral" # "neutral" or "diff"
 # extent_marker_scope = "progress" # "progress" or "hunk"
+# extent_marker_context = false # show extent markers on unchanged lines
 # [ui.blame]
 # enabled = false           # Show git blame hints (opt-in)
 # mode = "one_shot"         # "one_shot" or "toggle"
@@ -283,6 +296,11 @@ hunk = "none"               # "none" | "hunk" | "file"
 #   mode = "on"              # "on" or "off"
 #   theme = "tokyonight"     # builtin name or "custom.tmTheme" (from ~/.config/oyo/themes)
 #                             # default: ui.theme.name, fallback to "ansi"
+#   [ui.syntax.warmup]
+#   active_lines = 100       # lines per tick while navigating
+#   pending_lines = 300      # lines per tick while catching up to a pending checkpoint
+#   idle_lines = 1000        # lines per tick while idle
+#   debounce_ms = 80         # wait before warming a new viewport target
 syntax = "on"
 # [ui.unified]
 # modified_step_mode = "mixed" # "mixed" or "modified" (unified pane only)
@@ -330,6 +348,10 @@ name = "tokyonight"
 fg = "syntax"
 bg = true
 highlight = "text"
+max_bytes = 16777216
+full_context_max_bytes = 2097152
+defer = true
+idle_ms = 250
 extent_marker = "diff"
 extent_marker_scope = "hunk"
 

README.md

@@ -15,4 +15,12 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 anyhow = { workspace = true }
-similar = { workspace = true }
+imara-diff = { workspace = true }
+rustc-hash = { workspace = true }
+
+[dev-dependencies]
+criterion = "0.5"
+
+[[bench]]
+name = "perf"
+harness = false

crates/oyo-core/Cargo.toml

@@ -0,0 +1,197 @@
+use criterion::{black_box, BatchSize, BenchmarkId, Criterion};
+use criterion::{criterion_group, criterion_main};
+use oyo_core::diff::DiffEngine;
+use oyo_core::step::{AnimationFrame, DiffNavigator};
+use std::sync::Arc;
+use std::time::Duration;
+
+struct BenchInputs {
+    old: Arc<str>,
+    new: Arc<str>,
+    diff: oyo_core::diff::DiffResult,
+}
+
+fn build_inputs(hunks: usize, changes_per_hunk: usize, context_lines: usize) -> BenchInputs {
+    let (old, new) = make_text(hunks, changes_per_hunk, context_lines);
+    let engine = DiffEngine::new().with_context(context_lines);
+    let diff = engine.diff_strings(&old, &new);
+    BenchInputs {
+        old: Arc::from(old),
+        new: Arc::from(new),
+        diff,
+    }
+}
+
+fn make_text(hunks: usize, changes_per_hunk: usize, context_lines: usize) -> (String, String) {
+    let mut old = String::new();
+    let mut new = String::new();
+    let gap = context_lines + 2;
+    for hunk in 0..hunks {
+        for idx in 0..gap {
+            let line = format!("ctx {hunk} {idx}\n");
+            old.push_str(&line);
+            new.push_str(&line);
+        }
+        for change in 0..changes_per_hunk {
+            old.push_str(&format!("old {hunk} {change}\n"));
+            new.push_str(&format!("new {hunk} {change}\n"));
+        }
+    }
+    (old, new)
+}
+
+fn bench_prev_hunk(c: &mut Criterion) {
+    let inputs = build_inputs(100, 20, 3);
+    c.bench_function("prev_hunk/100x20", |b| {
+        b.iter_batched(
+            || {
+                let mut nav = DiffNavigator::new(
+                    inputs.diff.clone(),
+                    inputs.old.clone(),
+                    inputs.new.clone(),
+                    false,
+                );
+                nav.goto_end();
+                nav
+            },
+            |mut nav| {
+                black_box(nav.prev_hunk());
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn bench_next_hunk(c: &mut Criterion) {
+    let inputs = build_inputs(100, 20, 3);
+    c.bench_function("next_hunk/100x20", |b| {
+        b.iter_batched(
+            || {
+                DiffNavigator::new(
+                    inputs.diff.clone(),
+                    inputs.old.clone(),
+                    inputs.new.clone(),
+                    false,
+                )
+            },
+            |mut nav| {
+                black_box(nav.next_hunk());
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn bench_view_for_changes(c: &mut Criterion) {
+    let inputs = build_inputs(100, 20, 3);
+    c.bench_function("view_for_changes/100x20", |b| {
+        b.iter_batched(
+            || {
+                let mut nav = DiffNavigator::new(
+                    inputs.diff.clone(),
+                    inputs.old.clone(),
+                    inputs.new.clone(),
+                    false,
+                );
+                let mid = nav.state().total_steps / 2;
+                nav.goto(mid);
+                nav
+            },
+            |nav| {
+                black_box(nav.current_view_with_frame(AnimationFrame::Idle));
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn bench_view_for_changes_large_hunk(c: &mut Criterion) {
+    let inputs = build_inputs(1, 5000, 3);
+    let mut group = c.benchmark_group("view_for_changes_large_hunk");
+    group.measurement_time(Duration::from_secs(10));
+    group.sample_size(50);
+    group.bench_function("1x5000", |b| {
+        b.iter_batched(
+            || {
+                let mut nav = DiffNavigator::new(
+                    inputs.diff.clone(),
+                    inputs.old.clone(),
+                    inputs.new.clone(),
+                    false,
+                );
+                let mid = nav.state().total_steps / 2;
+                nav.goto(mid);
+                nav
+            },
+            |nav| {
+                black_box(nav.current_view_with_frame(AnimationFrame::Idle));
+            },
+            BatchSize::SmallInput,
+        );
+    });
+    group.finish();
+}
+
+fn bench_hunk_index_for_change_id(c: &mut Criterion) {
+    let inputs = build_inputs(200, 10, 3);
+    let change_ids: Vec<usize> = inputs.diff.changes.iter().map(|c| c.id).collect();
+    c.bench_with_input(
+        BenchmarkId::new("hunk_index_for_change_id", change_ids.len()),
+        &change_ids,
+        |b, ids| {
+            b.iter_batched(
+                || {
+                    DiffNavigator::new(
+                        inputs.diff.clone(),
+                        inputs.old.clone(),
+                        inputs.new.clone(),
+                        false,
+                    )
+                },
+                |nav| {
+                    for id in ids.iter().take(1000) {
+                        black_box(nav.hunk_index_for_change_id(*id));
+                    }
+                },
+                BatchSize::SmallInput,
+            );
+        },
+    );
+}
+
+fn bench_is_applied(c: &mut Criterion) {
+    let inputs = build_inputs(200, 10, 3);
+    let change_ids: Vec<usize> = inputs.diff.changes.iter().map(|c| c.id).collect();
+    c.bench_function("is_applied/200x10", |b| {
+        b.iter_batched(
+            || {
+                let mut nav = DiffNavigator::new(
+                    inputs.diff.clone(),
+                    inputs.old.clone(),
+                    inputs.new.clone(),
+                    false,
+                );
+                nav.goto_end();
+                nav
+            },
+            |nav| {
+                let state = nav.state();
+                for id in change_ids.iter().take(1000) {
+                    black_box(state.is_applied(*id));
+                }
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+criterion_group!(
+    benches,
+    bench_prev_hunk,
+    bench_next_hunk,
+    bench_view_for_changes,
+    bench_view_for_changes_large_hunk,
+    bench_hunk_index_for_change_id,
+    bench_is_applied
+);
+criterion_main!(benches);