refactor(vulkan-ffi): extract validation messenger module

adapters/fparkan-render-vulkan/src/ffi.rs

@@ -29,6 +29,7 @@
 
 mod instance;
 mod surface;
+mod validation;
 
 pub use self::instance::{
     create_vulkan_instance_probe, plan_vulkan_instance, probe_vulkan_loader,
@@ -44,16 +45,14 @@ pub use self::surface::{
     create_vulkan_surface_probe, plan_vulkan_surface, render_surface_plan_json, VulkanSurfaceError,
     VulkanSurfacePlan, VulkanSurfaceProbe,
 };
+use self::validation::{create_validation_messenger, VulkanValidationMessenger};
 use crate::policy::*;
 use crate::shader_manifest::{
     triangle_shader_manifest, validate_shader_manifest, VulkanShaderManifestError,
 };
 use ash::{khr::swapchain, vk};
 use fparkan_platform::NativeWindowHandles;
-use std::collections::BTreeSet;
 use std::ffi::{CStr, CString};
-use std::sync::atomic::{AtomicU32, Ordering};
-use std::sync::Mutex;
 /// Minimum Vulkan API version accepted by the Stage 0 backend.
 pub const MIN_VULKAN_API_VERSION: u32 = vk::API_VERSION_1_1;
 const KHR_PORTABILITY_ENUMERATION_EXTENSION: &str = "VK_KHR_portability_enumeration";
@@ -653,88 +652,6 @@ impl std::fmt::Display for VulkanSmokeRendererError {
 
 impl std::error::Error for VulkanSmokeRendererError {}
 
-struct VulkanValidationShared {
-    warning_count: AtomicU32,
-    error_count: AtomicU32,
-    vuids: Mutex<BTreeSet<String>>,
-}
-
-impl Default for VulkanValidationShared {
-    fn default() -> Self {
-        Self {
-            warning_count: AtomicU32::new(0),
-            error_count: AtomicU32::new(0),
-            vuids: Mutex::new(BTreeSet::new()),
-        }
-    }
-}
-
-struct VulkanValidationMessenger {
-    loader: ash::ext::debug_utils::Instance,
-    messenger: vk::DebugUtilsMessengerEXT,
-    shared: Box<VulkanValidationShared>,
-}
-
-impl VulkanValidationMessenger {
-    fn report(&self) -> VulkanValidationReport {
-        let vuids = self
-            .shared
-            .vuids
-            .lock()
-            .map(|values| values.iter().cloned().collect::<Vec<_>>())
-            .unwrap_or_default();
-        VulkanValidationReport {
-            warning_count: self.shared.warning_count.load(Ordering::Relaxed),
-            error_count: self.shared.error_count.load(Ordering::Relaxed),
-            vuids,
-        }
-    }
-}
-
-impl Drop for VulkanValidationMessenger {
-    fn drop(&mut self) {
-        // SAFETY: The messenger belongs to this instance-level loader and is destroyed once.
-        unsafe {
-            self.loader
-                .destroy_debug_utils_messenger(self.messenger, None);
-        };
-    }
-}
-
-unsafe extern "system" fn vulkan_validation_callback(
-    message_severity: vk::DebugUtilsMessageSeverityFlagsEXT,
-    _message_types: vk::DebugUtilsMessageTypeFlagsEXT,
-    callback_data: *const vk::DebugUtilsMessengerCallbackDataEXT<'_>,
-    user_data: *mut std::ffi::c_void,
-) -> vk::Bool32 {
-    // SAFETY: The debug messenger stores a stable pointer to `VulkanValidationShared` for the messenger lifetime.
-    let Some(shared) = (unsafe { (user_data as *const VulkanValidationShared).as_ref() }) else {
-        return vk::FALSE;
-    };
-    if message_severity.contains(vk::DebugUtilsMessageSeverityFlagsEXT::ERROR) {
-        shared.error_count.fetch_add(1, Ordering::Relaxed);
-    } else if message_severity.contains(vk::DebugUtilsMessageSeverityFlagsEXT::WARNING) {
-        shared.warning_count.fetch_add(1, Ordering::Relaxed);
-    }
-    // SAFETY: Vulkan invokes the callback with either a null pointer or a valid callback-data payload.
-    let Some(callback_data) = (unsafe { callback_data.as_ref() }) else {
-        return vk::FALSE;
-    };
-    if let Some(vuid) = (!callback_data.p_message_id_name.is_null()).then(|| {
-        // SAFETY: `p_message_id_name` is a Vulkan-owned NUL-terminated string for the callback duration.
-        unsafe { CStr::from_ptr(callback_data.p_message_id_name) }
-            .to_string_lossy()
-            .into_owned()
-    }) {
-        if vuid.starts_with("VUID-") {
-            if let Ok(mut vuids) = shared.vuids.lock() {
-                vuids.insert(vuid);
-            }
-        }
-    }
-    vk::FALSE
-}
-
 struct VulkanAllocatedBuffer {
     buffer: vk::Buffer,
     memory: vk::DeviceMemory,
@@ -1379,38 +1296,6 @@ impl Drop for VulkanSmokeRenderer {
     }
 }
 
-fn create_validation_messenger(
-    instance: &VulkanInstanceProbe,
-) -> Result<VulkanValidationMessenger, VulkanSmokeRendererError> {
-    let shared = Box::new(VulkanValidationShared::default());
-    let loader = ash::ext::debug_utils::Instance::new(&instance.entry, &instance.instance);
-    let create_info = vk::DebugUtilsMessengerCreateInfoEXT::default()
-        .message_severity(
-            vk::DebugUtilsMessageSeverityFlagsEXT::WARNING
-                | vk::DebugUtilsMessageSeverityFlagsEXT::ERROR,
-        )
-        .message_type(
-            vk::DebugUtilsMessageTypeFlagsEXT::GENERAL
-                | vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION
-                | vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE,
-        )
-        .pfn_user_callback(Some(vulkan_validation_callback))
-        .user_data((&raw const *shared).cast_mut().cast());
-    let messenger =
-        // SAFETY: The create info points at a stable boxed user-data allocation for the messenger lifetime.
-        unsafe { loader.create_debug_utils_messenger(&create_info, None) }.map_err(|error| {
-            VulkanSmokeRendererError::VulkanOperation {
-                context: "vkCreateDebugUtilsMessengerEXT",
-                result: error,
-            }
-        })?;
-    Ok(VulkanValidationMessenger {
-        loader,
-        messenger,
-        shared,
-    })
-}
-
 fn create_command_pool(
     device: &VulkanLogicalDeviceProbe,
 ) -> Result<vk::CommandPool, VulkanSmokeRendererError> {