Use atomic_refcell instead of parking_lot for wasm32 targets (#1404)

Closes https://github.com/emilk/egui/issues/1401

epaint/Cargo.toml

@@ -56,9 +56,17 @@ ahash = { version = "0.7", default-features = false, features = ["std"] }
 bytemuck = { version = "1.7.2", optional = true, features = ["derive"] }
 cint = { version = "^0.2.2", optional = true }
 nohash-hasher = "0.2"
-parking_lot = "0.12"                                                      # Using parking_lot over std::sync::Mutex gives 50% speedups in some real-world scenarios.
 serde = { version = "1", optional = true, features = ["derive", "rc"] }
 
+# native:
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+parking_lot = "0.12" # Using parking_lot over std::sync::Mutex gives 50% speedups in some real-world scenarios.
+
+# web:
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+atomic_refcell = "0.1" # Used instead of parking_lot on on wasm. See https://github.com/emilk/egui/issues/1401
+
+
 [dev-dependencies]
 criterion = { version = "0.3", default-features = false }
 

epaint/src/mutex.rs

@@ -2,9 +2,12 @@
 
 // ----------------------------------------------------------------------------
 
+#[cfg(not(target_arch = "wasm32"))]
 #[cfg(not(debug_assertions))]
 mod mutex_impl {
     /// Provides interior mutability.
+    ///
+    /// Uses `parking_lot` crate on native targets, and `atomic_refcell` on `wasm32` targets.
     #[derive(Default)]
     pub struct Mutex<T>(parking_lot::Mutex<T>);
 
@@ -24,9 +27,12 @@ mod mutex_impl {
     }
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 #[cfg(debug_assertions)]
 mod mutex_impl {
     /// Provides interior mutability.
+    ///
+    /// Uses `parking_lot` crate on native targets, and `atomic_refcell` on `wasm32` targets.
     #[derive(Default)]
     pub struct Mutex<T>(parking_lot::Mutex<T>);
 
@@ -104,6 +110,7 @@ mod mutex_impl {
     }
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 mod rw_lock_impl {
     /// The lock you get from [`RwLock::read`].
     pub use parking_lot::MappedRwLockReadGuard as RwLockReadGuard;
@@ -112,6 +119,8 @@ mod rw_lock_impl {
     pub use parking_lot::MappedRwLockWriteGuard as RwLockWriteGuard;
 
     /// Provides interior mutability.
+    ///
+    /// Uses `parking_lot` crate on native targets, and `atomic_refcell` on `wasm32` targets.
     #[derive(Default)]
     pub struct RwLock<T>(parking_lot::RwLock<T>);
 
@@ -133,12 +142,83 @@ mod rw_lock_impl {
     }
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 mod arc_impl {
     pub use std::sync::Arc;
 }
 
 // ----------------------------------------------------------------------------
 
+#[cfg(target_arch = "wasm32")]
+mod mutex_impl {
+    // `atomic_refcell` will panic if multiple threads try to access the same value
+
+    /// Provides interior mutability.
+    ///
+    /// Uses `parking_lot` crate on native targets, and `atomic_refcell` on `wasm32` targets.
+    #[derive(Default)]
+    pub struct Mutex<T>(atomic_refcell::AtomicRefCell<T>);
+
+    /// The lock you get from [`Mutex`].
+    pub use atomic_refcell::AtomicRefMut as MutexGuard;
+
+    impl<T> Mutex<T> {
+        #[inline(always)]
+        pub fn new(val: T) -> Self {
+            Self(atomic_refcell::AtomicRefCell::new(val))
+        }
+
+        /// Panics if already locked.
+        #[inline(always)]
+        pub fn lock(&self) -> MutexGuard<'_, T> {
+            self.0.borrow_mut()
+        }
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+mod rw_lock_impl {
+    // `atomic_refcell` will panic if multiple threads try to access the same value
+
+    /// The lock you get from [`RwLock::read`].
+    pub use atomic_refcell::AtomicRef as RwLockReadGuard;
+
+    /// The lock you get from [`RwLock::write`].
+    pub use atomic_refcell::AtomicRefMut as RwLockWriteGuard;
+
+    /// Provides interior mutability.
+    ///
+    /// Uses `parking_lot` crate on native targets, and `atomic_refcell` on `wasm32` targets.
+    #[derive(Default)]
+    pub struct RwLock<T>(atomic_refcell::AtomicRefCell<T>);
+
+    impl<T> RwLock<T> {
+        #[inline(always)]
+        pub fn new(val: T) -> Self {
+            Self(atomic_refcell::AtomicRefCell::new(val))
+        }
+
+        #[inline(always)]
+        pub fn read(&self) -> RwLockReadGuard<'_, T> {
+            self.0.borrow()
+        }
+
+        /// Panics if already locked.
+        #[inline(always)]
+        pub fn write(&self) -> RwLockWriteGuard<'_, T> {
+            self.0.borrow_mut()
+        }
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+mod arc_impl {
+    // pub use std::rc::Rc as Arc; // TODO(emilk): optimize single threaded code by using `Rc` instead of `Arc`.
+    pub use std::sync::Arc;
+}
+
+// ----------------------------------------------------------------------------
+
 pub use arc_impl::Arc;
 pub use mutex_impl::{Mutex, MutexGuard};
 pub use rw_lock_impl::{RwLock, RwLockReadGuard, RwLockWriteGuard};