LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
Bench: thumbnail request example
radialmonsterdbc05bedc702
diff --git a/crates/ui-egui/examples/thumb_request_bench.rs b/crates/ui-egui/examples/thumb_request_bench.rsnew file mode 100644index 000000000..675c920d5--- /dev/null+++ b/crates/ui-egui/examples/thumb_request_bench.rs@@ -0,0 +1,341 @@+use lightcraft_catalog::{Op, Photo, PhotoId, Source};+use lightcraft_develop::{BrushStroke, DevelopSettings, Mask, MaskComponent, MaskShape};+use lightcraft_engine::Session;+use lightcraft_engine::media::{RenderJob, RenderResult};+use lightcraft_ui_egui::{+ LightcraftApp, Services,+ headless::Headless,+ panels::grid::request_thumb,+ render::{RenderOffload, Slot, Tex},+};+use std::alloc::{GlobalAlloc, Layout, System};+use std::cell::Cell;+use std::{+ hint::black_box,+ sync::Arc,+ time::{Duration, Instant},+};++/// Counts allocations made by the current thread (the UI thread is the one measured).+struct Counting;++thread_local! {+ static ALLOCS: Cell<u64> = const { Cell::new(0) };+ static BYTES: Cell<u64> = const { Cell::new(0) };+}++fn count(size: usize) {+ let _ = ALLOCS.try_with(|n| n.set(n.get() + 1));+ let _ = BYTES.try_with(|n| n.set(n.get() + size as u64));+}++// SAFETY: every call is forwarded unchanged to the system allocator; the counters are plain+// thread-locals that never allocate. Dev-only example.+#[allow(unsafe_code)]+unsafe impl GlobalAlloc for Counting {+ unsafe fn alloc(&self, l: Layout) -> *mut u8 {+ count(l.size());+ // SAFETY: same contract as ours.+ unsafe { System.alloc(l) }+ }+ unsafe fn alloc_zeroed(&self, l: Layout) -> *mut u8 {+ count(l.size());+ // SAFETY: same contract as ours.+ unsafe { System.alloc_zeroed(l) }+ }+ unsafe fn realloc(&self, p: *mut u8, l: Layout, new: usize) -> *mut u8 {+ count(new);+ // SAFETY: same contract as ours.+ unsafe { System.realloc(p, l, new) }+ }+ unsafe fn dealloc(&self, p: *mut u8, l: Layout) {+ // SAFETY: same contract as ours.+ unsafe { System.dealloc(p, l) }+ }+}++#[global_allocator]+static A: Counting = Counting;++fn allocs() -> (u64, u64) {+ (ALLOCS.with(Cell::get), BYTES.with(Cell::get))+}++struct Blocked;+impl RenderOffload for Blocked {+ fn try_start(&mut self, _: Slot, job: RenderJob) -> Option<RenderJob> {+ Some(job)+ }+ fn finished(&mut self) -> Vec<(Slot, RenderResult, f64)> {+ vec![]+ }+}+fn settings(points: usize) -> DevelopSettings {+ let mut s = DevelopSettings::default();+ if points > 0 {+ let stroke = BrushStroke {+ points: (0..points).map(|i| lightcraft_geom::Point::new((i % 100) as f64 / 100.0, (i / 100) as f64 / 100.0)).collect(),+ ..Default::default()+ };+ s.masks.push(Mask {+ components: vec![MaskComponent { name: None, op: Default::default(), invert: false, shape: MaskShape::Brush { strokes: vec![stroke] } }],+ ..Default::default()+ });+ }+ s+}+fn summary(name: &str, mut times: Vec<f64>) {+ times.sort_by(f64::total_cmp);+ println!("{name},median_ms={:.6},p95_ms={:.6}", times[times.len() / 2], times[times.len() * 95 / 100]);+}+fn frames() -> usize {+ std::env::var("FRAMES").ok().and_then(|s| s.parse().ok()).unwrap_or(300).max(1)+}++fn micro(points: usize, pending: bool) {+ let frames = frames();+ let n = 200;+ let mut session = Session::new();+ for i in 1..=n {+ let mut p =+ Photo::new(PhotoId(i), Source::File { path: format!("N:/audit-only/IMG_{i}.jpg") }, "sample.jpg", "JPEG", 6000, 4000, "2026-01-01");+ p.develop = Arc::new(settings(points));+ p.content_hash = Some(format!("{i:032x}"));+ session.catalog.apply(Op::AddPhoto { photo: Box::new(p) }).unwrap();+ }+ let mut app = LightcraftApp::new(session, Services::default());+ app.renderer.set_offload(Box::new(Blocked));+ let ctx = egui::Context::default();+ let texture = ctx.load_texture("audit", egui::ColorImage::new([1, 1], vec![egui::Color32::GRAY]), Default::default());+ for i in 1..=n {+ let id = PhotoId(i);+ if !pending {+ let key = app.session.thumb_job(id, 384).unwrap().key;+ app.renderer.textures.insert(+ Slot::Thumb(id),+ Tex { key, photo: id, tex: texture.clone(), size: [1, 1], histogram: None, ms: 0.0, quick: None, pixels: None },+ );+ }+ request_thumb(&mut app, id, 384, 10);+ }+ let mut times = Vec::with_capacity(frames);+ let (a0, b0) = allocs();+ for _ in 0..frames {+ let t = Instant::now();+ for i in 1..=n {+ request_thumb(black_box(&mut app), PhotoId(i), 384, 10);+ }+ times.push(t.elapsed().as_secs_f64() * 1000.0);+ }+ let (a1, b1) = allocs();+ println!("micro,points={points},pending={pending},allocs_per_frame={},bytes_per_frame={}", (a1 - a0) / frames as u64, (b1 - b0) / frames as u64);+ summary(&format!("micro,points={points},pending={pending},cells={n}"), times);+ // The draw fast path must notice a develop edit and a size-bucket change.+ let mut edit = settings(points);+ edit.light.exposure = 1.0;+ app.session.catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(edit), label: "audit edit".into(), edited: None }).unwrap();+ request_thumb(&mut app, PhotoId(1), 384, 10);+ assert_eq!(app.renderer.wanted(Slot::Thumb(PhotoId(1))), Some(app.session.thumb_job(PhotoId(1), 384).unwrap().key));+ request_thumb(&mut app, PhotoId(1), 512, 10);+ assert_eq!(app.renderer.wanted(Slot::Thumb(PhotoId(1))), Some(app.session.thumb_job(PhotoId(1), 512).unwrap().key));+}+fn collect(root: &std::path::Path, ext: &str, paths: &mut Vec<std::path::PathBuf>) {+ for e in std::fs::read_dir(root).unwrap() {+ let p = e.unwrap().path();+ if p.is_dir() {+ collect(&p, ext, paths);+ } else if p.extension().is_some_and(|x| x.eq_ignore_ascii_case(ext)) {+ paths.push(p);+ }+ }+}+fn verify_texture(h: &Headless, id: PhotoId) {+ let p = h.app.session.catalog.photo(id).unwrap();+ let tex = h.app.renderer.thumb(id).unwrap();+ // Justified rows can choose different buckets even with the same slider value.+ // Verify the actual displayed resolution independently of candidate request/hash helpers.+ let edge = tex.size[0].max(tex.size[1]);+ assert!([128, 256, 384, 512].contains(&edge), "thumbnail must use a supported size bucket");+ let Source::File { path } = &p.source else { unreachable!() };+ let (source, info) = h.app.session.media.file_loader.as_ref().unwrap()(path, 512).unwrap();+ println!("decode,path={path},raw={},preview_only={:?}", info.raw, p.preview_only);+ if std::env::var_os("REQUIRE_RAW").is_some() {+ assert!(p.preview_only.is_none(), "embedded-preview fallback does not validate RAW decoding");+ assert!(info.raw, "fresh loader must return decoded RAW data");+ }+ let req = lightcraft_engine::pipeline::RenderRequest { apply_crop: true, ..lightcraft_engine::pipeline::RenderRequest::fit(edge, edge) };+ // Fresh direct CPU render: no candidate job/hash/source/preview cache helpers.+ let expected = lightcraft_engine::pipeline::render(&source, &info, &p.develop, &req).image;+ assert_eq!(tex.size, [expected.width, expected.height]);+ assert_eq!(tex.pixels.as_ref().unwrap().pixels.iter().flat_map(|c| c.to_array()).collect::<Vec<_>>(), expected.as_bytes());+}++fn real() {+ let frames = frames();+ let mut paths = vec![];+ let ext = std::env::var("PHOTO_EXT").unwrap_or_else(|_| "jpg".into());+ let Ok(root) = std::env::var("PHOTO_ROOT") else {+ eprintln!("REAL_PHOTOS needs PHOTO_ROOT, a folder of photos to sample");+ return;+ };+ collect(std::path::Path::new(&root), &ext, &mut paths);+ paths.sort();+ let offset = std::env::var("PHOTO_OFFSET").ok().and_then(|s| s.parse::<usize>().ok()).unwrap_or(0);+ let limit = std::env::var("PHOTO_LIMIT").ok().and_then(|s| s.parse::<usize>().ok()).unwrap_or(4).clamp(1, 4);+ paths = paths.into_iter().skip(offset).take(limit).collect();+ assert!(!paths.is_empty(), "selected photo batch is empty");+ println!("batch,extension={ext},offset={offset},limit={limit},photos={}", paths.len());+ let mut session = Session::new().with_fs();+ for (i, path) in paths.iter().enumerate() {+ let path = path.to_string_lossy().into_owned();+ let probe = session.media.file_probe.as_ref().unwrap()(&path).unwrap();+ let mut p =+ Photo::new(PhotoId(i as u64 + 1), Source::File { path: path.clone() }, "photo", &probe.format, probe.width, probe.height, "2026-01-01");+ p.file_size = probe.file_size;+ p.kind = probe.kind;+ p.meta = probe.meta;+ p.as_shot_wb = probe.as_shot_wb;+ p.embedded_lens = probe.embedded_lens;+ p.content_hash = probe.content_hash;+ p.preview_only = probe.preview_only;+ lightcraft_engine::import::apply_import_defaults(&session, &mut p);+ session.catalog.apply(Op::AddPhoto { photo: Box::new(p) }).unwrap();+ }+ let mut h = Headless::new(LightcraftApp::new(session, Services { png: None, ..Default::default() }), [1400.0, 900.0], 1.0);+ h.app.renderer = lightcraft_ui_egui::render::Renderer::with_worker_threads(1);+ h.app.renderer.keep_pixels = true;+ h.app.ui.view = lightcraft_ui_egui::state::ViewMode::PhotoGrid;+ h.app.ui.thumb_size = if ext == "rw2" { 160.0 } else { 100.0 };+ let mut loading_frame = vec![];+ let mut loading_grid = vec![];+ let mut busy = 0;+ for _ in 0..120 {+ let t = Instant::now();+ h.step();+ loading_frame.push(t.elapsed().as_secs_f64() * 1000.0);+ loading_grid.push(h.app.caches.grid_stats.last_show.as_secs_f64() * 1000.0);+ busy += usize::from(h.app.renderer.in_flight() > 0);+ }+ summary("loading,frame", loading_frame);+ summary("loading,grid", loading_grid);+ println!("loading,frames_with_pending={busy}");+ assert!(h.settle(Duration::from_secs(120)), "real library did not settle");+ for i in 1..=paths.len() {+ request_thumb(&mut h.app, PhotoId(i as u64), 256, 20);+ }+ assert!(h.settle(Duration::from_secs(120)));+ println!("real,photos={},textures={},in_flight={}", paths.len(), h.app.renderer.thumb_textures(), h.app.renderer.in_flight());+ let stats = h.app.caches.grid_stats.clone();+ let mut frame = Vec::with_capacity(frames);+ let mut grid = Vec::with_capacity(frames);+ let (a0, b0) = allocs();+ for _ in 0..frames {+ let t = Instant::now();+ h.step();+ frame.push(t.elapsed().as_secs_f64() * 1000.0);+ grid.push(h.app.caches.grid_stats.last_show.as_secs_f64() * 1000.0);+ }+ let (a1, b1) = allocs();+ println!("real,allocs_per_frame={},bytes_per_frame={}", (a1 - a0) / frames as u64, (b1 - b0) / frames as u64);+ summary("real,frame", frame);+ summary("real,grid", grid);+ println!("real,cells_per_frame={}", (h.app.caches.grid_stats.cells_visited - stats.cells_visited) / frames as u64);+ assert!(h.settle(Duration::from_secs(120)), "grid's displayed thumbnail bucket must settle before verification");+ let mut checks: Vec<_> = h+ .app+ .renderer+ .textures+ .iter()+ .filter_map(|(slot, t)| {+ if let Slot::Thumb(id) = slot {+ let mut hash = 0xcbf29ce484222325u64;+ for color in &t.pixels.as_ref().unwrap().pixels {+ for b in color.to_array() {+ hash = (hash ^ b as u64).wrapping_mul(0x100000001b3);+ }+ }+ Some((id.0, t.key, t.size, hash))+ } else {+ None+ }+ })+ .collect();+ checks.sort_by_key(|x| x.0);+ let mut hash = 0xcbf29ce484222325u64;+ for b in format!("{checks:?}").bytes() {+ hash = (hash ^ b as u64).wrapping_mul(0x100000001b3);+ }+ println!("real,verified_textures={},keys_sizes_pixels_checksum={hash:016x}", checks.len());+ assert_eq!(checks.len(), paths.len(), "every original must render successfully");+ if std::env::var_os("VERIFY_PIXELS").is_some() {+ for i in 1..=paths.len() {+ verify_texture(&h, PhotoId(i as u64));+ }+ println!("oracle,exact_fresh_pixel_matches={}", paths.len());+ }+ let mut scroll_frame = vec![];+ let mut scroll_grid = vec![];+ let start = h.app.grid_scroll;+ let mut max_scroll = 0.0f32;+ for i in 0..frames {+ h.app.synthetic.push(egui::Event::PointerMoved(egui::pos2(800.0, 400.0)));+ h.app.synthetic.push(egui::Event::MouseWheel {+ unit: egui::MouseWheelUnit::Point,+ delta: egui::vec2(0.0, if (i / 45) % 2 == 0 { -12.0 } else { 12.0 }),+ phase: egui::TouchPhase::Move,+ modifiers: Default::default(),+ });+ let t = Instant::now();+ h.step();+ scroll_frame.push(t.elapsed().as_secs_f64() * 1000.0);+ scroll_grid.push(h.app.caches.grid_stats.last_show.as_secs_f64() * 1000.0);+ max_scroll = max_scroll.max(h.app.grid_scroll.unwrap_or(0.0));+ }+ summary("scroll,frame", scroll_frame);+ summary("scroll,grid", scroll_grid);+ println!("scroll,start={start:?},end={:?},max={max_scroll}", h.app.grid_scroll);+ if max_scroll == 0.0 {+ println!("scroll,not_applicable=bounded_batch_fits_view");+ }+ let id = PhotoId(1);+ let old = h.app.renderer.thumb(id).unwrap().pixels.as_ref().unwrap().clone();+ let mut edit = (*h.app.session.catalog.photo(id).unwrap().develop).clone();+ edit.light.exposure += 0.5;+ let undo = h.app.session.catalog.apply(Op::SetDevelop { id, settings: Arc::new(edit), label: "audit".into(), edited: None }).unwrap();+ request_thumb(&mut h.app, id, 256, 20);+ assert!(h.settle(Duration::from_secs(120)));+ let edited = h.app.renderer.thumb(id).unwrap().pixels.as_ref().unwrap().clone();+ assert_ne!(old.pixels, edited.pixels, "edit must change actual rendered pixels");+ if std::env::var_os("VERIFY_PIXELS").is_some() {+ verify_texture(&h, id);+ }+ let mut hash = 0xcbf29ce484222325u64;+ for c in &edited.pixels {+ for b in c.to_array() {+ hash = (hash ^ b as u64).wrapping_mul(0x100000001b3);+ }+ }+ println!("edit,exposure_plus_half_stop,pixels_checksum={hash:016x}");+ h.app.session.catalog.apply(undo).unwrap();+ request_thumb(&mut h.app, id, 256, 20);+ assert!(h.settle(Duration::from_secs(120)));+ assert_eq!(old.pixels, h.app.renderer.thumb(id).unwrap().pixels.as_ref().unwrap().pixels, "undo restores pixels");+ if std::env::var_os("VERIFY_PIXELS").is_some() {+ verify_texture(&h, id);+ println!("oracle,edit_and_undo_match_fresh_pixels=true");+ }+ println!("undo,pixels_restored=true");+}+fn main() {+ println!("mode={}", std::env::var("THUMB_AUDIT_MODE").unwrap_or_else(|_| "baseline".into()));+ if std::env::var_os("SKIP_MICRO").is_none() {+ for points in [0, 200, 1000] {+ for pending in [false, true] {+ micro(points, pending);+ }+ }+ }+ if std::env::var_os("REAL_PHOTOS").is_some() {+ real();+ }+}