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

Merge pull request #596 from mahkoh/jorth/vulkan--1

Browse source 
vulkan: handle exported sync file being -1
This commit is contained in:
mahkoh 2025-09-08 12:43:00 +02:00 • committed by GitHub
commit 4fb7a859dc
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 45 additions and 57 deletions
Download patch file Download diff file Expand all files Collapse all files

10
src/gfx_apis/vulkan/fence.rs
View file

@ -41,12 +41,16 @@ impl VulkanDevice {
} }
impl VulkanFence { impl VulkanFence {
pub fn export_sync_file(&self) -> Result<SyncFile, VulkanError> { pub fn export_sync_file(&self) -> Result<Option<SyncFile>, VulkanError> {
let info = FenceGetFdInfoKHR::default() let info = FenceGetFdInfoKHR::default()
.fence(self.fence) .fence(self.fence)
.handle_type(ExternalFenceHandleTypeFlags::SYNC_FD); .handle_type(ExternalFenceHandleTypeFlags::SYNC_FD);
let res = unsafe { self.device.external_fence_fd.get_fence_fd(&info) }; let res = unsafe { self.device.external_fence_fd.get_fence_fd(&info) };
res.map_err(VulkanError::ExportSyncFile) let fd = res.map_err(VulkanError::ExportSyncFile)?;
.map(|fd| SyncFile(Rc::new(OwnedFd::new(fd)))) if fd == -1 {
Ok(None)
} else {
Ok(Some(SyncFile(Rc::new(OwnedFd::new(fd)))))
}
} }
} }

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

@ -1658,7 +1658,7 @@ impl VulkanRenderer {
} }
zone!("export_sync_file"); zone!("export_sync_file");
let release_sync_file = match release_fence.export_sync_file() { let release_sync_file = match release_fence.export_sync_file() {
Ok(s) => Some(s), Ok(s) => s,
Err(e) => { Err(e) => {
log::error!("Could not export sync file from fence: {}", ErrorFmt(e)); log::error!("Could not export sync file from fence: {}", ErrorFmt(e));
self.block(); self.block();
@ -2069,18 +2069,13 @@ async fn await_release(
frame: Rc<PendingFrame>, frame: Rc<PendingFrame>,
renderer: Rc<VulkanRenderer>, renderer: Rc<VulkanRenderer>,
) { ) {
let mut is_released = false; if let Some(sync_file) = sync_file
if let Some(sync_file) = sync_file { && let Err(e) = ring.readable(&sync_file).await
if let Err(e) = ring.readable(&sync_file).await { {
log::error!( log::error!(
"Could not wait for release semaphore to be signaled: {}", "Could not wait for release semaphore to be signaled: {}",
ErrorFmt(e) ErrorFmt(e)
); );
} else {
is_released = true;
}
}
if !is_released {
frame.renderer.block(); frame.renderer.block();
} }
if let Some(buf) = frame.cmd.take() { if let Some(buf) = frame.cmd.take() {

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

@ -136,11 +136,8 @@ impl VulkanShmImage {
ptr::copy_nonoverlapping(buf, mem, total_size as usize); ptr::copy_nonoverlapping(buf, mem, total_size as usize);
} }
})?; })?;
let Some((cmd, fence, sync_file, point)) = let (cmd, fence, sync_file, point) =
self.submit_buffer_image_copy(img, &staging, cpy, false, TransferType::Upload)? self.submit_buffer_image_copy(img, &staging, cpy, false, TransferType::Upload)?;
else {
return Ok(());
};
let future = img.renderer.eng.spawn( let future = img.renderer.eng.spawn(
"await upload", "await upload",
await_upload(point, img.clone(), cmd, sync_file, fence, staging), await_upload(point, img.clone(), cmd, sync_file, fence, staging),
@ -156,8 +153,15 @@ impl VulkanShmImage {
regions: &[BufferImageCopy2], regions: &[BufferImageCopy2],
use_transfer_queue: bool, use_transfer_queue: bool,
tt: TransferType, tt: TransferType,
) -> Result<Option<(Rc<VulkanCommandBuffer>, Rc<VulkanFence>, SyncFile, u64)>, VulkanError> ) -> Result<
{ (
Rc<VulkanCommandBuffer>,
Rc<VulkanFence>,
Option<SyncFile>,
u64,
),
VulkanError,
> {
let memory_barrier = |sam, ssm, dam, dsm| { let memory_barrier = |sam, ssm, dam, dsm| {
BufferMemoryBarrier2::default() BufferMemoryBarrier2::default()
.buffer(staging.buffer) .buffer(staging.buffer)
@ -308,11 +312,11 @@ impl VulkanShmImage {
Err(e) => { Err(e) => {
log::error!("Could not export sync file from fence: {}", ErrorFmt(e)); log::error!("Could not export sync file from fence: {}", ErrorFmt(e));
img.renderer.block(); img.renderer.block();
return Ok(None); None
} }
}; };
let point = img.renderer.allocate_point(); let point = img.renderer.allocate_point();
Ok(Some((cmd, release_fence, release_sync_file, point))) Ok((cmd, release_fence, release_sync_file, point))
} }
} }
@ -320,12 +324,13 @@ async fn await_upload(
id: u64, id: u64,
img: Rc<VulkanImage>, img: Rc<VulkanImage>,
buf: Rc<VulkanCommandBuffer>, buf: Rc<VulkanCommandBuffer>,
sync_file: SyncFile, sync_file: Option<SyncFile>,
_fence: Rc<VulkanFence>, _fence: Rc<VulkanFence>,
_staging: VulkanStagingBuffer, _staging: VulkanStagingBuffer,
) { ) {
let res = img.renderer.ring.readable(&sync_file.0).await; if let Some(sync_file) = sync_file
if let Err(e) = res { && let Err(e) = img.renderer.ring.readable(&sync_file.0).await
{
log::error!( log::error!(
"Could not wait for sync file to become readable: {}", "Could not wait for sync file to become readable: {}",
ErrorFmt(e) ErrorFmt(e)

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

@ -227,7 +227,7 @@ impl VulkanShmImage {
let id = img.renderer.allocate_point(); let id = img.renderer.allocate_point();
let pending = img.renderer.eng.spawn( let pending = img.renderer.eng.spawn(
"await_transfer_to_transfer", "await_transfer_to_transfer",
await_gfx_queue_release(id, img.clone(), None, None, sync_file, tt), await_gfx_queue_release(id, img.clone(), None, None, Some(sync_file), tt),
); );
img.renderer.pending_submits.set(id, pending); img.renderer.pending_submits.set(id, pending);
img.queue_state.set(QueueState::Releasing); img.queue_state.set(QueueState::Releasing);
@ -453,11 +453,8 @@ impl VulkanShmImage {
let regions = &*data.regions.borrow(); let regions = &*data.regions.borrow();
let staging = data.staging.get().unwrap().staging.get().unwrap(); let staging = data.staging.get().unwrap().staging.get().unwrap();
staging.upload(|_, _| ())?; staging.upload(|_, _| ())?;
let Some((cmd, fence, sync_file, point)) = let (cmd, fence, sync_file, point) =
self.submit_buffer_image_copy(img, &staging, regions, true, TransferType::Upload)? self.submit_buffer_image_copy(img, &staging, regions, true, TransferType::Upload)?;
else {
return Ok(());
};
img.queue_state.set(QueueState::Releasing); img.queue_state.set(QueueState::Releasing);
let future = img.renderer.eng.spawn( let future = img.renderer.eng.spawn(
"await async upload", "await async upload",
@ -484,23 +481,8 @@ impl VulkanShmImage {
return Ok(()); return Ok(());
} }
img.renderer.check_defunct()?; img.renderer.check_defunct()?;
let Some((cmd, fence, sync_file, point)) = let (cmd, fence, sync_file, point) =
self.submit_buffer_image_copy(img, &staging, copies, true, TransferType::Download)? self.submit_buffer_image_copy(img, &staging, copies, true, TransferType::Download)?;
else {
img.queue_state.set(QueueState::Released {
to: QueueFamily::Gfx,
});
let data = self.async_data.as_ref().unwrap();
let client_mem = data.client_mem.get().unwrap();
return self.async_transfer_initiate_host_copy(
&img,
data,
&staging,
copies,
&client_mem,
TransferType::Download,
);
};
img.queue_state.set(QueueState::Releasing); img.queue_state.set(QueueState::Releasing);
let future = img.renderer.eng.spawn( let future = img.renderer.eng.spawn(
"await async image to buffer copy", "await async image to buffer copy",
@ -598,11 +580,12 @@ async fn await_gfx_queue_release(
img: Rc<VulkanImage>, img: Rc<VulkanImage>,
buf: Option<Rc<VulkanCommandBuffer>>, buf: Option<Rc<VulkanCommandBuffer>>,
_fence: Option<Rc<VulkanFence>>, _fence: Option<Rc<VulkanFence>>,
sync_file: SyncFile, sync_file: Option<SyncFile>,
tt: TransferType, tt: TransferType,
) { ) {
let res = img.renderer.ring.readable(&sync_file.0).await; if let Some(sync_file) = sync_file
if let Err(e) = res { && let Err(e) = img.renderer.ring.readable(&sync_file.0).await
{
log::error!( log::error!(
"Could not wait for sync file to become readable: {}", "Could not wait for sync file to become readable: {}",
ErrorFmt(e) ErrorFmt(e)
@ -640,11 +623,12 @@ pub async fn await_async_transfer_release_to_gfx(
img: Rc<VulkanImage>, img: Rc<VulkanImage>,
buf: Rc<VulkanCommandBuffer>, buf: Rc<VulkanCommandBuffer>,
_fence: Rc<VulkanFence>, _fence: Rc<VulkanFence>,
sync_file: SyncFile, sync_file: Option<SyncFile>,
tt: TransferType, tt: TransferType,
) { ) {
let res = img.renderer.ring.readable(&sync_file.0).await; if let Some(sync_file) = sync_file
if let Err(e) = res { && let Err(e) = img.renderer.ring.readable(&sync_file.0).await
{
log::error!( log::error!(
"Could not wait for sync file to become readable: {}", "Could not wait for sync file to become readable: {}",
ErrorFmt(e) ErrorFmt(e)