Refactoring reference processing to pass in the language.

Author: aardvark179

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

@@ -189,7 +189,7 @@ public RubyContext(RubyLanguage language, TruffleLanguage.Env env) {
         referenceProcessor = new ReferenceProcessor(this);
         finalizationService = new FinalizationService(referenceProcessor);
         markingService = new MarkingService(referenceProcessor);
-        dataObjectFinalizationService = new DataObjectFinalizationService(referenceProcessor);
+        dataObjectFinalizationService = new DataObjectFinalizationService(language, referenceProcessor);
 
         // We need to construct this at runtime
         random = createRandomInstance();

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

@@ -10,24 +10,28 @@
 package org.truffleruby.core;
 
 import java.lang.ref.ReferenceQueue;
+import java.util.concurrent.locks.ReentrantLock;
 
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.cext.DataHolder;
 import org.truffleruby.core.MarkingService.ExtensionCallStack;
+import org.truffleruby.core.mutex.MutexOperations;
 import org.truffleruby.language.RubyBaseRootNode;
 import org.truffleruby.language.backtrace.InternalRootNode;
 
+import com.oracle.truffle.api.CallTarget;
 import com.oracle.truffle.api.interop.ArityException;
 import com.oracle.truffle.api.interop.InteropLibrary;
 import com.oracle.truffle.api.interop.UnsupportedMessageException;
 import com.oracle.truffle.api.interop.UnsupportedTypeException;
+import com.oracle.truffle.api.profiles.ConditionProfile;
 import com.oracle.truffle.api.frame.VirtualFrame;
 
 /** Finalizers are implemented with phantom references and reference queues, and are run in a dedicated Ruby thread. */
 public class DataObjectFinalizationService extends ReferenceProcessingService<DataObjectFinalizerReference> {
 
-    // We need a base node here, it shoudl extend ruby base root node and implement internal root node.
+    // We need a base node here, it should extend ruby base root node and implement internal root node.
     public static class DataObjectFinalizerRootNode extends RubyBaseRootNode implements InternalRootNode {
 
         @Child private InteropLibrary nullNode;
@@ -64,21 +68,21 @@ public Object execute(DataObjectFinalizerReference ref) {
 
     private final DataObjectFinalizerRootNode rootNode;
 
-    public DataObjectFinalizationService(ReferenceQueue<Object> processingQueue) {
+    public DataObjectFinalizationService(RubyLanguage language, ReferenceQueue<Object> processingQueue) {
         super(processingQueue);
-        rootNode = new DataObjectFinalizerRootNode(RubyLanguage.getCurrentLanguage());
+        rootNode = new DataObjectFinalizerRootNode(language);
     }
 
-    public DataObjectFinalizationService(ReferenceProcessor referenceProcessor) {
-        this(referenceProcessor.processingQueue);
+    public DataObjectFinalizationService(RubyLanguage language, ReferenceProcessor referenceProcessor) {
+        this(language, referenceProcessor.processingQueue);
     }
 
     public DataObjectFinalizerReference addFinalizer(RubyContext context, Object object, Object callable,
             DataHolder dataHolder) {
         final DataObjectFinalizerReference newRef = createRef(object, callable, dataHolder);
 
         add(newRef);
-        context.getReferenceProcessor().processReferenceQueue();
+        context.getReferenceProcessor().processReferenceQueue(this);
 
         return newRef;
     }

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

@@ -64,7 +64,7 @@ public FinalizerReference addFinalizer(RubyContext context, Object object, Class
         newRef.addFinalizer(owner, action, root);
 
         add(newRef);
-        context.getReferenceProcessor().processReferenceQueue();
+        context.getReferenceProcessor().processReferenceQueue(this);
 
         return newRef;
     }
@@ -78,7 +78,7 @@ public void addAdditionalFinalizer(RubyContext context, FinalizerReference exist
         assert Thread.holdsLock(object) : "caller must synchronize access to the FinalizerReference";
         existingRef.addFinalizer(owner, action, root);
 
-        context.getReferenceProcessor().processReferenceQueue();
+        context.getReferenceProcessor().processReferenceQueue(this);
     }
 
     public final void drainFinalizationQueue(RubyContext context) {

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

@@ -147,7 +147,7 @@ public ReferenceProcessor(RubyContext context) {
             this.context = context;
         }
 
-        protected void processReferenceQueue() {
+        protected void processReferenceQueue(ReferenceProcessingService<?> service) {
             if (processOnMainThread()) {
                 drainReferenceQueues();
             } else {
@@ -159,7 +159,7 @@ protected void processReferenceQueue() {
                  * assumption and a low risk of leaking a tiny number of bytes if it doesn't hold. */
                 if (processingThread == null && !context.isPreInitializing() && context.isInitialized() &&
                         !context.isFinalizing()) {
-                    createProcessingThread();
+                    createProcessingThread(service);
                 }
             }
         }
@@ -171,7 +171,7 @@ public boolean processOnMainThread() {
         private static final String THREAD_NAME = "Ruby-reference-processor";
 
         @TruffleBoundary
-        protected void createProcessingThread() {
+        protected void createProcessingThread(ReferenceProcessingService<?> service) {
             final ThreadManager threadManager = context.getThreadManager();
             final RubyLanguage language = context.getLanguageSlow();
             RubyThread newThread;
@@ -182,7 +182,8 @@ protected void createProcessingThread() {
                 newThread = threadManager.createBootThread(THREAD_NAME);
                 processingThread = newThread;
             }
-            final String sharingReason = "creating " + THREAD_NAME + " thread";
+            final String sharingReason = "creating " + THREAD_NAME + " thread for " +
+                    service.getClass().getSimpleName();
 
             threadManager.initialize(newThread, DummyNode.INSTANCE, THREAD_NAME, sharingReason, () -> {
                 while (true) {