refactor jli init activity away from System; add JIT initialization indicator

Author: John Rose

src/hotspot/share/classfile/systemDictionary.cpp

@@ -45,6 +45,7 @@
 #include "classfile/systemDictionary.hpp"
 #include "classfile/vmClasses.hpp"
 #include "classfile/vmSymbols.hpp"
+#include "compiler/compileBroker.hpp"
 #include "gc/shared/gcTraceTime.inline.hpp"
 #include "interpreter/bootstrapInfo.hpp"
 #include "jfr/jfrEvents.hpp"
@@ -2035,6 +2036,11 @@ Method* SystemDictionary::find_method_handle_intrinsic(vmIntrinsicID iid,
 
   // Throw OOM or the pending exception in the JavaThread
   if (throw_error && !HAS_PENDING_EXCEPTION) {
+    if (!CompileBroker::is_initialized() && !Arguments::is_interpreter_only()) {
+      // Give a more accurate diagnostic; we didn't fill up the code cache:
+      THROW_MSG_NULL(vmSymbols::java_lang_InternalError(),
+                     "Compile method handle intrinsic requested before compiler start-up");
+    }
     THROW_MSG_NULL(vmSymbols::java_lang_OutOfMemoryError(),
                    "Out of space in CodeCache for method handle intrinsic");
   }

src/hotspot/share/compiler/compileBroker.cpp

@@ -770,7 +770,7 @@ void CompileBroker::compilation_init(JavaThread* THREAD) {
                                           CHECK);
   }
 
-  _initialized = true;
+  Atomic::release_store(&_initialized, true);
 }
 
 #if defined(ASSERT) && COMPILER2_OR_JVMCI
@@ -1329,7 +1329,7 @@ nmethod* CompileBroker::compile_method(const methodHandle& method, int osr_bci,
                                        CompileTask::CompileReason compile_reason,
                                        TRAPS) {
   // Do nothing if compilebroker is not initialized or compiles are submitted on level none
-  if (!_initialized || comp_level == CompLevel_none) {
+  if (!is_initialized() || comp_level == CompLevel_none) {
     return nullptr;
   }
 

src/hotspot/share/compiler/compileBroker.hpp

@@ -288,6 +288,10 @@ class CompileBroker: AllStatic {
     standard_entry_bci = InvocationEntryBci
   };
 
+  static bool is_initialized() {
+    return Atomic::load_acquire(&_initialized);
+  }
+
   static AbstractCompiler* compiler(int comp_level) {
     if (is_c2_compile(comp_level)) return _compilers[1]; // C2
     if (is_c1_compile(comp_level)) return _compilers[0]; // C1

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

@@ -37,6 +37,7 @@
 import java.lang.annotation.Annotation;
 import java.lang.foreign.MemorySegment;
 import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
 import java.lang.invoke.StringConcatFactory;
 import java.lang.module.ModuleDescriptor;
@@ -2228,21 +2229,15 @@ private static void initPhase1() {
         // system properties, java.lang and other core classes are now initialized
         VM.initLevel(VM.JAVA_LANG_SYSTEM_INITED);
 
-        try {
-            initJSR292Classes();
-        } catch (Throwable ex) {
-            throw new InternalError(ex);
-        }
-        VM.initLevel(VM.JAVA_LANG_INVOKE_INITED);
+        initJavaLangInvokeClasses();
     }
 
     // do phase1 initializations specific to JSR 292 APIs
-    private static void initJSR292Classes() throws Throwable {
-        var mh = java.lang.invoke.MethodHandles.identity(int.class);
-        int z = 0;
-        z |= (int) mh.invokeExact(z);
-        z |= (Integer) mh.invoke((Object)0);
-        if (z != 0)  throw new AssertionError();
+    private static void initJavaLangInvokeClasses() {
+        // Merely touching MethodHandles is enough to warm up the
+        // java.lang.invoke subsystem.
+        MethodHandles.identity(int.class);
+        VM.initLevel(VM.JAVA_LANG_INVOKE_INITED);
     }
 
     /**

src/java.base/share/classes/java/lang/invoke/MethodHandles.java

@@ -8140,4 +8140,44 @@ public static VarHandle collectCoordinates(VarHandle target, int pos, MethodHand
     public static VarHandle dropCoordinates(VarHandle target, int pos, Class<?>... valueTypes) {
         return VarHandles.dropCoordinates(target, pos, valueTypes);
     }
+
+    // During VM bootstrap, java.lang.System (indirectly) calls this
+    // method in order to inititalize the java.lang.invoke subsystem.
+    private static void initializeViaSmokeTest() throws Throwable {
+        // First exercise the direct method handle infrastructure.
+        var MT_identity = MethodType.methodType(MethodHandle.class, Class.class);
+        var MH_identity = publicLookup().findStatic(MethodHandles.class, "identity", MT_identity);
+        // Get a MH from a combinator, two ways; make sure it is the same both ways.
+        var intid = (MethodHandle) MH_identity.invoke(int.class);
+        var mh = identity(int.class);
+        int z = 0;  // should always be zero, badness detected if non-zero
+        if (intid != mh)  z |= 1;
+        // Invoke the MH directly.  Only zeroes should come out.
+        z |= (int) mh.invokeExact(z);
+        assert z == 0;
+        z |= (Integer) mh.invoke((Object)0);
+        assert z == 0;
+        z |= (int) new MutableCallSite(mh).dynamicInvoker().invoke(z);
+        assert z == 0;
+        // Run the MH through a call site, two ways.
+        intid = new ConstantCallSite(intid).dynamicInvoker();
+        if (intid != mh)  z |= 2;
+        assert z == 0;
+        z |= (int) new MutableCallSite(mh).dynamicInvoker().invoke(z);
+        assert z == 0;
+        // Try out a VH
+        int[] a = { -1 };
+        var vh = arrayElementVarHandle(int[].class);
+        vh.set(a, 0, z);
+        z |= a[0];
+        assert z == 0;
+        // Mix a VH into a MH
+        z |= (int) vh.toMethodHandle(VarHandle.AccessMode.GET).bindTo(a).invokeExact(0);
+        // Z must still be zero.
+        if (z != 0)  throw new AssertionError();
+    }
+    static {
+        try { initializeViaSmokeTest(); }
+        catch (Throwable ex) { throw new InternalError(ex); }
+    }
 }

src/java.base/share/classes/jdk/internal/misc/CDS.java

@@ -48,6 +48,9 @@ public class CDS {
     private static final int IS_USING_ARCHIVE                = 1 << 3;
     private static final int configStatus = getCDSConfigStatus();
 
+    // TO DO: maybe hook something like this logic into AOT assembly shutdown:
+    //private static void shutdownAOTAssembly() { configStatus = IS_USING_ARCHIVE; }
+
     /**
      * Should we log the use of lambda form invokers?
      */

src/java.base/share/classes/jdk/internal/misc/VM.java

@@ -59,6 +59,7 @@ public class VM {
     private static volatile int initLevel;
     private static final @Stable boolean[] initLevelReached = new boolean[INIT_LEVEL_LIMIT];
     private static final Object lock = new Object();
+    private static @Stable boolean isAOTCacheInited;  // independent sub-state
 
     /**
      * Sets the init level.
@@ -100,19 +101,28 @@ public static boolean initLevelReached(byte level) {
         return initLevelReached[level];
     }
 
-    private static @Stable boolean isAOTCacheInited;
-    public static void setAOTCacheInited() {
+    // TO DO: maybe hook something like this logic into AOT assembly shutdown:
+    //private static void shutdownAOTAssembly() { setAOTCacheInited(); }
+    static void setAOTCacheInited() {
         if (isAOTCacheInited) {
             throw new InternalError("AOT cache already inited");
         }
-        isAOTCacheInited = true;
+        isAOTCacheInited = CDS.isDumpingStaticArchive() ? false : true;
+        // Note: this is not just another state such as
+        // AOT_ASSEMBLY_DONE < VM_STARTED.
+        //
+        // That is because the AOT assembly phase runs up from
+        // VM_STARTED through SYSTEM_BOOTED in order to synthesize an
+        // AOT cache full of loaded classes and other goodies.
+        // Thus, the true set of states is roughly the cross
+        // product (initLevel, inassembly = !isAOTCacheInited).
     }
 
     /**
      * Returns {@code true} if the AOT cache has been initialized.
      * This is almost always {@code true}, but may be false during a
-     * special run of the VM called the "assembly phase", which
-     * populates an AOT cache.  If there was never an AOT cache for
+     * special run of the VM called the "AOT assembly phase", which
+     * populates an AOT cache.  If there never was an AOT cache for
      * this run of the VM, the boolean is also {@code true}, as if
      * there was a very tiny AOT cache that was instantaneously
      * initialized.