make signal sync

packages/generational-box/Cargo.toml

@@ -8,10 +8,16 @@ edition = "2018"
 
 [dependencies]
 bumpalo = { version = "3.6" }
+parking_lot = "0.12.1"
 
 [dev-dependencies]
 rand = "0.8.5"
+criterion = "0.3"
 
 [features]
 default = ["check_generation"]
 check_generation = []
+
+[[bench]]
+name = "lock"
+harness = false

packages/generational-box/benches/lock.rs

@@ -0,0 +1,24 @@
+#![allow(unused)]
+use generational_box::{GenerationalBox, Owner, Store};
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+fn create(owner: &Owner) -> GenerationalBox<u32> {
+    owner.insert(0)
+}
+
+fn set_read(signal: GenerationalBox<u32>) -> u32 {
+    signal.set(1);
+    *signal.read()
+}
+
+fn bench_fib(c: &mut Criterion) {
+    let store = Store::default();
+    let owner = store.owner();
+    c.bench_function("create", |b| b.iter(|| create(black_box(&owner))));
+    let signal = create(&owner);
+    c.bench_function("set_read", |b| b.iter(|| set_read(black_box(signal))));
+}
+
+criterion_group!(benches, bench_fib);
+criterion_main!(benches);

packages/generational-box/src/lib.rs

@@ -1,11 +1,15 @@
 #![doc = include_str!("../README.md")]
 #![warn(missing_docs)]
 
+use parking_lot::{
+    MappedRwLockReadGuard, MappedRwLockWriteGuard, Mutex, RwLock, RwLockReadGuard, RwLockWriteGuard,
+};
 use std::{
-    cell::{Cell, Ref, RefCell, RefMut},
+    cell::RefCell,
     fmt::Debug,
     marker::PhantomData,
     rc::Rc,
+    sync::{atomic::AtomicU32, Arc},
 };
 
 use bumpalo::Bump;
@@ -29,12 +33,12 @@ fn reused() {
     let first_ptr;
     {
         let owner = store.owner();
-        first_ptr = owner.insert(1).raw.data.as_ptr();
+        first_ptr = owner.insert(1).raw.data.data_ptr();
         drop(owner);
     }
     {
         let owner = store.owner();
-        let second_ptr = owner.insert(1234).raw.data.as_ptr();
+        let second_ptr = owner.insert(1234).raw.data.data_ptr();
         assert_eq!(first_ptr, second_ptr);
         drop(owner);
     }
@@ -161,7 +165,7 @@ impl<T: 'static> Debug for GenerationalBox<T> {
         #[cfg(any(debug_assertions, feature = "check_generation"))]
         f.write_fmt(format_args!(
             "{:?}@{:?}",
-            self.raw.data.as_ptr(),
+            self.raw.data.data_ptr(),
             self.generation
         ))?;
         #[cfg(not(any(debug_assertions, feature = "check_generation")))]
@@ -175,7 +179,10 @@ impl<T: 'static> GenerationalBox<T> {
     fn validate(&self) -> bool {
         #[cfg(any(debug_assertions, feature = "check_generation"))]
         {
-            self.raw.generation.get() == self.generation
+            self.raw
+                .generation
+                .load(std::sync::atomic::Ordering::Relaxed)
+                == self.generation
         }
         #[cfg(not(any(debug_assertions, feature = "check_generation")))]
         {
@@ -184,10 +191,10 @@ impl<T: 'static> GenerationalBox<T> {
     }
 
     /// Try to read the value. Returns None if the value is no longer valid.
-    pub fn try_read(&self) -> Option<Ref<'static, T>> {
+    pub fn try_read(&self) -> Option<MappedRwLockReadGuard<'static, T>> {
         self.validate()
             .then(|| {
-                Ref::filter_map(self.raw.data.borrow(), |any| {
+                RwLockReadGuard::try_map(self.raw.data.read(), |any| {
                     any.as_ref()?.downcast_ref::<T>()
                 })
                 .ok()
@@ -196,15 +203,15 @@ impl<T: 'static> GenerationalBox<T> {
     }
 
     /// Read the value. Panics if the value is no longer valid.
-    pub fn read(&self) -> Ref<'static, T> {
+    pub fn read(&self) -> MappedRwLockReadGuard<'static, T> {
         self.try_read().unwrap()
     }
 
     /// Try to write the value. Returns None if the value is no longer valid.
-    pub fn try_write(&self) -> Option<RefMut<'static, T>> {
+    pub fn try_write(&self) -> Option<MappedRwLockWriteGuard<'static, T>> {
         self.validate()
             .then(|| {
-                RefMut::filter_map(self.raw.data.borrow_mut(), |any| {
+                RwLockWriteGuard::try_map(self.raw.data.write(), |any| {
                     any.as_mut()?.downcast_mut::<T>()
                 })
                 .ok()
@@ -213,14 +220,14 @@ impl<T: 'static> GenerationalBox<T> {
     }
 
     /// Write the value. Panics if the value is no longer valid.
-    pub fn write(&self) -> RefMut<'static, T> {
+    pub fn write(&self) -> MappedRwLockWriteGuard<'static, T> {
         self.try_write().unwrap()
     }
 
     /// Set the value. Panics if the value is no longer valid.
     pub fn set(&self, value: T) {
         self.validate().then(|| {
-            *self.raw.data.borrow_mut() = Some(Box::new(value));
+            *self.raw.data.write() = Some(Box::new(value));
         });
     }
 
@@ -228,7 +235,8 @@ impl<T: 'static> GenerationalBox<T> {
     pub fn ptr_eq(&self, other: &Self) -> bool {
         #[cfg(any(debug_assertions, feature = "check_generation"))]
         {
-            self.raw.data.as_ptr() == other.raw.data.as_ptr() && self.generation == other.generation
+            self.raw.data.data_ptr() == other.raw.data.data_ptr()
+                && self.generation == other.generation
         }
         #[cfg(not(any(debug_assertions, feature = "check_generation")))]
         {
@@ -247,25 +255,26 @@ impl<T> Clone for GenerationalBox<T> {
 
 #[derive(Clone, Copy)]
 struct MemoryLocation {
-    data: &'static RefCell<Option<Box<dyn std::any::Any>>>,
+    data: &'static RwLock<Option<Box<dyn std::any::Any>>>,
     #[cfg(any(debug_assertions, feature = "check_generation"))]
-    generation: &'static Cell<u32>,
+    generation: &'static AtomicU32,
 }
 
 impl MemoryLocation {
     #[allow(unused)]
     fn drop(&self) {
-        let old = self.data.borrow_mut().take();
+        let old = self.data.write().take();
         #[cfg(any(debug_assertions, feature = "check_generation"))]
         if old.is_some() {
             drop(old);
-            let new_generation = self.generation.get() + 1;
-            self.generation.set(new_generation);
+            let new_generation = self.generation.load(std::sync::atomic::Ordering::Relaxed) + 1;
+            self.generation
+                .store(new_generation, std::sync::atomic::Ordering::Relaxed);
         }
     }
 
     fn replace<T: 'static>(&mut self, value: T) -> GenerationalBox<T> {
-        let mut inner_mut = self.data.borrow_mut();
+        let mut inner_mut = self.data.write();
 
         let raw = Box::new(value);
         let old = inner_mut.replace(raw);
@@ -273,7 +282,7 @@ impl MemoryLocation {
         GenerationalBox {
             raw: *self,
             #[cfg(any(debug_assertions, feature = "check_generation"))]
-            generation: self.generation.get(),
+            generation: self.generation.load(std::sync::atomic::Ordering::Relaxed),
             _marker: PhantomData,
         }
     }
@@ -282,14 +291,12 @@ impl MemoryLocation {
 /// Handles recycling generational boxes that have been dropped. Your application should have one store or one store per thread.
 #[derive(Clone)]
 pub struct Store {
-    bump: &'static Bump,
-    recycled: Rc<RefCell<Vec<MemoryLocation>>>,
+    recycled: Arc<Mutex<Vec<MemoryLocation>>>,
 }
 
 impl Default for Store {
     fn default() -> Self {
         Self {
-            bump: Box::leak(Box::new(Bump::new())),
             recycled: Default::default(),
         }
     }
@@ -298,18 +305,18 @@ impl Default for Store {
 impl Store {
     fn recycle(&self, location: MemoryLocation) {
         location.drop();
-        self.recycled.borrow_mut().push(location);
+        self.recycled.lock().push(location);
     }
 
     fn claim(&self) -> MemoryLocation {
-        if let Some(location) = self.recycled.borrow_mut().pop() {
+        if let Some(location) = self.recycled.lock().pop() {
             location
         } else {
-            let data: &'static RefCell<_> = self.bump.alloc(RefCell::new(None));
+            let data: &'static RwLock<_> = Box::leak(Box::new(RwLock::new(None)));
             MemoryLocation {
                 data,
                 #[cfg(any(debug_assertions, feature = "check_generation"))]
-                generation: self.bump.alloc(Cell::new(0)),
+                generation: Box::leak(Box::new(Default::default())),
             }
         }
     }
@@ -344,7 +351,9 @@ impl Owner {
         GenerationalBox {
             raw: location,
             #[cfg(any(debug_assertions, feature = "check_generation"))]
-            generation: location.generation.get(),
+            generation: location
+                .generation
+                .load(std::sync::atomic::Ordering::Relaxed),
             _marker: PhantomData,
         }
     }

packages/signals/Cargo.toml

@@ -12,6 +12,8 @@ generational-box = { workspace = true }
 tracing = { workspace = true }
 simple_logger = "4.2.0"
 serde = { version = "1", features = ["derive"], optional = true }
+parking_lot = "0.12.1"
+once_cell = "1.18.0"
 
 [dev-dependencies]
 dioxus = { workspace = true }

packages/signals/src/impls.rs

@@ -1,7 +1,6 @@
 use crate::rt::CopyValue;
 use crate::signal::{ReadOnlySignal, Signal, Write};
-
-use std::cell::{Ref, RefMut};
+use parking_lot::{MappedRwLockReadGuard, MappedRwLockWriteGuard};
 
 use std::{
     fmt::{Debug, Display},
@@ -38,8 +37,8 @@ macro_rules! read_impls {
 
         impl<T: 'static> $ty<Vec<T>> {
             /// Read a value from the inner vector.
-            pub fn get(&self, index: usize) -> Option<Ref<'_, T>> {
-                Ref::filter_map(self.read(), |v| v.get(index)).ok()
+            pub fn get(&self, index: usize) -> Option<MappedRwLockReadGuard<'static, T>> {
+                MappedRwLockReadGuard::try_map(self.read(), |v| v.get(index)).ok()
             }
         }
 
@@ -53,8 +52,8 @@ macro_rules! read_impls {
             }
 
             /// Attemps to read the inner value of the Option.
-            pub fn as_ref(&self) -> Option<Ref<'_, T>> {
-                Ref::filter_map(self.read(), |v| v.as_ref()).ok()
+            pub fn as_ref(&self) -> Option<MappedRwLockReadGuard<'static, T>> {
+                MappedRwLockReadGuard::try_map(self.read(), |v| v.as_ref()).ok()
             }
         }
     };
@@ -182,19 +181,22 @@ macro_rules! write_impls {
             }
 
             /// Gets the value out of the Option, or inserts the given value if the Option is empty.
-            pub fn get_or_insert(&self, default: T) -> Ref<'_, T> {
+            pub fn get_or_insert(&self, default: T) -> MappedRwLockReadGuard<'_, T> {
                 self.get_or_insert_with(|| default)
             }
 
             /// Gets the value out of the Option, or inserts the value returned by the given function if the Option is empty.
-            pub fn get_or_insert_with(&self, default: impl FnOnce() -> T) -> Ref<'_, T> {
+            pub fn get_or_insert_with(
+                &self,
+                default: impl FnOnce() -> T,
+            ) -> MappedRwLockReadGuard<'_, T> {
                 let borrow = self.read();
                 if borrow.is_none() {
                     drop(borrow);
                     self.with_mut(|v| *v = Some(default()));
-                    Ref::map(self.read(), |v| v.as_ref().unwrap())
+                    MappedRwLockReadGuard::map(self.read(), |v| v.as_ref().unwrap())
                 } else {
-                    Ref::map(borrow, |v| v.as_ref().unwrap())
+                    MappedRwLockReadGuard::map(borrow, |v| v.as_ref().unwrap())
                 }
             }
         }
@@ -238,15 +240,15 @@ impl<T: Clone + 'static> IntoIterator for CopyValue<Vec<T>> {
 
 impl<T: 'static> CopyValue<Vec<T>> {
     /// Write to an element in the inner vector.
-    pub fn get_mut(&self, index: usize) -> Option<RefMut<'_, T>> {
-        RefMut::filter_map(self.write(), |v| v.get_mut(index)).ok()
+    pub fn get_mut(&self, index: usize) -> Option<MappedRwLockWriteGuard<'static, T>> {
+        MappedRwLockWriteGuard::try_map(self.write(), |v| v.get_mut(index)).ok()
     }
 }
 
 impl<T: 'static> CopyValue<Option<T>> {
     /// Deref the inner value mutably.
-    pub fn as_mut(&self) -> Option<RefMut<'_, T>> {
-        RefMut::filter_map(self.write(), |v| v.as_mut()).ok()
+    pub fn as_mut(&self) -> Option<MappedRwLockWriteGuard<'static, T>> {
+        MappedRwLockWriteGuard::try_map(self.write(), |v| v.as_mut()).ok()
     }
 }
 
@@ -281,14 +283,14 @@ impl<T: Clone + 'static> IntoIterator for Signal<Vec<T>> {
 
 impl<T: 'static> Signal<Vec<T>> {
     /// Returns a reference to an element or `None` if out of bounds.
-    pub fn get_mut(&self, index: usize) -> Option<Write<'_, T, Vec<T>>> {
+    pub fn get_mut(&self, index: usize) -> Option<Write<T, Vec<T>>> {
         Write::filter_map(self.write(), |v| v.get_mut(index))
     }
 }
 
 impl<T: 'static> Signal<Option<T>> {
     /// Returns a reference to an element or `None` if out of bounds.
-    pub fn as_mut(&self) -> Option<Write<'_, T, Option<T>>> {
+    pub fn as_mut(&self) -> Option<Write<T, Option<T>>> {
         Write::filter_map(self.write(), |v| v.as_mut())
     }
 }

packages/signals/src/rt.rs

@@ -1,5 +1,3 @@
-use std::cell::{Ref, RefMut};
-
 use std::mem::MaybeUninit;
 use std::ops::Deref;
 use std::rc::Rc;
@@ -8,9 +6,12 @@ use dioxus_core::prelude::*;
 use dioxus_core::ScopeId;
 
 use generational_box::{GenerationalBox, Owner, Store};
+use parking_lot::{MappedRwLockReadGuard, MappedRwLockWriteGuard};
 
 use crate::Effect;
 
+static STORE: once_cell::sync::Lazy<Store> = once_cell::sync::Lazy::new(Store::default);
+
 fn current_store() -> Store {
     match consume_context() {
         Some(rt) => rt,
@@ -117,22 +118,22 @@ impl<T: 'static> CopyValue<T> {
     }
 
     /// Try to read the value. If the value has been dropped, this will return None.
-    pub fn try_read(&self) -> Option<Ref<'_, T>> {
+    pub fn try_read(&self) -> Option<MappedRwLockReadGuard<'static, T>> {
         self.value.try_read()
     }
 
     /// Read the value. If the value has been dropped, this will panic.
-    pub fn read(&self) -> Ref<'static, T> {
+    pub fn read(&self) -> MappedRwLockReadGuard<'static, T> {
         self.value.read()
     }
 
     /// Try to write the value. If the value has been dropped, this will return None.
-    pub fn try_write(&self) -> Option<RefMut<'static, T>> {
+    pub fn try_write(&self) -> Option<MappedRwLockWriteGuard<'static, T>> {
         self.value.try_write()
     }
 
     /// Write the value. If the value has been dropped, this will panic.
-    pub fn write(&self) -> RefMut<'static, T> {
+    pub fn write(&self) -> MappedRwLockWriteGuard<'static, T> {
         self.value.write()
     }
 
@@ -168,7 +169,7 @@ impl<T: 'static> PartialEq for CopyValue<T> {
 }
 
 impl<T> Deref for CopyValue<T> {
-    type Target = dyn Fn() -> Ref<'static, T>;
+    type Target = dyn Fn() -> MappedRwLockReadGuard<'static, T>;
 
     fn deref(&self) -> &Self::Target {
         // https://github.com/dtolnay/case-studies/tree/master/callable-types

packages/signals/src/signal.rs

@@ -1,5 +1,5 @@
 use std::{
-    cell::{Ref, RefCell, RefMut},
+    cell::RefCell,
     mem::MaybeUninit,
     ops::{Deref, DerefMut},
     rc::Rc,
@@ -10,6 +10,7 @@ use dioxus_core::{
     prelude::{current_scope_id, has_context, provide_context, schedule_update_any},
     ScopeId, ScopeState,
 };
+use parking_lot::{MappedRwLockReadGuard, MappedRwLockWriteGuard};
 
 use crate::{get_effect_stack, CopyValue, Effect, EffectStack};
 
@@ -173,7 +174,7 @@ impl<T: 'static> Signal<T> {
 
     /// Get the current value of the signal. This will subscribe the current scope to the signal.
     /// If the signal has been dropped, this will panic.
-    pub fn read(&self) -> Ref<T> {
+    pub fn read(&self) -> MappedRwLockReadGuard<'static, T> {
         let inner = self.inner.read();
         if let Some(effect) = inner.effect_stack.current() {
             let mut effect_subscribers = inner.effect_subscribers.borrow_mut();
@@ -197,14 +198,14 @@ impl<T: 'static> Signal<T> {
                 }
             }
         }
-        Ref::map(inner, |v| &v.value)
+        MappedRwLockReadGuard::map(inner, |v| &v.value)
     }
 
     /// Get a mutable reference to the signal's value.
     /// If the signal has been dropped, this will panic.
-    pub fn write(&self) -> Write<'_, T> {
+    pub fn write(&self) -> Write<T> {
         let inner = self.inner.write();
-        let borrow = RefMut::map(inner, |v| &mut v.value);
+        let borrow = MappedRwLockWriteGuard::map(inner, |v| &mut v.value);
         Write {
             write: borrow,
             signal: SignalSubscriberDrop { signal: *self },
@@ -281,7 +282,7 @@ impl<T: 'static> PartialEq for Signal<T> {
 }
 
 impl<T> Deref for Signal<T> {
-    type Target = dyn Fn() -> Ref<'static, T>;
+    type Target = dyn Fn() -> MappedRwLockReadGuard<'static, T>;
 
     fn deref(&self) -> &Self::Target {
         // https://github.com/dtolnay/case-studies/tree/master/callable-types
@@ -324,17 +325,17 @@ impl<T: 'static> Drop for SignalSubscriberDrop<T> {
 }
 
 /// A mutable reference to a signal's value.
-pub struct Write<'a, T: 'static, I: 'static = T> {
-    write: RefMut<'a, T>,
+pub struct Write<T: 'static, I: 'static = T> {
+    write: MappedRwLockWriteGuard<'static, T>,
     signal: SignalSubscriberDrop<I>,
 }
 
-impl<'a, T: 'static, I: 'static> Write<'a, T, I> {
+impl<T: 'static, I: 'static> Write<T, I> {
     /// Map the mutable reference to the signal's value to a new type.
-    pub fn map<O>(myself: Self, f: impl FnOnce(&mut T) -> &mut O) -> Write<'a, O, I> {
+    pub fn map<O>(myself: Self, f: impl FnOnce(&mut T) -> &mut O) -> Write<O, I> {
         let Self { write, signal } = myself;
         Write {
-            write: RefMut::map(write, f),
+            write: MappedRwLockWriteGuard::map(write, f),
             signal,
         }
     }
@@ -343,14 +344,14 @@ impl<'a, T: 'static, I: 'static> Write<'a, T, I> {
     pub fn filter_map<O>(
         myself: Self,
         f: impl FnOnce(&mut T) -> Option<&mut O>,
-    ) -> Option<Write<'a, O, I>> {
+    ) -> Option<Write<O, I>> {
         let Self { write, signal } = myself;
-        let write = RefMut::filter_map(write, f).ok();
+        let write = MappedRwLockWriteGuard::try_map(write, f).ok();
         write.map(|write| Write { write, signal })
     }
 }
 
-impl<'a, T: 'static, I: 'static> Deref for Write<'a, T, I> {
+impl<T: 'static, I: 'static> Deref for Write<T, I> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
@@ -358,7 +359,7 @@ impl<'a, T: 'static, I: 'static> Deref for Write<'a, T, I> {
     }
 }
 
-impl<T, I> DerefMut for Write<'_, T, I> {
+impl<T, I> DerefMut for Write<T, I> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.write
     }
@@ -381,7 +382,7 @@ impl<T: 'static> ReadOnlySignal<T> {
     }
 
     /// Get the current value of the signal. This will subscribe the current scope to the signal.
-    pub fn read(&self) -> Ref<T> {
+    pub fn read(&self) -> MappedRwLockReadGuard<'static, T> {
         self.inner.read()
     }
 
@@ -405,7 +406,7 @@ impl<T: 'static> PartialEq for ReadOnlySignal<T> {
 }
 
 impl<T> Deref for ReadOnlySignal<T> {
-    type Target = dyn Fn() -> Ref<'static, T>;
+    type Target = dyn Fn() -> MappedRwLockReadGuard<'static, T>;
 
     fn deref(&self) -> &Self::Target {
         // https://github.com/dtolnay/case-studies/tree/master/callable-types