monolith

use crate::Error;

use ash::vk;

use gpu_allocator::vulkan::{Allocator, AllocatorCreateDesc};

use std::sync::Mutex;

/// Everything that must outlive every Vulkan object the renderer hands out.

/// Fields drop in declaration order, so the allocator frees its memory before

/// the device is destroyed.

pub(crate) struct Shared {

    pub allocator: Mutex<Allocator>,

    pub device: Device,

}

/// Loaders for the extensions that dmabuf import, export and fence export

/// need. Absent when the device lacks any of them.

pub(crate) struct DmabufExt {

    pub memory_fd: ash::khr::external_memory_fd::Device,

    pub fence_fd: ash::khr::external_fence_fd::Device,

    pub modifier: ash::ext::image_drm_format_modifier::Device,

}

const DMABUF_EXTENSIONS: [&std::ffi::CStr; 5] = [

    ash::khr::external_memory_fd::NAME,

    ash::ext::external_memory_dma_buf::NAME,

    ash::ext::image_drm_format_modifier::NAME,

    ash::ext::queue_family_foreign::NAME,

    ash::khr::external_fence_fd::NAME,

];

pub(crate) struct Device {

    pub _entry: ash::Entry,

    pub instance: ash::Instance,

    pub physical: vk::PhysicalDevice,

    pub device: ash::Device,

    pub queue: Mutex<vk::Queue>,

    pub queue_family: u32,

    pub push_descriptor: ash::khr::push_descriptor::Device,

    pub dmabuf: Option<DmabufExt>,

    pub name: String,

    /// Signalled fences kept for reuse, see `FenceInner`.

    pub spare_fences: Mutex<Vec<vk::Fence>>,

}

impl Drop for Device {

    fn drop(&mut self) {

        unsafe {

            let _ = self.device.device_wait_idle();

            for f in self

                .spare_fences

                .get_mut()

                .unwrap_or_else(|e| e.into_inner())

                .drain(..)

            {

                self.device.destroy_fence(f, None);

            }

            self.device.destroy_device(None);

            self.instance.destroy_instance(None);

        }

    }

}

impl Shared {

    /// Opens the first suitable device, or the one whose name contains

    /// `MONOLITH_VK_DEVICE` when that is set. With `node`, only the device

    /// behind that DRM device number qualifies.

    pub fn new(node: Option<u64>) -> Result<Self, Error> {

        let entry = unsafe { ash::Entry::load()? };

        let app = vk::ApplicationInfo::default()

            .application_name(c"monolith")

            .engine_name(c"monolith")

            .api_version(vk::API_VERSION_1_3);

        let instance = unsafe {

            entry.create_instance(

                &vk::InstanceCreateInfo::default().application_info(&app),

                None,

            )?

        };

        let wanted = std::env::var("MONOLITH_VK_DEVICE").ok();

        let picked = unsafe { pick_physical(&instance, wanted.as_deref(), node) };

        let Some((physical, queue_family, name)) = picked else {

            unsafe { instance.destroy_instance(None) };

            return Err(Error::NoSuitableDevice);

        };

        let priorities = [1.0];

        let available: Vec<_> = unsafe { instance.enumerate_device_extension_properties(physical) }

            .unwrap_or_default()

            .iter()

            .filter_map(|e| e.extension_name_as_c_str().ok().map(ToOwned::to_owned))

            .collect();

        let has_dmabuf = DMABUF_EXTENSIONS

            .iter()

            .all(|n| available.iter().any(|a| a.as_c_str() == *n));

        let mut extensions = vec![ash::khr::push_descriptor::NAME.as_ptr()];

        if has_dmabuf {

            extensions.extend(DMABUF_EXTENSIONS.iter().map(|n| n.as_ptr()));

        }

        let global_priority = [

            ash::khr::global_priority::NAME,

            ash::ext::global_priority::NAME,

        ]

        .into_iter()

        .find(|n| available.iter().any(|a| a.as_c_str() == *n));

        let mut priorities_to_try = vec![None];

        if let Some(name) = global_priority {

            extensions.push(name.as_ptr());

            priorities_to_try = vec![

                Some(vk::QueueGlobalPriorityKHR::REALTIME),

                Some(vk::QueueGlobalPriorityKHR::HIGH),

                None,

            ];

        }

        let mut created = Err(vk::Result::ERROR_INITIALIZATION_FAILED);

        for priority in priorities_to_try {

            let mut features13 = vk::PhysicalDeviceVulkan13Features::default()

                .dynamic_rendering(true)

                .synchronization2(true);

            let mut global = vk::DeviceQueueGlobalPriorityCreateInfoKHR::default()

                .global_priority(priority.unwrap_or(vk::QueueGlobalPriorityKHR::MEDIUM));

            let mut queue = vk::DeviceQueueCreateInfo::default()

                .queue_family_index(queue_family)

                .queue_priorities(&priorities);

            if priority.is_some() {

                queue = queue.push_next(&mut global);

            }

            let queues = [queue];

            let info = vk::DeviceCreateInfo::default()

                .queue_create_infos(&queues)

                .enabled_extension_names(&extensions)

                .push_next(&mut features13);

            created = unsafe { instance.create_device(physical, &info, None) };

            match &created {

                Ok(_) => {

                    tracing::info!(?priority, "queue global priority");

                    break;

                }

                Err(e) => tracing::debug!(?priority, "queue global priority refused: {e}"),

            }

        }

        let device = match created {

            Ok(d) => d,

            Err(e) => {

                unsafe { instance.destroy_instance(None) };

                return Err(e.into());

            }

        };

        let queue = unsafe { device.get_device_queue(queue_family, 0) };

        let push_descriptor = ash::khr::push_descriptor::Device::new(&instance, &device);

        let dmabuf = has_dmabuf.then(|| DmabufExt {

            memory_fd: ash::khr::external_memory_fd::Device::new(&instance, &device),

            fence_fd: ash::khr::external_fence_fd::Device::new(&instance, &device),

            modifier: ash::ext::image_drm_format_modifier::Device::new(&instance, &device),

        });

        let allocator = Allocator::new(&AllocatorCreateDesc {

            instance: instance.clone(),

            device: device.clone(),

            physical_device: physical,

            debug_settings: Default::default(),

            buffer_device_address: false,

            allocation_sizes: Default::default(),

        });

        let device = Device {

            _entry: entry,

            instance,

            physical,

            device,

            queue: Mutex::new(queue),

            queue_family,

            push_descriptor,

            dmabuf,

            name,

            spare_fences: Mutex::new(Vec::new()),

        };

        Ok(Self {

            allocator: Mutex::new(allocator?),

            device,

        })

    }

}

/// Whether `physical` is the device behind DRM device number `node`, as its

/// primary or render node.

unsafe fn serves_node(instance: &ash::Instance, physical: vk::PhysicalDevice, node: u64) -> bool {

    let mut drm = vk::PhysicalDeviceDrmPropertiesEXT::default();

    let mut props = vk::PhysicalDeviceProperties2::default().push_next(&mut drm);

    unsafe { instance.get_physical_device_properties2(physical, &mut props) };

    let (major, minor) = (

        rustix::fs::major(node) as i64,

        rustix::fs::minor(node) as i64,

    );

    (drm.has_primary == vk::TRUE && (drm.primary_major, drm.primary_minor) == (major, minor))

        || (drm.has_render == vk::TRUE && (drm.render_major, drm.render_minor) == (major, minor))

}

unsafe fn pick_physical(

    instance: &ash::Instance,

    wanted: Option<&str>,

    node: Option<u64>,

) -> Option<(vk::PhysicalDevice, u32, String)> {

    let devices = unsafe { instance.enumerate_physical_devices() }.ok()?;

    let mut candidates = Vec::new();

    for physical in devices {

        let props = unsafe { instance.get_physical_device_properties(physical) };

        if props.api_version < vk::API_VERSION_1_3 {

            continue;

        }

        let name = props

            .device_name_as_c_str()

            .unwrap_or(c"unknown")

            .to_string_lossy()

            .into_owned();

        if wanted.is_some_and(|w| !name.contains(w)) {

            continue;

        }

        let mut f13 = vk::PhysicalDeviceVulkan13Features::default();

        let mut f2 = vk::PhysicalDeviceFeatures2::default().push_next(&mut f13);

        unsafe { instance.get_physical_device_features2(physical, &mut f2) };

        if f13.dynamic_rendering == vk::FALSE || f13.synchronization2 == vk::FALSE {

            continue;

        }

        let extensions =

            unsafe { instance.enumerate_device_extension_properties(physical) }.unwrap_or_default();

        let has = |n: &std::ffi::CStr| {

            extensions

                .iter()

                .any(|e| e.extension_name_as_c_str().ok() == Some(n))

        };

        if !has(ash::khr::push_descriptor::NAME) {

            continue;

        }

        if let Some(node) = node

            && !(has(ash::ext::physical_device_drm::NAME)

                && unsafe { serves_node(instance, physical, node) })

        {

            continue;

        }

        let families = unsafe { instance.get_physical_device_queue_family_properties(physical) };

        let Some(family) = families

            .iter()

            .position(|f| f.queue_flags.contains(vk::QueueFlags::GRAPHICS))

        else {

            continue;

        };

        let rank = match props.device_type {

            vk::PhysicalDeviceType::DISCRETE_GPU => 0,

            vk::PhysicalDeviceType::INTEGRATED_GPU => 1,

            vk::PhysicalDeviceType::VIRTUAL_GPU => 2,

            _ => 3,

        };

        candidates.push((rank, physical, family as u32, name));

    }

    candidates.sort_by_key(|c| c.0);

    candidates.into_iter().next().map(|(_, p, f, n)| (p, f, n))

}