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,
@@ -566,7 +566,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>,
@@ -1557,7 +1557,7 @@ impl Queue {
     ) -> (PendingSubmission<'a>, SubmissionIndex) {
         // 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;
@@ -1600,7 +1600,7 @@ impl Queue {
         let PendingSubmission {
             queue: _,
             snatch_guard,
-            mut fence,
+            fence,
             command_index_guard,
             mut executions,
             mut surface_textures,
@@ -1671,7 +1671,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))?;
@@ -1692,7 +1692,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) }
     }
 

wgpu-hal/src/gles/fence.rs

@@ -1,20 +1,29 @@
-use alloc::vec::Vec;
+use alloc::{sync::Arc, vec::Vec};
 use core::sync::atomic::Ordering;
+use parking_lot::RwLock;
 
 use glow::HasContext;
 
 use crate::AtomicFenceValue;
 
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 struct GLFence {
-    sync: glow::Fence,
+    // Since a fence can be `Copy`ed, there can exist some
+    // cases where (without proper synchronisation),
+    // a fence could be destroyed while something else is
+    // still using it. Therefore, while a function is
+    // using this fence, it should read this. (write
+    // should be done when destroying it)
+    //
+    // The arc should not be kept after a function has finished
+    sync: Arc<RwLock<glow::Fence>>,
     value: crate::FenceValue,
 }
 
 #[derive(Debug)]
 pub struct Fence {
     last_completed: AtomicFenceValue,
-    pending: Vec<GLFence>,
+    pending: RwLock<Vec<GLFence>>,
     fence_behavior: wgt::GlFenceBehavior,
 }
 
@@ -29,24 +38,27 @@ impl Fence {
     pub fn new(options: &wgt::GlBackendOptions) -> Self {
         Self {
             last_completed: AtomicFenceValue::new(0),
-            pending: Vec::new(),
+            pending: RwLock::new(Vec::new()),
             fence_behavior: options.fence_behavior,
         }
     }
 
     pub fn signal(
-        &mut self,
+        &self,
         gl: &glow::Context,
         value: crate::FenceValue,
     ) -> Result<(), crate::DeviceError> {
         if self.fence_behavior.is_auto_finish() {
-            *self.last_completed.get_mut() = value;
+            self.last_completed.store(value, Ordering::Release);
             return Ok(());
         }
 
         let sync = unsafe { gl.fence_sync(glow::SYNC_GPU_COMMANDS_COMPLETE, 0) }
             .map_err(|_| crate::DeviceError::OutOfMemory)?;
-        self.pending.push(GLFence { sync, value });
+        self.pending.write().push(GLFence {
+            sync: Arc::new(RwLock::new(sync)),
+            value,
+        });
 
         Ok(())
     }
@@ -62,12 +74,15 @@ impl Fence {
             return max_value;
         }
 
-        for gl_fence in self.pending.iter() {
+        let pending = self.pending.read();
+
+        for gl_fence in pending.iter() {
+            let fence = gl_fence.sync.read();
             if gl_fence.value <= max_value {
                 // We already know this was good, no need to check again
                 continue;
             }
-            let status = unsafe { gl.get_sync_status(gl_fence.sync) };
+            let status = unsafe { gl.get_sync_status(*fence) };
             if status == glow::SIGNALED {
                 max_value = gl_fence.value;
             } else {
@@ -82,20 +97,27 @@ impl Fence {
         max_value
     }
 
-    pub fn maintain(&mut self, gl: &glow::Context) {
+    pub fn maintain(&self, gl: &glow::Context) {
         if self.fence_behavior.is_auto_finish() {
             return;
         }
 
         let latest = self.get_latest(gl);
-        for &gl_fence in self.pending.iter() {
+        let mut pending = self.pending.write();
+        for gl_fence in pending.iter() {
+            // We don't need to keep around this lock until after the retain - we need to make
+            // sure nothing is using it by writing to it, but any new references must come
+            // from `self.pending`, which is write-locked, so nothing else can take a
+            // copy of this value
+            let sync = *gl_fence.sync.write();
+
             if gl_fence.value <= latest {
                 unsafe {
-                    gl.delete_sync(gl_fence.sync);
+                    gl.delete_sync(sync);
                 }
             }
         }
-        self.pending.retain(|&gl_fence| gl_fence.value > latest);
+        pending.retain(|gl_fence| gl_fence.value > latest);
     }
 
     pub fn wait(
@@ -115,9 +137,10 @@ impl Fence {
             return Ok(true);
         }
 
+        let pending = self.pending.read();
+
         // Find a matching fence
-        let gl_fence = self
-            .pending
+        let gl_fence = pending
             .iter()
             // Greater or equal as an abundance of caution, but there should be one fence per value
             .find(|gl_fence| gl_fence.value >= wait_value);
@@ -130,14 +153,20 @@ impl Fence {
         // We should have found a fence with the exact value.
         debug_assert_eq!(gl_fence.value, wait_value);
 
+        let sync = gl_fence.sync.clone();
+
+        drop(pending);
+
         let status = unsafe {
             gl.client_wait_sync(
-                gl_fence.sync,
+                *sync.read(),
                 glow::SYNC_FLUSH_COMMANDS_BIT,
                 timeout_ns.min(i32::MAX as u32) as i32,
             )
         };
 
+        drop(sync);
+
         let signalled = match status {
             glow::ALREADY_SIGNALED | glow::CONDITION_SATISFIED => true,
             glow::TIMEOUT_EXPIRED | glow::WAIT_FAILED => false,
@@ -159,9 +188,13 @@ impl Fence {
             return;
         }
 
-        for gl_fence in self.pending {
+        for gl_fence in self.pending.into_inner() {
             unsafe {
-                gl.delete_sync(gl_fence.sync);
+                gl.delete_sync(
+                    Arc::into_inner(gl_fence.sync)
+                        .expect("A function has failed to drop all its references to this")
+                        .into_inner(),
+                );
             }
         }
     }

wgpu-hal/src/gles/queue.rs

@@ -1901,7 +1901,7 @@ impl crate::Queue for super::Queue {
         &self,
         command_buffers: &[&super::CommandBuffer],
         _surface_textures: &[&super::Texture],
-        (signal_fence, signal_value): (&mut super::Fence, crate::FenceValue),
+        (signal_fence, signal_value): (&super::Fence, crate::FenceValue),
     ) -> Result<(), crate::DeviceError> {
         let shared = Arc::clone(&self.shared);
         let gl = &shared.context.lock();