Skip to content

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.toml
index 3770a91b2,8bb6e1148..36c37c32e
--- a/apps/lightcraft-cli/Cargo.toml
+++ b/apps/lightcraft-cli/Cargo.toml
@@@ -19,11 -19,5 +19,12 @@@ lightcraft-mcp = { workspace = true
lightcraft-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.rs
index 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.rs
index 6fcddef33,f022268ed..291ec8db7
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@@ -18,7 -18,7 +18,8 @@@ pub mod files
pub 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.rs
index 49d7a6db2,e10b31a1e..77ff7e815
--- a/crates/engine/src/media.rs
+++ b/crates/engine/src/media.rs
@@@ -123,8 -119,9 +125,9 @@@ impl Default for MediaCache
file_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.rs
index e02a2818b,010ff7ba0..1fbf3fefa
--- a/crates/gpu/src/ctx.rs
+++ b/crates/gpu/src/ctx.rs
@@@ -77,98 -76,36 +77,128 @@@ impl Buf
impl 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.rs
index 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.md
index 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 |