Make the Ruby Language cleaner non-static.

aardvark179 · aardvark179 · commit d1270bc45b1c · 2022-04-14T22:07:04.000+01:00
diff --git a/src/main/java/org/truffleruby/RubyLanguage.java b/src/main/java/org/truffleruby/RubyLanguage.java
@@ -167,8 +167,6 @@ public final class RubyLanguage extends TruffleLanguage<RubyContext> {
     public static final String MIME_TYPE_MAIN_SCRIPT = "application/x-ruby;main-script=true";
     public static final String[] MIME_TYPES = { MIME_TYPE, MIME_TYPE_COVERAGE, MIME_TYPE_MAIN_SCRIPT };
 
-    public static final Cleaner cleaner = Cleaner.create();
-
     public static final String PLATFORM = String.format(
             "%s-%s%s",
             Platform.getArchName(),
@@ -213,6 +211,8 @@ public static final class ThreadLocalState {
     public final SymbolTable symbolTable;
     public final KeywordArgumentsDescriptorManager keywordArgumentsDescriptorManager = new KeywordArgumentsDescriptorManager();
     public final FrozenStringLiterals frozenStringLiterals;
+    public final Cleaner cleaner = Cleaner.create();
+
 
     public volatile ValueWrapperManager.HandleBlockWeakReference[] handleBlockSharedMap = new ValueWrapperManager.HandleBlockWeakReference[0];
     public final ValueWrapperManager.HandleBlockAllocator handleBlockAllocator = new ValueWrapperManager.HandleBlockAllocator();
diff --git a/src/main/java/org/truffleruby/cext/CExtNodes.java b/src/main/java/org/truffleruby/cext/CExtNodes.java
@@ -708,7 +708,7 @@ public abstract static class RbStrNewNulNode extends CoreMethodArrayArgumentsNod
         @Specialization
         protected RubyString rbStrNewNul(int byteLength,
                 @Cached StringNodes.MakeStringNode makeStringNode) {
-            final Rope rope = NativeRope.newBuffer(getContext(), byteLength, byteLength);
+            final Rope rope = NativeRope.newBuffer(getLanguage(), byteLength, byteLength);
 
             return makeStringNode.fromRope(rope, Encodings.BINARY);
         }
@@ -766,7 +766,7 @@ protected RubyString rbStrResize(RubyString string, int newByteLength,
                 nativeRope.clearCodeRange();
                 return string;
             } else {
-                final NativeRope newRope = nativeRope.resize(getContext(), newByteLength);
+                final NativeRope newRope = nativeRope.resize(getLanguage(), newByteLength);
 
                 // Like MRI's rb_str_resize()
                 newRope.clearCodeRange();
@@ -788,7 +788,7 @@ protected RubyString trStrCapaResize(RubyString string, int newCapacity,
             if (nativeRope.getCapacity() == newCapacity) {
                 return string;
             } else {
-                final NativeRope newRope = nativeRope.expandCapacity(getContext(), newCapacity);
+                final NativeRope newRope = nativeRope.expandCapacity(getLanguage(), newCapacity);
                 string.setRope(newRope);
                 return string;
             }
@@ -1215,7 +1215,8 @@ protected NativeRope toNative(RubyString string,
                         bytesNode.execute(currentRope),
                         currentRope.getEncoding(),
                         characterLengthNode.execute(currentRope),
-                        codeRangeNode.execute(currentRope));
+                        codeRangeNode.execute(currentRope),
+                        getLanguage());
                 string.setRope(nativeRope);
             }
 
@@ -1224,7 +1225,7 @@ protected NativeRope toNative(RubyString string,
 
         @Specialization
         protected NativeRope toNativeImmutable(ImmutableRubyString string) {
-            return string.getNativeRope();
+            return string.getNativeRope(getLanguage());
         }
 
     }
diff --git a/src/main/java/org/truffleruby/cext/ValueWrapperManager.java b/src/main/java/org/truffleruby/cext/ValueWrapperManager.java
@@ -234,7 +234,7 @@ public HandleBlock(RubyContext context, RubyLanguage language, ValueWrapperManag
             this.base = base;
             this.wrappers = new ValueWrapper[BLOCK_SIZE];
             this.count = 0;
-            this.cleanable = RubyLanguage.cleaner.register(this, HandleBlock.makeCleaner(manager, base, allocator));
+            this.cleanable = language.cleaner.register(this, HandleBlock.makeCleaner(manager, base, allocator));
         }
 
         private static Runnable makeCleaner(ValueWrapperManager manager, long base, HandleBlockAllocator allocator) {
diff --git a/src/main/java/org/truffleruby/core/array/ArrayNodes.java b/src/main/java/org/truffleruby/core/array/ArrayNodes.java
@@ -2349,7 +2349,7 @@ protected RubyArray storeToNative(RubyArray array,
                 @CachedLibrary("store") ArrayStoreLibrary stores,
                 @Cached IntValueProfile arraySizeProfile) {
             final int size = arraySizeProfile.profile(array.size);
-            Pointer pointer = Pointer.mallocAutoRelease(size * Pointer.SIZE);
+            Pointer pointer = Pointer.mallocAutoRelease(size * Pointer.SIZE, getLanguage());
             NativeArrayStorage newStore = new NativeArrayStorage(pointer, size);
             stores.copyContents(store, 0, newStore, 0, size);
             getContext().getMarkingService().addMarker(
diff --git a/src/main/java/org/truffleruby/core/rope/NativeRope.java b/src/main/java/org/truffleruby/core/rope/NativeRope.java
@@ -13,6 +13,7 @@
 import org.jcodings.Encoding;
 import org.jcodings.specific.ASCIIEncoding;
 import org.truffleruby.RubyContext;
+import org.truffleruby.RubyLanguage;
 import org.truffleruby.core.string.StringAttributes;
 import org.truffleruby.core.string.StringSupport;
 import org.truffleruby.extra.ffi.Pointer;
@@ -31,8 +32,9 @@ public NativeRope(
             byte[] bytes,
             Encoding encoding,
             int characterLength,
-            CodeRange codeRange) {
-        this(allocateNativePointer(bytes), bytes.length, encoding, characterLength, codeRange);
+            CodeRange codeRange,
+            RubyLanguage language) {
+        this(allocateNativePointer(bytes, language), bytes.length, encoding, characterLength, codeRange);
     }
 
     private NativeRope(Pointer pointer, int byteLength, Encoding encoding, int characterLength, CodeRange codeRange) {
@@ -44,23 +46,23 @@ private NativeRope(Pointer pointer, int byteLength, Encoding encoding, int chara
         this.pointer = pointer;
     }
 
-    private static Pointer allocateNativePointer(byte[] bytes) {
-        final Pointer pointer = Pointer.mallocAutoRelease(bytes.length + 1);
+    private static Pointer allocateNativePointer(byte[] bytes, RubyLanguage language) {
+        final Pointer pointer = Pointer.mallocAutoRelease(bytes.length + 1, language);
         pointer.writeBytes(0, bytes, 0, bytes.length);
         pointer.writeByte(bytes.length, (byte) 0);
         return pointer;
     }
 
-    private static Pointer copyNativePointer(RubyContext context, Pointer existing) {
-        final Pointer pointer = Pointer.mallocAutoRelease(existing.getSize());
+    private static Pointer copyNativePointer(RubyLanguage language, Pointer existing) {
+        final Pointer pointer = Pointer.mallocAutoRelease(existing.getSize(), language);
         pointer.writeBytes(0, existing, 0, existing.getSize());
         return pointer;
     }
 
-    public static NativeRope newBuffer(RubyContext context, int byteCapacity, int byteLength) {
+    public static NativeRope newBuffer(RubyLanguage language, int byteCapacity, int byteLength) {
         assert byteCapacity >= byteLength;
 
-        final Pointer pointer = Pointer.callocAutoRelease(byteCapacity + 1);
+        final Pointer pointer = Pointer.callocAutoRelease(byteCapacity + 1, language);
 
         return new NativeRope(
                 pointer,
@@ -75,15 +77,15 @@ public NativeRope withByteLength(int newByteLength, int characterLength, CodeRan
         return new NativeRope(pointer, newByteLength, getEncoding(), characterLength, codeRange);
     }
 
-    public NativeRope makeCopy(RubyContext context) {
-        final Pointer newPointer = copyNativePointer(context, pointer);
+    public NativeRope makeCopy(RubyLanguage language) {
+        final Pointer newPointer = copyNativePointer(language, pointer);
         return new NativeRope(newPointer, byteLength(), getEncoding(), characterLength(), getCodeRange());
     }
 
-    public NativeRope resize(RubyContext context, int newByteLength) {
+    public NativeRope resize(RubyLanguage language, int newByteLength) {
         assert byteLength() != newByteLength;
 
-        final Pointer pointer = Pointer.mallocAutoRelease(newByteLength + 1);
+        final Pointer pointer = Pointer.mallocAutoRelease(newByteLength + 1, language);
         pointer.writeBytes(0, this.pointer, 0, Math.min(getNativePointer().getSize(), newByteLength));
         pointer.writeByte(newByteLength, (byte) 0); // Like MRI
         return new NativeRope(pointer, newByteLength, getEncoding(), UNKNOWN_CHARACTER_LENGTH, CodeRange.CR_UNKNOWN);
@@ -94,9 +96,9 @@ public NativeRope resize(RubyContext context, int newByteLength) {
      * @param context the Ruby context
      * @param newCapacity the size in bytes minus one of the new pointer length
      * @return the new NativeRope */
-    public NativeRope expandCapacity(RubyContext context, int newCapacity) {
+    public NativeRope expandCapacity(RubyLanguage language, int newCapacity) {
         assert getCapacity() != newCapacity;
-        final Pointer pointer = Pointer.mallocAutoRelease(newCapacity + 1);
+        final Pointer pointer = Pointer.mallocAutoRelease(newCapacity + 1, language);
         pointer.writeBytes(0, this.pointer, 0, Math.min(getNativePointer().getSize(), newCapacity));
         pointer.writeByte(newCapacity, (byte) 0); // Like MRI
         return new NativeRope(
diff --git a/src/main/java/org/truffleruby/core/string/ImmutableRubyString.java b/src/main/java/org/truffleruby/core/string/ImmutableRubyString.java
@@ -39,8 +39,8 @@
 public class ImmutableRubyString extends ImmutableRubyObject implements TruffleObject {
 
     public final LeafRope rope;
-    private volatile NativeRope nativeRope = null;
     public final RubyEncoding encoding;
+    private NativeRope nativeRope = null;
 
     ImmutableRubyString(LeafRope rope, RubyEncoding encoding) {
         assert rope.encoding == encoding.jcoding;
@@ -58,16 +58,16 @@ public boolean isNative() {
         return nativeRope != null;
     }
 
-    public synchronized NativeRope getNativeRope() {
+    public synchronized NativeRope getNativeRope(RubyLanguage language) {
         if (nativeRope == null) {
-            nativeRope = createNativeRope();
+            nativeRope = createNativeRope(language);
         }
         return nativeRope;
     }
 
     @TruffleBoundary
-    private NativeRope createNativeRope() {
-        return new NativeRope(rope.getBytes(), rope.getEncoding(), rope.characterLength(), rope.getCodeRange());
+    private NativeRope createNativeRope(RubyLanguage language) {
+        return new NativeRope(rope.getBytes(), rope.getEncoding(), rope.characterLength(), rope.getCodeRange(), language);
     }
 
     // region RubyStringLibrary messages
diff --git a/src/main/java/org/truffleruby/core/string/StringNodes.java b/src/main/java/org/truffleruby/core/string/StringNodes.java
@@ -1751,7 +1751,7 @@ protected Object initializeCopyFromNative(RubyString self, Object from,
                 @CachedLibrary(limit = "LIBSTRING_CACHE") RubyStringLibrary stringsFrom,
                 @Cached @Shared("stringGetAssociatedNode") StringGetAssociatedNode stringGetAssociatedNode) {
             self.setRope(
-                    ((NativeRope) stringsFrom.getRope(from)).makeCopy(getContext()),
+                    ((NativeRope) stringsFrom.getRope(from)).makeCopy(getLanguage()),
                     stringsFrom.getEncoding(from));
             final Object associated = stringGetAssociatedNode.execute(from);
             copyAssociated(self, associated);
diff --git a/src/main/java/org/truffleruby/extra/ffi/Pointer.java b/src/main/java/org/truffleruby/extra/ffi/Pointer.java
@@ -39,9 +39,9 @@ public static Pointer malloc(long size) {
         return new Pointer(UNSAFE.allocateMemory(size), size);
     }
 
-    /** Includes {@link #enableAutorelease(RubyContext)} and avoids locking for it */
-    public static Pointer mallocAutoRelease(long size) {
-        return new Pointer(UNSAFE.allocateMemory(size), size, true);
+    /** Includes {@link #enableAutorelease(RubyLanguage)} and avoids locking for it */
+    public static Pointer mallocAutoRelease(long size, RubyLanguage langauge) {
+        return new Pointer(UNSAFE.allocateMemory(size), size, langauge);
     }
 
     /** Allocates memory and produces a pointer to it. Clears the memory before returning it. Use {@link #malloc} if you
@@ -52,9 +52,9 @@ public static Pointer calloc(long size) {
         return pointer;
     }
 
-    /** Includes {@link #enableAutorelease(RubyContext)} and avoids locking for it */
-    public static Pointer callocAutoRelease(long size) {
-        final Pointer pointer = mallocAutoRelease(size);
+    /** Includes {@link #enableAutorelease(RubyLanguage)} and avoids locking for it */
+    public static Pointer callocAutoRelease(long size, RubyLanguage langauge) {
+        final Pointer pointer = mallocAutoRelease(size, langauge);
         pointer.writeBytes(0, size, (byte) 0);
         return pointer;
     }
@@ -93,12 +93,10 @@ public Pointer(long address, long size) {
         this.size = size;
     }
 
-    private Pointer(long address, long size, boolean autoRelease) {
+    private Pointer(long address, long size, RubyLanguage langauge) {
         this.address = address;
         this.size = size;
-        if (autoRelease) {
-            enableAutoreleaseUnsynchronized();
-        }
+        enableAutoreleaseUnsynchronized(langauge);
     }
 
     public boolean isNull() {
@@ -344,20 +342,20 @@ public synchronized boolean isAutorelease() {
     }
 
     @TruffleBoundary
-    public synchronized void enableAutorelease(RubyContext context) {
+    public synchronized void enableAutorelease(RubyLanguage language) {
         if (cleanable != null) {
             return;
         }
 
-        enableAutoreleaseUnsynchronized();
+        enableAutoreleaseUnsynchronized(language);
     }
 
     @TruffleBoundary
-    private void enableAutoreleaseUnsynchronized() {
+    private void enableAutoreleaseUnsynchronized(RubyLanguage language) {
         // We must be careful here that the finalizer does not capture the Pointer itself that we'd
         // like to finalize.
         autoReleaseState = new AutoReleaseState(address);
-        cleanable = RubyLanguage.cleaner.register(this, autoReleaseState);
+        cleanable = language.cleaner.register(this, autoReleaseState);
 
     }
 
diff --git a/src/main/java/org/truffleruby/extra/ffi/PointerNodes.java b/src/main/java/org/truffleruby/extra/ffi/PointerNodes.java
@@ -198,7 +198,7 @@ public abstract static class PointerSetAutoreleaseNode extends CoreMethodArrayAr
 
         @Specialization(guards = "autorelease")
         protected boolean enableAutorelease(RubyPointer pointer, boolean autorelease) {
-            pointer.pointer.enableAutorelease(getContext());
+            pointer.pointer.enableAutorelease(getLanguage());
             return autorelease;
         }
 

Original file line number	Diff line number	Diff line change
`@@ -234,7 +234,7 @@ public HandleBlock(RubyContext context, RubyLanguage language, ValueWrapperManag`
`234`	`234`	`this.base = base;`
`235`	`235`	`this.wrappers = new ValueWrapper[BLOCK_SIZE];`
`236`	`236`	`this.count = 0;`
`237`		`- this.cleanable = RubyLanguage.cleaner.register(this, HandleBlock.makeCleaner(manager, base, allocator));`
	`237`	`+ this.cleanable = language.cleaner.register(this, HandleBlock.makeCleaner(manager, base, allocator));`
`238`	`238`	`}`
`239`	`239`
`240`	`240`	`private static Runnable makeCleaner(ValueWrapperManager manager, long base, HandleBlockAllocator allocator) {`
Original file line number	Diff line number	Diff line change
`@@ -39,9 +39,9 @@ public static Pointer malloc(long size) {`
`39`	`39`	`return new Pointer(UNSAFE.allocateMemory(size), size);`
`40`	`40`	`}`
`41`	`41`
`42`		`- /** Includes {@link #enableAutorelease(RubyContext)} and avoids locking for it */`
`43`		`- public static Pointer mallocAutoRelease(long size) {`
`44`		`- return new Pointer(UNSAFE.allocateMemory(size), size, true);`
	`42`	`+ /** Includes {@link #enableAutorelease(RubyLanguage)} and avoids locking for it */`
	`43`	`+ public static Pointer mallocAutoRelease(long size, RubyLanguage langauge) {`
	`44`	`+ return new Pointer(UNSAFE.allocateMemory(size), size, langauge);`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`/** Allocates memory and produces a pointer to it. Clears the memory before returning it. Use {@link #malloc} if you`
`@@ -52,9 +52,9 @@ public static Pointer calloc(long size) {`
`52`	`52`	`return pointer;`
`53`	`53`	`}`
`54`	`54`
`55`		`- /** Includes {@link #enableAutorelease(RubyContext)} and avoids locking for it */`
`56`		`- public static Pointer callocAutoRelease(long size) {`
`57`		`- final Pointer pointer = mallocAutoRelease(size);`
	`55`	`+ /** Includes {@link #enableAutorelease(RubyLanguage)} and avoids locking for it */`
	`56`	`+ public static Pointer callocAutoRelease(long size, RubyLanguage langauge) {`
	`57`	`+ final Pointer pointer = mallocAutoRelease(size, langauge);`
`58`	`58`	`pointer.writeBytes(0, size, (byte) 0);`
`59`	`59`	`return pointer;`
`60`	`60`	`}`
`@@ -93,12 +93,10 @@ public Pointer(long address, long size) {`
`93`	`93`	`this.size = size;`
`94`	`94`	`}`
`95`	`95`
`96`		`- private Pointer(long address, long size, boolean autoRelease) {`
	`96`	`+ private Pointer(long address, long size, RubyLanguage langauge) {`
`97`	`97`	`this.address = address;`
`98`	`98`	`this.size = size;`
`99`		`- if (autoRelease) {`
`100`		`- enableAutoreleaseUnsynchronized();`
`101`		`- }`
	`99`	`+ enableAutoreleaseUnsynchronized(langauge);`
`102`	`100`	`}`
`103`	`101`
`104`	`102`	`public boolean isNull() {`
`@@ -344,20 +342,20 @@ public synchronized boolean isAutorelease() {`
`344`	`342`	`}`
`345`	`343`
`346`	`344`	`@TruffleBoundary`
`347`		`- public synchronized void enableAutorelease(RubyContext context) {`
	`345`	`+ public synchronized void enableAutorelease(RubyLanguage language) {`
`348`	`346`	`if (cleanable != null) {`
`349`	`347`	`return;`
`350`	`348`	`}`
`351`	`349`
`352`		`- enableAutoreleaseUnsynchronized();`
	`350`	`+ enableAutoreleaseUnsynchronized(language);`
`353`	`351`	`}`
`354`	`352`
`355`	`353`	`@TruffleBoundary`
`356`		`- private void enableAutoreleaseUnsynchronized() {`
	`354`	`+ private void enableAutoreleaseUnsynchronized(RubyLanguage language) {`
`357`	`355`	`// We must be careful here that the finalizer does not capture the Pointer itself that we'd`
`358`	`356`	`// like to finalize.`
`359`	`357`	`autoReleaseState = new AutoReleaseState(address);`
`360`		`- cleanable = RubyLanguage.cleaner.register(this, autoReleaseState);`
	`358`	`+ cleanable = language.cleaner.register(this, autoReleaseState);`
`361`	`359`
`362`	`360`	`}`
`363`	`361`
Original file line number	Diff line number	Diff line change
`@@ -198,7 +198,7 @@ public abstract static class PointerSetAutoreleaseNode extends CoreMethodArrayAr`
`198`	`198`
`199`	`199`	`@Specialization(guards = "autorelease")`
`200`	`200`	`protected boolean enableAutorelease(RubyPointer pointer, boolean autorelease) {`
`201`		`- pointer.pointer.enableAutorelease(getContext());`
	`201`	`+ pointer.pointer.enableAutorelease(getLanguage());`
`202`	`202`	`return autorelease;`
`203`	`203`	`}`
`204`	`204`