Use a ReentrantLock for TruffleRuby.synchronized(object) {}

* So the SafepointManager can interrupt while the thread is trying to acquire the lock.
* It seems not possible to interrupt acquiring a monitor with Java `synchronized`.

Author: eregon

CHANGELOG.md

@@ -19,6 +19,7 @@ Bug fixes:
 * Fix `Enumerator::Lazy#{chunk_while, slice_before, slice_after, slice_when}` to return instances of `Enumerator::Lazy` (#2273).
 * Fix `Truffle::Interop.source_location` to return unavailable source sections for modules instead of null (#2257).
 * Fix usage of `Thread.handle_interrupt` in `MonitorMixin#mon_synchronize`.
+* Fixed `TruffleRuby.synchronized` to handle guest safepoints (#2277).
 
 Compatibility:
 

src/main/java/org/truffleruby/Layouts.java

@@ -19,6 +19,7 @@ public abstract class Layouts {
 
     public static final HiddenKey OBJECT_ID_IDENTIFIER = new HiddenKey("object_id"); // long
     public static final HiddenKey FROZEN_IDENTIFIER = new HiddenKey("frozen?"); // boolean
+    public static final HiddenKey OBJECT_LOCK = new HiddenKey("object_lock"); // ReentrantLock
     public static final HiddenKey ASSOCIATED_IDENTIFIER = new HiddenKey("associated"); // Pointer[]
     public static final HiddenKey FINALIZER_REF_IDENTIFIER = new HiddenKey("finalizerRef"); // FinalizerReference
     public static final HiddenKey MARKED_OBJECTS_IDENTIFIER = new HiddenKey("marked_objects"); // Object[]

src/main/java/org/truffleruby/extra/TruffleRubyNodes.java

@@ -10,14 +10,17 @@
 package org.truffleruby.extra;
 
 import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.object.DynamicObjectLibrary;
 import org.jcodings.specific.UTF8Encoding;
+import org.truffleruby.Layouts;
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.builtins.CoreMethod;
 import org.truffleruby.builtins.CoreMethodArrayArgumentsNode;
 import org.truffleruby.builtins.CoreMethodNode;
 import org.truffleruby.builtins.CoreModule;
 import org.truffleruby.builtins.YieldingCoreMethodNode;
+import org.truffleruby.core.mutex.MutexOperations;
 import org.truffleruby.core.proc.RubyProc;
 import org.truffleruby.core.rope.CodeRange;
 import org.truffleruby.core.string.StringNodes;
@@ -29,6 +32,8 @@
 import com.oracle.truffle.api.dsl.Specialization;
 import org.truffleruby.language.RubyDynamicObject;
 
+import java.util.concurrent.locks.ReentrantLock;
+
 @CoreModule("TruffleRuby")
 public abstract class TruffleRubyNodes {
 
@@ -104,11 +109,39 @@ protected Object fullMemoryBarrier() {
     @CoreMethod(names = "synchronized", onSingleton = true, required = 1, needsBlock = true)
     public abstract static class SynchronizedNode extends YieldingCoreMethodNode {
 
-        // We must not allow to synchronize on boxed primitives.
+        /** We must not allow to synchronize on boxed primitives as that would be misleading. We use a ReentrantLock and
+         * not simply Java's {@code synchronized} here as we need to be able to interrupt for guest safepoints and it is
+         * not possible to interrupt Java's {@code synchronized (object) {}}. */
         @Specialization
         protected Object synchronize(RubyDynamicObject object, RubyProc block) {
-            synchronized (object) {
+            final ReentrantLock lock = getLockAndLock(object);
+            try {
                 return yield(block);
+            } finally {
+                MutexOperations.unlockInternal(lock);
+            }
+        }
+
+        @TruffleBoundary
+        private ReentrantLock getLockAndLock(RubyDynamicObject object) {
+            final ReentrantLock lock = getLock(object);
+            MutexOperations.lockInternal(getContext(), lock, this);
+            return lock;
+        }
+
+        @TruffleBoundary
+        private ReentrantLock getLock(RubyDynamicObject object) {
+            final DynamicObjectLibrary objectLibrary = DynamicObjectLibrary.getUncached();
+
+            synchronized (object) {
+                ReentrantLock lock = (ReentrantLock) objectLibrary.getOrDefault(object, Layouts.OBJECT_LOCK, null);
+                if (lock != null) {
+                    return lock;
+                } else {
+                    lock = new ReentrantLock();
+                    objectLibrary.put(object, Layouts.OBJECT_LOCK, lock);
+                    return lock;
+                }
             }
         }