Track run-time conditions when creating handler

Author: vjovanov

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/impl/ConfigurationCondition.java

@@ -105,4 +105,11 @@ public int hashCode() {
         return Objects.hash(type, runtimeChecked);
     }
 
+    @Override
+    public String toString() {
+        return "ConfigurationCondition(" +
+                        "type=" + type +
+                        ", runtimeChecked=" + runtimeChecked +
+                        ')';
+    }
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/configure/ConfigurationFiles.java

@@ -125,16 +125,16 @@ public static final class Options {
         @Option(help = "When configuration files do not match their schema, abort the image build instead of emitting a warning.")//
         public static final HostedOptionKey<Boolean> StrictConfiguration = new HostedOptionKey<>(false);
 
-        @Option(help = "Testing flag: the typeReachable condition is treated as typeReached so the semantics of programs can change.")//
+        @Option(help = "Testing flag: the 'typeReachable' condition is treated as typeReached so the semantics of programs can change.")//
         public static final HostedOptionKey<Boolean> TreatAllTypeReachableConditionsAsTypeReached = new HostedOptionKey<>(false);
 
-        @Option(help = "Testing flag: the 'name' is treated as 'type' reflection configuration.")//
+        @Option(help = "Testing flag: the 'name' is treated as 'type' in reflection configuration.")//
         public static final HostedOptionKey<Boolean> TreatAllNameEntriesAsType = new HostedOptionKey<>(false);
 
         @Option(help = "Testing flag: the 'typeReached' condition is always satisfied however it prints the stack trace where it would not be satisfied.")//
         public static final HostedOptionKey<Boolean> TrackUnsatisfiedTypeReachedConditions = new HostedOptionKey<>(false);
 
-        @Option(help = "Testing flag: print 'typeReached' conditions that are used on interfaces at build time.")//
+        @Option(help = "Testing flag: print 'typeReached' conditions that are used on interfaces without default methods at build time.")//
         public static final HostedOptionKey<Boolean> TrackTypeReachedOnInterfaces = new HostedOptionKey<>(false);
 
         @Option(help = "Testing flag: every type is considered as it participates in a typeReachable condition.")//

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/Resources.java

@@ -319,6 +319,7 @@ public ResourceStorageEntryBase getAtRuntime(String name, boolean throwOnMissing
      * tried on the same resource name, causing an unexpected exception if we throw directly.
      */
     public ResourceStorageEntryBase getAtRuntime(Module module, String resourceName, boolean throwOnMissing) {
+        VMError.guarantee(ImageInfo.inImageRuntimeCode(), "This function should be used only at runtime.");
         String canonicalResourceName = toCanonicalForm(resourceName);
         String moduleName = moduleName(module);
         ConditionalRuntimeValue<ResourceStorageEntryBase> entry = resources.get(createStorageKey(module, canonicalResourceName));

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/localization/LocalizationSupport.java

@@ -162,7 +162,6 @@ public void prepareBundle(String bundleName, ResourceBundle bundle, Function<Str
                     Optional<Module> module = findModule.apply(bundleNameWithModule[0]);
                     String finalResourceName = resourceName;
                     module.ifPresent(m -> ImageSingletons.lookup(RuntimeResourceSupport.class).addResource(m, finalResourceName));
-
                 }
             }
         }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/reflect/serialize/SerializationRegistry.java

@@ -27,7 +27,8 @@
 
 public interface SerializationRegistry {
 
+    boolean isRegisteredForSerialization(Class<?> cl);
+
     Object getSerializationConstructorAccessor(Class<?> serializationTargetClass, Class<?> targetConstructorClass);
 
-    boolean isRegisteredForSerialization(Class<?> aClass);
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/reflect/serialize/SerializationSupport.java

@@ -31,9 +31,7 @@
 import java.lang.invoke.SerializedLambda;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Modifier;
-import java.util.Map;
 import java.util.Objects;
-import java.util.concurrent.ConcurrentHashMap;
 
 import org.graalvm.collections.EconomicMap;
 import org.graalvm.collections.MapCursor;
@@ -157,19 +155,27 @@ public SerializationLookupKey getKeyFromConstructorAccessorClass(Class<?> constr
         return null;
     }
 
-    private final Map<Class<?>, RuntimeConditionSet> classes = new ConcurrentHashMap<>();
-    private final Map<String, RuntimeConditionSet> lambdaCapturingClasses = new ConcurrentHashMap<>();
+    private final EconomicMap<Class<?>, RuntimeConditionSet> classes = EconomicMap.create();
+    private final EconomicMap<String, RuntimeConditionSet> lambdaCapturingClasses = EconomicMap.create();
 
     @Platforms(Platform.HOSTED_ONLY.class)
     public void registerSerializationTargetClass(ConfigurationCondition cnd, Class<?> serializationTargetClass) {
-        classes.computeIfAbsent(serializationTargetClass, k -> RuntimeConditionSet.emptySet())
-                        .addCondition(cnd);
+        synchronized (classes) {
+            var previous = classes.putIfAbsent(serializationTargetClass, RuntimeConditionSet.createHosted(cnd));
+            if (previous != null) {
+                previous.addCondition(cnd);
+            }
+        }
     }
 
     @Platforms(Platform.HOSTED_ONLY.class)
     public void registerLambdaCapturingClass(ConfigurationCondition cnd, String lambdaCapturingClass) {
-        lambdaCapturingClasses.computeIfAbsent(lambdaCapturingClass, k -> RuntimeConditionSet.emptySet())
-                        .addCondition(cnd);
+        synchronized (lambdaCapturingClasses) {
+            var previousConditions = lambdaCapturingClasses.putIfAbsent(lambdaCapturingClass, RuntimeConditionSet.createHosted(cnd));
+            if (previousConditions != null) {
+                previousConditions.addCondition(cnd);
+            }
+        }
     }
 
     @Platforms(Platform.HOSTED_ONLY.class)
@@ -205,8 +211,8 @@ public Object getSerializationConstructorAccessor(Class<?> rawDeclaringClass, Cl
     }
 
     @Override
-    public boolean isRegisteredForSerialization(Class<?> jClass) {
-        var conditionSet = classes.get(jClass);
+    public boolean isRegisteredForSerialization(Class<?> clazz) {
+        var conditionSet = classes.get(clazz);
         return conditionSet != null && conditionSet.satisfied();
     }
 }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ConditionalConfigurationRegistry.java

@@ -34,44 +34,52 @@
 import org.graalvm.nativeimage.hosted.Feature;
 import org.graalvm.nativeimage.impl.ConfigurationCondition;
 
+import com.oracle.svm.core.util.VMError;
 import com.oracle.svm.hosted.classinitialization.ClassInitializationSupport;
 
 public abstract class ConditionalConfigurationRegistry {
+    private Feature.BeforeAnalysisAccess beforeAnalysisAccess;
     private final Map<Class<?>, Collection<Runnable>> pendingReachabilityHandlers = new ConcurrentHashMap<>();
 
     protected void registerConditionalConfiguration(ConfigurationCondition condition, Consumer<ConfigurationCondition> consumer) {
         Objects.requireNonNull(condition, "Cannot use null value as condition for conditional configuration. Please ensure that you register a non-null condition.");
         Objects.requireNonNull(consumer, "Cannot use null value as runnable for conditional configuration. Please ensure that you register a non-null runnable.");
+        if (condition.isRuntimeChecked() && !condition.isAlwaysTrue()) {
+            /*
+             * We do this before the type is reached as the handler runs during analysis when it is
+             * too late to register types for reached tracking. If the type is never reached, there
+             * is no damage as subtypes will also never be reached.
+             */
+            ClassInitializationSupport.singleton().addForTypeReachedTracking(condition.getType());
+        }
         if (ConfigurationCondition.alwaysTrue().equals(condition)) {
             /* analysis optimization to include new types as early as possible */
             consumer.accept(ConfigurationCondition.alwaysTrue());
         } else {
-            Collection<Runnable> handlers = pendingReachabilityHandlers.computeIfAbsent(condition.getType(), key -> new ConcurrentLinkedQueue<>());
             ConfigurationCondition runtimeCondition;
             if (condition.isRuntimeChecked()) {
-                ClassInitializationSupport.singleton().addForTypeReachedTracking(condition.getType());
                 runtimeCondition = condition;
             } else {
                 runtimeCondition = ConfigurationCondition.alwaysTrue();
             }
+            if (beforeAnalysisAccess == null) {
+                Collection<Runnable> handlers = pendingReachabilityHandlers.computeIfAbsent(condition.getType(), key -> new ConcurrentLinkedQueue<>());
+                handlers.add(() -> consumer.accept(runtimeCondition));
+            } else {
+                beforeAnalysisAccess.registerReachabilityHandler(access -> consumer.accept(runtimeCondition), condition.getType());
+            }
 
-            handlers.add(() -> consumer.accept(runtimeCondition));
         }
 
     }
 
-    public void flushConditionalConfiguration(Feature.BeforeAnalysisAccess b) {
+    public void setAnalysisAccess(Feature.BeforeAnalysisAccess beforeAnalysisAccess) {
+        VMError.guarantee(this.beforeAnalysisAccess == null, "Analysis access can be set only once.");
+        this.beforeAnalysisAccess = Objects.requireNonNull(beforeAnalysisAccess);
         for (Map.Entry<Class<?>, Collection<Runnable>> reachabilityEntry : pendingReachabilityHandlers.entrySet()) {
-            b.registerReachabilityHandler(access -> reachabilityEntry.getValue().forEach(Runnable::run), reachabilityEntry.getKey());
+            this.beforeAnalysisAccess.registerReachabilityHandler(access -> reachabilityEntry.getValue().forEach(Runnable::run), reachabilityEntry.getKey());
         }
         pendingReachabilityHandlers.clear();
     }
 
-    public void flushConditionalConfiguration(Feature.DuringAnalysisAccess b) {
-        if (!pendingReachabilityHandlers.isEmpty()) {
-            b.requireAnalysisIteration();
-        }
-        flushConditionalConfiguration((Feature.BeforeAnalysisAccess) b);
-    }
-
 }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ResourcesFeature.java

@@ -195,6 +195,7 @@ public void addGlob(ConfigurationCondition condition, String module, String glob
             globWorkSet.add(new ConditionalPattern(condition, resolvedGlob));
         }
 
+        @Override
         public void addCondition(ConfigurationCondition condition, Module module, String resourcePath) {
             var conditionalResource = Resources.singleton().getResourceStorage().get(createStorageKey(module, resourcePath));
             if (conditionalResource != null) {
@@ -436,7 +437,7 @@ public void beforeAnalysis(BeforeAnalysisAccess access) {
             try {
                 collector.prepareProgressReporter();
                 ImageSingletons.lookup(ClassLoaderSupport.class).collectResources(collector);
-                collector.flushConditionalConfiguration(access);
+                collector.setAnalysisAccess(access);
             } finally {
                 collector.shutDownProgressReporter();
             }
@@ -450,12 +451,7 @@ public void beforeAnalysis(BeforeAnalysisAccess access) {
         resourcePatternWorkSet = Set.of();
         globWorkSet = Set.of();
 
-        resourceRegistryImpl().flushConditionalConfiguration(access);
-    }
-
-    @Override
-    public void duringAnalysis(DuringAnalysisAccess access) {
-        resourceRegistryImpl().flushConditionalConfiguration(access);
+        resourceRegistryImpl().setAnalysisAccess(access);
     }
 
     private static final class ResourceCollectorImpl extends ConditionalConfigurationRegistry implements ResourceCollector {

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/classinitialization/ClassInitializationSupport.java

@@ -495,11 +495,13 @@ private static void addAllInterfaces(Class<?> clazz, EconomicSet<Class<?>> resul
 
     public void addForTypeReachedTracking(Class<?> clazz) {
         if (TrackTypeReachedOnInterfaces.getValue() && clazz.isInterface() && !metaAccess.lookupJavaType(clazz).declaresDefaultMethods()) {
-            LogUtils.info("Detected 'typeReached' on interface type without default methods: " + clazz);
+            LogUtils.info("Detected 'typeReached' on interface type without default methods: %s", clazz.getName());
         }
 
         if (!isAlwaysReached(clazz)) {
-            UserError.guarantee(!configurationSealed, "It is not possible to register types for reachability tracking after the analysis has started.");
+            UserError.guarantee(!configurationSealed || typesRequiringReachability.contains(clazz),
+                            "It is not possible to register types for reachability tracking after the analysis has started if they were not registered before analysis started. Trying to register: %s",
+                            clazz.getName());
             typesRequiringReachability.add(clazz);
         }
     }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIAccessFeature.java

@@ -257,12 +257,7 @@ public void beforeAnalysis(BeforeAnalysisAccess arg) {
             registerJavaCallTrampoline(access, variant, true);
         }
 
-        /* duplicated to reduce the number of analysis iterations */
-        getConditionalConfigurationRegistry().flushConditionalConfiguration(access);
-    }
-
-    private static ConditionalConfigurationRegistry getConditionalConfigurationRegistry() {
-        return singleton().runtimeSupport;
+        singleton().runtimeSupport.setAnalysisAccess(access);
     }
 
     private static void registerJavaCallTrampoline(BeforeAnalysisAccessImpl access, CallVariant variant, boolean nonVirtual) {
@@ -319,7 +314,6 @@ private boolean wereElementsAdded() {
 
     @Override
     public void duringAnalysis(DuringAnalysisAccess a) {
-        getConditionalConfigurationRegistry().flushConditionalConfiguration(a);
         DuringAnalysisAccessImpl access = (DuringAnalysisAccessImpl) a;
         if (!wereElementsAdded()) {
             return;