jruby · Mar 2, 2015 · Mar 2, 2015
Showing with 34 additions and 25 deletions.

+34 −25 truffle/src/main/java/org/jruby/truffle/runtime/subsystems/SafepointManager.java
diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/subsystems/SafepointManager.java b/truffle/src/main/java/org/jruby/truffle/runtime/subsystems/SafepointManager.java
@@ -19,7 +19,6 @@
 import org.jruby.RubyThread.Status;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.core.RubyThread;
-import org.jruby.truffle.runtime.util.Consumer;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -128,50 +127,60 @@ private void step(Node currentNode, RubyThread thread, boolean isDrivingThread)
     }
 
     public void pauseAllThreadsAndExecute(Node currentNode, SafepointAction action) {
-        pauseAllThreadsAndExecute(currentNode, true, action);
-    }
-
-    public void pauseAllThreadsAndExecuteFromNonRubyThread(Node currentNode, SafepointAction action) {
-        enterThread();
-        try {
-            pauseAllThreadsAndExecute(currentNode, false, action);
-        } finally {
-            leaveThread();
-        }
-    }
-
-    public void pauseAllThreadsAndExecute(Node currentNode, boolean holdsGlobalLock, SafepointAction action) {
-        CompilerDirectives.transferToInterpreter();
-
         if (lock.isHeldByCurrentThread()) {
             throw new IllegalStateException("Re-entered SafepointManager");
         }
 
+        // Need to lock interruptibly since we are in the registered threads.
         while (true) {
             try {
                 lock.lockInterruptibly();
                 break;
             } catch (InterruptedException e) {
-                poll(currentNode, holdsGlobalLock);
+                poll(currentNode);
             }
         }
 
         try {
-            this.action = action;
+            pauseAllThreadsAndExecute(currentNode, true, action);
+        } finally {
+            lock.unlock();
+        }
+    }
 
-            /* this is a potential cause for race conditions,
-             * but we need to invalidate first so the interrupted threads
-             * see the invalidation in poll() in their catch(InterruptedException) clause
-             * and wait on the barrier instead of retrying their blocking action. */
-            assumption.invalidate();
-            interruptOtherThreads();
+    public void pauseAllThreadsAndExecuteFromNonRubyThread(Node currentNode, SafepointAction action) {
+        if (lock.isHeldByCurrentThread()) {
+            throw new IllegalStateException("Re-entered SafepointManager");
+        }
 
-            assumptionInvalidated(currentNode, holdsGlobalLock, true);
+        assert !runningThreads.contains(Thread.currentThread());
+        // Just wait to grab the lock, since we are not in the registered threads.
+        lock.lock();
+        try {
+            enterThread();
+            try {
+                pauseAllThreadsAndExecute(currentNode, false, action);
+            } finally {
+                leaveThread();
+            }
         } finally {
             lock.unlock();
         }
     }
 
+    private void pauseAllThreadsAndExecute(Node currentNode, boolean holdsGlobalLock, SafepointAction action) {
+        this.action = action;
+
+        /* this is a potential cause for race conditions,
+         * but we need to invalidate first so the interrupted threads
+         * see the invalidation in poll() in their catch(InterruptedException) clause
+         * and wait on the barrier instead of retrying their blocking action. */
+        assumption.invalidate();
+        interruptOtherThreads();
+
+        assumptionInvalidated(currentNode, holdsGlobalLock, true);
+    }
+
     private void interruptOtherThreads() {
         Thread current = Thread.currentThread();
         for (Thread thread : runningThreads) {