LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
Merge main into M5.6 (memory) branch
Brandon Thomasd6431d0b8a6a
diff --cc apps/lightcraft-cli/Cargo.tomlindex 3770a91b2,8bb6e1148..36c37c32e--- a/apps/lightcraft-cli/Cargo.toml+++ b/apps/lightcraft-cli/Cargo.toml@@@ -19,11 -19,5 +19,12 @@@ lightcraft-mcp = { workspace = truelightcraft-ui-egui = { workspace = true }lightcraft-codecs = { workspace = true }lightcraft-raster = { workspace = true }+ lightcraft-merge = { workspace = true }serde_json = { workspace = true }+dhat = { workspace = true, optional = true }++[features]+# Heap profiling: `cargo run --release -p lightcraft-cli --features dhat-heap -- snapshot …` counts+# every allocation (live/peak bytes in `library.memory` / `ui.inspect`) and writes dhat-heap.json+# (open it in DHAT's viewer: allocation sites by bytes at the peak). Slows allocation-heavy work.+dhat-heap = ["dep:dhat"]diff --cc apps/lightcraft/src/main.rsindex f6ea375f6,b2ad72362..6ac150ecd--- a/apps/lightcraft/src/main.rs+++ b/apps/lightcraft/src/main.rs@@@ -12,8 -12,9 +12,10 @@@//! `{"id":1,"method":"ui.inspect","params":{}}` → `{"id":1,"ok":true,"result":…}`.//! See `lightcraft_ui_egui::control` for the methods.+mod alloc_release;mod control_server;+ #[cfg(target_os = "macos")]+ mod native_menu;use lightcraft_engine::Session;use lightcraft_ui_egui::{LightcraftApp, Services, UiState};diff --cc crates/engine/src/lib.rsindex 6fcddef33,f022268ed..291ec8db7--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@@ -18,7 -18,7 +18,8 @@@ pub mod filespub mod import;pub mod library;pub mod media;+pub mod memory;+ pub mod merge;pub mod presets;pub mod sidecar;mod view;diff --cc crates/engine/src/media.rsindex 49d7a6db2,e10b31a1e..77ff7e815--- a/crates/engine/src/media.rs+++ b/crates/engine/src/media.rs@@@ -123,8 -119,9 +125,9 @@@ impl Default for MediaCachefile_loader: None,file_probe: None,preview_loader: None,+ file_bytes: None,scenes: Vec::new(),- rendered: Arc::new(PreviewCache::memory(RENDERED_MEM_BYTES)),+ rendered: Arc::new(PreviewCache::memory(rendered_budget(budget))),}}}diff --cc crates/gpu/src/ctx.rsindex e02a2818b,010ff7ba0..1fbf3fefa--- a/crates/gpu/src/ctx.rs+++ b/crates/gpu/src/ctx.rs@@@ -77,98 -76,36 +77,128 @@@ impl Bufimpl Drop for Buf {fn drop(&mut self) {- if let Some(b) = self.buf.take() {- // during thread teardown the list may already be gone: then the buffer leaks- let mut b = Some(b);- let _ = RETIRED.try_with(|r| r.0.borrow_mut().extend(b.take()));- if let Some(b) = b {- std::mem::forget(b);+ let Some(b) = self.buf.take() else { return };+ // Outside a render this thread has no commands recorded (only renders record), so the+ // buffer is reusable at once; without this, buffers dropped on threads that rarely+ // submit (the UI thread clearing a view's stages) would wait indefinitely.- if !IN_RENDER.with(|c| c.get() > 0)- && let Some(g) = crate::existing_device()- {++ let Ok(in_render) = IN_RENDER.try_with(|c| c.get() > 0) else {++ // thread teardown: wgpu's thread-locals may be gone too, and dropping (or trimming++ // the pool, which drops) could abort — leak it (the device owns its memory)++ std::mem::forget(b);++ return;++ };++ if !in_render && let Some(g) = crate::existing_device() {+ g.pool([b]);+ return;+ }- RETIRED_BYTES.fetch_add(b.0.size(), Ordering::Relaxed);- RETIRED.with(|r| r.borrow_mut().push(b));++ // during thread teardown the list may already be gone: then the buffer leaks++ let size = b.0.size();++ let mut b = Some(b);++ let _ = RETIRED.try_with(|r| r.0.borrow_mut().extend(b.take()));++ match b {++ Some(b) => std::mem::forget(b),++ None => {++ RETIRED_BYTES.fetch_add(size, Ordering::Relaxed);+ }+ }}}+ /// Buffers dropped on a thread since its last submit.-struct Retired(std::cell::RefCell<Vec<wgpu::Buffer>>);++struct Retired(std::cell::RefCell<Vec<Tracked>>);++ impl Drop for Retired {+ /// At thread exit wgpu's own thread-locals may already be destroyed, and dropping a buffer+ /// then aborts the process: leak the few buffers left instead (the device owns their memory).+ fn drop(&mut self) {+ for b in self.0.get_mut().drain(..) {++ RETIRED_BYTES.fetch_sub(b.0.size(), Ordering::Relaxed);+ std::mem::forget(b);+ }+ }+ }+++/// This thread's retired buffers (empty during thread teardown).++fn take_retired() -> Vec<Tracked> {++ let retired = RETIRED.try_with(|r| std::mem::take(&mut *r.0.borrow_mut())).unwrap_or_default();++ RETIRED_BYTES.fetch_sub(retired.iter().map(|b| b.0.size()).sum(), Ordering::Relaxed);++ retired++}+++thread_local! {+ /// Renders running on this thread (they may hold recorded, unsubmitted commands).+ static IN_RENDER: std::cell::Cell<u32> = const { std::cell::Cell::new(0) };+}++/// Marks a render on this thread; when it ends, the buffers it released join the pool (everything+/// it recorded has been submitted by then).+pub(crate) struct RenderScope<'a>(&'a Gpu);++impl<'a> RenderScope<'a> {+ pub fn new(g: &'a Gpu) -> RenderScope<'a> {+ IN_RENDER.with(|c| c.set(c.get() + 1));+ RenderScope(g)+ }+}++impl Drop for RenderScope<'_> {+ fn drop(&mut self) {+ let outer = IN_RENDER.with(|c| {+ c.set(c.get().saturating_sub(1));+ c.get() == 0+ });+ if outer {- let retired = RETIRED.with(|r| std::mem::take(&mut *r.borrow_mut()));- RETIRED_BYTES.fetch_sub(retired.iter().map(|b| b.0.size()).sum(), Ordering::Relaxed);- self.0.pool(retired);++ self.0.pool(take_retired());+ }+ }+}++/// A device buffer, counted in [`ALLOCATED`] while it exists.+pub(crate) struct Tracked(wgpu::Buffer);++impl Tracked {+ fn new(b: wgpu::Buffer) -> Tracked {+ ALLOCATED.fetch_add(b.size(), Ordering::Relaxed);+ Tracked(b)+ }+}++impl Drop for Tracked {+ fn drop(&mut self) {+ ALLOCATED.fetch_sub(self.0.size(), Ordering::Relaxed);+ }+}+thread_local! {- /// Buffers dropped on this thread since its last submit.- static RETIRED: std::cell::RefCell<Vec<Tracked>> = const { std::cell::RefCell::new(Vec::new()) };+ static RETIRED: Retired = const { Retired(std::cell::RefCell::new(Vec::new())) };}-/// Most bytes kept in the free pool.-const POOL_BYTES: u64 = 2 << 30;+/// Bytes of device buffers that exist (in use, retired or pooled).+static ALLOCATED: AtomicU64 = AtomicU64::new(0);+/// Bytes waiting in per-thread retired lists.+static RETIRED_BYTES: AtomicU64 = AtomicU64::new(0);+/// Bytes in the free pool.+static POOLED: AtomicU64 = AtomicU64::new(0);+/// Most bytes kept in the free pool (see [`crate::set_pool_limit`]).+pub(crate) static POOL_LIMIT: AtomicU64 = AtomicU64::new(DEFAULT_POOL_BYTES);++/// Default for the most bytes kept in the free pool (apps derive it from their memory budget).+pub(crate) const DEFAULT_POOL_BYTES: u64 = 256 << 20;++/// Device buffers held by the renderer (bytes).+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub struct GpuMemory {+ /// Every buffer that exists (in use + retired + pooled).+ pub allocated: u64,+ /// Of which recycled buffers waiting in the free pool.+ pub pooled: u64,+ /// Of which buffers dropped since their thread's last submit (pooled at its next submit).+ pub retired: u64,+}++pub(crate) fn memory() -> GpuMemory {+ GpuMemory { allocated: ALLOCATED.load(Ordering::Relaxed), pooled: POOLED.load(Ordering::Relaxed), retired: RETIRED_BYTES.load(Ordering::Relaxed) }+}pub struct Gpu {pub device: wgpu::Device,@@@ -325,43 -253,12 +358,42 @@@ impl Gpu/// Submit command buffers, then make the buffers this thread dropped before reusable.pub fn submit(&self, cmds: impl IntoIterator<Item = wgpu::CommandBuffer>) {self.queue.submit(cmds);- let retired = RETIRED.with(|r| std::mem::take(&mut *r.borrow_mut()));- RETIRED_BYTES.fetch_sub(retired.iter().map(|b| b.0.size()).sum(), Ordering::Relaxed);- let retired = RETIRED.with(|r| std::mem::take(&mut *r.0.borrow_mut()));++ let retired = take_retired();+ self.pool(retired);+ }++ /// Put reusable buffers into the free pool (trimmed to its limit).+ fn pool(&self, bufs: impl IntoIterator<Item = Tracked>) {+ let mut added = false;+ {+ let mut f = self.free.lock().unwrap_or_else(|e| e.into_inner());+ for b in bufs {+ POOLED.fetch_add(b.0.size(), Ordering::Relaxed);+ f.push(b);+ added = true;+ }+ }+ if added {+ self.trim(POOL_LIMIT.load(Ordering::Relaxed));+ }+ }++ /// Free pooled buffers (oldest first) until at most `keep` bytes stay pooled.+ pub fn trim(&self, keep: u64) {let mut f = self.free.lock().unwrap_or_else(|e| e.into_inner());- f.extend(retired);- let mut total: u64 = f.iter().map(|b| b.size()).sum();- while total > POOL_BYTES && !f.is_empty() {- total -= f.remove(0).size();+ let mut total: u64 = f.iter().map(|b| b.0.size()).sum();+ let mut dropped = Vec::new();+ while total > keep && !f.is_empty() {+ let b = f.remove(0);+ total -= b.0.size();+ POOLED.fetch_sub(b.0.size(), Ordering::Relaxed);+ dropped.push(b);+ }+ drop(f);+ if !dropped.is_empty() {+ drop(dropped);+ // let wgpu release the memory now rather than at its next maintenance+ let _ = self.device.poll(wgpu::PollType::Poll);}}diff --cc crates/ui-egui/src/control.rsindex 9fad1a4fd,16a9240db..74d9792d4--- a/crates/ui-egui/src/control.rs+++ b/crates/ui-egui/src/control.rs@@@ -77,10 -77,9 +77,10 @@@ pub fn inspect(app: &LightcraftApp, ctx"selection": app.session.selection.ids.iter().map(|p| p.0).collect::<Vec<_>>(),"activeMask": app.session.active_mask,"widgetCount": app.widgets.len(),- "perf": {"frameMs": app.perf.frame_ms, "fps": app.perf.fps, "lastRenderMs": app.renderer.last_main_ms, "renderQueue": app.renderer.queued(), "rendersInFlight": app.renderer.in_flight(), "rendersDone": app.renderer.completed, "thumbTextures": app.renderer.thumb_textures(), "gpu": (lightcraft_engine::gpu::ready() && lightcraft_engine::gpu::available()).then(lightcraft_engine::gpu::adapter_name).flatten()},+ "perf": {"frameMs": app.perf.frame_ms, "fps": app.perf.fps, "lastRenderMs": app.renderer.last_main_ms, "renderQueue": app.renderer.queued(), "rendersInFlight": app.renderer.in_flight(), "mergeRunning": app.merge.busy(), "lastMerge": app.merge.last_result, "rendersDone": app.renderer.completed, "thumbTextures": app.renderer.thumb_textures(), "gpu": (lightcraft_engine::gpu::ready() && lightcraft_engine::gpu::available()).then(lightcraft_engine::gpu::adapter_name).flatten()},"loupe": app.loupe_shown.map(|(p, src)| json!({"photo": p.0, "source": src, "pending": app.renderer.is_pending(crate::render::Slot::Main)})),"status": app.ui.status,+ "memory": memory(app),})}diff --cc docs/control-protocol.mdindex 254040b53,71d5ee05c..b013a2ea4--- a/docs/control-protocol.md+++ b/docs/control-protocol.md@@@ -19,8 -19,9 +19,9 @@@ mode ([mcp.md](mcp.md)) is a thin laye|---|---|---|| `engine.execute` (alias `ui.menu.invoke`) | `{command, params?}` | Run any engine or UI command (see `engine.commands`) || `engine.commands` | — | Engine + UI commands: id, label, menu, shortcut, params doc, enabled |- | `ui.menu.list` | — | Menu entries |+ | `ui.menu.list` | — | Menu entries (flat: id, label, menu path, shortcut, enabled) |+ | `ui.menu.tree` | — | The menu bar as shown (File … Help): items `{id, params?, label, shortcut?, enabled, checked?}`, separators, submenus — the model behind the native macOS menu bar and the in-window menus |-| `ui.inspect` | — | UI state, window, canvas/image rects, active photo, selection, perf, status |+| `ui.inspect` | — | UI state, window, canvas/image rects, active photo, selection, perf, status, memory (bytes per cache, see `library.memory`; plus stage caches and textures) || `ui.widgets` | `{filter?}` | On-screen widgets `{id, rect: [x, y, w, h]}` (screen points) || `ui.clickWidget` / `ui.dragWidget` | `{id, count?, fx?, fy?}` / `{id, toX?, toY?, dx?, dy?, steps?}` | Real egui input on a widget || `ui.move` / `ui.click` / `ui.drag` | `{x, y, count?, button?}` / `{x, y, toX, toY, steps?}` | Raw pointer input, screen points |