monolith

use crate::device::Shared;

use crate::error::{WAIT, observe, waited};

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

    }

    /// Whether the GPU has signalled, or the error the query failed with.

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

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

            State::Pending => unsafe { self.shared.device.device.get_fence_status(self.fence) },

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

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

        }

    }

    /// Like `status` for callers that cannot report a failure. A failed query

    /// counts as signalled so nobody waits on a fence that cannot signal.

    pub fn signaled(&self) -> bool {

        self.status().unwrap_or_else(|e| {

            observe(e);

            true

        })

    }

    /// 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.

    /// Gives up with `TIMEOUT` after [`WAIT`], so a hung GPU cannot freeze the

    /// caller.

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

        if self.exportable {

            drop(self.export());

        }

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

            State::Pending => unsafe {

                self.shared.device.device.wait_for_fences(

                    &[self.fence],

                    true,

                    WAIT.as_nanos() as u64,

                )

            },

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

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

                let timeout = rustix::event::Timespec {

                    tv_sec: WAIT.as_secs() as _,

                    tv_nsec: 0,

                };

                if readable(fd, Some(&timeout)) {

                    Ok(())

                } else {

                    Err(vk::Result::TIMEOUT)

                }

            }

        };

        if waited_for.is_ok() {

            waited();

        }

        waited_for

    }

    #[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(|e| {

            observe(e);

            Interrupted

        })

    }

    fn is_exportable(&self) -> bool {

        self.0.exportable

    }

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

        self.0.export()

    }

}