Reduce lock overhead when calling markers.

Author: aardvark179

lib/truffle/truffle/cext.rb

@@ -1501,7 +1501,7 @@ def run_marker(obj)
       data_holder = Primitive.object_hidden_var_get obj, DATA_HOLDER
       data = Primitive.data_holder_get_data(data_holder)
       # This call is done without pushing a new frame as the marking service manages frames itself.
-      Primitive.call_with_c_mutex(mark, [data]) unless Truffle::Interop.null?(data)
+      mark.call(data) unless Truffle::Interop.null?(data)
       set_mark_list_on_object(obj)
     end
   end

src/main/java/org/truffleruby/cext/CExtNodes.java

@@ -30,7 +30,6 @@
 import org.truffleruby.builtins.Primitive;
 import org.truffleruby.builtins.PrimitiveArrayArgumentsNode;
 import org.truffleruby.builtins.YieldingCoreMethodNode;
-import org.truffleruby.cext.CExtNodesFactory.CallWithCExtLockNodeFactory;
 import org.truffleruby.cext.CExtNodesFactory.StringToNativeNodeGen;
 import org.truffleruby.cext.UnwrapNode.UnwrapCArrayNode;
 import org.truffleruby.core.MarkingService.ExtensionCallStack;
@@ -165,26 +164,56 @@ private static long getNativeStringCapacity(Pointer pointer) {
     @Primitive(name = "call_with_c_mutex_and_frame")
     public abstract static class CallWithCExtLockAndFrameNode extends PrimitiveArrayArgumentsNode {
 
-        @Child protected CallWithCExtLockNode callCextNode = CallWithCExtLockNodeFactory.create(RubyNode.EMPTY_ARRAY);
         @Child protected MarkingServiceNodes.RunMarkOnExitNode runMarksNode = MarkingServiceNodes.RunMarkOnExitNode
                 .create();
 
-        @Specialization
+        @Specialization(limit = "getCacheLimit()")
         protected Object callWithCExtLockAndFrame(
-                VirtualFrame frame, Object receiver, RubyArray argsArray, Object specialVariables, Object block) {
-            final ExtensionCallStack extensionStack = getLanguage().getCurrentFiber().extensionCallStack;
+                VirtualFrame frame, Object receiver, RubyArray argsArray, Object specialVariables, Object block,
+                @CachedLibrary("receiver") InteropLibrary receivers,
+                @Cached ArrayToObjectArrayNode arrayToObjectArrayNode,
+                @Cached TranslateInteropExceptionNode translateInteropExceptionNode,
+                @Cached ConditionProfile ownedProfile,
+                @Cached MarkingServiceNodes.RunMarkOnExitNode runMarksNode) {
+            final ExtensionCallStack extensionStack = getLanguage()
+                    .getCurrentThread()
+                    .getCurrentFiber().extensionCallStack;
             final boolean keywordsGiven = RubyArguments.getDescriptor(frame) instanceof KeywordArgumentsDescriptor;
             extensionStack.push(keywordsGiven, specialVariables, block);
             try {
-                try {
-                    return callCextNode.execute(receiver, argsArray);
-                } finally {
-                    runMarksNode.execute(extensionStack);
+                final Object[] args = arrayToObjectArrayNode.executeToObjectArray(argsArray);
+
+                if (getContext().getOptions().CEXT_LOCK) {
+                    final ReentrantLock lock = getContext().getCExtensionsLock();
+                    boolean owned = ownedProfile.profile(lock.isHeldByCurrentThread());
+
+                    if (!owned) {
+                        MutexOperations.lockInternal(getContext(), lock, this);
+                    }
+                    try {
+                        return InteropNodes.execute(receiver, args, receivers, translateInteropExceptionNode);
+                    } finally {
+                        runMarksNode.execute(extensionStack);
+                        if (!owned) {
+                            MutexOperations.unlockInternal(lock);
+                        }
+                    }
+                } else {
+                    try {
+                        return InteropNodes.execute(receiver, args, receivers, translateInteropExceptionNode);
+                    } finally {
+                        runMarksNode.execute(extensionStack);
+                    }
                 }
+
             } finally {
                 extensionStack.pop();
             }
         }
+
+        protected int getCacheLimit() {
+            return getLanguage().options.DISPATCH_CACHE;
+        }
     }
 
     @Primitive(name = "call_with_c_mutex_and_frame_and_unwrap")

src/main/java/org/truffleruby/core/array/ArrayToObjectArrayNode.java

@@ -13,9 +13,11 @@
 import org.truffleruby.language.RubyBaseNode;
 
 import com.oracle.truffle.api.dsl.Bind;
+import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.ImportStatic;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.library.CachedLibrary;
+import com.oracle.truffle.api.profiles.IntValueProfile;
 
 @ImportStatic(ArrayGuards.class)
 public abstract class ArrayToObjectArrayNode extends RubyBaseNode {
@@ -34,8 +36,9 @@ public Object[] unsplat(Object[] arguments) {
     @Specialization(limit = "storageStrategyLimit()")
     protected Object[] toObjectArrayOther(RubyArray array,
             @Bind("array.getStore()") Object store,
+            @Cached("createIdentityProfile()") IntValueProfile sizeProfile,
             @CachedLibrary("store") ArrayStoreLibrary stores) {
-        final int size = array.size;
+        final int size = sizeProfile.profile(array.size);
         return stores.boxedCopyOfRange(store, 0, size);
     }