[GR-68826] TruffleString: remove Java String caching.

PullRequest: graal/21883

Author: djoooooe

truffle/src/com.oracle.truffle.api.strings/src/com/oracle/truffle/api/strings/AbstractTruffleString.java

@@ -86,7 +86,6 @@ public abstract sealed class AbstractTruffleString permits TruffleString, Mutabl
      * <li>{@link LazyLong}</li>
      * <li>{@link LazyConcat}</li>
      * <li>{@link NativePointer}</li>
-     * <li>{@link String} (only for caching results of {@link #toJavaStringUncached()})</li>
      * </ul>
      */
     private Object data;
@@ -155,8 +154,6 @@ static boolean isByte(int i) {
     private static void validateData(Object data, int offset, int length, int stride) {
         if (data instanceof byte[]) {
             TStringOps.validateRegion((byte[]) data, offset, length, stride);
-        } else if (data instanceof String) {
-            TStringOps.validateRegion(TStringUnsafe.getJavaStringArray((String) data), offset, length, stride);
         } else if (data instanceof LazyLong || data instanceof LazyConcat) {
             validateDataLazy(offset, length, stride);
         } else if (data instanceof NativePointer) {
@@ -418,10 +415,6 @@ final boolean isLazyLong() {
         return data instanceof AbstractTruffleString.LazyLong;
     }
 
-    final boolean isJavaString() {
-        return data instanceof String;
-    }
-
     static TruffleStringIterator forwardIterator(AbstractTruffleString a, byte[] arrayA, long offsetA, int codeRangeA, Encoding encoding) {
         return forwardIterator(a, arrayA, offsetA, codeRangeA, encoding, TruffleString.ErrorHandling.BEST_EFFORT);
     }
@@ -1359,7 +1352,7 @@ public final String toString() {
     public final String toStringDebug() {
         Object curData = data;
         String dataString;
-        if (curData instanceof byte[] || curData instanceof NativePointer || curData instanceof String) {
+        if (curData instanceof byte[] || curData instanceof NativePointer) {
             dataString = String.format("\"%s\"", toJavaStringUncached());
         } else if (curData instanceof LazyLong lazyLong) {
             dataString = String.format("LazyLong(%d)", lazyLong.value);

truffle/src/com.oracle.truffle.api.strings/src/com/oracle/truffle/api/strings/TStringInternalNodes.java

@@ -2009,15 +2009,7 @@ static TruffleString doNonEmpty(Node node, String javaString, int charOffset, in
                     TStringOps.arraycopyWithStride(node, arrayJS, offsetJS + byteArrayBaseOffset(), 0, 0, array, offset + byteArrayBaseOffset(), 0, 0, length << stride);
                 }
             }
-            int hash = TStringUnsafe.getJavaStringHashMasked(javaString);
-            final TruffleString cacheEntry;
-            if (length == javaString.length()) {
-                assert charOffset == 0;
-                cacheEntry = TruffleString.createWrapJavaString(javaString, codePointLength, codeRange);
-            } else {
-                cacheEntry = null;
-            }
-            return TruffleString.createFromByteArrayWithCacheEntry(array, offset, length, stride, Encoding.UTF_16, codePointLength, codeRange, hash, cacheEntry);
+            return TruffleString.createFromByteArray(array, offset, length, stride, Encoding.UTF_16, codePointLength, codeRange, TStringUnsafe.getJavaStringHashMasked(javaString), true);
         }
     }
 

truffle/src/com.oracle.truffle.api.strings/src/com/oracle/truffle/api/strings/TruffleString.java

@@ -148,18 +148,6 @@ private TruffleString(Object data, int offset, int length, int stride, Encoding
         super(data, offset, length, stride, encoding, isCacheHead ? FLAG_CACHE_HEAD : 0, codePointLength, codeRange, hashCode);
     }
 
-    private TruffleString(Object data, int offset, int length, int stride, Encoding encoding, int codePointLength, int codeRange, int hashCode, boolean isCacheHead, TruffleString cacheEntry) {
-        this(data, offset, length, stride, encoding, codePointLength, codeRange, hashCode, isCacheHead);
-        if (cacheEntry != null) {
-            assert !cacheEntry.isCacheHead();
-            assert isCacheHead();
-            assert next == null;
-            TruffleString cacheHead = this;
-            cacheEntry.next = cacheHead;
-            cacheHead.next = cacheEntry;
-        }
-    }
-
     private static TruffleString create(Object data, int offset, int length, int stride, Encoding encoding, int codePointLength, int codeRange, int hashCode, boolean isCacheHead) {
         TruffleString string = new TruffleString(data, offset, length, stride, encoding, codePointLength, codeRange, hashCode, isCacheHead);
         if (AbstractTruffleString.DEBUG_ALWAYS_CREATE_JAVA_STRING) {
@@ -168,14 +156,6 @@ private static TruffleString create(Object data, int offset, int length, int str
         return string;
     }
 
-    private static TruffleString createWithCacheEntry(Object data, int offset, int length, int stride, Encoding encoding, int codePointLength, int codeRange, int hashCode, TruffleString cacheEntry) {
-        TruffleString string = new TruffleString(data, offset, length, stride, encoding, codePointLength, codeRange, hashCode, true, cacheEntry);
-        if (AbstractTruffleString.DEBUG_ALWAYS_CREATE_JAVA_STRING) {
-            string.toJavaStringUncached();
-        }
-        return string;
-    }
-
     static TruffleString createFromByteArray(byte[] bytes, int length, int stride, Encoding encoding, int codePointLength, int codeRange) {
         return createFromByteArray(bytes, 0, length, stride, encoding, codePointLength, codeRange, true);
     }
@@ -216,14 +196,6 @@ static TruffleString createFromArray(Object bytes, int offset, int length, int s
         return TruffleString.create(bytes, offset, length, stride, encoding, codePointLength, codeRange, hashCode, isCacheHead);
     }
 
-    static TruffleString createFromByteArrayWithCacheEntry(byte[] bytes, int offset, int length, int stride, Encoding encoding, int codePointLength, int codeRange, int hashCode,
-                    TruffleString cacheEntry) {
-        assert offset >= 0;
-        assert offset + ((long) length << stride) <= bytes.length;
-        assert attrsAreCorrect(bytes, encoding, offset, length, codePointLength, codeRange, stride);
-        return TruffleString.createWithCacheEntry(bytes, offset, length, stride, encoding, codePointLength, codeRange, hashCode, cacheEntry);
-    }
-
     static TruffleString createConstant(byte[] bytes, int length, int stride, Encoding encoding, int codePointLength, int codeRange) {
         return createConstant(bytes, length, stride, encoding, codePointLength, codeRange, true);
     }
@@ -250,12 +222,6 @@ static TruffleString createLazyConcat(TruffleString a, TruffleString b, Encoding
         return TruffleString.create(new LazyConcat(a, b), 0, length, stride, encoding, a.codePointLength() + b.codePointLength(), codeRange, 0, true);
     }
 
-    static TruffleString createWrapJavaString(String str, int codePointLength, int codeRange) {
-        int stride = TStringUnsafe.getJavaStringStride(str);
-        int hash = TStringUnsafe.getJavaStringHashMasked(str);
-        return TruffleString.create(str, 0, str.length(), stride, Encoding.UTF_16, codePointLength, codeRange, hash, false);
-    }
-
     private static boolean attrsAreCorrect(Object dataA, Encoding encoding, int offset, int length, int codePointLength, int codeRange, int stride) {
         CompilerAsserts.neverPartOfCompilation();
         int knownCodeRange = TSCodeRange.getUnknownCodeRangeForEncoding(encoding.id);
@@ -341,7 +307,7 @@ private static boolean hasDuplicateEncoding(TruffleString cacheHead, TruffleStri
     }
 
     private static boolean cacheEntryEquals(TruffleString a, TruffleString b) {
-        return b.encoding() == a.encoding() && a.isNative() == b.isNative() && a.stride() == b.stride() && (!isUTF16(a.encoding()) || b.isJavaString() == a.isJavaString());
+        return b.encoding() == a.encoding() && a.isNative() == b.isNative() && a.stride() == b.stride();
     }
 
     @TruffleBoundary
@@ -353,7 +319,6 @@ private boolean cacheRingIsValid() {
         CompilerAsserts.neverPartOfCompilation();
         TruffleString head = null;
         TruffleString cur = this;
-        boolean javaStringVisited = false;
         BitSet visitedManaged = new BitSet(Encoding.values().length);
         BitSet visitedNativeRegular = new BitSet(Encoding.values().length);
         BitSet visitedNativeCompact = new BitSet(Encoding.values().length);
@@ -363,22 +328,17 @@ private boolean cacheRingIsValid() {
                 assert head == null : "multiple cache heads";
                 head = cur;
             }
-            if (cur.isJavaString()) {
-                assert !javaStringVisited : "duplicate cached java string";
-                javaStringVisited = true;
+            Encoding encoding = Encoding.get(cur.encoding());
+            if (cur.isManaged()) {
+                assert !visitedManaged.get(cur.encoding()) : "duplicate managed " + encoding;
+                visitedManaged.set(cur.encoding());
             } else {
-                Encoding encoding = Encoding.get(cur.encoding());
-                if (cur.isManaged()) {
-                    assert !visitedManaged.get(cur.encoding()) : "duplicate managed " + encoding;
-                    visitedManaged.set(cur.encoding());
+                if (cur.stride() == encoding.naturalStride) {
+                    assert !visitedNativeRegular.get(cur.encoding()) : "duplicate native " + encoding;
+                    visitedNativeRegular.set(cur.encoding());
                 } else {
-                    if (cur.stride() == encoding.naturalStride) {
-                        assert !visitedNativeRegular.get(cur.encoding()) : "duplicate native " + encoding;
-                        visitedNativeRegular.set(cur.encoding());
-                    } else {
-                        assert !visitedNativeCompact.get(cur.encoding()) : "duplicate compact native " + encoding;
-                        visitedNativeCompact.set(cur.encoding());
-                    }
+                    assert !visitedNativeCompact.get(cur.encoding()) : "duplicate compact native " + encoding;
+                    visitedNativeCompact.set(cur.encoding());
                 }
             }
             assert visited.add(cur) : "not a ring structure";
@@ -2540,13 +2500,12 @@ TruffleString nativeImmutable(TruffleString a, Encoding encoding, boolean cacheR
             CompilerAsserts.partialEvaluationConstant(cacheResult);
             a.checkEncoding(encoding);
             TruffleString cur = a.next;
-            assert !a.isJavaString();
             if (cacheResult && cur != null) {
-                while (cur != a && (cur.isNative() || cur.isJavaString() || !cur.isCompatibleToIntl(encoding))) {
+                while (cur != a && (cur.isNative() || !cur.isCompatibleToIntl(encoding))) {
                     cur = cur.next;
                 }
                 if (cacheHit.profile(this, cur != a)) {
-                    assert cur.isCompatibleToIntl(encoding) && cur.isManaged() && !cur.isJavaString();
+                    assert cur.isCompatibleToIntl(encoding) && cur.isManaged();
                     return cur;
                 }
             }
@@ -6940,7 +6899,6 @@ public abstract static class ToJavaStringNode extends AbstractPublicNode {
         @Specialization
         static String doUTF16(TruffleString a,
                         @Bind Node node,
-                        @Cached InlinedConditionProfile cacheHit,
                         @Cached @Exclusive InlinedConditionProfile managedProfileA,
                         @Cached @Exclusive InlinedConditionProfile nativeProfileA,
                         @Cached @Shared TStringInternalNodes.GetCodePointLengthNode getCodePointLengthNode,
@@ -6952,26 +6910,13 @@ static String doUTF16(TruffleString a,
                 return "";
             }
             TruffleString cur = a.next;
-            if (cur != null) {
-                while (cur != a && !cur.isJavaString()) {
-                    cur = cur.next;
-                }
-                if (cacheHit.profile(node, cur.isJavaString())) {
-                    return (String) cur.data();
-                }
-            }
-            cur = a.next;
             if (cur != null) {
                 while (cur != a && !cur.isCompatibleToIntl(Encoding.UTF_16)) {
                     cur = cur.next;
                 }
             } else {
                 cur = a;
             }
-            if (cur.isJavaString()) {
-                // java string was inserted in parallel
-                return (String) cur.data();
-            }
             Encoding encodingA = Encoding.get(cur.encoding());
             final AbstractTruffleString utf16String;
             final byte[] utf16Array;
@@ -7009,9 +6954,7 @@ static String doUTF16(TruffleString a,
                     assert transCoded.isManaged();
                     utf16Offset = byteArrayBaseOffset() + transCoded.offset();
                 }
-                String javaString = createJavaStringNode.execute(node, utf16String, utf16Array, utf16Offset);
-                a.cacheInsert(TruffleString.createWrapJavaString(javaString, utf16String.codePointLength(), utf16String.codeRange()));
-                return javaString;
+                return createJavaStringNode.execute(node, utf16String, utf16Array, utf16Offset);
             } finally {
                 Reference.reachabilityFence(dataCur);
             }
@@ -7173,13 +7116,12 @@ static TruffleString asNative(TruffleString a, NativeAllocator allocator, Encodi
                     return a;
                 }
                 TruffleString cur = a.next;
-                assert !a.isJavaString();
                 if (cacheResult && cur != null) {
                     while (cur != a && (!cur.isNative() || !cur.isCompatibleToIntl(encoding) || cur.stride() != (useCompaction ? strideA : encoding.naturalStride))) {
                         cur = cur.next;
                     }
                     if (cacheHit.profile(node, cur != a)) {
-                        assert cur.isCompatibleToIntl(encoding) && cur.isNative() && !cur.isJavaString() && cur.stride() == (useCompaction ? strideA : encoding.naturalStride);
+                        assert cur.isCompatibleToIntl(encoding) && cur.isNative() && cur.stride() == (useCompaction ? strideA : encoding.naturalStride);
                         return cur;
                     }
                 }
@@ -7426,20 +7368,17 @@ static TruffleString immutable(Node node, TruffleString a, Encoding targetEncodi
             }
             final boolean mustCompact = a.stride() > targetEncoding.naturalStride;
             if (noOpProfile.profile(node, isCompatible && !mustCompact)) {
-                assert !a.isJavaString();
                 return a;
             }
             if (a.isEmpty()) {
                 return targetEncoding.getEmpty();
             }
             TruffleString cur = a.next;
-            assert !a.isJavaString();
             if (cur != null) {
-                while (cur != a && cur.encoding() != targetEncoding.id || (isUTF16(targetEncoding) && cur.isJavaString())) {
+                while (cur != a && cur.encoding() != targetEncoding.id) {
                     cur = cur.next;
                 }
                 if (cacheHit.profile(node, cur.encoding() == targetEncoding.id)) {
-                    assert !cur.isJavaString();
                     return cur;
                 }
             }
@@ -7567,7 +7506,6 @@ public abstract static class ForceEncodingNode extends AbstractPublicNode {
 
         @Specialization(guards = "isCompatibleAndNotCompacted(a, expectedEncoding, targetEncoding)")
         static TruffleString compatibleImmutable(TruffleString a, @SuppressWarnings("unused") Encoding expectedEncoding, @SuppressWarnings("unused") Encoding targetEncoding) {
-            assert !a.isJavaString();
             return a;
         }