Use cleaner for handle blocks on context disposal.

Author: aardvark179

CHANGELOG.md

@@ -22,6 +22,7 @@ Performance:
 
 * Reimplement `Float#to_s` for better performance (#1584, @aardvark179).
 * Improve reference processing by making C object free functions and other finalizers more lightweight (@aardvark179).
+* Improve performance of `RSTRING_PTR` for interned strings (@aardvark179).
 
 Changes:
 

src/main/java/org/truffleruby/RubyLanguage.java

@@ -182,9 +182,9 @@ public final class RubyLanguage extends TruffleLanguage<RubyContext> {
 
     public static final TruffleLogger LOGGER = TruffleLogger.getLogger(TruffleRuby.LANGUAGE_ID);
 
-    /** This is a truly empty frame descriptor and should only by dummy root nodes which require no variables any other
-     * root nodes should should use {#link
-     * {@link TranslatorEnvironment#newFrameDescriptorBuilder(org.truffleruby.parser.ParentFrameDescriptor, boolean)}}. */
+    /** This is a truly empty frame descriptor and should only by dummy root nodes which require no variables. Any other
+     * root nodes should should use
+     * {@link TranslatorEnvironment#newFrameDescriptorBuilder(org.truffleruby.parser.ParentFrameDescriptor, boolean)}. */
     public static final FrameDescriptor EMPTY_FRAME_DESCRIPTOR = new FrameDescriptor(Nil.INSTANCE);
 
     /** We need an extra indirection added to ContextThreadLocal due to multiple Fibers of different Ruby Threads

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

@@ -1212,11 +1212,11 @@ protected NativeRope toNative(RubyString string,
                 nativeRope = (NativeRope) currentRope;
             } else {
                 nativeRope = new NativeRope(
+                        getLanguage(),
                         bytesNode.execute(currentRope),
                         currentRope.getEncoding(),
                         characterLengthNode.execute(currentRope),
-                        codeRangeNode.execute(currentRope),
-                        getLanguage());
+                        codeRangeNode.execute(currentRope));
                 string.setRope(nativeRope);
             }
 

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

@@ -148,7 +148,7 @@ public void freeAllBlocksInMap(RubyLanguage language) {
             }
             HandleBlock block = ref.get();
             if (block != null) {
-                allocator.addFreeBlock(block.base);
+                block.cleanable.clean();
             }
         }
     }

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

@@ -31,7 +31,8 @@
 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. */
+/** C-ext data 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 should extend ruby base root node and implement internal root node.

src/main/java/org/truffleruby/core/rope/NativeRope.java

@@ -28,12 +28,12 @@ public class NativeRope extends Rope {
     private final Pointer pointer;
 
     public NativeRope(
+            RubyLanguage language,
             byte[] bytes,
             Encoding encoding,
             int characterLength,
-            CodeRange codeRange,
-            RubyLanguage language) {
-        this(allocateNativePointer(bytes, language), bytes.length, encoding, characterLength, codeRange);
+            CodeRange codeRange) {
+        this(allocateNativePointer(language, bytes), bytes.length, encoding, characterLength, codeRange);
     }
 
     private NativeRope(Pointer pointer, int byteLength, Encoding encoding, int characterLength, CodeRange codeRange) {
@@ -45,7 +45,7 @@ private NativeRope(Pointer pointer, int byteLength, Encoding encoding, int chara
         this.pointer = pointer;
     }
 
-    private static Pointer allocateNativePointer(byte[] bytes, RubyLanguage language) {
+    private static Pointer allocateNativePointer(RubyLanguage language, byte[] bytes) {
         final Pointer pointer = Pointer.mallocAutoRelease(bytes.length + 1, language);
         pointer.writeBytes(0, bytes, 0, bytes.length);
         pointer.writeByte(bytes.length, (byte) 0);

src/main/java/org/truffleruby/core/string/ImmutableRubyString.java

@@ -58,17 +58,20 @@ public boolean isNative() {
         return nativeRope != null;
     }
 
-    public synchronized NativeRope getNativeRope(RubyLanguage language) {
+    public NativeRope getNativeRope(RubyLanguage language) {
         if (nativeRope == null) {
-            nativeRope = createNativeRope(language);
+            return createNativeRope(language);
         }
         return nativeRope;
     }
 
     @TruffleBoundary
-    private NativeRope createNativeRope(RubyLanguage language) {
-        return new NativeRope(rope.getBytes(), rope.getEncoding(), rope.characterLength(), rope.getCodeRange(),
-                language);
+    private synchronized NativeRope createNativeRope(RubyLanguage language) {
+        if (nativeRope == null) {
+            nativeRope = new NativeRope(language, rope.getBytes(), rope.getEncoding(), rope.characterLength(),
+                    rope.getCodeRange());
+        }
+        return nativeRope;
     }
 
     // region RubyStringLibrary messages

src/main/java/org/truffleruby/extra/ffi/Pointer.java

@@ -39,8 +39,8 @@ public static Pointer malloc(long size) {
     }
 
     /** 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);
+    public static Pointer mallocAutoRelease(long size, RubyLanguage language) {
+        return new Pointer(UNSAFE.allocateMemory(size), size, language);
     }
 
     /** Allocates memory and produces a pointer to it. Clears the memory before returning it. Use {@link #malloc} if you
@@ -52,8 +52,8 @@ public static Pointer calloc(long size) {
     }
 
     /** Includes {@link #enableAutorelease(RubyLanguage)} and avoids locking for it */
-    public static Pointer callocAutoRelease(long size, RubyLanguage langauge) {
-        final Pointer pointer = mallocAutoRelease(size, langauge);
+    public static Pointer callocAutoRelease(long size, RubyLanguage language) {
+        final Pointer pointer = mallocAutoRelease(size, language);
         pointer.writeBytes(0, size, (byte) 0);
         return pointer;
     }
@@ -65,7 +65,7 @@ public static Pointer callocAutoRelease(long size, RubyLanguage langauge) {
     private AutoReleaseState autoReleaseState = null;
 
     /** This is needed because we need a mutable object to hold the pointer address so that it can be freed or marked as
-     * not to be freed if auto-release is disabled. THis can't be the address field on the pointer itself as that would
+     * not to be freed if auto-release is disabled. This can't be the address field on the pointer itself as that would
      * prevent the pointer from being collected, and we can't retrieve this from the cleaner as it is effectively
      * opaque. */
     private static class AutoReleaseState implements Runnable {
@@ -96,10 +96,10 @@ public Pointer(long address, long size) {
         this.size = size;
     }
 
-    private Pointer(long address, long size, RubyLanguage langauge) {
+    private Pointer(long address, long size, RubyLanguage language) {
         this.address = address;
         this.size = size;
-        enableAutoreleaseUnsynchronized(langauge);
+        enableAutoreleaseUnsynchronized(language);
     }
 
     public boolean isNull() {

src/main/java/org/truffleruby/language/objects/shared/ShareInternalFieldsNode.java

@@ -30,7 +30,8 @@
 import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.profiles.ConditionProfile;
 
-/** Share the internal fields of an object, accessible by its Layout */
+/** Share the plain Java fields which may contain objets for subclasses of RubyDynamicObject.
+ * {@link RubyDynamicObject#metaClass} is handled by {@link ShareObjectNode}. */
 @ImportStatic({ ShapeCachingGuards.class, ArrayGuards.class })
 public abstract class ShareInternalFieldsNode extends RubyBaseNode {
 
@@ -85,7 +86,7 @@ protected void shareCachedQueue(RubyQueue object,
 
     @Specialization
     protected void shareCachedBasicObject(RubyBasicObject object) {
-        /* No internal fields for RubyBasicObject */
+        /* No extra Java fields for RubyBasicObject */
     }
 
     @Specialization(

src/main/java/org/truffleruby/language/objects/shared/WriteBarrierNode.java

@@ -91,7 +91,7 @@ protected void writeBarrierFinalizer(FinalizerReference ref) {
 
     @Specialization
     @TruffleBoundary
-    protected void writeBarrierFinalizer(DataObjectFinalizerReference ref) {
+    protected void writeBarrierDataFinalizer(DataObjectFinalizerReference ref) {
         SharedObjects.writeBarrier(getLanguage(), ref.callable);
         SharedObjects.writeBarrier(getLanguage(), ref.dataHolder);
     }