Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

chore: remove pool-era layer helpers and benchmark examples

Wraient159ebdcd0bef
diff --git a/apps/desktop-gpui/examples/export-progress-coalesce-benchmark.rs b/apps/desktop-gpui/examples/export-progress-coalesce-benchmark.rs
deleted file mode 100644
index d807ccf36..000000000
--- a/apps/desktop-gpui/examples/export-progress-coalesce-benchmark.rs
+++ /dev/null
@@ -1,122 +0,0 @@
-//! Model-update counts in the export-progress drain loop, at 60 msg/s with a
-//! 50 ms consumer over 5 s.
-//!
-//! Measures update invocations, not `cx.notify()` render cost.
-//!
-//! Run: cargo run -p cap-desktop-gpui --example export-progress-coalesce-benchmark --release
-
-use std::hint::black_box;
-use std::time::{Duration, Instant};
-
-const MESSAGE_RATE_PER_SEC: u64 = 60;
-const CONSUMER_CADENCE_MS: u64 = 50;
-const RUN_SECS: u64 = 5;
-
-#[derive(Default)]
-struct MockExportUi {
- rendered: u32,
- total_frames: u32,
- phase: u8,
- label: String,
-}
-
-#[inline(never)]
-fn mock_update(ui: &mut MockExportUi, rendered: u32, total: u32) {
- ui.rendered = rendered;
- ui.total_frames = total;
- ui.phase = 1;
- ui.label = format!("{rendered} / {total} frames");
- black_box(&ui.label);
-}
-
-fn report(label: &str, samples: &mut [f64]) {
- samples.sort_by(|a, b| a.partial_cmp(b).expect("no NaN timings"));
- let n = samples.len() as f64;
- let mean = samples.iter().sum::<f64>() / n;
- let p50 = samples[(n * 0.50) as usize];
- let p95 = samples[(n * 0.95) as usize];
- println!(
- "{label}: n={} mean={mean:.2}us p50={p50:.2}us p95={p95:.2}us",
- samples.len()
- );
-}
-
-fn spawn_producer() -> flume::Receiver<(u32, u32)> {
- let (tx, rx) = flume::unbounded::<(u32, u32)>();
- let total = (MESSAGE_RATE_PER_SEC * RUN_SECS) as u32;
- std::thread::spawn(move || {
- let interval = Duration::from_nanos(1_000_000_000 / MESSAGE_RATE_PER_SEC);
- for i in 1..=total {
- let _ = tx.send((i.min(total), total));
- std::thread::sleep(interval);
- }
- });
- rx
-}
-
-fn run_old() -> (u64, Vec<f64>, (u32, u32)) {
- let rx = spawn_producer();
- let mut ui = MockExportUi::default();
- let mut updates = 0;
- let mut costs = Vec::new();
- loop {
- while let Ok((rendered, total)) = rx.try_recv() {
- let started = Instant::now();
- mock_update(&mut ui, rendered, total);
- black_box(&mut ui);
- updates += 1;
- costs.push(started.elapsed().as_secs_f64() * 1e6);
- }
- if rx.is_disconnected() {
- break;
- }
- std::thread::sleep(Duration::from_millis(CONSUMER_CADENCE_MS));
- }
- (updates, costs, (ui.rendered, ui.total_frames))
-}
-
-fn run_new() -> (u64, Vec<f64>, (u32, u32)) {
- let rx = spawn_producer();
- let mut ui = MockExportUi::default();
- let mut updates = 0;
- let mut costs = Vec::new();
- loop {
- let mut latest: Option<(u32, u32)> = None;
- while let Ok((rendered, total)) = rx.try_recv() {
- latest = Some((rendered, total));
- }
- if let Some((rendered, total)) = latest {
- let started = Instant::now();
- mock_update(&mut ui, rendered, total);
- black_box(&mut ui);
- updates += 1;
- costs.push(started.elapsed().as_secs_f64() * 1e6);
- }
- if rx.is_disconnected() {
- break;
- }
- std::thread::sleep(Duration::from_millis(CONSUMER_CADENCE_MS));
- }
- (updates, costs, (ui.rendered, ui.total_frames))
-}
-
-fn main() {
- println!(
- "export progress drain: {MESSAGE_RATE_PER_SEC} msg/s for {RUN_SECS}s, consumer every {CONSUMER_CADENCE_MS}ms"
- );
- let (old_updates, mut old_costs, old_final) = run_old();
- let (new_updates, mut new_costs, new_final) = run_new();
-
- assert_eq!(old_final, new_final, "visible end state must match");
- assert_eq!(old_final.0, old_final.1, "progress must reach 100%");
-
- println!("old updates: {old_updates}");
- println!("new updates: {new_updates}");
- println!(
- "update reduction: {:.1}x",
- old_updates as f64 / new_updates as f64
- );
- println!("final UI state old={old_final:?} new={new_final:?} (identical)");
- report("old per-update cost", &mut old_costs);
- report("new per-update cost", &mut new_costs);
-}
diff --git a/crates/export/examples/preview-layers-benchmark.rs b/crates/export/examples/preview-layers-benchmark.rs
deleted file mode 100644
index 1595bfb74..000000000
--- a/crates/export/examples/preview-layers-benchmark.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-//! Per-frame cost of acquiring `RendererLayers`: fresh build vs pooled reuse.
-//!
-//! Run: `cargo run --release -p cap-export --example preview-layers-benchmark`
-//! Needs a wgpu adapter (software fallback works).
-
-use std::time::Instant;
-
-use cap_rendering::{
- RendererLayers, create_shared_device, return_reusable_layers, take_reusable_layers,
-};
-
-const ITERATIONS: usize = 5;
-const KEY: &str = "preview-layers-benchmark";
-
-fn report(label: &str, samples: &mut [f64]) {
- samples.sort_by(|a, b| a.partial_cmp(b).expect("no NaN timings"));
- let n = samples.len() as f64;
- let mean = samples.iter().sum::<f64>() / n;
- let p50 = samples[(n * 0.5) as usize];
- let max = samples[samples.len() - 1];
- println!(
- "{label}: n={} mean={mean:.1}ms p50={p50:.1}ms max={max:.1}ms",
- samples.len()
- );
-}
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
- let shared = create_shared_device().await?;
-
- let mut baseline_ms = Vec::with_capacity(ITERATIONS);
- for _ in 0..ITERATIONS {
- let started = Instant::now();
- let layers = RendererLayers::new_with_options(
- &shared.device,
- &shared.queue,
- shared.is_software_adapter,
- );
- baseline_ms.push(started.elapsed().as_secs_f64() * 1000.0);
- drop(layers);
- }
-
- return_reusable_layers(
- shared.device.clone(),
- KEY.to_string(),
- RendererLayers::new_with_options(&shared.device, &shared.queue, shared.is_software_adapter),
- );
-
- let mut pooled_ms = Vec::with_capacity(ITERATIONS);
- for _ in 0..ITERATIONS {
- let started = Instant::now();
- let layers = take_reusable_layers(&shared.device, KEY).expect("pool primed above");
- pooled_ms.push(started.elapsed().as_secs_f64() * 1000.0);
- return_reusable_layers(shared.device.clone(), KEY.to_string(), layers);
- }
-
- report("baseline build layers per frame", &mut baseline_ms);
- report("pooled take layers per frame ", &mut pooled_ms);
- let base_mean = baseline_ms.iter().sum::<f64>() / baseline_ms.len() as f64;
- let pool_mean = pooled_ms.iter().sum::<f64>() / pooled_ms.len() as f64;
- println!(
- "per-frame saving: {saved:.1}ms ({reduction:.1}x)",
- saved = base_mean - pool_mean,
- reduction = base_mean / pool_mean.max(0.001),
- );
- Ok(())
-}
diff --git a/crates/rendering/src/lib.rs b/crates/rendering/src/lib.rs
index e6dbce722..75e6e1c11 100644
--- a/crates/rendering/src/lib.rs
+++ b/crates/rendering/src/lib.rs
@@ -1352,21 +1352,6 @@ fn take_pooled_layers(device: &wgpu::Device, key: &str) -> Option<RendererLayers
Some(pool.swap_remove(index).2)
}
-/// Layers are never shared across keys: they cache per-project assets under
-/// ids that are only unique within a recording.
-pub fn take_reusable_layers(device: &wgpu::Device, key: &str) -> Option<RendererLayers> {
- take_pooled_layers(device, key).map(|mut layers| {
- layers.reset_frame_state();
- layers
- })
-}
-
-/// Only return layers after a clean render; a failed render may leave layer
-/// state behind.
-pub fn return_reusable_layers(device: wgpu::Device, key: String, layers: RendererLayers) {
- return_pooled_layers(device, key, layers);
-}
-
/// Builds a fresh set of layers for the next project's first render, off
/// its critical path (an idle engine calls this between tasks).
pub fn prebuild_spare_layers(