monolith

public

Star0

Fork 0

Watch0

198 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `43e0e8e33c3e`

tarball

atagen <boss@atagen.co>2026-10-19 07:56 UTC

2 files changed+143-4

render-vk: persist a pipeline cache and warm pipelines at startup

Pipelines::get compiled on first use with a null VkPipelineCache, so the first spawn animation paid the driver compiler mid-frame and every run paid it again. The cache is loaded from $XDG_CACHE_HOME/monolith/pipelines.bin after its header is checked against the device, since some drivers crash on a foreign cache instead of rejecting it, and the common pipelines are built in VulkanRenderer::with_node.

Modified file: crates/render-vk/src/pipeline.rs+140 additions−3 deletions@@ -1,8 +1,12 @@
 use crate::Error;
 use crate::device::Shared;
+use crate::format::{SUPPORTED, vk_format};
 use ash::vk;
 use std::collections::HashMap;
+use std::path::PathBuf;
 use std::sync::Arc;
+use std::sync::atomic::{AtomicU32, Ordering};
+use std::time::Instant;
 
 /// Push constants shared by every shader, see `shaders/push.glsl`.
 /// `dst` is the quad in normalized device coordinates as (x, y, w, h),
@@ -44,6 +48,9 @@ pub(crate) struct Pipelines {
     texture: vk::ShaderModule,
     effect: vk::ShaderModule,
     cache: HashMap<(vk::Format, Kind), vk::Pipeline>,
+    vk_cache: vk::PipelineCache,
+    cache_path: Option<PathBuf>,
+    loaded_len: usize,
 }
 
 const QUAD_VERT: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/quad.vert.spv"));
@@ -86,6 +93,25 @@ impl Pipelines {
                 d.create_shader_module(&vk::ShaderModuleCreateInfo::default().code(&words), None)?
             })
         };
+        let cache_path = cache_path();
+        let props = unsafe {
+            shared
+                .device
+                .instance
+                .get_physical_device_properties(shared.device.physical)
+        };
+        let loaded = cache_path
+            .as_ref()
+            .and_then(|p| std::fs::read(p).ok())
+            .filter(|data| header_matches(data, &props))
+            .unwrap_or_default();
+        let create = |data: &[u8]| unsafe {
+            d.create_pipeline_cache(
+                &vk::PipelineCacheCreateInfo::default().initial_data(data),
+                None,
+            )
+        };
+        let vk_cache = create(&loaded).or_else(|_| create(&[])).unwrap_or_default();
         Ok(Self {
             shared: shared.clone(),
             set_layout,
@@ -95,9 +121,65 @@ impl Pipelines {
             texture: module(TEXTURE_FRAG)?,
             effect: module(EFFECT_FRAG)?,
             cache: HashMap::new(),
+            vk_cache,
+            cache_path,
+            loaded_len: loaded.len(),
         })
     }
 
+    /// Compiles the pipelines a frame draws with for every render format, so
+    /// the first spawn animation does not stall on the driver compiler.
+    pub fn warm(&mut self) {
+        let began = Instant::now();
+        for fourcc in SUPPORTED {
+            let Some(format) = vk_format(fourcc) else {
+                continue;
+            };
+            for kind in [Kind::Solid, Kind::Texture, Kind::Effect] {
+                if let Err(e) = self.get(format.format, kind) {
+                    tracing::warn!(?kind, "cannot warm a pipeline: {e}");
+                    return;
+                }
+            }
+        }
+        tracing::debug!(elapsed = ?began.elapsed(), "warmed pipelines");
+    }
+
+    fn save_cache(&self) {
+        let Some(path) = &self.cache_path else {
+            return;
+        };
+        if self.vk_cache == vk::PipelineCache::null() {
+            return;
+        }
+        let Ok(data) = (unsafe {
+            self.shared
+                .device
+                .device
+                .get_pipeline_cache_data(self.vk_cache)
+        }) else {
+            return;
+        };
+        if data.len() == self.loaded_len {
+            return;
+        }
+        static WRITERS: AtomicU32 = AtomicU32::new(0);
+        let tmp = path.with_extension(format!(
+            "{}.{}.tmp",
+            std::process::id(),
+            WRITERS.fetch_add(1, Ordering::Relaxed)
+        ));
+        let written = path
+            .parent()
+            .map_or(Ok(()), std::fs::create_dir_all)
+            .and_then(|()| std::fs::write(&tmp, &data))
+            .and_then(|()| std::fs::rename(&tmp, path));
+        if let Err(e) = written {
+            tracing::debug!("cannot save the pipeline cache: {e}");
+            let _ = std::fs::remove_file(&tmp);
+        }
+    }
+
     pub fn get(&mut self, format: vk::Format, kind: Kind) -> Result<vk::Pipeline, Error> {
         if let Some(&p) = self.cache.get(&(format, kind)) {
             return Ok(p);
@@ -156,9 +238,8 @@ impl Pipelines {
             .dynamic_state(&dynamic)
             .layout(self.layout)
             .push_next(&mut rendering);
-        let pipeline =
-            unsafe { d.create_graphics_pipelines(vk::PipelineCache::null(), &[info], None) }
-                .map_err(|(_, e)| e)?[0];
+        let pipeline = unsafe { d.create_graphics_pipelines(self.vk_cache, &[info], None) }
+            .map_err(|(_, e)| e)?[0];
         self.cache.insert((format, kind), pipeline);
         Ok(pipeline)
     }
@@ -166,11 +247,13 @@ impl Pipelines {
 
 impl Drop for Pipelines {
     fn drop(&mut self) {
+        self.save_cache();
         let d = &self.shared.device.device;
         unsafe {
             for (_, p) in self.cache.drain() {
                 d.destroy_pipeline(p, None);
             }
+            d.destroy_pipeline_cache(self.vk_cache, None);
             d.destroy_shader_module(self.vert, None);
             d.destroy_shader_module(self.solid, None);
             d.destroy_shader_module(self.texture, None);
@@ -180,3 +263,57 @@ impl Drop for Pipelines {
         }
     }
 }
+
+fn cache_path() -> Option<PathBuf> {
+    let base = std::env::var_os("XDG_CACHE_HOME")
+        .filter(|v| !v.is_empty())
+        .map(PathBuf::from)
+        .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".cache")))?;
+    Some(base.join("monolith").join("pipelines.bin"))
+}
+
+/// Whether `data` opens with a cache header written by this driver on this
+/// device. The spec lets a driver reject a foreign cache but some crash on
+/// one instead, so the header is checked first.
+fn header_matches(data: &[u8], props: &vk::PhysicalDeviceProperties) -> bool {
+    let word = |at: usize| {
+        data.get(at..at + 4)
+            .and_then(|b| b.try_into().ok())
+            .map(u32::from_ne_bytes)
+    };
+    word(0).is_some_and(|size| size >= 32 && size as usize <= data.len())
+        && word(4) == Some(vk::PipelineCacheHeaderVersion::ONE.as_raw() as u32)
+        && word(8) == Some(props.vendor_id)
+        && word(12) == Some(props.device_id)
+        && data.get(16..32) == Some(&props.pipeline_cache_uuid[..])
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn props() -> vk::PhysicalDeviceProperties {
+        vk::PhysicalDeviceProperties {
+            vendor_id: 0x10de,
+            device_id: 0x2487,
+            pipeline_cache_uuid: [7; 16],
+            ..Default::default()
+        }
+    }
+
+    fn header(vendor: u32, uuid: u8) -> Vec<u8> {
+        let words = [32u32, 1, vendor, 0x2487];
+        let mut data: Vec<u8> = words.iter().flat_map(|w| w.to_ne_bytes()).collect();
+        data.extend([uuid; 16]);
+        data
+    }
+
+    #[test]
+    fn cache_header_must_match_the_device_and_driver() {
+        assert!(header_matches(&header(0x10de, 7), &props()));
+        assert!(!header_matches(&header(0x1002, 7), &props()));
+        assert!(!header_matches(&header(0x10de, 8), &props()));
+        assert!(!header_matches(&header(0x10de, 7)[..20], &props()));
+        assert!(!header_matches(&[], &props()));
+    }
+}

Modified file: crates/render-vk/src/renderer/mod.rs+3 additions−1 deletions@@ -143,13 +143,15 @@ impl VulkanRenderer {
                 )?
             };
         }
+        let mut pipelines = Pipelines::new(&shared)?;
+        pipelines.warm();
         Ok(Self {
             pending: Vec::new(),
             uploads: Vec::new(),
             upload_bytes: 0,
             dmabuf_textures: HashMap::new(),
             dmabuf_targets: HashMap::new(),
-            pipelines: Pipelines::new(&shared)?,
+            pipelines,
             pool,
             spare_cmds: Vec::new(),
             submissions: Cell::new(0),

monolith

Commit 43e0e8e33c3e

Commit `43e0e8e33c3e`