Move fence synchronisation into wgpu-hal

wgpu-core/src/device/mod.rs

@@ -28,7 +28,7 @@ pub mod ray_tracing;
 pub mod resource;
 #[cfg(any(feature = "trace", feature = "replay"))]
 pub mod trace;
-pub(crate) use resource::{FenceReadGuard, FenceWriteGuard};
+pub(crate) use resource::FenceReadGuard;
 pub use {life::WaitIdleError, resource::Device};
 
 pub const SHADER_STAGE_COUNT: usize = hal::MAX_CONCURRENT_SHADER_STAGES;

wgpu-core/src/device/queue.rs

@@ -24,7 +24,7 @@ use crate::{
         CommandAllocator, CommandBuffer, CommandEncoder, CommandEncoderError, CopySide,
         TransferError,
     },
-    device::{DeviceError, FenceReadGuard, FenceWriteGuard, WaitIdleError},
+    device::{DeviceError, FenceReadGuard, WaitIdleError},
     get_lowest_common_denom,
     global::Global,
     hal_label,
@@ -568,7 +568,7 @@ impl WebGpuError for QueueSubmitError {
 pub(crate) struct PendingSubmission<'a> {
     queue: &'a Queue,
     snatch_guard: SnatchGuard<'a>,
-    fence: FenceWriteGuard<'a>,
+    fence: FenceReadGuard<'a>,
     command_index_guard: RwLockWriteGuard<'a, CommandIndices>,
     // Command buffers to be executed, along with trackers for the resources they use.
     pub executions: Vec<EncoderInFlight>,
@@ -1563,7 +1563,7 @@ impl Queue {
     ) -> Result<PendingSubmission<'a>, (SubmissionIndex, DeviceError)> {
         // Lock ordering requires that the fence lock be acquired after the snatch lock and
         // before the command index lock.
-        let fence = self.device.fence.write();
+        let fence = self.device.fence.read();
 
         let mut command_index_guard = self.device.command_indices.write();
         command_index_guard.active_submission_index += 1;
@@ -1610,7 +1610,7 @@ impl Queue {
         let PendingSubmission {
             queue: _,
             snatch_guard,
-            mut fence,
+            fence,
             command_index_guard,
             mut executions,
             mut surface_textures,
@@ -1681,7 +1681,7 @@ impl Queue {
                 self.raw().submit(
                     &hal_command_buffers,
                     &submit_surface_textures,
-                    (fence.as_mut(), submit_index),
+                    (fence.as_ref(), submit_index),
                 )
             }
             .map_err(|e| self.device.handle_hal_error(e))?;
@@ -1702,7 +1702,7 @@ impl Queue {
         self.lock_life().track_submission(submit_index, executions);
 
         Ok(SubmissionResult {
-            fence: RwLockWriteGuard::downgrade(fence),
+            fence,
             snatch_guard,
         })
     }

wgpu-core/src/device/resource.rs

@@ -41,7 +41,7 @@ use crate::{
         TextureInitTrackerAction,
     },
     instance::{Adapter, RequestDeviceError},
-    lock::{rank, Mutex, RwLock, RwLockReadGuard, RwLockWriteGuard},
+    lock::{rank, Mutex, RwLock, RwLockReadGuard},
     pipeline::{self, ColorStateError},
     pool::ResourcePool,
     present,
@@ -289,7 +289,6 @@ pub struct Device {
 }
 
 pub(crate) type FenceReadGuard<'a> = RwLockReadGuard<'a, ManuallyDrop<Box<dyn hal::DynFence>>>;
-pub(crate) type FenceWriteGuard<'a> = RwLockWriteGuard<'a, ManuallyDrop<Box<dyn hal::DynFence>>>;
 
 pub(crate) enum DeferredDestroy {
     TextureViews(WeakVec<TextureView>),

wgpu-core/src/lock/observing.rs

@@ -185,15 +185,6 @@ impl<'a, T> RwLockReadGuard<'a, T> {
     }
 }
 
-impl<'a, T> RwLockWriteGuard<'a, T> {
-    pub fn downgrade(this: Self) -> RwLockReadGuard<'a, T> {
-        RwLockReadGuard {
-            inner: parking_lot::RwLockWriteGuard::downgrade(this.inner),
-            _state: this._state,
-        }
-    }
-}
-
 impl<T: core::fmt::Debug> core::fmt::Debug for RwLock<T> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         self.inner.fmt(f)
@@ -226,11 +217,11 @@ impl<'a, T> core::ops::DerefMut for RwLockWriteGuard<'a, T> {
 ///
 /// This type serves two purposes:
 ///
-/// - Operations like `RwLockWriteGuard::downgrade` would like to be able to
-///   destructure lock guards and reassemble their pieces into new guards, but
-///   if the guard type itself implements `Drop`, we can't destructure it
-///   without unsafe code or pointless `Option`s whose state is almost always
-///   statically known.
+/// - Operations would like to be able to destructure lock guards and
+///   reassemble their pieces into new guards, but if the guard type
+///   itself implements `Drop`, we can't destructure it without unsafe
+///   code or pointless `Option`s whose state is almost always statically
+///   known.
 ///
 /// - We can just implement `Drop` for this type once, and then use it in lock
 ///   guards, rather than implementing `Drop` separately for each guard type.

wgpu-core/src/lock/ranked.rs

@@ -110,11 +110,11 @@ impl LockState {
 ///
 /// This type serves two purposes:
 ///
-/// - Operations like `RwLockWriteGuard::downgrade` would like to be able to
-///   destructure lock guards and reassemble their pieces into new guards, but
-///   if the guard type itself implements `Drop`, we can't destructure it
-///   without unsafe code or pointless `Option`s whose state is almost always
-///   statically known.
+/// - Operations would like to be able to destructure lock guards and
+///   reassemble their pieces into new guards, but if the guard type
+///   itself implements `Drop`, we can't destructure it without unsafe
+///   code or pointless `Option`s whose state is almost always statically
+///   known.
 ///
 /// - We can just implement `Drop` for this type once, and then use it in lock
 ///   guards, rather than implementing `Drop` separately for each guard type.
@@ -299,15 +299,6 @@ impl<'a, T> RwLockReadGuard<'a, T> {
     }
 }
 
-impl<'a, T> RwLockWriteGuard<'a, T> {
-    pub fn downgrade(this: Self) -> RwLockReadGuard<'a, T> {
-        RwLockReadGuard {
-            inner: parking_lot::RwLockWriteGuard::downgrade(this.inner),
-            saved: this.saved,
-        }
-    }
-}
-
 impl<T: fmt::Debug> fmt::Debug for RwLock<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.inner.fmt(f)

wgpu-core/src/lock/vanilla.rs

@@ -116,12 +116,6 @@ impl<'a, T> RwLockReadGuard<'a, T> {
     }
 }
 
-impl<'a, T> RwLockWriteGuard<'a, T> {
-    pub fn downgrade(this: Self) -> RwLockReadGuard<'a, T> {
-        RwLockReadGuard(parking_lot::RwLockWriteGuard::downgrade(this.0))
-    }
-}
-
 impl<T: fmt::Debug> fmt::Debug for RwLock<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.0.fmt(f)

wgpu-hal/src/dx12/mod.rs

@@ -1670,7 +1670,7 @@ impl crate::Queue for Queue {
         &self,
         command_buffers: &[&CommandBuffer],
         _surface_textures: &[&Texture],
-        (signal_fence, signal_value): (&mut Fence, crate::FenceValue),
+        (signal_fence, signal_value): (&Fence, crate::FenceValue),
     ) -> Result<(), crate::DeviceError> {
         let mut temp_lists = self.temp_lists.lock();
         temp_lists.clear();

wgpu-hal/src/dynamic/mod.rs

@@ -57,10 +57,6 @@ trait DynResourceExt {
     ///
     /// - Panics if `self` is not downcastable to `T`.
     fn expect_downcast_ref<T: DynResource>(&self) -> &T;
-    /// # Panics
-    ///
-    /// - Panics if `self` is not downcastable to `T`.
-    fn expect_downcast_mut<T: DynResource>(&mut self) -> &mut T;
 
     /// Unboxes a `Box<dyn DynResource>` to a concrete type.
     ///
@@ -77,12 +73,6 @@ impl<R: DynResource + ?Sized> DynResourceExt for R {
             .expect("Resource doesn't have the expected backend type.")
     }
 
-    fn expect_downcast_mut<'a, T: DynResource>(&'a mut self) -> &'a mut T {
-        self.as_any_mut()
-            .downcast_mut()
-            .expect("Resource doesn't have the expected backend type.")
-    }
-
     unsafe fn unbox<T: DynResource + 'static>(self: Box<Self>) -> T {
         debug_assert!(
             <Self as Any>::type_id(self.as_ref()) == TypeId::of::<T>(),

wgpu-hal/src/dynamic/queue.rs

@@ -12,7 +12,7 @@ pub trait DynQueue: DynResource {
         &self,
         command_buffers: &[&dyn DynCommandBuffer],
         surface_textures: &[&dyn DynSurfaceTexture],
-        signal_fence: (&mut dyn DynFence, FenceValue),
+        signal_fence: (&dyn DynFence, FenceValue),
     ) -> Result<(), DeviceError>;
     unsafe fn present(
         &self,
@@ -28,7 +28,7 @@ impl<Q: Queue + DynResource> DynQueue for Q {
         &self,
         command_buffers: &[&dyn DynCommandBuffer],
         surface_textures: &[&dyn DynSurfaceTexture],
-        signal_fence: (&mut dyn DynFence, FenceValue),
+        signal_fence: (&dyn DynFence, FenceValue),
     ) -> Result<(), DeviceError> {
         let command_buffers = command_buffers
             .iter()
@@ -38,7 +38,7 @@ impl<Q: Queue + DynResource> DynQueue for Q {
             .iter()
             .map(|surface| (*surface).expect_downcast_ref())
             .collect::<Vec<_>>();
-        let signal_fence = (signal_fence.0.expect_downcast_mut(), signal_fence.1);
+        let signal_fence = (signal_fence.0.expect_downcast_ref(), signal_fence.1);
         unsafe { Q::submit(self, &command_buffers, &surface_textures, signal_fence) }
     }