Refactor to avoid storing RubyLangauge in reference processor.

Author: aardvark179

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

@@ -86,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 = language.getCurrentThread().getCurrentFiber().extensionCallStack;
+    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()) {

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

@@ -65,10 +65,10 @@ public MarkRunnerService(
         }
 
         @Override
-        protected void processReference(RubyContext context, ProcessingReference<?> reference) {
+        protected void processReference(RubyContext context, RubyLanguage language, ProcessingReference<?> reference) {
             /* We need to keep all the objects that might be marked alive during the marking process itself, so we add
              * the arrays to a list to achieve this. */
-            super.processReference(context, reference);
+            super.processReference(context, language, reference);
             ArrayList<ValueWrapperManager.HandleBlock> keptObjectLists = new ArrayList<>();
             ValueWrapperManager.HandleBlock block;
             while (true) {
@@ -80,14 +80,14 @@ protected void processReference(RubyContext context, ProcessingReference<?> refe
                 }
             }
             if (!keptObjectLists.isEmpty()) {
-                runAllMarkers(context);
+                runAllMarkers(context, language);
             }
             keptObjectLists.clear();
         }
 
         @TruffleBoundary
-        public void runAllMarkers(RubyContext context) {
-            ExtensionCallStack stack = markingService.language.getCurrentThread().getCurrentFiber().extensionCallStack;
+        public void runAllMarkers(RubyContext context, RubyLanguage language) {
+            final ExtensionCallStack stack = language.getCurrentThread().getCurrentFiber().extensionCallStack;
             stack.push(stack.getVariables(), stack.getBlock());
             try {
                 // TODO (eregon, 15 Sept 2020): there seems to be no synchronization here while walking the list of
@@ -96,7 +96,7 @@ public void runAllMarkers(RubyContext context) {
                 MarkerReference nextMarker;
                 while (currentMarker != null) {
                     nextMarker = currentMarker.getNext();
-                    markingService.runMarker(context, currentMarker);
+                    markingService.runMarker(context, language, currentMarker);
                     if (nextMarker == currentMarker) {
                         throw new Error("The MarkerReference linked list structure has become broken.");
                     }
@@ -184,11 +184,11 @@ public void addMarker(Object object, MarkerAction action) {
         add(new MarkerReference(object, processingQueue, action, this));
     }
 
-    private void runMarker(RubyContext context, MarkerReference markerReference) {
-        runCatchingErrors(context, this::runMarkerInternal, markerReference);
+    private void runMarker(RubyContext context, RubyLanguage language, MarkerReference markerReference) {
+        runCatchingErrors(context, language, this::runMarkerInternal, markerReference);
     }
 
-    private void runMarkerInternal(RubyContext context, MarkerReference markerReference) {
+    private void runMarkerInternal(RubyContext context, RubyLanguage language, MarkerReference markerReference) {
         if (!context.isFinalizing()) {
             Object owner = markerReference.get();
             if (owner != null) {

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

@@ -12,7 +12,6 @@
 import java.lang.ref.PhantomReference;
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.WeakReference;
-import java.util.function.BiConsumer;
 
 import com.oracle.truffle.api.CompilerDirectives;
 import org.truffleruby.RubyContext;
@@ -172,6 +171,7 @@ protected void processReferenceQueue(Class<?> owner) {
 
         protected void createProcessingThread(Class<?> owner) {
             final ThreadManager threadManager = context.getThreadManager();
+            final RubyLanguage language = context.getLanguageSlow();
             RubyThread newThread;
             synchronized (this) {
                 if (processingThread != null) {
@@ -205,7 +205,7 @@ protected void createProcessingThread(Class<?> owner) {
                                 }
                                 return ref;
                             });
-                    reference.service().processReference(context, reference);
+                    reference.service().processReference(context, language, reference);
                 }
             });
         }
@@ -228,7 +228,8 @@ public RubyThread getProcessingThread() {
         }
 
         protected final void drainReferenceQueues() {
-            ReferenceQueue<Object> sharedReferenceQueue = context.getLanguageSlow().sharedReferenceQueue;
+            final ReferenceQueue<Object> sharedReferenceQueue = context.getLanguageSlow().sharedReferenceQueue;
+            final RubyLanguage language = context.getLanguageSlow();
             while (true) {
                 @SuppressWarnings("unchecked")
                 ProcessingReference<?> reference = (ProcessingReference<?>) processingQueue.poll();
@@ -241,7 +242,7 @@ protected final void drainReferenceQueues() {
                     break;
                 }
 
-                reference.service().processReference(context, reference);
+                reference.service().processReference(context, language, reference);
             }
         }
 
@@ -251,21 +252,24 @@ protected final void drainReferenceQueues() {
     private R first = null;
 
     protected final ReferenceQueue<Object> processingQueue;
-    protected final RubyLanguage language;
 
     public ReferenceProcessingService(RubyLanguage language, ReferenceQueue<Object> processingQueue) {
-        this.language = language;
         this.processingQueue = processingQueue;
     }
 
     @SuppressWarnings("unchecked")
-    protected void processReference(RubyContext context, ProcessingReference<?> reference) {
+    protected void processReference(RubyContext context, RubyLanguage language, ProcessingReference<?> reference) {
         remove((R) reference);
     }
 
-    protected void runCatchingErrors(RubyContext context, BiConsumer<RubyContext, R> action, R reference) {
+    public interface ReferenceRunner<T, U, V> {
+        public void accept(T t, U u, V v);
+    }
+
+    protected void runCatchingErrors(RubyContext context, RubyLanguage language,
+            ReferenceRunner<RubyContext, RubyLanguage, R> action, R reference) {
         try {
-            action.accept(context, reference);
+            action.accept(context, language, reference);
         } catch (TerminationException e) {
             throw e;
         } catch (RaiseException e) {