entailz/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 {
pub fn export_sync_file(&self) -> Result<SyncFile, VulkanError> {
pub fn export_sync_file(&self) -> Result<Option<SyncFile>, VulkanError> {
let info = FenceGetFdInfoKHR::default()
.fence(self.fence)
.handle_type(ExternalFenceHandleTypeFlags::SYNC_FD);
let res = unsafe { self.device.external_fence_fd.get_fence_fd(&info) };
res.map_err(VulkanError::ExportSyncFile)
.map(|fd| SyncFile(Rc::new(OwnedFd::new(fd))))
let fd = res.map_err(VulkanError::ExportSyncFile)?;
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");
let release_sync_file = match release_fence.export_sync_file() {
Ok(s) => Some(s),
Ok(s) => s,
Err(e) => {
log::error!("Could not export sync file from fence: {}", ErrorFmt(e));
self.block();
@ -2069,18 +2069,13 @@ async fn await_release(
frame: Rc<PendingFrame>,
renderer: Rc<VulkanRenderer>,
) {
let mut is_released = false;
if let Some(sync_file) = sync_file {
if let Err(e) = ring.readable(&sync_file).await {
log::error!(
"Could not wait for release semaphore to be signaled: {}",
ErrorFmt(e)
);
} else {
is_released = true;
}
}
if !is_released {
if let Some(sync_file) = sync_file
&& let Err(e) = ring.readable(&sync_file).await
{
log::error!(
"Could not wait for release semaphore to be signaled: {}",
ErrorFmt(e)
);
frame.renderer.block();
}
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);
}
})?;
let Some((cmd, fence, sync_file, point)) =
self.submit_buffer_image_copy(img, &staging, cpy, false, TransferType::Upload)?
else {
return Ok(());
};
let (cmd, fence, sync_file, point) =
self.submit_buffer_image_copy(img, &staging, cpy, false, TransferType::Upload)?;
let future = img.renderer.eng.spawn(
"await upload",
await_upload(point, img.clone(), cmd, sync_file, fence, staging),
@ -156,8 +153,15 @@ impl VulkanShmImage {
regions: &[BufferImageCopy2],
use_transfer_queue: bool,
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| {
BufferMemoryBarrier2::default()
.buffer(staging.buffer)
@ -308,11 +312,11 @@ impl VulkanShmImage {
Err(e) => {
log::error!("Could not export sync file from fence: {}", ErrorFmt(e));
img.renderer.block();
return Ok(None);
None
}
};
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,
img: Rc<VulkanImage>,
buf: Rc<VulkanCommandBuffer>,
sync_file: SyncFile,
sync_file: Option<SyncFile>,
_fence: Rc<VulkanFence>,
_staging: VulkanStagingBuffer,
) {
let res = img.renderer.ring.readable(&sync_file.0).await;
if let Err(e) = res {
if let Some(sync_file) = sync_file
&& let Err(e) = img.renderer.ring.readable(&sync_file.0).await
{
log::error!(
"Could not wait for sync file to become readable: {}",
ErrorFmt(e)

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

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