monolith

use crate::device::Shared;

use ash::vk;

use rustix::event::{PollFd, PollFlags, poll};

use smithay::backend::renderer::sync::{Fence, Interrupted};

use std::fmt;

use std::os::fd::{FromRawFd, OwnedFd};

use std::sync::{Arc, Mutex};

enum State {

    Pending,

    /// Exporting a sync_file resets the Vulkan fence, so from then on the

    /// file is the only record of completion. `None` means it had already

    /// signalled when exported.

    Exported(Option<OwnedFd>),

}

pub(crate) struct FenceInner {

    shared: Arc<Shared>,

    fence: vk::Fence,

    exportable: bool,

    state: Mutex<State>,

}

impl FenceInner {

    pub fn new(shared: &Arc<Shared>) -> Result<Arc<Self>, vk::Result> {

        let exportable = shared.device.dmabuf.is_some();

        let mut export = vk::ExportFenceCreateInfo::default()

            .handle_types(vk::ExternalFenceHandleTypeFlags::SYNC_FD);

        let mut info = vk::FenceCreateInfo::default();

        if exportable {

            info = info.push_next(&mut export);

        }

        let spare = shared

            .device

            .spare_fences

            .lock()

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

            .pop();

        let fence = match spare {

            Some(f) => {

                unsafe { shared.device.device.reset_fences(&[f])? };

                f

            }

            None => unsafe { shared.device.device.create_fence(&info, None)? },

        };

        Ok(Arc::new(Self {

            shared: shared.clone(),

            fence,

            exportable,

            state: Mutex::new(State::Pending),

        }))

    }

    pub fn fence(&self) -> vk::Fence {

        self.fence

    }

    pub fn signaled(&self) -> bool {

        match &*self.state.lock().unwrap_or_else(|e| e.into_inner()) {

            State::Pending => {

                unsafe { self.shared.device.device.get_fence_status(self.fence) }.unwrap_or(true)

            }

            State::Exported(None) => true,

            State::Exported(Some(fd)) => readable(fd, Some(&Default::default())),

        }

    }

    /// Blocks until the GPU signals. A pending fence is first turned into its

    /// sync_file and polled, because waiting on the Vulkan fence itself sleeps

    /// in 10 ms steps on NVIDIA even when the work is done in microseconds.

    pub fn wait(&self) -> Result<(), vk::Result> {

        if self.exportable {

            drop(self.export());

        }

        match &*self.state.lock().unwrap_or_else(|e| e.into_inner()) {

            State::Pending => unsafe {

                self.shared

                    .device

                    .device

                    .wait_for_fences(&[self.fence], true, u64::MAX)

            },

            State::Exported(None) => Ok(()),

            State::Exported(Some(fd)) => {

                readable(fd, None);

                Ok(())

            }

        }

    }

    #[profiling::function]

    fn export(&self) -> Option<OwnedFd> {

        if !self.exportable {

            return None;

        }

        let ext = self.shared.device.dmabuf.as_ref()?;

        let mut state = self.state.lock().unwrap_or_else(|e| e.into_inner());

        if let State::Pending = *state {

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

                .fence(self.fence)

                .handle_type(vk::ExternalFenceHandleTypeFlags::SYNC_FD);

            let raw = unsafe { ext.fence_fd.get_fence_fd(&info) }.ok()?;

            *state = State::Exported((raw >= 0).then(|| unsafe { OwnedFd::from_raw_fd(raw) }));

        }

        match &*state {

            State::Exported(Some(fd)) => fd.try_clone().ok(),

            _ => None,

        }

    }

}

fn readable(fd: &OwnedFd, timeout: Option<&rustix::event::Timespec>) -> bool {

    let mut fds = [PollFd::new(fd, PollFlags::IN)];

    loop {

        match poll(&mut fds, timeout) {

            Ok(n) => return n > 0,

            Err(rustix::io::Errno::INTR) => continue,

            Err(_) => return true,

        }

    }

}

/// Fences go back to a pool instead of being destroyed, which cut the median

/// queue submit on NVIDIA from 87 to 52 us. One still pending is destroyed.

impl Drop for FenceInner {

    fn drop(&mut self) {

        let d = &self.shared.device.device;

        let state = self.state.get_mut().unwrap_or_else(|e| e.into_inner());

        let idle = match state {

            State::Pending => unsafe { d.get_fence_status(self.fence) }.unwrap_or(false),

            State::Exported(_) => true,

        };

        if idle {

            self.shared

                .device

                .spare_fences

                .lock()

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

                .push(self.fence);

        } else {

            unsafe { d.destroy_fence(self.fence, None) };

        }

    }

}

impl fmt::Debug for FenceInner {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        f.debug_tuple("FenceInner").field(&self.fence).finish()

    }

}

#[derive(Debug)]

pub(crate) struct VkFence(pub Arc<FenceInner>);

impl Fence for VkFence {

    fn is_signaled(&self) -> bool {

        self.0.signaled()

    }

    fn wait(&self) -> Result<(), Interrupted> {

        self.0.wait().map_err(|_| Interrupted)

    }

    fn is_exportable(&self) -> bool {

        self.0.exportable

    }

    fn export(&self) -> Option<OwnedFd> {

        self.0.export()

    }

}