kossLAN/wry
1
0
Fork 0
forked from wry/wry
Code Pull requests Activity

vulkan: move fence to core

Browse source
This commit is contained in:
Julian Orth 2026-03-02 10:45:14 +01:00
parent 7e6facf4e3
commit 3ecee1b17f
9 changed files with 89 additions and 91 deletions
Download patch file Download diff file Expand all files Collapse all files

86
src/copy_device.rs
View file

@ -14,7 +14,8 @@ use {
dmabuf::{DmaBuf, DmaBufIds, DmaBufPlane, PlaneVec},
},
vulkan_core::{
VULKAN_API_VERSION, VulkanCoreError, VulkanCoreInstance, map_extension_properties,
self, VULKAN_API_VERSION, VulkanCoreError, VulkanCoreInstance, device::VulkanDeviceInf,
fence::VulkanDeviceFenceExt, map_extension_properties,
},
},
ahash::{AHashMap, AHashSet},
@ -34,14 +35,13 @@ use {
CommandPoolCreateInfo, CopyBufferInfo2, CopyBufferToImageInfo2, CopyImageInfo2,
CopyImageToBufferInfo2, DependencyInfo, DeviceCreateInfo, DeviceMemory,
DeviceQueueCreateInfo, DrmFormatModifierPropertiesEXT,
DrmFormatModifierPropertiesListEXT, ExportFenceCreateInfo, ExportMemoryAllocateInfo,
Extent3D, ExternalBufferProperties, ExternalFenceFeatureFlags,
ExternalFenceHandleTypeFlags, ExternalFenceProperties,
ExternalImageFormatPropertiesKHR, ExternalMemoryBufferCreateInfo,
ExternalMemoryBufferCreateInfoKHR, ExternalMemoryFeatureFlags,
ExternalMemoryHandleTypeFlags, ExternalMemoryImageCreateInfo,
ExternalSemaphoreFeatureFlags, ExternalSemaphoreHandleTypeFlags,
ExternalSemaphoreProperties, Fence, FenceCreateInfo, FenceGetFdInfoKHR, Filter,
DrmFormatModifierPropertiesListEXT, ExportMemoryAllocateInfo, Extent3D,
ExternalBufferProperties, ExternalFenceFeatureFlags, ExternalFenceHandleTypeFlags,
ExternalFenceProperties, ExternalImageFormatPropertiesKHR,
ExternalMemoryBufferCreateInfo, ExternalMemoryBufferCreateInfoKHR,
ExternalMemoryFeatureFlags, ExternalMemoryHandleTypeFlags,
ExternalMemoryImageCreateInfo, ExternalSemaphoreFeatureFlags,
ExternalSemaphoreHandleTypeFlags, ExternalSemaphoreProperties, Filter,
FormatFeatureFlags, FormatProperties2, ImageAspectFlags, ImageBlit2, ImageCopy2,
ImageCreateFlags, ImageCreateInfo, ImageDrmFormatModifierExplicitCreateInfoEXT,
ImageFormatProperties2, ImageLayout, ImageMemoryBarrier2, ImageMemoryRequirementsInfo2,
@ -84,16 +84,12 @@ pub enum CopyDeviceError {
Core(#[from] VulkanCoreError),
#[error("Could not create a semaphore")]
CreateSemaphore(#[source] vk::Result),
#[error("Could not create a fence")]
CreateFence(#[source] vk::Result),
#[error("Could not dup a sync file")]
DupSyncFile(#[source] io::Error),
#[error("Could not dup a dma buf")]
DupDmaBuf(#[source] io::Error),
#[error("Could not import a sync file")]
ImportSyncFile(#[source] vk::Result),
#[error("Could not export a sync file")]
ExportSyncFile(#[source] vk::Result),
#[error("Could not submit the copy")]
SubmitCopy(#[source] vk::Result),
#[error("Could not enumerate the physical devices")]
@ -217,7 +213,7 @@ struct CopyDeviceInner {
external_fence_fd: external_fence_fd::Device,
external_memory_fd: external_memory_fd::Device,
semaphores: Stack<VulkanSemaphore>,
fences: Stack<VulkanFence>,
fences: Stack<Rc<VulkanFence>>,
submissions: Keyed<Rc<PendingSubmissions>>,
}
@ -276,7 +272,7 @@ struct Pending {
sync_file: Option<SyncFile>,
copy: Rc<CopyDeviceCopyInner>,
semaphore: Option<VulkanSemaphore>,
fence: Option<VulkanFence>,
fence: Option<Rc<VulkanFence>>,
}
struct VulkanSemaphore {
@ -284,10 +280,7 @@ struct VulkanSemaphore {
semaphore: Semaphore,
}
struct VulkanFence {
dev: Rc<CopyDeviceInner>,
fence: Fence,
}
type VulkanFence = vulkan_core::fence::VulkanFence<CopyDeviceInner>;
struct VulkanBuffer {
dev: Rc<CopyDeviceInner>,
@ -1258,21 +1251,6 @@ impl CopyDeviceInner {
semaphore,
})
}
fn create_fence(self: &Rc<Self>) -> Result<VulkanFence, CopyDeviceError> {
let mut export_info =
ExportFenceCreateInfo::default().handle_types(ExternalFenceHandleTypeFlags::SYNC_FD);
let create_info = FenceCreateInfo::default().push_next(&mut export_info);
let fence = unsafe {
self.dev
.create_fence(&create_info, None)
.map_err(CopyDeviceError::CreateFence)?
};
Ok(VulkanFence {
dev: self.clone(),
fence,
})
}
}
impl CopyDeviceCopy {
@ -1688,7 +1666,7 @@ impl CopyDeviceCopy {
)
.map_err(CopyDeviceError::SubmitCopy)?;
}
let sync_file = match signal_fence.export() {
let sync_file = match signal_fence.export_sync_file() {
Ok(f) => f,
Err(e) => {
log::error!("Could not export signal fence: {}", ErrorFmt(e));
@ -1730,26 +1708,6 @@ impl VulkanSemaphore {
}
}
impl VulkanFence {
fn export(&self) -> Result<Option<SyncFile>, CopyDeviceError> {
let info = FenceGetFdInfoKHR::default()
.fence(self.fence)
.handle_type(ExternalFenceHandleTypeFlags::SYNC_FD);
let fd = unsafe {
self.dev
.external_fence_fd
.get_fence_fd(&info)
.map_err(CopyDeviceError::ExportSyncFile)?
};
let fd = if fd == -1 {
None
} else {
Some(SyncFile(Rc::new(OwnedFd::new(fd))))
};
Ok(fd)
}
}
impl CopyDeviceRegistry {
pub fn new(ring: &Rc<IoUring>, eng: &Rc<AsyncEngine>) -> Self {
Self {
@ -1794,14 +1752,6 @@ impl Drop for VulkanSemaphore {
}
}
impl Drop for VulkanFence {
fn drop(&mut self) {
unsafe {
self.dev.dev.destroy_fence(self.fence, None);
}
}
}
impl Drop for CopyDeviceCopyInner {
fn drop(&mut self) {
unsafe {
@ -2039,3 +1989,13 @@ fn allocate_queues(
};
(queues_to_allocate, queue_indices)
}
impl VulkanDeviceInf for CopyDeviceInner {
fn device(&self) -> &Device {
&self.dev
}
fn external_fence_fd(&self) -> &external_fence_fd::Device {
&self.external_fence_fd
}
}

12
src/gfx_apis/vulkan.rs
View file

@ -9,7 +9,6 @@ mod descriptor_buffer;
mod device;
mod dmabuf_buffer;
mod eotfs;
mod fence;
mod format;
mod gpu_alloc_ash;
mod image;
@ -35,7 +34,8 @@ use {
STAGING_DOWNLOAD, STAGING_UPLOAD, ShmGfxTexture, StagingBufferUsecase,
},
gfx_apis::vulkan::{
image::VulkanImageMemory, instance::VulkanInstance, renderer::VulkanRenderer,
device::VulkanDevice, image::VulkanImageMemory, instance::VulkanInstance,
renderer::VulkanRenderer,
},
io_uring::IoUring,
pr_caps::PrCapsThread,
@ -46,7 +46,7 @@ use {
drm::{Drm, DrmError, syncobj::SyncobjCtx},
gbm::GbmError,
},
vulkan_core::VulkanCoreError,
vulkan_core::{self, VulkanCoreError},
},
ahash::AHashMap,
ash::vk,
@ -73,8 +73,6 @@ pub enum VulkanError {
CreateDevice(#[source] vk::Result),
#[error("Could not create a semaphore")]
CreateSemaphore(#[source] vk::Result),
#[error("Could not create a fence")]
CreateFence(#[source] vk::Result),
#[error("Could not create the buffer")]
CreateBuffer(#[source] vk::Result),
#[error("Could not create a shader module")]
@ -157,8 +155,6 @@ pub enum VulkanError {
IoctlExportSyncFile(#[source] OsError),
#[error("Could not import a sync file into a semaphore")]
ImportSyncFile(#[source] vk::Result),
#[error("Could not export a sync file from a semaphore")]
ExportSyncFile(#[source] vk::Result),
#[error("Could not fetch the render node of the device")]
FetchRenderNode(#[source] DrmError),
#[error("Device has no render node")]
@ -215,6 +211,8 @@ pub enum VulkanError {
DmaBufBufferOffsetAlignment,
}
type VulkanFence = vulkan_core::fence::VulkanFence<VulkanDevice>;
impl From<VulkanError> for GfxError {
fn from(value: VulkanError) -> Self {
Self(Box::new(value))

13
src/gfx_apis/vulkan/device.rs
View file

@ -14,7 +14,8 @@ use {
gbm::{GBM_BO_USE_RENDERING, GbmDevice},
},
vulkan_core::{
ApiVersionDisplay, Extensions, VULKAN_API_VERSION, map_extension_properties,
ApiVersionDisplay, Extensions, VULKAN_API_VERSION, device::VulkanDeviceInf,
map_extension_properties,
},
},
ahash::AHashMap,
@ -639,3 +640,13 @@ fn log_device(
}
}
}
impl VulkanDeviceInf for VulkanDevice {
fn device(&self) -> &Device {
&self.device
}
fn external_fence_fd(&self) -> &external_fence_fd::Device {
&self.external_fence_fd
}
}

4
src/gfx_apis/vulkan/renderer.rs
View file

@ -12,7 +12,7 @@ use {
GfxFormat, GfxTexture, GfxWriteModifier, ReleaseSync, SyncFile,
},
gfx_apis::vulkan::{
VulkanError,
VulkanError, VulkanFence,
allocator::{VulkanAllocator, VulkanThreadedAllocator},
buffer_cache::{GenericBufferWriter, VulkanBuffer, VulkanBufferCache},
command::{VulkanCommandBuffer, VulkanCommandPool},
@ -20,7 +20,6 @@ use {
descriptor_buffer::VulkanDescriptorBufferWriter,
device::VulkanDevice,
eotfs::{EOTF_LINEAR, EotfExt, VulkanEotf},
fence::VulkanFence,
image::{QueueFamily, QueueState, QueueTransfer, VulkanImage, VulkanImageMemory},
pipeline::{PipelineCreateInfo, VulkanPipeline},
sampler::VulkanSampler,
@ -40,6 +39,7 @@ use {
stack::Stack,
},
video::dmabuf::{DMA_BUF_SYNC_READ, DMA_BUF_SYNC_WRITE, dma_buf_export_sync_file},
vulkan_core::fence::VulkanDeviceFenceExt,
},
ahash::AHashMap,
arrayvec::ArrayVec,

4
src/gfx_apis/vulkan/shm_image.rs
View file

@ -4,10 +4,9 @@ use {
format::Format,
gfx_api::SyncFile,
gfx_apis::vulkan::{
VulkanError,
VulkanError, VulkanFence,
allocator::VulkanAllocation,
command::VulkanCommandBuffer,
fence::VulkanFence,
image::{QueueFamily, QueueState, VulkanImage, VulkanImageMemory},
renderer::{VulkanRenderer, image_barrier},
staging::VulkanStagingBuffer,
@ -15,6 +14,7 @@ use {
},
rect::Rect,
utils::errorfmt::ErrorFmt,
vulkan_core::fence::VulkanDeviceFenceExt,
},
ash::vk::{
AccessFlags2, Buffer, BufferImageCopy2, BufferMemoryBarrier2, CommandBufferBeginInfo,

4
src/gfx_apis/vulkan/transfer.rs
View file

@ -11,10 +11,9 @@ use {
AsyncShmGfxTextureCallback, PendingShmTransfer, ShmMemory, ShmMemoryBacking, SyncFile,
},
gfx_apis::vulkan::{
VulkanError,
VulkanError, VulkanFence,
command::VulkanCommandBuffer,
dmabuf_buffer::{TRANSFER_QUEUE_BUFFER_ALIGNMENT, VulkanDmabufBuffer},
fence::VulkanFence,
image::{QueueFamily, QueueState, QueueTransfer, VulkanImage, VulkanImageMemory},
renderer::image_barrier,
shm_image::VulkanShmImage,
@ -22,6 +21,7 @@ use {
},
rect::{Rect, Region},
utils::{clonecell::CloneCell, errorfmt::ErrorFmt},
vulkan_core::fence::VulkanDeviceFenceExt,
},
arrayvec::ArrayVec,
ash::vk::{

7
src/vulkan_core.rs
View file

@ -25,6 +25,9 @@ use {
uapi::{Ustr, ustr},
};
pub mod device;
pub mod fence;
static VULKAN_ENTRY: Lazy<Result<Entry, Arc<LoadingError>>> =
Lazy::new(|| unsafe { Entry::load() }.map_err(Arc::new));
@ -45,6 +48,10 @@ pub enum VulkanCoreError {
CreateInstance(#[source] vk::Result),
#[error("Could not create a debug-utils messenger")]
Messenger(#[source] vk::Result),
#[error("Could not create a fence")]
CreateFence(#[source] vk::Result),
#[error("Could not export a sync file from a semaphore")]
ExportSyncFile(#[source] vk::Result),
}
pub struct VulkanCoreInstance {

6
src/vulkan_core/device.rs Normal file
View file

@ -0,0 +1,6 @@
use ash::{Device, khr::external_fence_fd};
pub trait VulkanDeviceInf: Sized {
fn device(&self) -> &Device;
fn external_fence_fd(&self) -> &external_fence_fd::Device;
}

44
src/gfx_apis/vulkan/fence.rs → src/vulkan_core/fence.rs
View file

@ -1,7 +1,7 @@
use {
crate::{
gfx_api::SyncFile,
gfx_apis::vulkan::{VulkanError, device::VulkanDevice},
vulkan_core::{VulkanCoreError, device::VulkanDeviceInf},
},
ash::vk::{
ExportFenceCreateInfo, ExternalFenceHandleTypeFlags, Fence, FenceCreateInfo,
@ -11,27 +11,40 @@ use {
uapi::OwnedFd,
};
pub struct VulkanFence {
pub(super) device: Rc<VulkanDevice>,
pub(super) fence: Fence,
pub struct VulkanFence<D>
where
D: VulkanDeviceInf,
{
pub device: Rc<D>,
pub fence: Fence,
}
impl Drop for VulkanFence {
pub trait VulkanDeviceFenceExt: VulkanDeviceInf {
fn create_fence(self: &Rc<Self>) -> Result<Rc<VulkanFence<Self>>, VulkanCoreError>;
}
impl<D> Drop for VulkanFence<D>
where
D: VulkanDeviceInf,
{
fn drop(&mut self) {
unsafe {
self.device.device.destroy_fence(self.fence, None);
self.device.device().destroy_fence(self.fence, None);
}
}
}
impl VulkanDevice {
pub fn create_fence(self: &Rc<Self>) -> Result<Rc<VulkanFence>, VulkanError> {
impl<D> VulkanDeviceFenceExt for D
where
D: VulkanDeviceInf,
{
fn create_fence(self: &Rc<Self>) -> Result<Rc<VulkanFence<Self>>, VulkanCoreError> {
let fence = {
let mut export_info = ExportFenceCreateInfo::default()
.handle_types(ExternalFenceHandleTypeFlags::SYNC_FD);
let create_info = FenceCreateInfo::default().push_next(&mut export_info);
let fence = unsafe { self.device.create_fence(&create_info, None) };
fence.map_err(VulkanError::CreateFence)?
let fence = unsafe { self.device().create_fence(&create_info, None) };
fence.map_err(VulkanCoreError::CreateFence)?
};
Ok(Rc::new(VulkanFence {
device: self.clone(),
@ -40,13 +53,16 @@ impl VulkanDevice {
}
}
impl VulkanFence {
pub fn export_sync_file(&self) -> Result<Option<SyncFile>, VulkanError> {
impl<D> VulkanFence<D>
where
D: VulkanDeviceInf,
{
pub fn export_sync_file(&self) -> Result<Option<SyncFile>, VulkanCoreError> {
let info = FenceGetFdInfoKHR::default()
.fence(self.fence)
.handle_type(ExternalFenceHandleTypeFlags::SYNC_FD);
let res = unsafe { self.device.external_fence_fd.get_fence_fd(&info) };
let fd = res.map_err(VulkanError::ExportSyncFile)?;
let res = unsafe { self.device.external_fence_fd().get_fence_fd(&info) };
let fd = res.map_err(VulkanCoreError::ExportSyncFile)?;
if fd == -1 {
Ok(None)
} else {