Use atomic_refcell instead of parking_lot for wasm32 targets

eframe/Cargo.toml

@@ -71,6 +71,5 @@ image = { version = "0.24", default-features = false, features = [
   "jpeg",
   "png",
 ] }
-parking_lot = "0.12"
 poll-promise = "0.1"
 rfd = "0.8"

eframe/examples/custom_3d.rs

@@ -11,7 +11,7 @@
 
 use eframe::egui;
 
-use parking_lot::Mutex;
+use egui::mutex::Mutex;
 use std::sync::Arc;
 
 fn main() {

egui_extras/Cargo.toml

@@ -28,7 +28,6 @@ svg = ["resvg", "tiny-skia", "usvg"]
 
 [dependencies]
 egui = { version = "0.17.0", path = "../egui", default-features = false }
-parking_lot = "0.12"
 
 # Optional dependencies:
 

egui_extras/src/image.rs

@@ -1,4 +1,4 @@
-use parking_lot::Mutex;
+use egui::mutex::Mutex;
 
 /// An image to be shown in egui.
 ///

egui_glow/Cargo.toml

@@ -63,7 +63,6 @@ epi = { version = "0.17.0", path = "../epi", optional = true }
 bytemuck = "1.7"
 glow = "0.11"
 memoffset = "0.6"
-parking_lot = "0.12"
 tracing = "0.1"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

egui_glow/src/epi_backend.rs

@@ -54,7 +54,7 @@ pub fn run(app_name: &str, native_options: &epi::NativeOptions, app_creator: epi
     );
 
     {
-        let event_loop_proxy = parking_lot::Mutex::new(event_loop.create_proxy());
+        let event_loop_proxy = egui::mutex::Mutex::new(event_loop.create_proxy());
         integration.egui_ctx.set_request_repaint_callback(move || {
             event_loop_proxy.lock().send_event(RequestRepaintEvent).ok();
         });

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};