LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
M5.6c: one memory budget for caches, decode gate and GPU pool; peak RSS 1.9-2.3 GB -> 0.83-0.99 GB
Brandon Thomas7266f4153f41
diff --git a/apps/lightcraft-cli/src/alloc_release.rs b/apps/lightcraft-cli/src/alloc_release.rsnew file mode 100644index 000000000..0d0775bad--- /dev/null+++ b/apps/lightcraft-cli/src/alloc_release.rs@@ -0,0 +1,32 @@+//! Give memory the system allocator keeps after frees back to the system+//! ([`lightcraft_engine::memory::set_release_hook`]).+//!+//! macOS's allocator keeps freed large blocks mapped as "reusable": they no longer count in the+//! process's memory footprint but stay in its resident size until the system runs short. After a+//! raw decode (hundreds of MB of temporaries) that made the resident size climb towards the sum of+//! everything ever decoded. `malloc_zone_pressure_relief` (libSystem) returns those pages now.+//! Elsewhere (glibc, Windows) blocks this large are unmapped when freed: nothing to do.++/// Install the hook for this platform.+pub fn install() {+ #[cfg(target_os = "macos")]+ lightcraft_engine::memory::set_release_hook(macos::release);+}++#[cfg(target_os = "macos")]+#[allow(unsafe_code)]+mod macos {+ unsafe extern "C" {+ /// libSystem malloc: release free memory of `zone` (all zones when null) back to the+ /// system, up to `goal` bytes (0 = as much as possible). Returns the bytes released.+ fn malloc_zone_pressure_relief(zone: *mut std::ffi::c_void, goal: usize) -> usize;+ }++ pub fn release() {+ // SAFETY: a documented libSystem function taking a null zone (= every zone) and a size;+ // it only returns free pages to the system and touches no memory we own.+ unsafe {+ malloc_zone_pressure_relief(std::ptr::null_mut(), 0);+ }+ }+}diff --git a/apps/lightcraft-cli/src/main.rs b/apps/lightcraft-cli/src/main.rsindex 246fd96c7..2988c3278 100644--- a/apps/lightcraft-cli/src/main.rs+++ b/apps/lightcraft-cli/src/main.rs@@ -8,6 +8,8 @@//! lightcraft-cli controls [--json]//! ```+mod alloc_release;+use std::io::{BufReader, Write};use std::path::Path;use std::process::ExitCode;@@ -67,6 +69,7 @@ fn main() -> ExitCode {});dhat::Profiler::builder().file_name(file).build()};+ alloc_release::install();let args: Vec<String> = std::env::args().skip(1).collect();let r = match args.first().map(String::as_str) {Some("mcp") => mcp(&args[1..]),@@ -337,6 +340,9 @@ fn snapshot(args: &[String]) -> Result<(), String> {};if let Some(o) = reply.as_object_mut() {o.insert("id".into(), id);+ // wall time of the request (incl. the frames it ran), and since the start+ o.insert("ms".into(), json!((ts.elapsed().as_secs_f64() * 1e4).round() / 10.0));+ o.insert("t".into(), json!((t0.elapsed().as_secs_f64() * 1e4).round() / 10.0));}writeln!(out, "{reply}").map_err(|e| e.to_string())?;if method == "ui.screenshot" {diff --git a/apps/lightcraft/src/alloc_release.rs b/apps/lightcraft/src/alloc_release.rsnew file mode 100644index 000000000..0d0775bad--- /dev/null+++ b/apps/lightcraft/src/alloc_release.rs@@ -0,0 +1,32 @@+//! Give memory the system allocator keeps after frees back to the system+//! ([`lightcraft_engine::memory::set_release_hook`]).+//!+//! macOS's allocator keeps freed large blocks mapped as "reusable": they no longer count in the+//! process's memory footprint but stay in its resident size until the system runs short. After a+//! raw decode (hundreds of MB of temporaries) that made the resident size climb towards the sum of+//! everything ever decoded. `malloc_zone_pressure_relief` (libSystem) returns those pages now.+//! Elsewhere (glibc, Windows) blocks this large are unmapped when freed: nothing to do.++/// Install the hook for this platform.+pub fn install() {+ #[cfg(target_os = "macos")]+ lightcraft_engine::memory::set_release_hook(macos::release);+}++#[cfg(target_os = "macos")]+#[allow(unsafe_code)]+mod macos {+ unsafe extern "C" {+ /// libSystem malloc: release free memory of `zone` (all zones when null) back to the+ /// system, up to `goal` bytes (0 = as much as possible). Returns the bytes released.+ fn malloc_zone_pressure_relief(zone: *mut std::ffi::c_void, goal: usize) -> usize;+ }++ pub fn release() {+ // SAFETY: a documented libSystem function taking a null zone (= every zone) and a size;+ // it only returns free pages to the system and touches no memory we own.+ unsafe {+ malloc_zone_pressure_relief(std::ptr::null_mut(), 0);+ }+ }+}diff --git a/apps/lightcraft/src/main.rs b/apps/lightcraft/src/main.rsindex baac940f1..f6ea375f6 100644--- a/apps/lightcraft/src/main.rs+++ b/apps/lightcraft/src/main.rs@@ -12,6 +12,7 @@//! `{"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;use lightcraft_engine::Session;@@ -167,6 +168,7 @@ OPTIONS:";fn main() -> eframe::Result {+ alloc_release::install();let mut control_port: Option<u16> = std::env::var("LIGHTCRAFT_CONTROL_PORT").ok().and_then(|p| p.parse().ok());let mut files = Vec::new();let mut seed_demo = true;diff --git a/crates/engine/src/cmd/query.rs b/crates/engine/src/cmd/query.rsindex 1d0bb6c0f..964a0d8d0 100644--- a/crates/engine/src/cmd/query.rs+++ b/crates/engine/src/cmd/query.rs@@ -138,6 +138,15 @@ pub fn specs() -> Vec<CommandSpec> {cmd!(query "library.memory", "Memory Usage", [], None, "{} — bytes held by each cache (decoded sources, rendered previews, GPU buffers; heap when instrumented)", always, |s, _| {Ok(serde_json::to_value(s.memory_report()).unwrap_or_default())}),+ cmd!(query "app.memoryBudget", "Memory Budget", [], None, "{mb?: number} — set the memory budget shared by the caches (default: a quarter of RAM, at most 1536 MB); returns the report", always, |s, p| {+ if let Some(mb) = p.get("mb").and_then(Value::as_f64) {+ if !(64.0..=1_048_576.0).contains(&mb) {+ return Err(bad("app.memoryBudget", "mb must be 64..1048576"));+ }+ s.set_memory_budget((mb * 1048576.0) as usize);+ }+ Ok(serde_json::to_value(s.memory_report()).unwrap_or_default())+ }),cmd!(query "journal.list", "Command Journal", [], None, "{limit?}", always, |s, p| {let lim = p.get("limit").and_then(Value::as_u64).unwrap_or(100) as usize;let start = s.journal.len().saturating_sub(lim);diff --git a/crates/engine/src/files.rs b/crates/engine/src/files.rsindex 153922c9a..a857f6cb1 100644--- a/crates/engine/src/files.rs+++ b/crates/engine/src/files.rs@@ -191,19 +191,26 @@ pub fn bin_factor(raw: &lightcraft_raw::RawImage, max_edge: usize) -> Option<usi/// instead of each one waking the pool from outside and waiting for it (which costs more than the/// loops themselves when the machine is busy).pub fn load_bytes(bytes: &[u8], max_edge: usize) -> Result<(Rgb32f, SourceInfo), String> {- rayon::scope(|_| load_bytes_now(bytes, max_edge))+ rayon::scope(|_| load_bytes_now(std::borrow::Cow::Borrowed(bytes), max_edge))}-fn load_bytes_now(bytes: &[u8], max_edge: usize) -> Result<(Rgb32f, SourceInfo), String> {- if lightcraft_raw::probe(bytes).is_some() {- let mut raw = match lightcraft_raw::decode(bytes) {+/// [`load_bytes`] taking the file's bytes: a raw file's bytes are freed as soon as it is decoded+/// (less memory held while it is developed).+pub fn load_vec(bytes: Vec<u8>, max_edge: usize) -> Result<(Rgb32f, SourceInfo), String> {+ rayon::scope(move |_| load_bytes_now(std::borrow::Cow::Owned(bytes), max_edge))+}++fn load_bytes_now(bytes: std::borrow::Cow<'_, [u8]>, max_edge: usize) -> Result<(Rgb32f, SourceInfo), String> {+ if lightcraft_raw::probe(&bytes).is_some() {+ let mut raw = match lightcraft_raw::decode(&bytes) {Ok(r) => r,Err(lightcraft_raw::RawError::Unsupported(why)) => {// show the camera's embedded JPEG (rendered, not raw) until the variant is supported- return load_embedded_preview(bytes, max_edge).ok_or(format!("unsupported raw ({why}) without an embedded preview"));+ return load_embedded_preview(&bytes, max_edge).ok_or(format!("unsupported raw ({why}) without an embedded preview"));}Err(e) => return Err(e.to_string()),};+ drop(bytes);// Embedded lens corrections are applied by the pipeline ("Enable Profile Corrections"), not baked in.let lens = embedded_lens(&raw.info());raw.opcodes.list3.retain(|op| !is_lens_opcode(op));@@ -221,6 +228,8 @@ fn load_bytes_now(bytes: &[u8], max_edge: usize) -> Result<(Rgb32f, SourceInfo),raw.develop(method).map_err(|e| e.to_string())?}};+ // the samples aren't needed any more (the colour model below reads only the tags)+ raw.data = lightcraft_raw::RawData::U16(Vec::new());let mut stages = vec![("develop", t0.elapsed())];let xy = lightcraft_raw::color::as_shot_white_xy(&raw);let t = lightcraft_raw::color::camera_transform(&raw, xy);@@ -230,7 +239,7 @@ fn load_bytes_now(bytes: &[u8], max_edge: usize) -> Result<(Rgb32f, SourceInfo),let m = t.matrix.to_f32();let gain = 2f32.powf(t.baseline_exposure as f32);let wb = t.wb;- let img = img.map(|p| {+ img.map_in_place(|p| {let c = [p[0] * wb[0], p[1] * wb[1], p[2] * wb[2]];[((m[0][0] * c[0] + m[0][1] * c[1] + m[0][2] * c[2]) * gain).max(0.0),@@ -241,7 +250,7 @@ fn load_bytes_now(bytes: &[u8], max_edge: usize) -> Result<(Rgb32f, SourceInfo),stages.push(("colour", t0.elapsed()));let img = fit(&img, max_edge, max_edge, Filter::Box);stages.push(("fit", t0.elapsed()));- let img = img.oriented(raw.orientation);+ let img = img.into_oriented(raw.orientation);stages.push(("orient", t0.elapsed()));if lightcraft_pipeline::profiling() {let mut prev = std::time::Duration::ZERO;@@ -258,10 +267,11 @@ fn load_bytes_now(bytes: &[u8], max_edge: usize) -> Result<(Rgb32f, SourceInfo),let (temp, tint) = xy_to_temp_tint(xy);return Ok((img, SourceInfo { raw: true, as_shot_temp: temp.round(), as_shot_tint: tint.round(), lens }));}- let d = lightcraft_codecs::decode(bytes, lightcraft_codecs::DecodeOptions::fit(max_edge as u32, max_edge as u32)).map_err(|e| e.to_string())?;+ let d = lightcraft_codecs::decode(&bytes, lightcraft_codecs::DecodeOptions::fit(max_edge as u32, max_edge as u32)).map_err(|e| e.to_string())?;+ drop(bytes);let img = d.to_working();let img = if img.width.max(img.height) > max_edge { fit(&img, max_edge, max_edge, Filter::Mitchell) } else { img };- Ok((img.oriented(Orientation::from_exif(d.orientation)), SourceInfo::default()))+ Ok((img.into_oriented(Orientation::from_exif(d.orientation)), SourceInfo::default()))}/// Orientation for an embedded preview: its own EXIF orientation when it has one, else the raw file's.@@ -311,12 +321,27 @@ pub fn fs_preview_loader() -> PreviewLoader {}/// Filesystem-backed hooks (native). On the web the host installs bytes-based hooks instead.+///+/// Their working memory is bounded by [`crate::memory::work_gate`]: background loads (grid+/// thumbnails, neighbour prefetch: [`crate::memory::in_background`]) and import probes wait while+/// too much is in flight, each counting its file's size times the expansion of decoding it;+/// interactive loads (the loupe, exports) never wait — they are counted, so background work+/// yields to them.pub fn fs_hooks() -> (FileLoader, FileProbe) {let loader: FileLoader = Arc::new(|path: &str, max_edge: usize| {+ let len = std::fs::metadata(path).map(|m| m.len() as usize).unwrap_or(0);+ let weight = len * if max_edge <= crate::media::SourceLevel::Thumb.max_edge() { 3 } else { 6 };+ let gate = crate::memory::work_gate();+ let _permit = if crate::memory::is_background() { gate.acquire(weight) } else { gate.acquire_urgent(weight) };let bytes = std::fs::read(path).map_err(|e| format!("{path}: {e}"))?;- load_bytes(&bytes, max_edge)+ let r = load_vec(bytes, max_edge);+ // the file, the samples and the intermediate images are gone: give their pages back+ crate::memory::release();+ r});let probe: FileProbe = Arc::new(|path: &str| {+ let len = std::fs::metadata(path).map(|m| m.len() as usize).unwrap_or(0);+ let _permit = crate::memory::work_gate().acquire(len);let bytes = std::fs::read(path).map_err(|e| format!("{path}: {e}"))?;probe_bytes(path, &bytes)});diff --git a/crates/engine/src/import.rs b/crates/engine/src/import.rsindex e07199d68..2be62172b 100644--- a/crates/engine/src/import.rs+++ b/crates/engine/src/import.rs@@ -194,6 +194,7 @@ pub fn import(s: &mut Session, paths: &[String], mode: ImportMode) -> crate::Res}let probed = probe_all(s, &todo);+ crate::memory::release();let now = (s.clock)();let mut ops = Vec::new();for (path, info) in todo.into_iter().zip(probed) {diff --git a/crates/engine/src/media.rs b/crates/engine/src/media.rsindex f851b0321..49d7a6db2 100644--- a/crates/engine/src/media.rs+++ b/crates/engine/src/media.rs@@ -94,11 +94,15 @@ impl SourceRef {pub struct MediaCache {/// Decoded thumbnail-level sources (LRU by bytes).thumbs: Lru<PhotoId, Arc<Rgb32f>>,- previews: Vec<(PhotoId, Arc<Rgb32f>)>,+ /// Decoded preview-level sources with their last use ([`lightcraft_preview::next_tick`]).+ previews: Vec<(PhotoId, Arc<Rgb32f>, u64)>,/// The last full-resolution original (exports; one at a time: ~300 MB at 24 MP).- full: Option<(PhotoId, Arc<Rgb32f>)>,+ full: Option<(PhotoId, Arc<Rgb32f>, u64)>,/// How many previews to keep (LRU).pub preview_capacity: usize,+ /// Bytes all decoded sources and rendered previews in memory may take together (the cache+ /// share of [`crate::memory::budget`]); the least recently used entry of any of them goes first.+ budget: usize,pub file_loader: Option<FileLoader>,pub file_probe: Option<FileProbe>,pub preview_loader: Option<PreviewLoader>,@@ -109,57 +113,123 @@ pub struct MediaCache {impl Default for MediaCache {fn default() -> Self {+ let budget = crate::memory::cache_share(crate::memory::budget());MediaCache {- thumbs: Lru::new(THUMB_SOURCE_BYTES),+ thumbs: Lru::new(THUMB_SOURCE_BYTES.min(budget)),previews: Vec::new(),full: None,preview_capacity: 0,+ budget,file_loader: None,file_probe: None,preview_loader: None,scenes: Vec::new(),- rendered: Arc::new(PreviewCache::memory(RENDERED_MEM_BYTES)),+ rendered: Arc::new(PreviewCache::memory(rendered_budget(budget))),}}}+/// Memory for rendered previews out of the cache share.+fn rendered_budget(share: usize) -> usize {+ RENDERED_MEM_BYTES.min(share / 4)+}++fn source_bytes(img: &Rgb32f) -> usize {+ img.data.len() * 12 + 64+}+impl MediaCache {/// Keep rendered thumbnails on disk in `dir` as well.pub fn attach_disk_cache(&mut self, dir: &std::path::Path) {- self.rendered = Arc::new(PreviewCache::with_disk(RENDERED_MEM_BYTES, dir, DISK_CACHE_BYTES));+ self.rendered = Arc::new(PreviewCache::with_disk(rendered_budget(self.budget), dir, DISK_CACHE_BYTES));+ }++ /// Bytes the caches may hold together.+ pub fn budget(&self) -> usize {+ self.budget+ }++ /// Change the bytes the caches may hold together, evicting at once if needed.+ pub fn set_budget(&mut self, bytes: usize) {+ self.budget = bytes;+ self.thumbs.set_budget(THUMB_SOURCE_BYTES.min(bytes));+ self.rendered.set_mem_budget(rendered_budget(bytes));+ self.enforce_budget();+ }++ /// Bytes held by decoded sources and rendered previews in memory.+ pub fn held(&self) -> usize {+ let (t, p, f) = self.usage();+ t.bytes + p.bytes + f.bytes + self.rendered.mem_usage().1+ }++ /// Evict least recently used entries across the source caches and the rendered previews+ /// until they fit the budget. The newest preview-level source (the photo on screen, or the+ /// one just decoded) is never evicted here.+ pub fn enforce_budget(&mut self) {+ let mut held = self.held();+ while held > self.budget {+ let newest_preview = self.previews.iter().map(|e| e.2).max();+ let candidates = [+ self.thumbs.oldest_tick().map(|t| (t, 0)),+ self.previews.iter().filter(|e| Some(e.2) != newest_preview).map(|e| e.2).min().map(|t| (t, 1)),+ self.full.as_ref().map(|e| (e.2, 2)),+ self.rendered.oldest_tick().map(|t| (t, 3)),+ ];+ let Some((tick, which)) = candidates.into_iter().flatten().min() else { break };+ let freed = match which {+ 0 => self.thumbs.pop_oldest(),+ 1 => self.previews.iter().position(|e| e.2 == tick).map(|i| source_bytes(&self.previews.remove(i).1)),+ 2 => self.full.take().map(|e| source_bytes(&e.1)),+ _ => self.rendered.evict_oldest(),+ };+ match freed {+ Some(b) if b > 0 => held = held.saturating_sub(b),+ _ => break,+ }+ }}pub fn get(&mut self, id: PhotoId, level: SourceLevel) -> Option<Arc<Rgb32f>> {match level {SourceLevel::Thumb => self.thumbs.get(&id).cloned(),- SourceLevel::Preview => self.previews.iter().find(|(p, _)| *p == id).map(|(_, a)| a.clone()),- SourceLevel::Full => self.full.as_ref().filter(|(p, _)| *p == id).map(|(_, a)| a.clone()),+ SourceLevel::Preview => self.previews.iter_mut().find(|e| e.0 == id).map(|e| {+ e.2 = lightcraft_preview::next_tick();+ e.1.clone()+ }),+ SourceLevel::Full => self.full.as_mut().filter(|e| e.0 == id).map(|e| {+ e.2 = lightcraft_preview::next_tick();+ e.1.clone()+ }),}}pub fn insert(&mut self, id: PhotoId, level: SourceLevel, img: Arc<Rgb32f>) {+ let tick = lightcraft_preview::next_tick();match level {SourceLevel::Thumb => {- let cost = img.width * img.height * 12 + 64;+ let cost = source_bytes(&img);self.thumbs.insert(id, img, cost);}SourceLevel::Preview => {- self.previews.retain(|(p, _)| *p != id);- self.previews.push((id, img));+ self.previews.retain(|e| e.0 != id);+ self.previews.push((id, img, tick));let cap = if self.preview_capacity == 0 { 4 } else { self.preview_capacity };while self.previews.len() > cap {- self.previews.remove(0);+ let oldest = self.previews.iter().enumerate().min_by_key(|(_, e)| e.2).map(|(i, _)| i).unwrap_or(0);+ self.previews.remove(oldest);}}- SourceLevel::Full => self.full = Some((id, img)),+ SourceLevel::Full => self.full = Some((id, img, tick)),}+ self.enforce_budget();}/// Forget a photo's decoded sources (e.g. after its file changed).pub fn forget(&mut self, id: PhotoId) {self.thumbs.remove(&id);- self.previews.retain(|(p, _)| *p != id);- if self.full.as_ref().is_some_and(|(p, _)| *p == id) {+ self.previews.retain(|e| e.0 != id);+ if self.full.as_ref().is_some_and(|e| e.0 == id) {self.full = None;}}@@ -172,9 +242,8 @@ impl MediaCache {/// Decoded sources held: (thumbnail level, preview level, full size).pub fn usage(&self) -> (crate::memory::Usage, crate::memory::Usage, crate::memory::Usage) {use crate::memory::Usage;- let bytes = |i: &Rgb32f| i.data.len() * 12;- let previews = Usage::new(self.previews.len(), self.previews.iter().map(|(_, a)| bytes(a)).sum());- let full = self.full.as_ref().map(|(_, a)| Usage::new(1, bytes(a))).unwrap_or_default();+ let previews = Usage::new(self.previews.len(), self.previews.iter().map(|e| source_bytes(&e.1)).sum());+ let full = self.full.as_ref().map(|e| Usage::new(1, source_bytes(&e.1))).unwrap_or_default();(Usage::new(self.thumbs.len(), self.thumbs.cost()), previews, full)}@@ -536,6 +605,54 @@ pub type FileProbe = Arc<dyn Fn(&str) -> Result<ProbeInfo, String> + Send + Syncmod tests {use super::*;+ #[test]+ fn budget_evicts_least_recently_used_across_caches() {+ let img = |w: usize| Arc::new(Rgb32f::new(w, w));+ let mut m = MediaCache::default();+ let mb = 1 << 20;+ m.set_budget(30 * mb);+ // 3 previews of 12 MB (1000² × 12 B) don't fit 30 MB: the least recently used goes+ m.insert(PhotoId(1), SourceLevel::Preview, img(1000));+ m.insert(PhotoId(2), SourceLevel::Preview, img(1000));+ assert!(m.get(PhotoId(1), SourceLevel::Preview).is_some()); // 1 is now more recent than 2+ m.insert(PhotoId(3), SourceLevel::Preview, img(1000));+ assert!(m.get(PhotoId(2), SourceLevel::Preview).is_none());+ assert!(m.get(PhotoId(1), SourceLevel::Preview).is_some() && m.get(PhotoId(3), SourceLevel::Preview).is_some());+ // a thumbnail source and a rendered preview compete in the same budget+ m.insert(PhotoId(4), SourceLevel::Thumb, img(500));+ m.rendered.put(Hash128(7), Arc::new(lightcraft_raster::Rgba8::new(1000, 1000)));+ assert!(m.held() <= 30 * mb, "{}", m.held());+ // the newest preview (the one on screen) is never evicted, even alone over budget+ m.set_budget(mb);+ assert!(m.get(PhotoId(3), SourceLevel::Preview).is_some());+ assert_eq!(m.usage().1.count, 1);+ assert_eq!(m.usage().0.count, 0);+ assert_eq!(m.rendered.mem_usage().0, 0);+ }++ #[test]+ fn work_gate_waits_for_room() {+ use crate::memory::WorkGate;+ let g = Arc::new(WorkGate::new(100));+ let a = g.acquire(80);+ // more than fits waits until `a` is released; urgent work never waits+ let urgent = g.acquire_urgent(500);+ assert_eq!(g.usage().0, 580);+ drop(urgent);+ let g2 = g.clone();+ let t = std::thread::spawn(move || {+ let _b = g2.acquire(50);+ g2.usage().0+ });+ std::thread::sleep(std::time::Duration::from_millis(50));+ assert_eq!(g.usage().0, 80, "the second holder is still waiting");+ drop(a);+ assert_eq!(t.join().unwrap(), 50);+ assert_eq!(g.usage().0, 0);+ // a single holder may exceed the limit+ drop(g.acquire(1000));+ }+#[test]fn levels_cover_sizes_and_large_exports_use_the_original() {assert_eq!(SourceLevel::for_size(256), SourceLevel::Thumb);diff --git a/crates/engine/src/memory.rs b/crates/engine/src/memory.rsindex 2a9ba9e12..fa7cb878b 100644--- a/crates/engine/src/memory.rs+++ b/crates/engine/src/memory.rs@@ -6,10 +6,169 @@//! report more. A binary built with a heap profiler installs [`set_heap_stats`] (e.g.//! `lightcraft-cli` with `--features dhat-heap`) to add live/peak heap bytes.-use std::sync::OnceLock;+use std::sync::atomic::{AtomicUsize, Ordering};+use std::sync::{Condvar, Mutex, OnceLock};use serde::Serialize;+/// The memory budget: one number from which every cache's share is derived.+///+/// - half for the engine's caches (decoded sources and rendered previews), evicted least recently+/// used *across* them ([`crate::media::MediaCache`]);+/// - a quarter for the working memory of decodes in flight ([`work_gate`]);+/// - an eighth for the GPU renderer's pool of recycled buffers (trimmed when the app is idle).+///+/// The rest is headroom for what isn't cached (renders in progress, textures, the UI). Default:+/// a quarter of the machine's RAM, at most 1.5 GiB (`LIGHTCRAFT_MEMORY_MB` overrides it).+pub fn default_budget() -> usize {+ if let Some(mb) = std::env::var("LIGHTCRAFT_MEMORY_MB").ok().and_then(|v| v.trim().parse::<usize>().ok()).filter(|m| *m >= 64) {+ return mb << 20;+ }+ let cap = 3usize << 29; // 1.5 GiB+ match total_ram() {+ Some(ram) => (ram / 4).clamp(256 << 20, cap),+ None => cap,+ }+}++/// Physical memory (bytes), when the platform tells us without native calls.+fn total_ram() -> Option<usize> {+ #[cfg(target_os = "linux")]+ {+ let s = std::fs::read_to_string("/proc/meminfo").ok()?;+ let kb: usize = s.lines().find(|l| l.starts_with("MemTotal:"))?.split_whitespace().nth(1)?.parse().ok()?;+ Some(kb * 1024)+ }+ #[cfg(target_os = "macos")]+ {+ let out = std::process::Command::new("/usr/sbin/sysctl").args(["-n", "hw.memsize"]).output().ok()?;+ String::from_utf8_lossy(&out.stdout).trim().parse().ok()+ }+ #[cfg(not(any(target_os = "linux", target_os = "macos")))]+ {+ None+ }+}++static BUDGET: AtomicUsize = AtomicUsize::new(0);++/// The current budget (bytes).+pub fn budget() -> usize {+ match BUDGET.load(Ordering::Relaxed) {+ 0 => {+ let b = default_budget();+ BUDGET.store(b, Ordering::Relaxed);+ apply(b);+ b+ }+ b => b,+ }+}++/// Change the budget (bytes, at least 64 MiB) for the process: the decode gate and the GPU pool+/// follow at once; sessions apply their cache share with [`crate::Session::set_memory_budget`].+pub fn set_budget(bytes: usize) -> usize {+ let b = bytes.max(64 << 20);+ BUDGET.store(b, Ordering::Relaxed);+ apply(b);+ b+}++fn apply(b: usize) {+ if let Some(g) = GATE.get() {+ g.set_limit(b / 4);+ }+ lightcraft_gpu::set_pool_limit((b / 8) as u64);+}++/// Share of the budget for the engine's caches.+pub fn cache_share(budget: usize) -> usize {+ budget / 2+}++/// A weighted semaphore over bytes of working memory: [`WorkGate::acquire`] waits while other+/// holders already use the limit (one holder may always proceed, whatever its size).+pub struct WorkGate {+ state: Mutex<(usize, usize)>,+ cv: Condvar,+}++/// Bytes held from a [`WorkGate`] until dropped.+pub struct Permit<'a> {+ gate: &'a WorkGate,+ bytes: usize,+}++impl WorkGate {+ pub fn new(limit: usize) -> WorkGate {+ WorkGate { state: Mutex::new((0, limit)), cv: Condvar::new() }+ }++ fn lock(&self) -> std::sync::MutexGuard<'_, (usize, usize)> {+ self.state.lock().unwrap_or_else(|e| e.into_inner())+ }++ pub fn set_limit(&self, limit: usize) {+ self.lock().1 = limit;+ self.cv.notify_all();+ }++ /// Bytes held now and the limit.+ pub fn usage(&self) -> (usize, usize) {+ *self.lock()+ }++ /// Hold `bytes`, waiting until they fit (or nothing else is held).+ pub fn acquire(&self, bytes: usize) -> Permit<'_> {+ let mut g = self.lock();+ while g.0 > 0 && g.0 + bytes > g.1 {+ g = self.cv.wait(g).unwrap_or_else(|e| e.into_inner());+ }+ g.0 += bytes;+ Permit { gate: self, bytes }+ }++ /// Hold `bytes` without waiting (interactive work): counted, so background work waits for it.+ pub fn acquire_urgent(&self, bytes: usize) -> Permit<'_> {+ self.lock().0 += bytes;+ Permit { gate: self, bytes }+ }+}++impl Drop for Permit<'_> {+ fn drop(&mut self) {+ let mut g = self.gate.lock();+ g.0 = g.0.saturating_sub(self.bytes);+ drop(g);+ self.gate.cv.notify_all();+ }+}++thread_local! {+ static BACKGROUND: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };+}++/// Run `f` as background work (grid thumbnails, neighbour prefetch): its decodes wait at the+/// [`work_gate`] while interactive work holds the memory.+pub fn in_background<R>(f: impl FnOnce() -> R) -> R {+ let was = BACKGROUND.with(|b| b.replace(true));+ let r = f();+ BACKGROUND.with(|b| b.set(was));+ r+}++/// Is this thread running background work ([`in_background`])?+pub fn is_background() -> bool {+ BACKGROUND.with(|b| b.get())+}++/// The process-wide gate for decodes and import probes (limit: a quarter of the budget).+pub fn work_gate() -> &'static WorkGate {+ GATE.get_or_init(|| WorkGate::new(budget() / 4))+}++static GATE: OnceLock<WorkGate> = OnceLock::new();+/// Entries and bytes held by one cache.#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize)]pub struct Usage {@@ -60,12 +219,35 @@ pub struct MemoryReport {/// Sum of the above.pub engine_bytes: usize,pub gpu: GpuUsage,+ /// The memory budget (see [`budget`]) and the engine caches' share of it.+ pub budget: usize,+ pub cache_budget: usize,+ /// Working memory of decodes / probes in flight and its limit ([`work_gate`]).+ pub work_bytes: usize,+ pub work_limit: usize,/// Live/peak heap when the binary counts allocations.#[serde(skip_serializing_if = "Option::is_none")]pub heap: Option<HeapUsage>,}static HEAP: OnceLock<fn() -> HeapUsage> = OnceLock::new();+static RELEASE: OnceLock<fn()> = OnceLock::new();++/// Install a hook that hands memory the allocator keeps after frees back to the system (first+/// call wins). The macOS allocator keeps freed large blocks resident (reusable, but counted in+/// the resident size) until the system runs short; the apps install+/// `malloc_zone_pressure_relief` so the resident size follows what is actually held.+pub fn set_release_hook(f: fn()) {+ let _ = RELEASE.set(f);+}++/// Return freed memory to the system now (after large temporaries were dropped: a decode, an+/// import). No-op without a hook.+pub fn release() {+ if let Some(f) = RELEASE.get() {+ f();+ }+}/// Install the heap counter of an instrumented binary (first call wins).pub fn set_heap_stats(f: fn() -> HeapUsage) {@@ -96,7 +278,18 @@ impl crate::Session {rendered,engine_bytes: thumb_sources.bytes + preview_sources.bytes + full_source.bytes + rendered.bytes,gpu: gpu_usage(),+ budget: budget(),+ cache_budget: self.media.budget(),+ work_bytes: work_gate().usage().0,+ work_limit: work_gate().usage().1,heap: heap_stats(),}}++ /// Set the memory budget (bytes; process-wide) and apply this session's cache share.+ pub fn set_memory_budget(&mut self, bytes: usize) -> usize {+ let b = set_budget(bytes);+ self.media.set_budget(cache_share(b));+ b+ }}diff --git a/crates/gpu/src/ctx.rs b/crates/gpu/src/ctx.rsindex 25d6ef4d9..e02a2818b 100644--- a/crates/gpu/src/ctx.rs+++ b/crates/gpu/src/ctx.rs@@ -77,9 +77,47 @@ impl Buf {impl Drop for Buf {fn drop(&mut self) {- if let Some(b) = self.buf.take() {- RETIRED_BYTES.fetch_add(b.0.size(), Ordering::Relaxed);- RETIRED.with(|r| r.borrow_mut().push(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()+ {+ g.pool([b]);+ return;+ }+ RETIRED_BYTES.fetch_add(b.0.size(), Ordering::Relaxed);+ RETIRED.with(|r| r.borrow_mut().push(b));+ }+}++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);}}}@@ -114,8 +152,8 @@ 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.-pub(crate) const DEFAULT_POOL_BYTES: u64 = 2 << 30;+/// 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)]@@ -259,9 +297,17 @@ impl Gpu {let size = (len.max(1) * 4) as u64;let recycled = {let mut f = self.free.lock().unwrap_or_else(|e| e.into_inner());- let b = f.iter().position(|b| b.0.size() == size).map(|i| f.swap_remove(i));- if b.is_some() {- POOLED.fetch_sub(size, Ordering::Relaxed);+ // the smallest pooled buffer that holds `size` with at most 25 % to spare: photos of+ // slightly different sizes reuse each other's buffers instead of piling up new ones+ let b = f+ .iter()+ .enumerate()+ .filter(|(_, b)| b.0.size() >= size && b.0.size() <= size + size / 4)+ .min_by_key(|(_, b)| b.0.size())+ .map(|(i, _)| i)+ .map(|i| f.swap_remove(i));+ if let Some(b) = &b {+ POOLED.fetch_sub(b.0.size(), Ordering::Relaxed);}b};@@ -280,11 +326,24 @@ impl Gpu {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()));- let bytes: u64 = retired.iter().map(|b| b.0.size()).sum();- RETIRED_BYTES.fetch_sub(bytes, Ordering::Relaxed);- POOLED.fetch_add(bytes, Ordering::Relaxed);- self.free.lock().unwrap_or_else(|e| e.into_inner()).extend(retired);- self.trim(POOL_LIMIT.load(Ordering::Relaxed));+ RETIRED_BYTES.fetch_sub(retired.iter().map(|b| b.0.size()).sum(), Ordering::Relaxed);+ 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.diff --git a/crates/gpu/src/lib.rs b/crates/gpu/src/lib.rsindex c767a7d21..850d23fd9 100644--- a/crates/gpu/src/lib.rs+++ b/crates/gpu/src/lib.rs@@ -66,6 +66,12 @@ pub(crate) fn device() -> Option<&'static ctx::Gpu> {GPU.get_or_init(|| std::panic::catch_unwind(ctx::Gpu::new).ok().flatten()).as_ref()}+/// The device if it has been created (never creates it).+#[cfg(not(target_arch = "wasm32"))]+pub(crate) fn existing_device() -> Option<&'static ctx::Gpu> {+ GPU.get().and_then(|g| g.as_ref())+}+/// Create the device and compile the kernels on a background thread now (app start), so the/// first render doesn't wait ~0.3–0.4 s for it and the UI thread never does.pub fn warm_up() {@@ -183,7 +189,10 @@ pub fn render(src: &Arc<Rgb32f>, info: &SourceInfo, s: &DevelopSettings, req: &R}let gpu = device()?;let ext = stages.map(|c| c.extension::<GpuStages>());- let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| render::render(gpu, src, info, s, req, ext.as_deref())));+ let r = {+ let _scope = ctx::RenderScope::new(gpu);+ std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| render::render(gpu, src, info, s, req, ext.as_deref())))+ };match r {// a device error during the render: its result is not trustworthyOk(_) if BROKEN.load(Ordering::Relaxed) => None,diff --git a/crates/gpu/src/render.rs b/crates/gpu/src/render.rsindex b0dc21209..d229cdbae 100644--- a/crates/gpu/src/render.rs+++ b/crates/gpu/src/render.rs@@ -765,6 +765,7 @@ mod tests {#[ignore]fn bench_kernels() {let Some(gpu) = crate::device() else { return };+ let _scope = crate::ctx::RenderScope::new(gpu);let (w, h) = (6000, 4000);let src = gpu.upload(&vec![0.5f32; w * h * 3]);let time = |name: &str, f: &mut dyn FnMut(&mut Cx<'_>)| {diff --git a/crates/gpu/tests/memory.rs b/crates/gpu/tests/memory.rsnew file mode 100644index 000000000..2ef958cb1--- /dev/null+++ b/crates/gpu/tests/memory.rs@@ -0,0 +1,41 @@+//! Device-memory bookkeeping: a view's stages are counted, released buffers are pooled within+//! the pool limit, and trimming frees them. Skips when no GPU adapter exists.++use std::sync::Arc;++use lightcraft_develop::DevelopSettings;+use lightcraft_pipeline::{RenderRequest, SourceInfo, StageCache};++#[test]+fn stages_are_counted_and_the_pool_is_bounded_and_trimmed() {+ if !lightcraft_gpu::available() {+ eprintln!("skipped: no GPU adapter");+ return;+ }+ let limit = 64u64 << 20;+ lightcraft_gpu::set_pool_limit(limit);+ let info = SourceInfo { raw: true, ..Default::default() };+ let mut s = DevelopSettings::default();+ s.effects.clarity = 30.0;+ let stages = StageCache::default();+ // photos of slightly different sizes, like stepping through a library+ for (i, (w, h)) in [(1200usize, 800usize), (1190, 810), (1210, 790), (800, 1200)].into_iter().enumerate() {+ let src = Arc::new(lightcraft_scenes::demo_library()[i].render(w, h));+ let r = lightcraft_gpu::render(&src, &info, &s, &RenderRequest::fit(w, h), Some(&stages)).expect("gpu render");+ assert_eq!((r.image.width, r.image.height), (w, h));+ let m = lightcraft_gpu::memory();+ assert!(m.pooled <= limit, "pool {} over its limit", m.pooled);+ assert_eq!(m.retired, 0, "a finished render leaves nothing retired");+ }+ let held = lightcraft_gpu::stage_bytes(&stages);+ assert!(held >= 1200 * 800 * 3 * 4, "the view's stages hold at least its resampled source: {held}");+ let before = lightcraft_gpu::memory().allocated;+ stages.clear();+ let m = lightcraft_gpu::memory();+ assert_eq!(lightcraft_gpu::stage_bytes(&stages), 0);+ assert!(m.pooled <= limit && m.allocated <= before);+ lightcraft_gpu::trim_pool(0);+ let m = lightcraft_gpu::memory();+ assert_eq!(m.pooled, 0);+ assert!(m.allocated < before, "trimming frees the pooled buffers: {} → {}", before, m.allocated);+}diff --git a/crates/preview/src/lib.rs b/crates/preview/src/lib.rsindex 5490194e4..e36f1b414 100644--- a/crates/preview/src/lib.rs+++ b/crates/preview/src/lib.rs@@ -22,7 +22,7 @@ use std::sync::{Arc, Mutex};pub use disk::{DiskCache, decode_jpeg, encode_jpeg};pub use hash::{Hash128, Hasher128, hash_bytes};use lightcraft_raster::Rgba8;-pub use lru::Lru;+pub use lru::{Lru, next_tick};pub use pool::JobPool;/// Rendered-thumbnail cache: memory LRU over an optional disk cache.@@ -93,6 +93,25 @@ impl PreviewCache {}}+ /// Use tick ([`next_tick`]) of the least recently used image in memory.+ pub fn oldest_tick(&self) -> Option<u64> {+ self.mem.lock().unwrap_or_else(|e| e.into_inner()).oldest_tick()+ }++ /// Drop the least recently used image from memory (it stays on disk); returns its bytes.+ pub fn evict_oldest(&self) -> Option<usize> {+ self.mem.lock().unwrap_or_else(|e| e.into_inner()).pop_oldest()+ }++ /// Change the memory budget (bytes), evicting at once if needed.+ pub fn set_mem_budget(&self, bytes: usize) {+ let mut m = self.mem.lock().unwrap_or_else(|e| e.into_inner());+ m.set_budget(bytes);+ while m.cost() > bytes && m.len() > 1 {+ m.pop_oldest();+ }+ }+/// (entries, bytes) held in memory.pub fn mem_usage(&self) -> (usize, usize) {let m = self.mem.lock().unwrap_or_else(|e| e.into_inner());diff --git a/crates/preview/src/lru.rs b/crates/preview/src/lru.rsindex 1be8bca4d..a15d4eecb 100644--- a/crates/preview/src/lru.rs+++ b/crates/preview/src/lru.rs@@ -2,12 +2,20 @@use std::collections::{BTreeMap, HashMap};use std::hash::Hash;+use std::sync::atomic::{AtomicU64, Ordering};++static TICK: AtomicU64 = AtomicU64::new(1);++/// A process-wide use counter: entries of different caches (LRUs or not) compare by recency, so+/// a memory budget can evict the least recently used entry across all of them.+pub fn next_tick() -> u64 {+ TICK.fetch_add(1, Ordering::Relaxed)+}pub struct Lru<K, V> {map: HashMap<K, (V, usize, u64)>,- /// Use tick → key, oldest first.+ /// Use tick ([`next_tick`], shared by every LRU) → key, oldest first.order: BTreeMap<u64, K>,- tick: u64,cost: usize,budget: usize,}@@ -16,12 +24,11 @@ impl<K: Eq + Hash + Clone, V> Lru<K, V> {/// An LRU holding at most `budget` cost units (e.g. bytes). The most recent entry is always/// kept, even if it alone exceeds the budget.pub fn new(budget: usize) -> Self {- Lru { map: HashMap::new(), order: BTreeMap::new(), tick: 0, cost: 0, budget }+ Lru { map: HashMap::new(), order: BTreeMap::new(), cost: 0, budget }}fn touch(&mut self, k: &K) {- self.tick += 1;- let t = self.tick;+ let t = next_tick();if let Some(e) = self.map.get_mut(k) {self.order.remove(&e.2);e.2 = t;@@ -41,15 +48,28 @@ impl<K: Eq + Hash + Clone, V> Lru<K, V> {self.map.get(k).map(|e| &e.0)}+ /// Use tick of the least recently used entry.+ pub fn oldest_tick(&self) -> Option<u64> {+ self.order.first_key_value().map(|(t, _)| *t)+ }++ /// Remove the least recently used entry; returns its cost.+ pub fn pop_oldest(&mut self) -> Option<usize> {+ let (_, k) = self.order.pop_first()?;+ let (_, c, _) = self.map.remove(&k)?;+ self.cost -= c;+ Some(c)+ }+pub fn contains(&self, k: &K) -> bool {self.map.contains_key(k)}pub fn insert(&mut self, k: K, v: V, cost: usize) {self.remove(&k);- self.tick += 1;- self.order.insert(self.tick, k.clone());- self.map.insert(k, (v, cost, self.tick));+ let t = next_tick();+ self.order.insert(t, k.clone());+ self.map.insert(k, (v, cost, t));self.cost += cost;while self.cost > self.budget && self.map.len() > 1 {let Some((_, old)) = self.order.pop_first() else { break };diff --git a/crates/raster/src/lib.rs b/crates/raster/src/lib.rsindex 15f3e940c..50593f29b 100644--- a/crates/raster/src/lib.rs+++ b/crates/raster/src/lib.rs@@ -97,6 +97,19 @@ impl<T: Copy + Default> Image<T> {pub fn is_empty(&self) -> bool {self.data.is_empty()}+ /// [`Self::map`] into the same buffer (no second image in memory).+ pub fn map_in_place(&mut self, f: impl Fn(T) -> T + Sync + Send)+ where+ T: Send,+ {+ let w = self.width;+ par_rows(&mut self.data, w, |_, row| {+ for p in row.iter_mut() {+ *p = f(*p);+ }+ });+ }+pub fn map<U: Copy + Default + Send>(&self, f: impl Fn(T) -> U + Sync + Send) -> Image<U>whereT: Sync,@@ -139,6 +152,19 @@ impl<T: Copy + Default> Image<T> {}Self { width: w, height: h, data }}+ /// [`Self::crop`] in place: rows move to the front of the same buffer (no second image).+ pub fn into_crop(mut self, x0: usize, y0: usize, w: usize, h: usize) -> Self {+ let x0 = x0.min(self.width);+ let y0 = y0.min(self.height);+ let w = w.min(self.width - x0);+ let h = h.min(self.height - y0);+ for (i, y) in (y0..y0 + h).enumerate() {+ let src = y * self.width + x0;+ self.data.copy_within(src..src + w, i * w);+ }+ self.data.truncate(w * h);+ Self { width: w, height: h, data: self.data }+ }/// Rotate 90° clockwise.pub fn rotate_cw(&self) -> Self {let (w, h) = (self.width, self.height);@@ -157,6 +183,11 @@ impl<T: Copy + Default> Image<T> {out}/// Apply an EXIF orientation (stored → displayed).+ /// [`Self::oriented`] without a copy when `o` is the identity.+ pub fn into_oriented(self, o: lightcraft_geom::Orientation) -> Self {+ if o == lightcraft_geom::Orientation::Normal { self } else { self.oriented(o) }+ }+pub fn oriented(&self, o: lightcraft_geom::Orientation) -> Self {let (flip, turns) = o.to_parts();let mut img = if flip { self.flip_h() } else { self.clone() };@@ -231,6 +262,17 @@ mod tests {let img = Image::<u32>::from_fn(4, 3, |x, y| (y * 10 + x) as u32);let c = img.crop(1, 1, 2, 2);assert_eq!(c.data, vec![11, 12, 21, 22]);+ // the in-place variants equal the copying ones+ for (x, y, w, h) in [(1, 1, 2, 2), (0, 0, 4, 3), (2, 0, 9, 9), (0, 2, 4, 1), (3, 2, 1, 1)] {+ assert_eq!(img.clone().into_crop(x, y, w, h), img.crop(x, y, w, h));+ }+ for v in 1..=8 {+ let o = Orientation::from_exif(v);+ assert_eq!(img.clone().into_oriented(o), img.oriented(o));+ }+ let mut m = img.clone();+ m.map_in_place(|p| p * 2 + 1);+ assert_eq!(m, img.map(|p| p * 2 + 1));let r = img.rotate_cw();assert_eq!((r.width, r.height), (3, 4));// top-left of rotated = bottom-left of originaldiff --git a/crates/raw/src/lib.rs b/crates/raw/src/lib.rsindex d61e313b6..01c9fd2c5 100644--- a/crates/raw/src/lib.rs+++ b/crates/raw/src/lib.rs@@ -552,12 +552,13 @@ impl RawImage {pub fn develop(&self, method: Method) -> Result<Rgb32f> {let n = self.normalized()?;let mut rgb = demosaic(&n, method);+ drop(n);opcodes::apply_list3(&self.opcodes.list3, &mut rgb);let c = self.crop.clipped(rgb.width, rgb.height);if c.width == 0 || c.height == 0 || (c.x == 0 && c.y == 0 && c.width == rgb.width && c.height == rgb.height) {return Ok(rgb);}- Ok(rgb.crop(c.x, c.y, c.width, c.height))+ Ok(rgb.into_crop(c.x, c.y, c.width, c.height))}}diff --git a/crates/ui-egui/src/render.rs b/crates/ui-egui/src/render.rsindex 8cafb8d3e..86fa8d516 100644--- a/crates/ui-egui/src/render.rs+++ b/crates/ui-egui/src/render.rs@@ -90,8 +90,15 @@ pub struct Renderer {quick_tried: HashMap<Slot, u64>,/// Prefetch slot → key of the last job submitted (each runs once).prefetched: HashMap<Slot, u64>,+ /// Since when nothing has been pending, and whether the GPU pool was trimmed since.+ #[cfg(not(target_arch = "wasm32"))]+ idle: Option<(std::time::Instant, bool)>,}+/// After this long without renders the GPU renderer's pool of recycled buffers is freed.+#[cfg(not(target_arch = "wasm32"))]+const IDLE_TRIM: std::time::Duration = std::time::Duration::from_secs(3);+impl Default for Renderer {fn default() -> Self {let threads = if cfg!(target_arch = "wasm32") { 0 } else { JobPool::<Slot, RenderResult>::default_threads().min(6) };@@ -108,6 +115,8 @@ impl Default for Renderer {stages: HashMap::new(),quick_tried: HashMap::new(),prefetched: HashMap::new(),+ #[cfg(not(target_arch = "wasm32"))]+ idle: None,}}}@@ -149,7 +158,13 @@ impl Renderer {return;}let key = job.key;- self.pool.submit(slot, key, priority, Box::new(move || job.run()));+ let background = matches!(slot, Slot::Thumb(_) | Slot::ThumbQuick(_) | Slot::Prefetch(_));+ self.pool.submit(+ slot,+ key,+ priority,+ Box::new(move || if background { lightcraft_engine::memory::in_background(|| job.run()) } else { job.run() }),+ );}/// Request a stand-in for `slot` (once per job key).@@ -172,7 +187,7 @@ impl Renderer {self.prefetched.insert(slot, job.key);self.pending.insert(slot, (job.key, priority));let key = job.key;- self.pool.submit(slot, key, priority, Box::new(move || job.run()));+ self.pool.submit(slot, key, priority, Box::new(move || lightcraft_engine::memory::in_background(|| job.run())));}/// Is a request for `slot` queued or running?@@ -292,12 +307,37 @@ impl Renderer {}changed = true;}+ #[cfg(not(target_arch = "wasm32"))]+ self.trim_when_idle(ctx);if !self.pending.is_empty() {ctx.request_repaint_after(std::time::Duration::from_millis(16));}changed}+ /// Free the GPU renderer's recycled buffers once nothing has rendered for [`IDLE_TRIM`] (they+ /// are reallocated by the next render; while working, renders reuse them).+ #[cfg(not(target_arch = "wasm32"))]+ fn trim_when_idle(&mut self, ctx: &egui::Context) {+ if !self.pending.is_empty() {+ self.idle = None;+ return;+ }+ let now = std::time::Instant::now();+ let (since, trimmed) = *self.idle.get_or_insert((now, false));+ if trimmed {+ return;+ }+ let waited = now.duration_since(since);+ if waited >= IDLE_TRIM {+ lightcraft_engine::gpu::trim_pool(0);+ lightcraft_engine::memory::release();+ self.idle = Some((since, true));+ } else {+ ctx.request_repaint_after(IDLE_TRIM - waited);+ }+ }+/// What the renderer holds: per-view stage caches (CPU images and GPU buffers) and textures.pub fn memory(&self) -> serde_json::Value {let cpu: usize = self.stages.values().map(|s| s.bytes()).sum();diff --git a/docs/gpu-pipeline.md b/docs/gpu-pipeline.mdindex 82a57e612..b8db4585c 100644--- a/docs/gpu-pipeline.md+++ b/docs/gpu-pipeline.md@@ -100,6 +100,20 @@ the device on their first GPU render. `lightcraft_gpu::ready()` asks without blo`/usr/bin/time -l lightcraft-cli snapshot <files> --script steps.jsonl -o out.png` → "maximumresident set size" and "peak memory footprint". Run it several times: the high-water mark isnoisy (allocator caching, scheduling). On Apple silicon GPU buffers count in the footprint.+- Imports read raw headers only (`lightcraft_raw::probe_info`): no pixel data is decompressed.+- One budget (`memory::budget`, default min(25 % of RAM, 1.5 GiB); `LIGHTCRAFT_MEMORY_MB` or+ `app.memoryBudget {mb}`): half for the engine caches (decoded thumbnail / preview / full+ sources and rendered previews, evicted least recently used *across* them; the photo on screen+ stays), a quarter for decodes in flight (`memory::work_gate`: grid thumbnails, neighbour+ prefetch and import probes wait for room, loupe and export loads never wait), an eighth for the+ GPU buffer pool (reuse by best fit within 25 %; freed after 3 s idle).+- Decodes free the file's bytes and the raw samples as soon as they are consumed and colour /+ crop / orient in place. macOS keeps freed large blocks resident ("reusable") until the system+ is short of memory, so the resident size climbed with every photo decoded; the apps install+ `malloc_zone_pressure_relief` as `memory::set_release_hook`, called after each decode, import+ and idle trim.+- Result (M4 Pro, 14 raws, loupe, 12 steps): peak RSS 1.9–2.3 GB → 0.83–0.99 GB, peak footprint+ 2.5–2.6 GB → 0.91–0.96 GB, heap peak 930 → ~600 MB; stepping median ~13 ms (unchanged).## Open items- Keep the loupe texture on the GPU (render into an `egui-wgpu` texture on eframe's device instead of