ratomic 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26ce16d80118e646fc2ba303d9571820f3fcaee5e16a0f4bdf759d213169c04a
-  data.tar.gz: 0ed04ad6cbb1550954e66922436337927a365b492cdce1208f7dacedbb54b463
+  metadata.gz: 764ab083a8815f4f2bd0958be83d5209b10b21d8765dc19720fedd6d042eec89
+  data.tar.gz: 5bf02090ace17e0ca172bcc9f9f2a56f79030f0a92ecf669adecba72aa2ec641
 SHA512:
-  metadata.gz: 29e4ac24a57f8d01f7fa4e16741358c82b7ce2c1ba599f31b6fe01f95f8670047c59d545d15697f61b5f3639a805027a03d91c1a12768558ee6bf8dd54b77ea8
-  data.tar.gz: 2994138cff4ef33a4498e93fc841ed4f35a891157c805190a3afbd58d3451f609954b2af59c59d8352a2e21939f0114cac0a0745e9c31d0a03bd2e3a1174b1a4
+  metadata.gz: c7a3e86bfe551b27b28af6655bd7853c1be683d69e759d6b628388282e7443030fe8b56c7e036e1c25f8234de74052fc621747eb94484e84e979b771aaf7ebcc
+  data.tar.gz: 03e9c06d8c5771ab340e1219113b5f67c05da3e97c5ad2a5b7ddefb9e5b54103988eb6cb7c299e09a0808e27fec660b3eaea8a7a3fc200a5aa8dd84161faf484

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## 0.4.2
+
+### Fixed
+
+- Prevent `Map#compute` from deadlocking when multiple Ruby threads contend for the same key.
+
 ## 0.4.1
 
 ### Documentation

data/ext/ratomic/src/hashmap.rs

@@ -54,6 +54,21 @@ impl MapStore {
         self.map.len()
     }
 
+    fn with_entry<F, R, W>(&self, key: VALUE, mut on_locked: W, f: F) -> R
+    where
+        F: FnOnce(Entry<'_, RubyHashEql, VALUE>) -> R,
+        W: FnMut(),
+    {
+        let mut f = Some(f);
+        loop {
+            if let Some(entry) = self.map.try_entry(RubyHashEql(key)) {
+                return f.take().expect("entry closure already used")(entry);
+            }
+
+            on_locked();
+        }
+    }
+
     pub fn fetch_and_modify<F>(&self, key: VALUE, f: F)
     where
         F: FnOnce(VALUE) -> VALUE,
@@ -61,11 +76,18 @@ impl MapStore {
         self.map.alter(&RubyHashEql(key), |_, value| f(value));
     }
 
-    pub fn compute<F, E>(&self, key: VALUE, missing: VALUE, f: F) -> Result<VALUE, E>
+    pub fn compute<F, E, W>(
+        &self,
+        key: VALUE,
+        missing: VALUE,
+        on_locked: W,
+        f: F,
+    ) -> Result<VALUE, E>
     where
         F: FnOnce(VALUE) -> Result<VALUE, E>,
+        W: FnMut(),
     {
-        match self.map.entry(RubyHashEql(key)) {
+        self.with_entry(key, on_locked, |entry| match entry {
             Entry::Occupied(mut entry) => {
                 let new_value = f(*entry.get())?;
                 entry.insert(new_value);
@@ -76,7 +98,7 @@ impl MapStore {
                 entry.insert(new_value);
                 Ok(new_value)
             }
-        }
+        })
     }
 
     pub fn update<F, E>(&self, key: VALUE, f: F) -> Result<VALUE, E>

data/ext/ratomic/src/lib.rs

@@ -18,7 +18,7 @@ use magnus::{
 use mpmc_queue::MpmcQueue;
 use parking_lot::Mutex;
 use rb_sys::{rb_ext_ractor_safe, rb_thread_call_without_gvl, ruby_special_consts, VALUE};
-use std::{ffi::c_void, mem::transmute};
+use std::{ffi::c_void, mem::transmute, time::Duration};
 
 fn value_to_raw(value: Value) -> VALUE {
     unsafe { transmute::<Value, VALUE>(value) }
@@ -38,6 +38,22 @@ fn make_shareable(ruby: &Ruby, value: Value) -> Result<Value, Error> {
     ractor.funcall("make_shareable", (value,))
 }
 
+unsafe extern "C" fn sleep_briefly_without_gvl(_: *mut c_void) -> *mut c_void {
+    std::thread::sleep(Duration::from_millis(1));
+    std::ptr::null_mut()
+}
+
+fn wait_for_entry_without_gvl() {
+    unsafe {
+        rb_thread_call_without_gvl(
+            Some(sleep_briefly_without_gvl),
+            std::ptr::null_mut(),
+            None,
+            std::ptr::null_mut(),
+        );
+    }
+}
+
 struct Counter(AtomicCounter);
 
 impl Counter {
@@ -158,10 +174,15 @@ impl HashMap {
         }
 
         let proc = ruby.block_proc()?;
-        let raw = rb_self.0.compute(value_to_raw(key), qnil_raw(), |value| {
-            proc.call::<_, Value>((unsafe { value_from_raw(value) },))
-                .map(value_to_raw)
-        })?;
+        let raw = rb_self.0.compute(
+            value_to_raw(key),
+            qnil_raw(),
+            wait_for_entry_without_gvl,
+            |value| {
+                proc.call::<_, Value>((unsafe { value_from_raw(value) },))
+                    .map(value_to_raw)
+            },
+        )?;
 
         Ok(unsafe { value_from_raw(raw) }.into_value_with(ruby))
     }

data/lib/ratomic/version.rb

@@ -2,5 +2,5 @@
 
 module Ratomic
   # Current gem version string.
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ratomic
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Mike Perham
@@ -81,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Ractor-safe concurrent data structures for Ruby
 test_files: []