[GR-33075] Move marking and handle thread local data to RubyFiber.

PullRequest: truffleruby/2872

Author: aardvark179

src/main/java/org/truffleruby/RubyContext.java

@@ -210,7 +210,7 @@ public RubyContext(RubyLanguage language, TruffleLanguage.Env env) {
         coreLibrary = new CoreLibrary(this, language);
         nativeConfiguration = NativeConfiguration.loadNativeConfiguration(this);
         coreLibrary.initialize();
-        valueWrapperManager = new ValueWrapperManager(this);
+        valueWrapperManager = new ValueWrapperManager();
         Metrics.printTime("after-create-core-library");
 
         rootLexicalScope = new LexicalScope(null, coreLibrary.objectClass);

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

@@ -125,9 +125,10 @@ public abstract static class CallWithCExtLockAndFrameNode extends PrimitiveArray
 
         @Specialization
         protected Object callWithCExtLockAndFrame(
-                Object receiver, RubyArray argsArray, Object specialVariables, Object block,
-                @Cached MarkingServiceNodes.GetMarkerThreadLocalDataNode getDataNode) {
-            final ExtensionCallStack extensionStack = getDataNode.execute().getExtensionCallStack();
+                Object receiver, RubyArray argsArray, Object specialVariables, Object block) {
+            final ExtensionCallStack extensionStack = getLanguage()
+                    .getCurrentThread()
+                    .getCurrentFiber().extensionCallStack;
             extensionStack.push(specialVariables, block);
             try {
                 return callCextNode.execute(receiver, argsArray);
@@ -693,19 +694,17 @@ protected RubyString trStrCapaResize(RubyString string, int newCapacity,
     public abstract static class BlockProcNode extends CoreMethodArrayArgumentsNode {
 
         @Specialization
-        protected Object block(
-                @Cached MarkingServiceNodes.GetMarkerThreadLocalDataNode getDataNode) {
-            return getDataNode.execute().getExtensionCallStack().getBlock();
+        protected Object block() {
+            return getLanguage().getCurrentThread().getCurrentFiber().extensionCallStack.getBlock();
         }
     }
 
     @Primitive(name = "cext_special_variables_from_stack")
     public abstract static class VarsFromStackNode extends PrimitiveArrayArgumentsNode {
 
         @Specialization
-        protected Object variables(
-                @Cached MarkingServiceNodes.GetMarkerThreadLocalDataNode getDataNode) {
-            return getDataNode.execute().getExtensionCallStack().getVariables();
+        protected Object variables() {
+            return getLanguage().getCurrentThread().getCurrentFiber().extensionCallStack.getVariables();
         }
     }
 
@@ -1568,9 +1567,8 @@ protected Object createMarker(RubyDynamicObject object, RubyProc marker) {
     public abstract static class PushPreservingFrame extends CoreMethodArrayArgumentsNode {
 
         @Specialization
-        protected Object pushFrame(Object variables, RubyProc block,
-                @Cached MarkingServiceNodes.GetMarkerThreadLocalDataNode getDataNode) {
-            getDataNode.execute().getExtensionCallStack().push(variables, block);
+        protected Object pushFrame(Object variables, RubyProc block) {
+            getLanguage().getCurrentThread().getCurrentFiber().extensionCallStack.push(variables, block);
             return nil;
         }
     }
@@ -1579,9 +1577,8 @@ protected Object pushFrame(Object variables, RubyProc block,
     public abstract static class PopPreservingFrame extends CoreMethodArrayArgumentsNode {
 
         @Specialization
-        protected Object popFrame(
-                @Cached MarkingServiceNodes.GetMarkerThreadLocalDataNode getDataNode) {
-            getDataNode.execute().getExtensionCallStack().pop();
+        protected Object popFrame() {
+            getLanguage().getCurrentThread().getCurrentFiber().extensionCallStack.pop();
             return nil;
         }
     }

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

@@ -18,7 +18,6 @@
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.SuppressFBWarnings;
 import org.truffleruby.cext.ValueWrapperManagerFactory.AllocateHandleNodeGen;
-import org.truffleruby.cext.ValueWrapperManagerFactory.GetHandleBlockHolderNodeGen;
 import org.truffleruby.extra.ffi.Pointer;
 import org.truffleruby.language.ImmutableRubyObject;
 import org.truffleruby.language.NotProvided;
@@ -60,35 +59,8 @@ public class ValueWrapperManager {
 
     private volatile HandleBlockWeakReference[] blockMap = new HandleBlockWeakReference[0];
 
-    private final ThreadLocal<HandleThreadData> threadBlocks;
-
-    private final RubyContext context;
-
-    public ValueWrapperManager(RubyContext context) {
-        this.context = context;
-        this.threadBlocks = ThreadLocal.withInitial(this::makeThreadData);
-    }
-
-    public HandleThreadData makeThreadData() {
-        HandleThreadData threadData = new HandleThreadData();
-        HandleBlockHolder holder = threadData.holder;
-        context.getFinalizationService().addFinalizer(
-                context,
-                threadData,
-                ValueWrapperManager.class,
-                () -> context.getMarkingService().queueForMarking(holder.handleBlock),
-                null);
-        return threadData;
-    }
-
-    @TruffleBoundary
-    public HandleThreadData getBlockHolder() {
-        return threadBlocks.get();
-    }
-
-    @TruffleBoundary
-    public void cleanupBlockHolder() {
-        threadBlocks.remove();
+    public static HandleBlockHolder getBlockHolder(RubyContext context, RubyLanguage language) {
+        return language.getCurrentThread().getCurrentFiber().handleData;
     }
 
     /* We keep a map of long wrappers that have been generated because various C extensions assume that any given fixnum
@@ -102,7 +74,7 @@ public ValueWrapper doubleWrapper(double value) {
     }
 
     @TruffleBoundary
-    public synchronized void addToBlockMap(HandleBlock block, RubyLanguage language) {
+    public synchronized void addToBlockMap(HandleBlock block, RubyContext context, RubyLanguage language) {
         int blockIndex = block.getIndex();
         long blockBase = block.getBase();
         HandleBlockAllocator allocator = language.handleBlockAllocator;
@@ -117,7 +89,7 @@ public synchronized void addToBlockMap(HandleBlock block, RubyLanguage language)
     }
 
     @TruffleBoundary
-    public void addToSharedBlockMap(HandleBlock block, RubyLanguage language) {
+    public void addToSharedBlockMap(HandleBlock block, RubyContext context, RubyLanguage language) {
         synchronized (language) {
             int blockIndex = block.getIndex();
             long blockBase = block.getBase();
@@ -186,6 +158,11 @@ public void freeAllBlocksInMap(RubyLanguage language) {
         }
     }
 
+    public void cleanup(RubyContext context, HandleBlockHolder holder) {
+        context.getMarkingService().queueForMarking(holder.handleBlock);
+        holder.handleBlock = null;
+    }
+
     protected static class FreeHandleBlock {
         public final long start;
         public final FreeHandleBlock next;
@@ -299,86 +276,43 @@ public static final class HandleBlockWeakReference extends WeakReference<HandleB
         }
     }
 
-    protected static class HandleBlockHolder {
+    public static class HandleBlockHolder {
         protected HandleBlock handleBlock = null;
         protected HandleBlock sharedHandleBlock = null;
     }
 
-    protected static class HandleThreadData {
-
-        private final HandleBlockHolder holder = new HandleBlockHolder();
-
-        public HandleBlock currentBlock() {
-            return holder.handleBlock;
-        }
-
-        public HandleBlock currentSharedBlock() {
-            return holder.sharedHandleBlock;
-        }
-
-        public HandleBlock makeNewBlock(RubyContext context, HandleBlockAllocator allocator) {
-            return (holder.handleBlock = new HandleBlock(context, allocator));
-        }
-
-        public HandleBlock makeNewSharedBlock(RubyContext context, HandleBlockAllocator allocator) {
-            return (holder.sharedHandleBlock = new HandleBlock(context, allocator));
-        }
-    }
-
-    @GenerateUncached
-    public abstract static class GetHandleBlockHolderNode extends RubyBaseNode {
-
-        public abstract HandleThreadData execute(ValueWrapper wrapper);
-
-        @Specialization(guards = "cachedThread == currentJavaThread(wrapper)", limit = "getCacheLimit()")
-        protected HandleThreadData getHolderOnKnownThread(ValueWrapper wrapper,
-                @Cached("currentJavaThread(wrapper)") Thread cachedThread,
-                @Cached("getBlockHolder(wrapper)") HandleThreadData threadData) {
-            return threadData;
-        }
-
-        @Specialization(replaces = "getHolderOnKnownThread")
-        protected HandleThreadData getBlockHolder(ValueWrapper wrapper) {
-            return getContext().getValueWrapperManager().getBlockHolder();
-        }
-
-        protected static Thread currentJavaThread(ValueWrapper wrapper) {
-            return Thread.currentThread();
-        }
-
-        public int getCacheLimit() {
-            return getLanguage().options.THREAD_CACHE;
-        }
-
-        public static GetHandleBlockHolderNode create() {
-            return GetHandleBlockHolderNodeGen.create();
-        }
-    }
-
     @GenerateUncached
     public abstract static class AllocateHandleNode extends RubyBaseNode {
 
         public abstract long execute(ValueWrapper wrapper);
 
         @Specialization(guards = "!isSharedObject(wrapper)")
-        protected long allocateHandleOnKnownThread(ValueWrapper wrapper,
-                @Cached GetHandleBlockHolderNode getBlockHolderNode) {
-            return allocateHandle(wrapper, getContext(), getLanguage(), getBlockHolderNode.execute(wrapper), false);
+        protected long allocateHandleOnKnownThread(ValueWrapper wrapper) {
+            return allocateHandle(
+                    wrapper,
+                    getContext(),
+                    getLanguage(),
+                    getBlockHolder(getContext(), getLanguage()),
+                    false);
         }
 
         @Specialization(guards = "isSharedObject(wrapper)")
-        protected long allocateSharedHandleOnKnownThread(ValueWrapper wrapper,
-                @Cached GetHandleBlockHolderNode getBlockHolderNode) {
-            return allocateHandle(wrapper, getContext(), getLanguage(), getBlockHolderNode.execute(wrapper), true);
+        protected long allocateSharedHandleOnKnownThread(ValueWrapper wrapper) {
+            return allocateHandle(
+                    wrapper,
+                    getContext(),
+                    getLanguage(),
+                    getBlockHolder(getContext(), getLanguage()),
+                    true);
         }
 
         protected static long allocateHandle(ValueWrapper wrapper, RubyContext context, RubyLanguage language,
-                HandleThreadData threadData, boolean shared) {
+                HandleBlockHolder holder, boolean shared) {
             HandleBlock block;
             if (shared) {
-                block = threadData.holder.sharedHandleBlock;
+                block = holder.sharedHandleBlock;
             } else {
-                block = threadData.holder.handleBlock;
+                block = holder.handleBlock;
             }
 
             if (context.getOptions().CEXTS_TO_NATIVE_STATS) {
@@ -390,13 +324,11 @@ protected static long allocateHandle(ValueWrapper wrapper, RubyContext context,
                     context.getMarkingService().queueForMarking(block);
                 }
                 if (shared) {
-                    block = threadData
-                            .makeNewSharedBlock(context, language.handleBlockAllocator);
-                    context.getValueWrapperManager().addToSharedBlockMap(block, language);
+                    block = (holder.sharedHandleBlock = new HandleBlock(context, language.handleBlockAllocator));
+                    context.getValueWrapperManager().addToSharedBlockMap(block, context, language);
                 } else {
-                    block = threadData
-                            .makeNewBlock(context, language.handleBlockAllocator);
-                    context.getValueWrapperManager().addToBlockMap(block, language);
+                    block = (holder.handleBlock = new HandleBlock(context, language.handleBlockAllocator));
+                    context.getValueWrapperManager().addToBlockMap(block, context, language);
                 }
 
             }

src/main/java/org/truffleruby/core/FinalizationService.java

@@ -14,6 +14,7 @@
 import java.util.Objects;
 
 import org.truffleruby.RubyContext;
+import org.truffleruby.RubyLanguage;
 import org.truffleruby.core.MarkingService.ExtensionCallStack;
 import org.truffleruby.language.RubyDynamicObject;
 
@@ -85,14 +86,16 @@ public final void drainFinalizationQueue(RubyContext context) {
     }
 
     @Override
-    protected void processReference(RubyContext context, ProcessingReference<?> finalizerReference) {
-        super.processReference(context, finalizerReference);
+    protected void processReference(RubyContext context, RubyLanguage language,
+            ProcessingReference<?> finalizerReference) {
+        super.processReference(context, language, finalizerReference);
 
-        runCatchingErrors(context, this::processReferenceInternal, (FinalizerReference) finalizerReference);
+        runCatchingErrors(context, language, this::processReferenceInternal, (FinalizerReference) finalizerReference);
     }
 
-    protected void processReferenceInternal(RubyContext context, FinalizerReference finalizerReference) {
-        ExtensionCallStack stack = context.getMarkingService().getThreadLocalData().getExtensionCallStack();
+    protected void processReferenceInternal(RubyContext context, RubyLanguage language,
+            FinalizerReference finalizerReference) {
+        final ExtensionCallStack stack = language.getCurrentThread().getCurrentFiber().extensionCallStack;
         stack.push(stack.getVariables(), stack.getBlock());
         try {
             while (!context.isFinalizing()) {