Skip to content

Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.

perf(compositor): compare the background key without copying the background

Etienne Lescotf698032df7ea
diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rs
index b5a9a03ec..f7c5204b6 100644
--- a/crates/compositor/src/compositor_linux.rs
+++ b/crates/compositor/src/compositor_linux.rs
@@ -112,7 +112,7 @@ struct LayerBind {
/// Le fond tel que la passe 1 (et son flou) l'a laisse dans le RT, et tout ce qui l'a decide
/// (`key`, cf. `compose_frame`).
struct BgCache {
- key: Vec<u8>,
+ key: crate::frame_geometry::BackgroundKey,
tex: wgpu::Texture,
}
@@ -2377,33 +2377,14 @@ impl Compositor {
)
});
- // Tout ce qui decide du fond -- clear, calque, flou, taille -- ou `None` s'il bouge (fond
- // anime). Meme cle qu'a la frame d'avant : le fond est celui qu'elle a laisse, a l'octet
- // pres, et la passe 1 le recopie au lieu de le redessiner. Redessine, il coutait 1,7 ms
- // par frame 1080p sur une Radeon 610M (une image 4K echantillonnee sans mips), soit plus
- // que l'ecran lui-meme ; recopie, quelques dixiemes.
- let bg_key = match &bg_layer {
- None => Some(vec![0u8]),
- Some(BgLayer::Gradient(cb)) => (cb.fx[3] == 0.0).then(|| {
- let mut k = vec![1u8];
- k.extend_from_slice(layer_bytes(cb));
- k
- }),
- Some(BgLayer::Image(path, motion)) => (*motion == WallpaperMotion::None).then(|| {
- let mut k = vec![2u8];
- k.extend_from_slice(path.as_bytes());
- k
- }),
- }
- .map(|mut k| {
- for v in bg_clear.into_iter().chain([cfg.bg_blur, rw, rh]) {
- k.extend_from_slice(&v.to_le_bytes());
- }
- k
- });
- let bg_cached = bg_key
+ // Le fond de la frame d'avant, s'il est celui qu'on demande (`BackgroundKey`) : la passe 1
+ // le recopie au lieu de le redessiner.
+ let bg_desc = scene_ref.as_ref().map(|s| &s.background);
+ let bg_cached = self
+ .bg_cache
+ .borrow()
.as_ref()
- .is_some_and(|k| self.bg_cache.borrow().as_ref().is_some_and(|c| c.key == *k));
+ .is_some_and(|c| c.key.matches(bg_desc, cfg.bg_blur, lp.bg_color, [rw, rh]));
let bg_wanted = bg_layer.is_some();
// Fond (gradient mode 5 OU image mode 6), dessine dans la passe de fond.
@@ -3165,7 +3146,7 @@ impl Compositor {
self.draw_screen_group(&mut rpass, &screen_shadow, &window_frame, &screen_bind, &device_frame);
}
// Passe 1 : fond (clear a `bg_clear` + gradient mode 5 eventuel) puis son flou -- ou, s'il
- // n'a pas change (`bg_key`), la copie qu'en a gardee la frame d'avant.
+ // n'a pas change (`BackgroundKey`), la copie qu'en a gardee la frame d'avant.
let extent = wgpu::Extent3d {
width: self.render_w,
height: self.render_h,
@@ -3203,8 +3184,14 @@ impl Compositor {
}
// Blur du fond (avant l'ecran), si active par la scene/l'inspector.
self.blur_bg(&mut encoder, cfg.bg_blur);
- // Pas de cache pour un fond qui n'a pas pu se charger : la frame suivante reessaie.
- if let Some(key) = bg_key.filter(|_| bg_draw.is_some() == bg_wanted) {
+ // Pas de cache pour un fond anime, ni pour un fond qui n'a pas pu se charger : la frame
+ // suivante reessaie.
+ let key = (bg_draw.is_some() == bg_wanted)
+ .then(|| {
+ crate::frame_geometry::BackgroundKey::of(bg_desc, cfg.bg_blur, lp.bg_color, [rw, rh])
+ })
+ .flatten();
+ if let Some(key) = key {
let mut cache = self.bg_cache.borrow_mut();
let tex = match cache.take() {
Some(c) if c.tex.size() == extent => c.tex,
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rs
index 10aba1513..a8ef080e4 100644
--- a/crates/compositor/src/frame_geometry.rs
+++ b/crates/compositor/src/frame_geometry.rs
@@ -1601,6 +1601,54 @@ fn same_source_path(a: &str, b: &str) -> bool {
/// shader un temps borné, là où un `f32` de plusieurs heures perdrait la finesse du bruit.
pub const WALLPAPER_MOTION_PERIOD_S: f32 = 120.0;
+/// Ce qui décide à lui seul du fond composé — sa description, la force de son flou, la couleur
+/// de repli, la taille de rendu —, gardé avec sa copie (`bg_cache`) : tant que le fond demandé
+/// lui est égal, le backend recopie le fond de la frame d'avant au lieu de le redessiner, ce qui
+/// coûtait plus que l'écran lui-même (1,65 ms par frame 1080p sur une Radeon 610M, un wallpaper
+/// 4K échantillonné sans mips).
+///
+/// La comparaison de chaque frame (`matches`) ne construit ni ne copie rien : une image en data
+/// URI pèse plusieurs Mo. Seul `of`, au moment de garder un nouveau fond, la clone.
+#[derive(Clone, PartialEq)]
+pub struct BackgroundKey {
+ background: Option<crate::scene::SceneBackground>,
+ blur: f32,
+ fallback: [f32; 4],
+ render_px: [f32; 2],
+}
+
+impl BackgroundKey {
+ /// La clé d'un fond fixe ; `None` pour un fond animé, qui change à chaque frame.
+ pub fn of(
+ background: Option<&crate::scene::SceneBackground>,
+ blur: f32,
+ fallback: [f32; 4],
+ render_px: [f32; 2],
+ ) -> Option<BackgroundKey> {
+ use crate::scene::{SceneBackground as B, WallpaperMotion};
+ if let Some(B::Gradient { motion, .. } | B::Image { motion, .. }) = background {
+ if *motion != WallpaperMotion::None {
+ return None;
+ }
+ }
+ Some(BackgroundKey { background: background.cloned(), blur, fallback, render_px })
+ }
+
+ /// Le fond demandé est celui-ci.
+ pub fn matches(
+ &self,
+ background: Option<&crate::scene::SceneBackground>,
+ blur: f32,
+ fallback: [f32; 4],
+ render_px: [f32; 2],
+ ) -> bool {
+ self.background.as_ref() == background
+ && self.blur == blur
+ && self.fallback == fallback
+ && self.render_px == render_px
+ }
+}
+
/// Emplacements libres des modes 5 (dégradé) et 6 (image) pour le fond animé : `fx.zw` = (temps
/// programme replié, indice du mouvement), `mb.x` = aspect w/h du rect rempli (les nappes de
/// l'aurore restent rondes).
@@ -4429,6 +4477,36 @@ pub fn lru_evictions(entries: &[(String, u64, u64)], budget: u64, protect_from:
mod tests {
use super::lru_evictions;
+ /// Un fond fixe a une clé qui ne reconnaît que lui, chacune de ses entrées comptant ; un fond
+ /// animé n'en a pas.
+ #[test]
+ fn a_static_background_is_keyed_by_everything_that_draws_it() {
+ use crate::scene::{SceneBackground as B, WallpaperMotion};
+ use super::BackgroundKey;
+ let image = |path: &str, motion| B::Image { path: path.to_string(), motion };
+ let still = image("/w/1.jpg", WallpaperMotion::None);
+ let (blur, fallback, size) = (0.0, [0.0; 4], [1920.0, 1080.0]);
+ let key = BackgroundKey::of(Some(&still), blur, fallback, size).expect("fond fixe");
+ assert!(key.matches(Some(&still), blur, fallback, size));
+ let other = image("/w/2.jpg", WallpaperMotion::None);
+ assert!(!key.matches(Some(&other), blur, fallback, size), "autre image");
+ assert!(!key.matches(Some(&still), 0.5, fallback, size), "autre flou");
+ assert!(!key.matches(Some(&still), blur, [1.0, 0.0, 0.0, 1.0], size), "autre repli");
+ assert!(!key.matches(Some(&still), blur, fallback, [1280.0, 720.0]), "autre taille");
+ assert!(!key.matches(None, blur, fallback, size), "pas de scène");
+ let drifting = image("/w/1.jpg", WallpaperMotion::Drift);
+ assert!(!key.matches(Some(&drifting), blur, fallback, size), "même image, animée");
+ assert!(BackgroundKey::of(Some(&drifting), blur, fallback, size).is_none());
+ let aurora = B::Gradient {
+ angle_deg: 90.0,
+ stops: vec!["#000".into(), "#fff".into()],
+ offsets: vec![],
+ motion: WallpaperMotion::Aurora,
+ };
+ assert!(BackgroundKey::of(Some(&aurora), blur, fallback, size).is_none(), "dégradé animé");
+ assert!(BackgroundKey::of(None, blur, fallback, size).is_some(), "fond de repli");
+ }
+
/// Les modèles 3D, et eux seuls, passent par la variante « modèles » du shader de calque.
#[test]
fn only_the_3d_models_need_the_models_shader() {
diff --git a/crates/compositor/src/scene.rs b/crates/compositor/src/scene.rs
index de24278fd..bddd7d55c 100644
--- a/crates/compositor/src/scene.rs
+++ b/crates/compositor/src/scene.rs
@@ -291,7 +291,7 @@ impl SceneFrame {
}
/// Fond derrière l'écran (parsé depuis `settings.wallpaper`).
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Deserialize)]
#[serde(tag = "kind", rename_all = "lowercase")]
pub enum SceneBackground {
Color { color: String },