add while loop around condvar wait

luke-gruber · luke-gruber · commit 3aa4a775dc20 · 2025-07-11T14:32:04.000-04:00
diff --git a/bootstraptest/test_ractor.rb b/bootstraptest/test_ractor.rb
@@ -428,7 +428,7 @@ def test n
     end
   end
 
-  10_000.times do |i|
+  1_000.times do |i|
     echo_ractor << i
     raise unless port.receive == i
   end
@@ -452,7 +452,7 @@ def test n
         end
       end
 
-      10_000.times do |i|
+      1_000.times do |i|
         echo_ractor << i
         raise unless port.receive == i
       end
@@ -2002,6 +2002,7 @@ def initialize(a)
   r = Ractor.new port do |port|
     loop do
       obj = Ractor.receive
+      break if obj == :exit
       val = case obj
       when Hash
         obj['key'] == 'value' && obj.instance_variable_get("@b") == 'b'
@@ -2049,6 +2050,9 @@ def initialize(a)
       end
     end
   end
+
+  r << :exit
+  r.join
   'ok'
 }
 
diff --git a/ractor_sync.c b/ractor_sync.c
@@ -893,7 +893,7 @@ basket_type_name(enum ractor_basket_type type)
 
 //
 
-#else // win32
+#else // win32 + wasm
 
 static void
 ractor_cond_wait(rb_ractor_t *r, rb_thread_t *th)
@@ -903,7 +903,10 @@ ractor_cond_wait(rb_ractor_t *r, rb_thread_t *th)
     VM_ASSERT(locked_by && locked_by != Qnil);
     r->sync.locked_by = Qnil;
 #endif
-    rb_native_cond_wait(&th->sched.ractor_action_wakeup_cond, &r->sync.lock);
+    th->status = THREAD_STOPPED_FOREVER;
+    while (th->status == THREAD_STOPPED_FOREVER) {
+        rb_native_cond_wait(&th->sched.ractor_action_wakeup_cond, &r->sync.lock);
+    }
 
 #if RACTOR_CHECK_MODE > 0
     r->sync.locked_by = locked_by;
@@ -943,15 +946,14 @@ rb_ractor_sched_wait(rb_execution_context_t *ec, rb_ractor_t *cr, rb_unblock_fun
 static void
 rb_ractor_sched_wakeup(rb_ractor_t *r, rb_thread_t *th)
 {
-    RACTOR_LOCK(r);
-    {
+    if (th->status == THREAD_STOPPED_FOREVER) {
+        th->status = THREAD_RUNNABLE;
         rb_native_cond_signal(&th->sched.ractor_action_wakeup_cond);
     }
-    RACTOR_UNLOCK(r);
 }
 #endif
 
-// Wake up all ractors that are currently blocked on `rp`
+// TODO: wake up all threads on r that are currently blocked on `rp`, not all threads on r
 static void
 ractor_wakeup_all(const struct ractor_port *rp, enum ractor_wakeup_status wakeup_status)
 {
@@ -960,40 +962,21 @@ ractor_wakeup_all(const struct ractor_port *rp, enum ractor_wakeup_status wakeup
 
     RUBY_DEBUG_LOG("r:%u wakeup:%s", rb_ractor_id(r), wakeup_status_str(wakeup_status));
 
-    struct ractor_waiter *waiter;
-    struct ractor_waiter **waiters_on_port = NULL;
-    int num_waiters = 0;
     RACTOR_LOCK(r);
-    {
-        if (!ccan_list_empty(&r->sync.waiters)) {
-            ccan_list_for_each(&r->sync.waiters, waiter, node) {
-                if (waiter->wakeup_status == wakeup_none && (!waiter->port || ractor_port_id(waiter->port) == ractor_port_id(rp))) {
-                    num_waiters++;
-                }
-            }
-            if (num_waiters > 0) {
-                waiters_on_port = ALLOC_N(struct ractor_waiter*, num_waiters);
-                int i = 0;
-                ccan_list_for_each(&r->sync.waiters, waiter, node) {
-                    if (waiter->wakeup_status == wakeup_none && (!waiter->port || ractor_port_id(waiter->port) == ractor_port_id(rp))) {
-                        waiter->wakeup_status = wakeup_status;
-                        waiters_on_port[i++] = waiter;
-                    }
-                }
-                for (int i = 0; i < num_waiters; i++) {
-                    ccan_list_del(&waiters_on_port[i]->node);
-                }
-            }
+    while (1) {
+        struct ractor_waiter *waiter = ccan_list_pop(&r->sync.waiters, struct ractor_waiter, node);
+
+        if (waiter) {
+            VM_ASSERT(waiter->wakeup_status == wakeup_none);
+
+            waiter->wakeup_status = wakeup_status;
+            rb_ractor_sched_wakeup(r, waiter->th);
+        }
+        else {
+            break;
         }
     }
     RACTOR_UNLOCK(r);
-
-    for (int i = 0; i < num_waiters; i++) {
-        waiter = waiters_on_port[i];
-        RUBY_ASSERT(!waiter->port || ractor_port_id(waiter->port) == ractor_port_id(rp));
-        rb_ractor_sched_wakeup(r, waiter->th);
-    }
-    if (waiters_on_port) ruby_xfree(waiters_on_port);
 }
 
 static void
@@ -1010,22 +993,18 @@ ubf_ractor_wait(void *ptr)
 
     rb_native_mutex_unlock(&th->interrupt_lock);
     {
-        bool should_wake = false;
         RACTOR_LOCK(r);
         {
             if (waiter->wakeup_status == wakeup_none) {
                 RUBY_DEBUG_LOG("waiter:%p", (void *)waiter);
 
                 waiter->wakeup_status = wakeup_by_interrupt;
                 ccan_list_del(&waiter->node);
-                should_wake = true;
+                rb_ractor_sched_wakeup(r, th);
             }
         }
         RACTOR_UNLOCK(r);
 
-        if (should_wake) {
-            rb_ractor_sched_wakeup(r, th);
-        }
     }
     rb_native_mutex_lock(&th->interrupt_lock);
 }
@@ -1104,7 +1083,7 @@ ractor_check_received(rb_ractor_t *cr, struct ractor_queue *messages)
     return received;
 }
 
-// The port can be NULL when you're waiting on any ractor to wake you up, such as with `Ractor.select(*ractors)`
+// The port `rp` can be NULL when you're waiting on multiple ractors to wake you up, such as with `Ractor.select(*ractors)`
 static void
 ractor_wait_receive(rb_execution_context_t *ec, rb_ractor_t *cr, const struct ractor_port *rp)
 {
@@ -1114,7 +1093,7 @@ ractor_wait_receive(rb_execution_context_t *ec, rb_ractor_t *cr, const struct ra
     RACTOR_LOCK_SELF(cr);
     {
         if (ractor_check_received(cr, &messages)) {
-            deliverred = true;
+            deliverred = true; // any message was delivered, not necessarily to this port
         }
         else {
             ractor_wait(ec, cr, rp);
@@ -1432,7 +1411,7 @@ ractor_selector__wait(rb_execution_context_t *ec, VALUE selector)
             return rb_ary_new_from_args(2, data.rpv, data.v);
         }
 
-        ractor_wait_receive(ec, cr, NULL); // wait on any ractor port
+        ractor_wait_receive(ec, cr, NULL); // wait on any ractor port. TODO: should only wait on a group of ports
     }
 }
 
diff --git a/test/ruby/test_ractor.rb b/test/ruby/test_ractor.rb
@@ -154,11 +154,15 @@ def ractor_job(job_count, array_size)
           w_idx = i % 4
           workers[w_idx].send(job)
         end
+        workers.each do |w|
+          w.send(nil)
+        end
         results = []
         jobs.size.times do
           result = port.receive # dnt receive
           results << result
         end
+        workers.each(&:join)
         results
       end
       threads = []
diff --git a/thread_pthread.c b/thread_pthread.c
@@ -1369,9 +1369,11 @@ rb_ractor_sched_wait(rb_execution_context_t *ec, rb_ractor_t *cr, rb_unblock_fun
             thread_sched_wait_running_turn(sched, th, can_direct_transfer);
             th->status = THREAD_RUNNABLE;
         }
-        rb_ractor_lock_self(cr);
+        // NOTE: locking ractor here can result in deadlock (lock inversion issue).
+        // We must lock ractor after unlocking thread_sched_lock
     }
     thread_sched_unlock(sched, th);
+    rb_ractor_lock_self(cr);
 
     ubf_clear(th);
 

Original file line number	Diff line number	Diff line change
`@@ -1369,9 +1369,11 @@ rb_ractor_sched_wait(rb_execution_context_t ec, rb_ractor_t cr, rb_unblock_fun`
`1369`	`1369`	`thread_sched_wait_running_turn(sched, th, can_direct_transfer);`
`1370`	`1370`	`th->status = THREAD_RUNNABLE;`
`1371`	`1371`	`}`
`1372`		`- rb_ractor_lock_self(cr);`
	`1372`	`+ // NOTE: locking ractor here can result in deadlock (lock inversion issue).`
	`1373`	`+ // We must lock ractor after unlocking thread_sched_lock`
`1373`	`1374`	`}`
`1374`	`1375`	`thread_sched_unlock(sched, th);`
	`1376`	`+ rb_ractor_lock_self(cr);`
`1375`	`1377`
`1376`	`1378`	`ubf_clear(th);`
`1377`	`1379`