Refactor ProcessingReferences to extract common code.

Author: aardvark179

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

@@ -9,14 +9,14 @@
  */
 package org.truffleruby.core;
 
-import java.lang.ref.PhantomReference;
 import java.lang.ref.ReferenceQueue;
 import java.util.Collection;
 import java.util.Deque;
 import java.util.LinkedList;
 import java.util.Set;
 
 import org.truffleruby.RubyContext;
+import org.truffleruby.core.ReferenceProcessingService.PhantomProcessingReference;
 
 import com.oracle.truffle.api.object.DynamicObject;
 import org.truffleruby.language.objects.ObjectGraphNode;
@@ -52,38 +52,16 @@ public DynamicObject getRoot() {
         }
     }
 
-    public static class FinalizerReference extends PhantomReference<Object> implements ReferenceProcessingService.ProcessingReference<FinalizerReference>, ObjectGraphNode {
+    public static class FinalizerReference extends PhantomProcessingReference<FinalizerReference, Object> implements ObjectGraphNode {
 
         /**
          * All accesses to this Deque must be synchronized by taking the
          * {@link FinalizationService} monitor, to avoid concurrent access.
          */
         private final Deque<Finalizer> finalizers = new LinkedList<>();
-        private final FinalizationService service;
-
-        /** The doubly-linked list of FinalizerReference, needed to collect finalizer Procs for ObjectSpace. */
-        FinalizerReference next = null;
-        FinalizerReference prev = null;
 
         private FinalizerReference(Object object, ReferenceQueue<? super Object> queue, FinalizationService service) {
-            super(object, queue);
-            this.service = service;
-        }
-
-        public FinalizerReference getPrevious() {
-            return prev;
-        }
-
-        public void setPrevious(FinalizerReference previous) {
-            prev = previous;
-        }
-
-        public FinalizerReference getNext() {
-            return next;
-        }
-
-        public void setNext(FinalizerReference next) {
-            this.next = next;
+            super(object, queue, service);
         }
 
         private void addFinalizer(Class<?> owner, Runnable action, DynamicObject root) {
@@ -114,10 +92,6 @@ private void collectRoots(Collection<DynamicObject> roots) {
             }
         }
 
-        public ReferenceProcessingService<FinalizerReference> service() {
-            return service;
-        }
-
         @Override
         public void getAdjacentObjects(Set<DynamicObject> reachable) {
             collectRoots(reachable);
@@ -171,7 +145,7 @@ public synchronized void collectRoots(Collection<DynamicObject> roots) {
         FinalizerReference finalizerReference = getFirst();
         while (finalizerReference != null) {
             finalizerReference.collectRoots(roots);
-            finalizerReference = finalizerReference.next;
+            finalizerReference = finalizerReference.getNext();
         }
     }
 

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

@@ -10,10 +10,10 @@
 package org.truffleruby.core;
 
 import java.lang.ref.ReferenceQueue;
-import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 
 import org.truffleruby.RubyContext;
+import org.truffleruby.core.ReferenceProcessingService.WeakProcessingReference;
 import org.truffleruby.core.queue.UnsizedQueue;
 
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
@@ -45,69 +45,20 @@ public static interface MarkerAction {
         public abstract void mark(DynamicObject owner);
     }
 
-    public static class MarkerReference extends WeakReference<DynamicObject> implements ReferenceProcessingService.ProcessingReference<MarkerReference> {
+    public static class MarkerReference extends WeakProcessingReference<MarkerReference, DynamicObject> {
 
         private final MarkerAction action;
-        private final MarkingService service;
-        private MarkerReference next = null;
-        private MarkerReference prev = null;
 
         private MarkerReference(DynamicObject object, ReferenceQueue<? super Object> queue, MarkerAction action, MarkingService service) {
-            super(object, queue);
+            super(object, queue, service);
             this.action = action;
-            this.service = service;
-        }
-
-        public MarkerReference getPrevious() {
-            return prev;
-        }
-
-        public void setPrevious(MarkerReference previous) {
-            prev = previous;
-        }
-
-        public MarkerReference getNext() {
-            return next;
-        }
-
-        public void setNext(MarkerReference next) {
-            this.next = next;
-        }
-
-        public ReferenceProcessingService<MarkerReference> service() {
-            return service;
         }
     }
 
-    public static class MarkRunnerReference extends WeakReference<Object> implements ReferenceProcessingService.ProcessingReference<MarkRunnerReference> {
-
-        private final MarkRunnerService service;
-        private MarkRunnerReference next = null;
-        private MarkRunnerReference prev = null;
+    public static class MarkRunnerReference extends WeakProcessingReference<MarkRunnerReference, Object> {
 
         public MarkRunnerReference(Object object, ReferenceQueue<? super Object> queue, MarkRunnerService service) {
-            super(object, queue);
-            this.service = service;
-        }
-
-        public MarkRunnerReference getPrevious() {
-            return prev;
-        }
-
-        public void setPrevious(MarkRunnerReference previous) {
-            prev = previous;
-        }
-
-        public MarkRunnerReference getNext() {
-            return next;
-        }
-
-        public void setNext(MarkRunnerReference next) {
-            this.next = next;
-        }
-
-        public ReferenceProcessingService<MarkRunnerReference> service() {
-            return service;
+            super(object, queue, service);
         }
     }
 

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

@@ -9,7 +9,9 @@
  */
 package org.truffleruby.core;
 
+import java.lang.ref.PhantomReference;
 import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
 import java.util.function.Consumer;
 
 import org.truffleruby.RubyContext;
@@ -33,6 +35,74 @@ public static interface ProcessingReference<R extends ProcessingReference<R>> {
         public ReferenceProcessingService<R> service();
     }
 
+    public abstract static class WeakProcessingReference<R extends ProcessingReference<R>, T> extends WeakReference<T> implements ProcessingReference<R> {
+
+        private R next;
+        private R previous;
+        private ReferenceProcessingService<R> service;
+
+        public WeakProcessingReference(T object, ReferenceQueue<? super Object> queue, ReferenceProcessingService<R> service) {
+            super(object, queue);
+            this.service = service;
+        }
+
+        public R getPrevious() {
+            return previous;
+        }
+
+        public void setPrevious(R previous) {
+            this.previous = previous;
+        }
+
+        public R getNext() {
+            return next;
+        }
+
+        public void setNext(R next) {
+            this.next = next;
+        }
+
+        public ReferenceProcessingService<R> service() {
+            return service;
+        }
+    }
+
+    public abstract static class PhantomProcessingReference<R extends ProcessingReference<R>, T> extends PhantomReference<T> implements ProcessingReference<R> {
+
+        /**
+         * Doubly linked list of references to keep to allow the reference service to traverse them
+         * and to keep the references alive for processing.
+         */
+        private R next;
+        private R previous;
+        private ReferenceProcessingService<R> service;
+
+        public PhantomProcessingReference(T object, ReferenceQueue<? super Object> queue, ReferenceProcessingService<R> service) {
+            super(object, queue);
+            this.service = service;
+        }
+
+        public R getPrevious() {
+            return previous;
+        }
+
+        public void setPrevious(R previous) {
+            this.previous = previous;
+        }
+
+        public R getNext() {
+            return next;
+        }
+
+        public void setNext(R next) {
+            this.next = next;
+        }
+
+        public ReferenceProcessingService<R> service() {
+            return service;
+        }
+    }
+
     public static class ReferenceProcessor {
         protected final ReferenceQueue<Object> processingQueue = new ReferenceQueue<>();