Avoid eager initialization of lookup types and option descriptors.

Author: chumer

truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/OptimizedTruffleRuntime.java

@@ -195,9 +195,10 @@ public static OptimizedTruffleRuntime getRuntime() {
 
     private final LoopNodeFactory loopNodeFactory;
     private EngineCacheSupport engineCacheSupport;
-    private final UnmodifiableEconomicMap<String, Class<?>> lookupTypes;
+    private final Iterable<Class<?>> extraLookupTypes;
+    private UnmodifiableEconomicMap<String, Class<?>> lookupTypes;
     private final FloodControlHandler floodControlHandler;
-    private final List<OptionDescriptors> runtimeOptionDescriptors;
+    private final List<OptionDescriptors> extensionOptionDescriptors;
     protected volatile OptionDescriptors engineOptions;
 
     protected final TruffleCompilationSupport compilationSupport;
@@ -206,24 +207,22 @@ public static OptimizedTruffleRuntime getRuntime() {
     @SuppressWarnings("this-escape")
     public OptimizedTruffleRuntime(TruffleCompilationSupport compilationSupport, Iterable<Class<?>> extraLookupTypes) {
         this.compilationSupport = compilationSupport;
-        this.lookupTypes = initLookupTypes(extraLookupTypes);
+        this.extraLookupTypes = extraLookupTypes;
         List<OptionDescriptors> options = new ArrayList<>();
         this.loopNodeFactory = loadGraalRuntimeServiceProvider(LoopNodeFactory.class, options, true);
         EngineCacheSupport support = loadEngineCacheSupport(options);
         this.engineCacheSupport = support == null ? new EngineCacheSupport.Disabled() : support;
         this.previousEngineCacheSupportOptions = engineCacheSupport.getEngineOptions();
-        options.add(OptimizedRuntimeOptions.getDescriptors());
-        options.add(new CompilerOptionsDescriptors());
-        this.runtimeOptionDescriptors = options;
+        this.extensionOptionDescriptors = options;
         this.floodControlHandler = loadGraalRuntimeServiceProvider(FloodControlHandler.class, null, false);
     }
 
     public final void initializeEngineCacheSupport(EngineCacheSupport support) {
-        this.runtimeOptionDescriptors.remove(this.previousEngineCacheSupportOptions);
+        this.extensionOptionDescriptors.remove(this.previousEngineCacheSupportOptions);
         this.engineCacheSupport = support;
         OptionDescriptors engineCacheOptions = support.getEngineOptions();
         this.previousEngineCacheSupportOptions = engineCacheOptions;
-        this.runtimeOptionDescriptors.add(engineCacheOptions);
+        this.extensionOptionDescriptors.add(engineCacheOptions);
     }
 
     protected EngineCacheSupport loadEngineCacheSupport(List<OptionDescriptors> options) {
@@ -249,7 +248,15 @@ public String getName() {
      * Returns a set of classes that need to be initialized before compilations can be performed.
      */
     public final Iterable<Class<?>> getLookupTypes() {
-        return lookupTypes.getValues();
+        return getLookupTypesMap().getValues();
+    }
+
+    private UnmodifiableEconomicMap<String, Class<?>> getLookupTypesMap() {
+        UnmodifiableEconomicMap<String, Class<?>> map = this.lookupTypes;
+        if (map == null) {
+            this.lookupTypes = map = initLookupTypes(extraLookupTypes);
+        }
+        return map;
     }
 
     /**
@@ -500,7 +507,7 @@ private static UnmodifiableEconomicMap<String, Class<?>> initLookupTypes(Iterabl
      */
     @Override
     public ResolvedJavaType resolveType(MetaAccessProvider metaAccess, String className, boolean required) {
-        Class<?> c = lookupTypes.get(className);
+        Class<?> c = getLookupTypesMap().get(className);
         if (c == null) {
             if (!required) {
                 return null;
@@ -1121,16 +1128,24 @@ protected long getCompilerIdleDelay(OptimizedCallTarget callTarget) {
     }
 
     final OptionDescriptors getOptionDescriptors() {
-        // The engineOptions field needs to be initialized lazily because the
-        // OptimizedRuntimeAccessor
-        // cannot be used in the OptimizedTruffleRuntime constructor. The OptimizedTruffleRuntime
-        // must be
-        // fully initialized before using the accessor otherwise a NullPointerException will be
-        // thrown from the Accessor.Constants static initializer because the Truffle#getRuntime
-        // still returns null.
+        /*
+         * The engineOptions field needs to be initialized lazily because the
+         * OptimizedRuntimeAccessor cannot be used in the OptimizedTruffleRuntime constructor. The
+         * OptimizedTruffleRuntime must be fully initialized before using the accessor otherwise a
+         * NullPointerException will be thrown from the Accessor.Constants static initializer
+         * because the Truffle#getRuntime still returns null.
+         */
         OptionDescriptors res = engineOptions;
         if (res == null) {
-            res = OptimizedRuntimeAccessor.LANGUAGE.createOptionDescriptorsUnion(runtimeOptionDescriptors.toArray(new OptionDescriptors[runtimeOptionDescriptors.size()]));
+            List<OptionDescriptors> options = new ArrayList<>(extensionOptionDescriptors.size() + 2);
+            /*
+             * We initialize these options lazily so in case no engine options are used we don't
+             * need to load them.
+             */
+            options.addAll(extensionOptionDescriptors);
+            options.add(OptimizedRuntimeOptions.getDescriptors());
+            options.add(new CompilerOptionsDescriptors());
+            res = OptimizedRuntimeAccessor.LANGUAGE.createOptionDescriptorsUnion(options.toArray(OptionDescriptors[]::new));
             engineOptions = res;
         }
         return res;

truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/hotspot/HotSpotTruffleRuntime.java

@@ -130,6 +130,16 @@ private static Unsafe getUnsafe() {
         }
     }
 
+    /*
+     * Invoked before the first compilation, but still on an interpreter thread. This makes it safe
+     * to initialize certain classes.
+     */
+    private void onFirstCompilation() {
+        installDefaultListeners();
+        // make sure lookup types are installed lazily when the first compilation is scheduled
+        getLookupTypes();
+    }
+
     /**
      * Contains lazily computed data such as the compilation queue and helper for stack
      * introspection.
@@ -139,7 +149,7 @@ static final class Lazy extends BackgroundCompileQueue {
 
         Lazy(HotSpotTruffleRuntime runtime) {
             super(runtime);
-            runtime.installDefaultListeners();
+            runtime.onFirstCompilation();
         }
 
         @Override