From 964cc990e13974e342fd9208a53121cee751db37 Mon Sep 17 00:00:00 2001 From: Shailesh Vats <130390884+shaileshvats@users.noreply.github.com> Date: Sun, 25 Oct 2026 01:46:31 +0530 Subject: [PATCH] perf(desktop-gpui): write copy_rows output once instead of zero-filling first copy_rows backs every non-macOS camera preview frame (mirrored by default) and the library/import/clip thumbnail buffers. It allocated with vec![0; len] and then overwrote every byte, so each frame was written twice. Non-mirrored rows now extend a with_capacity Vec; mirrored rows reverse straight into spare capacity. Output is byte-identical. frame_copy_rows bench, Apple M2: 1.28-1.67x across camera 720p/1080p (mirrored and not), 4K import and thumbnail workloads. --- apps/desktop-gpui/kernels/Cargo.toml | 4 + .../kernels/benches/frame_copy_rows.rs | 84 +++++++++++++++++++ apps/desktop-gpui/kernels/src/frame.rs | 81 ++++++++++++++++-- 3 files changed, 160 insertions(+), 9 deletions(-) create mode 100644 apps/desktop-gpui/kernels/benches/frame_copy_rows.rs diff --git a/apps/desktop-gpui/kernels/Cargo.toml b/apps/desktop-gpui/kernels/Cargo.toml index fab553c503e..86823392bbb 100644 --- a/apps/desktop-gpui/kernels/Cargo.toml +++ b/apps/desktop-gpui/kernels/Cargo.toml @@ -47,6 +47,10 @@ harness = false name = "frame_unpad" harness = false +[[bench]] +name = "frame_copy_rows" +harness = false + [[bench]] name = "screenshot_mask" harness = false diff --git a/apps/desktop-gpui/kernels/benches/frame_copy_rows.rs b/apps/desktop-gpui/kernels/benches/frame_copy_rows.rs new file mode 100644 index 00000000000..3fbccc5608e --- /dev/null +++ b/apps/desktop-gpui/kernels/benches/frame_copy_rows.rs @@ -0,0 +1,84 @@ +use cap_gpui_kernels::frame as candidate; +use std::{hint::black_box, time::Instant}; + +type CopyRows = fn(&[u8], usize, usize, usize, bool) -> Option>; + +fn main() { + println!("workload,sample,before_ns,after_ns"); + for (name, width, height, bytes_per_pixel, stride_align, mirrored) in [ + ( + "camera-720p-mirrored", + 1280usize, + 720usize, + 4usize, + 64usize, + true, + ), + ("camera-1080p-mirrored", 1920, 1080, 4, 64, true), + ("camera-720p", 1280, 720, 4, 64, false), + ("camera-1080p", 1920, 1080, 4, 64, false), + ("import-4k-rgba", 3840, 2160, 4, 64, false), + ("library-thumb-rgb24", 1280, 720, 3, 64, false), + ("clip-thumb-bgra-padded", 1366, 768, 4, 256, false), + ] { + let row_bytes = width * bytes_per_pixel; + let stride = row_bytes.next_multiple_of(stride_align); + let src: Vec = (0..stride * height) + .map(|i| (i * 31 + i / 7) as u8) + .collect(); + let before = baseline::copy_rows(&src, row_bytes, stride, height, mirrored).unwrap(); + let after = candidate::copy_rows(&src, row_bytes, stride, height, mirrored).unwrap(); + assert_eq!(before, after, "{name}"); + for sample in 0..35 { + let run = |f: CopyRows| { + let start = Instant::now(); + let _ = black_box(f( + black_box(&src), + black_box(row_bytes), + black_box(stride), + black_box(height), + black_box(mirrored), + )); + start.elapsed().as_nanos() + }; + let (old, new) = if sample % 2 == 0 { + let old = run(baseline::copy_rows); + (old, run(candidate::copy_rows)) + } else { + let new = run(candidate::copy_rows); + (run(baseline::copy_rows), new) + }; + if sample >= 5 { + println!("{name},{},{old},{new}", sample - 5); + } + } + } +} + +// Inlined from main so before/after share one build and the same inputs. +mod baseline { + pub fn copy_rows( + data: &[u8], + row_bytes: usize, + stride: usize, + rows: usize, + mirrored: bool, + ) -> Option> { + if stride < row_bytes || data.len() < rows.checked_mul(stride)? { + return None; + } + let mut pixels = vec![0; rows.checked_mul(row_bytes)?]; + for (row, output) in pixels.chunks_exact_mut(row_bytes.max(1)).enumerate() { + let input = &data[row * stride..row * stride + row_bytes]; + if mirrored { + for (target, source) in output.chunks_exact_mut(4).zip(input.chunks_exact(4).rev()) + { + target.copy_from_slice(source); + } + } else { + output.copy_from_slice(input); + } + } + Some(pixels) + } +} diff --git a/apps/desktop-gpui/kernels/src/frame.rs b/apps/desktop-gpui/kernels/src/frame.rs index a5f6cc667d9..93ea72b4fcf 100644 --- a/apps/desktop-gpui/kernels/src/frame.rs +++ b/apps/desktop-gpui/kernels/src/frame.rs @@ -1,3 +1,5 @@ +use std::mem::MaybeUninit; + pub fn unpad_rows(data: &[u8], row_bytes: usize, stride: usize, rows: usize) -> Option> { if stride == 0 { return None; @@ -68,17 +70,31 @@ pub fn copy_rows( if stride < row_bytes || data.len() < rows.checked_mul(stride)? { return None; } - let mut pixels = vec![0; rows.checked_mul(row_bytes)?]; - for (row, output) in pixels.chunks_exact_mut(row_bytes.max(1)).enumerate() { - let input = &data[row * stride..row * stride + row_bytes]; - if mirrored { - for (target, source) in output.chunks_exact_mut(4).zip(input.chunks_exact(4).rev()) { - target.copy_from_slice(source); - } - } else { - output.copy_from_slice(input); + let output_len = rows.checked_mul(row_bytes)?; + if output_len == 0 { + return Some(Vec::new()); + } + if !mirrored { + let mut pixels = Vec::with_capacity(output_len); + for input in data.chunks(stride).take(rows) { + pixels.extend_from_slice(&input[..row_bytes]); } + return Some(pixels); } + let mut pixels = Vec::with_capacity(output_len); + let spare = &mut pixels.spare_capacity_mut()[..output_len]; + for (input, output) in data.chunks(stride).zip(spare.chunks_exact_mut(row_bytes)) { + let (target, padding) = output.as_chunks_mut::<4>(); + for (pixel, source) in target + .iter_mut() + .zip(input[..row_bytes].as_chunks::<4>().0.iter().rev()) + { + *pixel = source.map(MaybeUninit::new); + } + padding.fill(MaybeUninit::new(0)); + } + // SAFETY: every row writes all row_bytes of its chunk, so all output_len bytes are initialized. + unsafe { pixels.set_len(output_len) }; Some(pixels) } @@ -335,6 +351,53 @@ mod tests { assert_eq!(copy_rows(&PADDED, 8, 10, 3, false), None); } + fn zeroed_copy_rows( + data: &[u8], + row_bytes: usize, + stride: usize, + rows: usize, + mirrored: bool, + ) -> Vec { + let mut pixels = vec![0; rows * row_bytes]; + for (row, output) in pixels.chunks_exact_mut(row_bytes.max(1)).enumerate() { + let input = &data[row * stride..row * stride + row_bytes]; + if mirrored { + let source = input.as_chunks::<4>().0.iter().rev(); + for (target, source) in output.as_chunks_mut::<4>().0.iter_mut().zip(source) { + *target = *source; + } + } else { + output.copy_from_slice(input); + } + } + pixels + } + + #[test] + fn copy_rows_matches_a_zeroed_copy_for_every_shape() { + for (row_bytes, stride, rows) in [ + (0, 0, 3), + (0, 8, 3), + (8, 8, 0), + (4, 4, 1), + (12, 12, 5), + (12, 16, 5), + (15, 15, 3), + (15, 64, 3), + (1280 * 3, 1280 * 3 + 64, 7), + (1366 * 4, (1366 * 4usize).next_multiple_of(256), 9), + ] { + let data: Vec = (0..stride * rows + 5).map(|i| (i * 7 + 3) as u8).collect(); + for mirrored in [false, true] { + assert_eq!( + copy_rows(&data, row_bytes, stride, rows, mirrored).unwrap(), + zeroed_copy_rows(&data, row_bytes, stride, rows, mirrored), + "{row_bytes} {stride} {rows} {mirrored}" + ); + } + } + } + #[test] fn swaps_into_a_reused_buffer() { let mut target = vec![0; 99];