8383559: [lworld] Autobox cache removal causes performance regression with Renaissance benchmarks

src/hotspot/share/ci/ciField.cpp

@@ -499,9 +499,7 @@ bool ciField::is_call_site_target() {
 
 bool ciField::is_autobox_cache() {
   ciSymbol* klass_name = holder()->name();
-  // The box cache is disabled when boxes are value classes.
-  return (!Arguments::is_valhalla_enabled() &&
-          name() == ciSymbols::cache_field_name() &&
+  return (name() == ciSymbols::cache_field_name() &&
           holder()->uses_default_loader() &&
           (klass_name == ciSymbols::java_lang_Character_CharacterCache() ||
             klass_name == ciSymbols::java_lang_Byte_ByteCache() ||

src/hotspot/share/opto/type.cpp

@@ -327,7 +327,7 @@ const Type* Type::make_from_constant(ciConstant constant, bool require_constant,
         } else {
           guarantee(require_constant || oop_constant->should_be_constant(), "con_type must get computed");
           con_type = TypeOopPtr::make_from_constant(oop_constant, require_constant);
-          if (Compile::current()->eliminate_boxing() && is_autobox_cache) {
+          if (is_autobox_cache) {
             con_type = con_type->is_aryptr()->cast_to_autobox_cache();
           }
           if (stable_dimension > 0) {

src/hotspot/share/runtime/deoptimization.cpp

@@ -1146,7 +1146,6 @@ template<typename PrimitiveType, typename CacheType, typename BoxType> class Box
 protected:
   static BoxCache<PrimitiveType, CacheType, BoxType> *_singleton;
   BoxCache(Thread* thread) {
-    assert(!Arguments::is_valhalla_enabled(), "Should not use box caches with enable preview");
     InstanceKlass* ik = BoxCacheBase<CacheType>::find_cache_klass(thread, CacheType::symbol());
     if (ik->is_in_error_state()) {
       _low = 1;
@@ -1256,10 +1255,6 @@ class BooleanBoxCache : public BoxCacheBase<java_lang_Boolean> {
 BooleanBoxCache* BooleanBoxCache::_singleton = nullptr;
 
 oop Deoptimization::get_cached_box(AutoBoxObjectValue* bv, frame* fr, RegisterMap* reg_map, bool& cache_init_error, TRAPS) {
-  if (Arguments::enable_preview()) {
-    // Box caches are not used with enable preview.
-    return nullptr;
-  }
    Klass* k = java_lang_Class::as_Klass(bv->klass()->as_ConstantOopReadValue()->value()());
    BasicType box_type = vmClasses::box_klass_type(k);
    if (box_type != T_OBJECT) {

src/java.base/share/classes/java/lang/Boolean.java

@@ -183,10 +183,7 @@ public boolean booleanValue() {
     @IntrinsicCandidate
     @DeserializeConstructor
     public static Boolean valueOf(boolean b) {
-        if (!PreviewFeatures.isEnabled()) {
-            return (b ? TRUE : FALSE);
-        }
-        return new Boolean(b);
+        return (b ? TRUE : FALSE);
     }
 
     /**

src/java.base/share/classes/java/lang/Byte.java

@@ -28,6 +28,7 @@
 import jdk.internal.misc.CDS;
 import jdk.internal.misc.PreviewFeatures;
 import jdk.internal.value.DeserializeConstructor;
+import jdk.internal.value.ValueClass;
 import jdk.internal.vm.annotation.AOTSafeClassInitializer;
 import jdk.internal.vm.annotation.IntrinsicCandidate;
 import jdk.internal.vm.annotation.Stable;
@@ -123,25 +124,29 @@ private ByteCache() {}
         static Byte[] archivedCache;
 
         static {
-            if (!PreviewFeatures.isEnabled()) {
-                final int size = -(-128) + 127 + 1;
+            final int size = -(-128) + 127 + 1;
 
-                // Load and use the archived cache if it exists
+            // Load and use the archived cache if it exists
+            if (!PreviewFeatures.isEnabled()) {
                 CDS.initializeFromArchive(ByteCache.class);
-                if (archivedCache == null) {
-                    Byte[] c = new Byte[size];
-                    byte value = (byte)-128;
-                    for(int i = 0; i < size; i++) {
-                        c[i] = new Byte(value++);
-                    }
-                    archivedCache = c;
+            }
+            if (archivedCache == null) {
+                Byte[] c = newCacheArray(size);
+                byte value = (byte)-128;
+                for(int i = 0; i < size; i++) {
+                    c[i] = new Byte(value++);
                 }
-                cache = archivedCache;
-                assert cache.length == size;
-            } else {
-                cache = null;
-                assert archivedCache == null;
+                archivedCache = c;
             }
+            cache = archivedCache;
+            assert cache.length == size;
+        }
+
+        private static Byte[] newCacheArray(int size) {
+            if (PreviewFeatures.isEnabled()) {
+                return (Byte[]) ValueClass.newReferenceArray(Byte.class, size);
+            }
+            return new Byte[size];
         }
     }
 
@@ -173,11 +178,8 @@ private ByteCache() {}
     @IntrinsicCandidate
     @DeserializeConstructor
     public static Byte valueOf(byte b) {
-        if (!PreviewFeatures.isEnabled()) {
-            final int offset = 128;
-            return ByteCache.cache[(int) b + offset];
-        }
-        return new Byte(b);
+        final int offset = 128;
+        return ByteCache.cache[(int) b + offset];
     }
 
     /**

src/java.base/share/classes/java/lang/Character.java

@@ -28,6 +28,7 @@
 import jdk.internal.misc.CDS;
 import jdk.internal.misc.PreviewFeatures;
 import jdk.internal.value.DeserializeConstructor;
+import jdk.internal.value.ValueClass;
 import jdk.internal.vm.annotation.AOTSafeClassInitializer;
 import jdk.internal.vm.annotation.IntrinsicCandidate;
 import jdk.internal.vm.annotation.Stable;
@@ -9435,24 +9436,28 @@ private CharacterCache(){}
         static Character[] archivedCache;
 
         static {
-            if (!PreviewFeatures.isEnabled()) {
-                int size = 127 + 1;
+            int size = 127 + 1;
 
-                // Load and use the archived cache if it exists
+            // Load and use the archived cache if it exists
+            if (!PreviewFeatures.isEnabled()) {
                 CDS.initializeFromArchive(CharacterCache.class);
-                if (archivedCache == null) {
-                    Character[] c = new Character[size];
-                    for (int i = 0; i < size; i++) {
-                        c[i] = new Character((char) i);
-                    }
-                    archivedCache = c;
+            }
+            if (archivedCache == null) {
+                Character[] c = newCacheArray(size);
+                for (int i = 0; i < size; i++) {
+                    c[i] = new Character((char) i);
                 }
-                cache = archivedCache;
-                assert cache.length == size;
-            } else {
-                cache = null;
-                assert archivedCache == null;
+                archivedCache = c;
             }
+            cache = archivedCache;
+            assert cache.length == size;
+        }
+
+        private static Character[] newCacheArray(int size) {
+            if (PreviewFeatures.isEnabled()) {
+                return (Character[]) ValueClass.newReferenceArray(Character.class, size);
+            }
+            return new Character[size];
         }
     }
 
@@ -9487,10 +9492,8 @@ private CharacterCache(){}
     @IntrinsicCandidate
     @DeserializeConstructor
     public static Character valueOf(char c) {
-        if (!PreviewFeatures.isEnabled()) {
-            if (c <= 127) { // must cache
-                return CharacterCache.cache[(int) c];
-            }
+        if (c <= 127) { // must cache
+            return CharacterCache.cache[(int) c];
         }
         return new Character(c);
     }

src/java.base/share/classes/java/lang/Integer.java

@@ -30,6 +30,7 @@
 import jdk.internal.misc.VM;
 import jdk.internal.util.DecimalDigits;
 import jdk.internal.value.DeserializeConstructor;
+import jdk.internal.value.ValueClass;
 import jdk.internal.vm.annotation.AOTRuntimeSetup;
 import jdk.internal.vm.annotation.AOTSafeClassInitializer;
 import jdk.internal.vm.annotation.ForceInline;
@@ -913,12 +914,7 @@ private static final class IntegerCache {
         static Integer[] archivedCache;
 
         static {
-            if (!PreviewFeatures.isEnabled()) {
-                runtimeSetup();
-            } else {
-                cache = null;
-                assert archivedCache == null;
-            }
+            runtimeSetup();
         }
 
         @AOTRuntimeSetup
@@ -939,18 +935,22 @@ private static void runtimeSetup() {
             high = h;
 
             Integer[] precomputed = null;
-            if (cache != null) {
-                // IntegerCache has been AOT-initialized.
-                precomputed = cache;
-            } else {
-                // Legacy CDS archive support (to be deprecated):
-                // Load IntegerCache.archivedCache from archive, if possible
-                CDS.initializeFromArchive(IntegerCache.class);
-                precomputed = archivedCache;
+            if (!PreviewFeatures.isEnabled()) {
+                if (cache != null) {
+                    // IntegerCache has been AOT-initialized.
+                    precomputed = cache;
+                } else {
+                    // Legacy CDS archive support (to be deprecated):
+                    // Load IntegerCache.archivedCache from archive, if possible
+                    CDS.initializeFromArchive(IntegerCache.class);
+                    precomputed = archivedCache;
+                }
             }
 
             cache = loadOrInitializeCache(precomputed);
-            archivedCache = cache; // Legacy CDS archive support (to be deprecated)
+            if (!PreviewFeatures.isEnabled()) {
+                archivedCache = cache; // Legacy CDS archive support (to be deprecated)
+            }
             // range [-128, 127] must be interned (JLS7 5.1.7)
             assert IntegerCache.high >= 127;
         }
@@ -963,7 +963,7 @@ private static Integer[] loadOrInitializeCache(Integer[] precomputed) {
                 return precomputed;
             }
 
-            Integer[] c = new Integer[size];
+            Integer[] c = newCacheArray(size);
             int j = low;
             // If we loading a precomputed cache (from AOT cache or CDS archive),
             // we must use all instances from it.
@@ -982,6 +982,13 @@ private static Integer[] loadOrInitializeCache(Integer[] precomputed) {
             return c;
         }
 
+        private static Integer[] newCacheArray(int size) {
+            if (PreviewFeatures.isEnabled()) {
+                return (Integer[]) ValueClass.newReferenceArray(Integer.class, size);
+            }
+            return new Integer[size];
+        }
+
         private IntegerCache() {}
     }
 
@@ -1015,10 +1022,8 @@ private IntegerCache() {}
     @IntrinsicCandidate
     @DeserializeConstructor
     public static Integer valueOf(int i) {
-        if (!PreviewFeatures.isEnabled()) {
-            if (i >= IntegerCache.low && i <= IntegerCache.high)
-                return IntegerCache.cache[i + (-IntegerCache.low)];
-        }
+        if (i >= IntegerCache.low && i <= IntegerCache.high)
+            return IntegerCache.cache[i + (-IntegerCache.low)];
         return new Integer(i);
     }
 

src/java.base/share/classes/java/lang/Long.java

@@ -36,6 +36,7 @@
 import jdk.internal.misc.CDS;
 import jdk.internal.misc.PreviewFeatures;
 import jdk.internal.value.DeserializeConstructor;
+import jdk.internal.value.ValueClass;
 import jdk.internal.util.DecimalDigits;
 import jdk.internal.vm.annotation.AOTSafeClassInitializer;
 import jdk.internal.vm.annotation.ForceInline;
@@ -933,25 +934,29 @@ private LongCache() {}
         static Long[] archivedCache;
 
         static {
-            if (!PreviewFeatures.isEnabled()) {
-                int size = -(-128) + 127 + 1;
+            int size = -(-128) + 127 + 1;
 
-                // Load and use the archived cache if it exists
+            // Load and use the archived cache if it exists
+            if (!PreviewFeatures.isEnabled()) {
                 CDS.initializeFromArchive(LongCache.class);
-                if (archivedCache == null) {
-                    Long[] c = new Long[size];
-                    long value = -128;
-                    for(int i = 0; i < size; i++) {
-                        c[i] = new Long(value++);
-                    }
-                    archivedCache = c;
+            }
+            if (archivedCache == null) {
+                Long[] c = newCacheArray(size);
+                long value = -128;
+                for(int i = 0; i < size; i++) {
+                    c[i] = new Long(value++);
                 }
-                cache = archivedCache;
-                assert cache.length == size;
-            } else {
-                cache = null;
-                assert archivedCache == null;
+                archivedCache = c;
             }
+            cache = archivedCache;
+            assert cache.length == size;
+        }
+
+        private static Long[] newCacheArray(int size) {
+            if (PreviewFeatures.isEnabled()) {
+                return (Long[]) ValueClass.newReferenceArray(Long.class, size);
+            }
+            return new Long[size];
         }
     }
 
@@ -985,11 +990,9 @@ private LongCache() {}
     @IntrinsicCandidate
     @DeserializeConstructor
     public static Long valueOf(long l) {
-        if (!PreviewFeatures.isEnabled()) {
-            if (l >= -128 && l <= 127) { // will cache
-                final int offset = 128;
-                return LongCache.cache[(int) l + offset];
-            }
+        if (l >= -128 && l <= 127) { // will cache
+            final int offset = 128;
+            return LongCache.cache[(int) l + offset];
         }
         return new Long(l);
     }