[wgpu-core]: Switch to wgpu-types for locking primitives

bushrat011899 · bushrat011899 · commit 78341a4e79a0 · 2026-07-31T20:19:51.000+10:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/wgpu-core/Cargo.toml b/wgpu-core/Cargo.toml
@@ -199,7 +199,6 @@ indexmap.workspace = true
 log.workspace = true
 macro_rules_attribute = { workspace = true, optional = true }
 once_cell = { workspace = true, features = ["std"] }
-parking_lot.workspace = true
 profiling = { workspace = true, default-features = false }
 raw-window-handle.workspace = true
 ron = { workspace = true, optional = true }
@@ -211,5 +210,11 @@ thiserror.workspace = true
 [target.'cfg(not(target_has_atomic = "64"))'.dependencies]
 portable-atomic = { workspace = true, optional = true }
 
+[target.'cfg(not(target_family = "wasm"))'.dependencies]
+# FIXME: Native platforms mandate `Send`/`Sync`, which is only possible with `std` enabled.
+wgpu-types = { workspace = true, features = [
+    "std",
+] }
+
 [build-dependencies]
 cfg_aliases.workspace = true
diff --git a/wgpu-core/src/command/compute.rs b/wgpu-core/src/command/compute.rs
@@ -1,5 +1,5 @@
-use parking_lot::Mutex;
 use thiserror::Error;
+use wgpu_types::sync::Mutex;
 use wgt::{
     error::{ErrorType, WebGpuError},
     BufferAddress, DynamicOffset,
diff --git a/wgpu-core/src/command/render.rs b/wgpu-core/src/command/render.rs
@@ -1,7 +1,7 @@
 use alloc::{borrow::Cow, boxed::Box, sync::Arc, vec::Vec};
 use core::{convert::Infallible, fmt, num::NonZeroU32, ops::Range, str};
-use parking_lot::Mutex;
 use smallvec::SmallVec;
+use wgpu_types::sync::Mutex;
 
 use arrayvec::ArrayVec;
 use thiserror::Error;
diff --git a/wgpu-core/src/device/global.rs b/wgpu-core/src/device/global.rs
@@ -712,7 +712,7 @@ impl Global {
         // no lock rank here because only one thread should be using compute pass
         // and it's only used by id variants of compute pass methods on global
         // so no deadlock (or concurrent lock) should happen in practise
-        let id = fid.assign(Arc::new(parking_lot::Mutex::new(*render_bundle_encoder)));
+        let id = fid.assign(Arc::new(wgt::sync::Mutex::new(*render_bundle_encoder)));
 
         (id, error)
     }
diff --git a/wgpu-core/src/device/resource.rs b/wgpu-core/src/device/resource.rs
@@ -205,13 +205,11 @@ impl ExternalTextureParams {
 
 /// Because all operations are push/swap (no longlived lock),
 /// we can have mutex without lock rank
-pub(crate) struct DeferredBufferMapPendingClosures(
-    parking_lot::Mutex<Vec<BufferMapPendingClosure>>,
-);
+pub(crate) struct DeferredBufferMapPendingClosures(wgt::sync::Mutex<Vec<BufferMapPendingClosure>>);
 
 impl DeferredBufferMapPendingClosures {
     pub(crate) fn new() -> Self {
-        Self(parking_lot::Mutex::new(Vec::new()))
+        Self(wgt::sync::Mutex::new(Vec::new()))
     }
 
     pub(crate) fn push(&self, closure: BufferMapPendingClosure) {
diff --git a/wgpu-core/src/hub.rs b/wgpu-core/src/hub.rs
@@ -134,7 +134,7 @@ use crate::{
     },
 };
 
-use parking_lot::Mutex;
+use wgpu_types::sync::Mutex;
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct HubReport {
diff --git a/wgpu-core/src/lock/mod.rs b/wgpu-core/src/lock/mod.rs
@@ -27,8 +27,8 @@
 //!
 //! Otherwise, `wgpu-core` uses the [`vanilla`] module's locks.
 //!
-//! [`Mutex`]: parking_lot::Mutex
-//! [`RwLock`]: parking_lot::RwLock
+//! [`Mutex`]: wgpu_types::sync::Mutex
+//! [`RwLock`]: wgpu_types::sync::RwLock
 //! [`SnatchLock`]: crate::snatch::SnatchLock
 
 pub mod rank;
diff --git a/wgpu-core/src/lock/observing.rs b/wgpu-core/src/lock/observing.rs
@@ -42,30 +42,30 @@ pub type RankData = Option<HeldLock>;
 
 /// A `Mutex` instrumented for lock acquisition order observation.
 ///
-/// This is just a wrapper around a [`parking_lot::Mutex`], along with
+/// This is just a wrapper around a [`wgpu_types::sync::Mutex`], along with
 /// its rank in the `wgpu_core` lock ordering.
 ///
 /// For details, see [the module documentation][self].
 pub struct Mutex<T> {
-    inner: parking_lot::Mutex<T>,
+    inner: wgpu_types::sync::Mutex<T>,
     rank: LockRank,
 }
 
 /// A guard produced by locking [`Mutex`].
 ///
-/// This is just a wrapper around a [`parking_lot::MutexGuard`], along
+/// This is just a wrapper around a [`wgpu_types::sync::MutexGuard`], along
 /// with the state needed to track lock acquisition.
 ///
 /// For details, see [the module documentation][self].
 pub struct MutexGuard<'a, T> {
-    inner: parking_lot::MutexGuard<'a, T>,
+    inner: wgpu_types::sync::MutexGuard<'a, T>,
     _state: LockStateGuard,
 }
 
 impl<T> Mutex<T> {
     pub fn new(rank: LockRank, value: T) -> Mutex<T> {
         Mutex {
-            inner: parking_lot::Mutex::new(value),
+            inner: wgpu_types::sync::Mutex::new(value),
             rank,
         }
     }
@@ -110,41 +110,41 @@ impl<T: core::fmt::Debug> core::fmt::Debug for Mutex<T> {
 
 /// An `RwLock` instrumented for lock acquisition order observation.
 ///
-/// This is just a wrapper around a [`parking_lot::RwLock`], along with
+/// This is just a wrapper around a [`wgpu_types::sync::RwLock`], along with
 /// its rank in the `wgpu_core` lock ordering.
 ///
 /// For details, see [the module documentation][self].
 pub struct RwLock<T> {
-    inner: parking_lot::RwLock<T>,
+    inner: wgpu_types::sync::RwLock<T>,
     rank: LockRank,
 }
 
 /// A read guard produced by locking [`RwLock`] for reading.
 ///
-/// This is just a wrapper around a [`parking_lot::RwLockReadGuard`], along with
+/// This is just a wrapper around a [`wgpu_types::sync::RwLockReadGuard`], along with
 /// the state needed to track lock acquisition.
 ///
 /// For details, see [the module documentation][self].
 pub struct RwLockReadGuard<'a, T> {
-    inner: parking_lot::RwLockReadGuard<'a, T>,
+    inner: wgpu_types::sync::RwLockReadGuard<'a, T>,
     _state: LockStateGuard,
 }
 
 /// A write guard produced by locking [`RwLock`] for writing.
 ///
-/// This is just a wrapper around a [`parking_lot::RwLockWriteGuard`], along
+/// This is just a wrapper around a [`wgpu_types::sync::RwLockWriteGuard`], along
 /// with the state needed to track lock acquisition.
 ///
 /// For details, see [the module documentation][self].
 pub struct RwLockWriteGuard<'a, T> {
-    inner: parking_lot::RwLockWriteGuard<'a, T>,
+    inner: wgpu_types::sync::RwLockWriteGuard<'a, T>,
     _state: LockStateGuard,
 }
 
 impl<T> RwLock<T> {
     pub fn new(rank: LockRank, value: T) -> RwLock<T> {
         RwLock {
-            inner: parking_lot::RwLock::new(value),
+            inner: wgpu_types::sync::RwLock::new(value),
             rank,
         }
     }
diff --git a/wgpu-core/src/lock/rank.rs b/wgpu-core/src/lock/rank.rs
@@ -26,8 +26,8 @@
 /// TODO(<https://github.com/gfx-rs/wgpu/issues/5572>): Resolve invalid
 /// acquisitions of DEVICE_COMMAND_INDICES followed by COMMAND_BUFFER_DATA.
 ///
-/// [`Mutex`]: parking_lot::Mutex
-/// [`RwLock`]: parking_lot::RwLock
+/// [`Mutex`]: wgpu_types::sync::Mutex
+/// [`RwLock`]: wgpu_types::sync::RwLock
 /// [`SnatchLock`]: crate::snatch::SnatchLock
 /// [`CommandBuffer::data`]: crate::command::CommandBuffer::data
 #[derive(Debug, Copy, Clone)]
diff --git a/wgpu-core/src/lock/ranked.rs b/wgpu-core/src/lock/ranked.rs
@@ -63,23 +63,23 @@ pub use LockState as RankData;
 
 /// A `Mutex` instrumented for deadlock prevention.
 ///
-/// This is just a wrapper around a [`parking_lot::Mutex`], along with
+/// This is just a wrapper around a [`wgpu_types::sync::Mutex`], along with
 /// its rank in the `wgpu_core` lock ordering.
 ///
 /// For details, see [the module documentation][self].
 pub struct Mutex<T> {
-    inner: parking_lot::Mutex<T>,
+    inner: wgpu_types::sync::Mutex<T>,
     rank: LockRank,
 }
 
 /// A guard produced by locking [`Mutex`].
 ///
-/// This is just a wrapper around a [`parking_lot::MutexGuard`], along
+/// This is just a wrapper around a [`wgpu_types::sync::MutexGuard`], along
 /// with the state needed to track lock acquisition.
 ///
 /// For details, see [the module documentation][self].
 pub struct MutexGuard<'a, T> {
-    inner: parking_lot::MutexGuard<'a, T>,
+    inner: wgpu_types::sync::MutexGuard<'a, T>,
     #[cfg_attr(not(miri), expect(unused))] // but `Drop` has important side effects
     saved: LockStateGuard,
 }
@@ -216,7 +216,7 @@ fn release(saved: LockState) {
 impl<T> Mutex<T> {
     pub fn new(rank: LockRank, value: T) -> Mutex<T> {
         Mutex {
-            inner: parking_lot::Mutex::new(value),
+            inner: wgpu_types::sync::Mutex::new(value),
             rank,
         }
     }
@@ -261,41 +261,41 @@ impl<T: fmt::Debug> fmt::Debug for Mutex<T> {
 
 /// An `RwLock` instrumented for deadlock prevention.
 ///
-/// This is just a wrapper around a [`parking_lot::RwLock`], along with
+/// This is just a wrapper around a [`wgpu_types::sync::RwLock`], along with
 /// its rank in the `wgpu_core` lock ordering.
 ///
 /// For details, see [the module documentation][self].
 pub struct RwLock<T> {
-    inner: parking_lot::RwLock<T>,
+    inner: wgpu_types::sync::RwLock<T>,
     rank: LockRank,
 }
 
 /// A read guard produced by locking [`RwLock`] for reading.
 ///
-/// This is just a wrapper around a [`parking_lot::RwLockReadGuard`], along with
+/// This is just a wrapper around a [`wgpu_types::sync::RwLockReadGuard`], along with
 /// the state needed to track lock acquisition.
 ///
 /// For details, see [the module documentation][self].
 pub struct RwLockReadGuard<'a, T> {
-    inner: parking_lot::RwLockReadGuard<'a, T>,
+    inner: wgpu_types::sync::RwLockReadGuard<'a, T>,
     saved: LockStateGuard,
 }
 
 /// A write guard produced by locking [`RwLock`] for writing.
 ///
-/// This is just a wrapper around a [`parking_lot::RwLockWriteGuard`], along
+/// This is just a wrapper around a [`wgpu_types::sync::RwLockWriteGuard`], along
 /// with the state needed to track lock acquisition.
 ///
 /// For details, see [the module documentation][self].
 pub struct RwLockWriteGuard<'a, T> {
-    inner: parking_lot::RwLockWriteGuard<'a, T>,
+    inner: wgpu_types::sync::RwLockWriteGuard<'a, T>,
     saved: LockStateGuard,
 }
 
 impl<T> RwLock<T> {
     pub fn new(rank: LockRank, value: T) -> RwLock<T> {
         RwLock {
-            inner: parking_lot::RwLock::new(value),
+            inner: wgpu_types::sync::RwLock::new(value),
             rank,
         }
     }
diff --git a/wgpu-core/src/lock/vanilla.rs b/wgpu-core/src/lock/vanilla.rs
@@ -1,4 +1,4 @@
-//! Plain, uninstrumented wrappers around [`parking_lot`] lock types.
+//! Plain, uninstrumented wrappers around [`wgpu_types::sync`] lock types.
 //!
 //! These definitions are used when no particular lock instrumentation
 //! Cargo feature is selected.
@@ -9,26 +9,26 @@ use crate::lock::rank::LockRank;
 
 pub struct RankData;
 
-/// A plain wrapper around [`parking_lot::Mutex`].
+/// A plain wrapper around [`wgpu_types::sync::Mutex`].
 ///
-/// This is just like [`parking_lot::Mutex`], except that our [`new`]
+/// This is just like [`wgpu_types::sync::Mutex`], except that our [`new`]
 /// method takes a rank, indicating where the new mutex should sit in
 /// `wgpu-core`'s lock ordering. The rank is ignored.
 ///
 /// See the [`lock`] module documentation for other wrappers.
 ///
 /// [`new`]: Mutex::new
 /// [`lock`]: crate::lock
-pub struct Mutex<T>(parking_lot::Mutex<T>);
+pub struct Mutex<T>(wgpu_types::sync::Mutex<T>);
 
 /// A guard produced by locking [`Mutex`].
 ///
-/// This is just a wrapper around a [`parking_lot::MutexGuard`].
-pub struct MutexGuard<'a, T>(parking_lot::MutexGuard<'a, T>);
+/// This is just a wrapper around a [`wgpu_types::sync::MutexGuard`].
+pub struct MutexGuard<'a, T>(wgpu_types::sync::MutexGuard<'a, T>);
 
 impl<T> Mutex<T> {
     pub fn new(_rank: LockRank, value: T) -> Mutex<T> {
-        Mutex(parking_lot::Mutex::new(value))
+        Mutex(wgpu_types::sync::Mutex::new(value))
     }
 
     pub fn lock(&self) -> MutexGuard<'_, T> {
@@ -64,31 +64,31 @@ impl<T: fmt::Debug> fmt::Debug for Mutex<T> {
     }
 }
 
-/// A plain wrapper around [`parking_lot::RwLock`].
+/// A plain wrapper around [`wgpu_types::sync::RwLock`].
 ///
-/// This is just like [`parking_lot::RwLock`], except that our [`new`]
+/// This is just like [`wgpu_types::sync::RwLock`], except that our [`new`]
 /// method takes a rank, indicating where the new mutex should sit in
 /// `wgpu-core`'s lock ordering. The rank is ignored.
 ///
 /// See the [`lock`] module documentation for other wrappers.
 ///
 /// [`new`]: RwLock::new
 /// [`lock`]: crate::lock
-pub struct RwLock<T>(parking_lot::RwLock<T>);
+pub struct RwLock<T>(wgpu_types::sync::RwLock<T>);
 
 /// A read guard produced by locking [`RwLock`] as a reader.
 ///
-/// This is just a wrapper around a [`parking_lot::RwLockReadGuard`].
-pub struct RwLockReadGuard<'a, T>(parking_lot::RwLockReadGuard<'a, T>);
+/// This is just a wrapper around a [`wgpu_types::sync::RwLockReadGuard`].
+pub struct RwLockReadGuard<'a, T>(wgpu_types::sync::RwLockReadGuard<'a, T>);
 
 /// A write guard produced by locking [`RwLock`] as a writer.
 ///
-/// This is just a wrapper around a [`parking_lot::RwLockWriteGuard`].
-pub struct RwLockWriteGuard<'a, T>(parking_lot::RwLockWriteGuard<'a, T>);
+/// This is just a wrapper around a [`wgpu_types::sync::RwLockWriteGuard`].
+pub struct RwLockWriteGuard<'a, T>(wgpu_types::sync::RwLockWriteGuard<'a, T>);
 
 impl<T> RwLock<T> {
     pub fn new(_rank: LockRank, value: T) -> RwLock<T> {
-        RwLock(parking_lot::RwLock::new(value))
+        RwLock(wgpu_types::sync::RwLock::new(value))
     }
 
     pub fn read(&self) -> RwLockReadGuard<'_, T> {
diff --git a/wgpu-core/src/storage.rs b/wgpu-core/src/storage.rs
@@ -4,7 +4,7 @@ use core::mem;
 use crate::id::{Id, Marker};
 use crate::resource::ResourceType;
 use crate::{Epoch, Index};
-use parking_lot::Mutex;
+use wgpu_types::sync::Mutex;
 
 /// An entry in a `Storage::map` table.
 #[derive(Debug)]

Original file line number	Diff line number	Diff line change
`@@ -712,7 +712,7 @@ impl Global {`
`712`	`712`	`// no lock rank here because only one thread should be using compute pass`
`713`	`713`	`// and it's only used by id variants of compute pass methods on global`
`714`	`714`	`// so no deadlock (or concurrent lock) should happen in practise`
`715`		`- let id = fid.assign(Arc::new(parking_lot::Mutex::new(*render_bundle_encoder)));`
	`715`	`+ let id = fid.assign(Arc::new(wgt::sync::Mutex::new(*render_bundle_encoder)));`
`716`	`716`
`717`	`717`	`(id, error)`
`718`	`718`	`}`