Refactor to not use the monitor's lock for condition variables.

Author: aardvark179

lib/mri/monitor.rb

@@ -107,13 +107,7 @@ class ConditionVariable < ::ConditionVariable
     # even if no other thread doesn't signal.
     #
     def wait(timeout = nil)
-      if timeout
-        raise ArgumentError, 'Timeout must be positive' if timeout < 0
-        timeout = timeout * 1_000_000_000
-        timeout = Primitive.rb_num2long(timeout)
-      end
-
-      Primitive.condition_variable_wait(self, nil, timeout)
+      super(@mon_mutex, timeout)
     end
 
     #
@@ -133,6 +127,12 @@ def wait_until
         wait
       end
     end
+
+    private
+
+    def initialize(mutex)
+      @mon_mutex = mutex
+    end
   end
 
   def self.extend_object(obj)
@@ -192,7 +192,7 @@ def mon_synchronize(&block)
   # receiver.
   #
   def new_cond
-    Primitive.mutex_linked_condition_variable(ConditionVariable, @mon_mutex)
+    ConditionVariable.new(@mon_mutex)
   end
 
   # Use <tt>extend MonitorMixin</tt> or <tt>include MonitorMixin</tt> instead

src/main/java/org/truffleruby/core/monitor/TruffleMonitorNodes.java

@@ -9,45 +9,24 @@
  */
 package org.truffleruby.core.monitor;
 
-import java.util.concurrent.locks.Condition;
-import java.util.concurrent.locks.ReentrantLock;
-
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Specialization;
-import com.oracle.truffle.api.object.Shape;
 import com.oracle.truffle.api.profiles.BranchProfile;
 
 import org.truffleruby.builtins.CoreMethodArrayArgumentsNode;
 import org.truffleruby.builtins.CoreModule;
 import org.truffleruby.builtins.Primitive;
-import org.truffleruby.core.klass.RubyClass;
 import org.truffleruby.core.mutex.MutexOperations;
-import org.truffleruby.core.mutex.RubyConditionVariable;
 import org.truffleruby.core.mutex.RubyMutex;
 import org.truffleruby.core.proc.RubyProc;
 import org.truffleruby.core.thread.GetCurrentRubyThreadNode;
 import org.truffleruby.core.thread.RubyThread;
 import org.truffleruby.language.control.RaiseException;
-import org.truffleruby.language.objects.AllocationTracing;
 import org.truffleruby.language.yield.CallBlockNode;
 
 @CoreModule("Truffle::MonitorOperations")
 public abstract class TruffleMonitorNodes {
 
-    @Primitive(name = "mutex_linked_condition_variable")
-    public abstract static class LinkedConditionVariableNode extends CoreMethodArrayArgumentsNode {
-
-        @Specialization
-        protected RubyConditionVariable linkedConditionVariable(RubyClass rubyClass, RubyMutex mutex) {
-            final ReentrantLock condLock = mutex.lock;
-            final Condition condition = MutexOperations.newCondition(condLock);
-            final Shape shape = getLanguage().conditionVariableShape;
-            final RubyConditionVariable instance = new RubyConditionVariable(rubyClass, shape, condLock, condition);
-            AllocationTracing.trace(instance, this);
-            return instance;
-        }
-    }
-
     @Primitive(name = "monitor_synchronize")
     public abstract static class SynchronizeNode extends CoreMethodArrayArgumentsNode {
 

src/main/java/org/truffleruby/core/mutex/ConditionVariableNodes.java

@@ -82,26 +82,6 @@ protected RubyConditionVariable withTimeout(RubyConditionVariable condVar, RubyM
             return condVar;
         }
 
-        @Specialization
-        protected RubyConditionVariable noMutexNoTimeout(RubyConditionVariable condVar, Nil mutex, Nil timeout,
-                @Cached GetCurrentRubyThreadNode getCurrentRubyThreadNode,
-                @Cached BranchProfile errorProfile) {
-            final RubyThread thread = getCurrentRubyThreadNode.execute();
-
-            waitInternal(condVar, null, thread, -1);
-            return condVar;
-        }
-
-        @Specialization
-        protected RubyConditionVariable noMutexWithTimeout(RubyConditionVariable condVar, Nil mutex, long timeout,
-                @Cached GetCurrentRubyThreadNode getCurrentRubyThreadNode,
-                @Cached BranchProfile errorProfile) {
-            final RubyThread thread = getCurrentRubyThreadNode.execute();
-
-            waitInternal(condVar, null, thread, timeout);
-            return condVar;
-        }
-
         @TruffleBoundary
         private void waitInternal(RubyConditionVariable conditionVariable, ReentrantLock mutexLock,
                 RubyThread thread, long durationInNanos) {
@@ -123,9 +103,11 @@ private void waitInternal(RubyConditionVariable conditionVariable, ReentrantLock
             // If there is an interrupt, it should be consumed by condition.await() and the Ruby Thread sleep status
             // must imply being ready to be interrupted by Thread#{run,wakeup}.
             condLock.lock();
+            int holdCount = 0;
             try {
-                if (mutexLock != null) {
+                while (mutexLock.isHeldByCurrentThread()) {
                     mutexLock.unlock();
+                    holdCount++;
                 }
 
                 conditionVariable.waiters++;
@@ -143,8 +125,12 @@ private void waitInternal(RubyConditionVariable conditionVariable, ReentrantLock
                 }
             } finally {
                 condLock.unlock();
-                if (mutexLock != null) {
-                    MutexOperations.internalLockEvenWithException(getContext(), mutexLock, this);
+                MutexOperations.internalLockEvenWithException(getContext(), mutexLock, this);
+                if (holdCount > 1) {
+                    // We know we already hold the lock, so we can skip the rest of the logic at this point.
+                    for (int i = 1; i < holdCount; i++) {
+                        mutexLock.tryLock();
+                    }
                 }
             }
         }