[GR-31713] Implement a prototype of Reachability Analysis for Native Image

substratevm/mx.substratevm/suite.py

@@ -408,13 +408,28 @@
             "workingSets": "SVM",
         },
 
+
+        "com.oracle.graal.reachability": {
+            "subDir": "src",
+            "sourceDirs": ["src"],
+            "dependencies": [
+                "com.oracle.graal.pointsto",
+            ],
+            "checkstyle": "com.oracle.svm.core",
+            "javaCompliance": "11+",
+            "annotationProcessors": [
+                "compiler:GRAAL_PROCESSOR",
+            ],
+            "workingSets": "SVM",
+        },
+
         "com.oracle.svm.hosted": {
             "subDir": "src",
             "sourceDirs": ["src"],
             "dependencies": [
                 "com.oracle.objectfile",
                 "com.oracle.svm.core",
-                "com.oracle.graal.pointsto",
+                "com.oracle.graal.reachability"
             ],
             "requires" : [
                 "java.desktop",

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/AbstractAnalysisEngine.java

@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 2021, 2021, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.pointsto;
+
+import com.oracle.graal.pointsto.api.HostVM;
+import com.oracle.graal.pointsto.api.PointstoOptions;
+import com.oracle.graal.pointsto.constraints.UnsupportedFeatures;
+import com.oracle.graal.pointsto.meta.AnalysisField;
+import com.oracle.graal.pointsto.meta.AnalysisMetaAccess;
+import com.oracle.graal.pointsto.meta.AnalysisMethod;
+import com.oracle.graal.pointsto.meta.AnalysisType;
+import com.oracle.graal.pointsto.meta.AnalysisUniverse;
+import com.oracle.graal.pointsto.meta.HostedProviders;
+import com.oracle.graal.pointsto.reports.StatisticsPrinter;
+import com.oracle.graal.pointsto.util.CompletionExecutor;
+import com.oracle.graal.pointsto.util.Timer;
+import jdk.vm.ci.meta.ConstantReflectionProvider;
+import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
+import org.graalvm.compiler.debug.DebugContext;
+import org.graalvm.compiler.debug.DebugHandlersFactory;
+import org.graalvm.compiler.nodes.spi.Replacements;
+import org.graalvm.compiler.options.OptionValues;
+import org.graalvm.compiler.printer.GraalDebugHandlersFactory;
+
+import java.io.PrintWriter;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ForkJoinPool;
+
+public abstract class AbstractAnalysisEngine implements BigBang {
+
+    private final Boolean extendedAsserts;
+    private final Timer processFeaturesTimer;
+    private final Timer analysisTimer;
+    protected final Timer checkObjectsTimer;
+    protected final Timer reachabilityTimer;
+    protected final AnalysisMetaAccess metaAccess;
+    private final HostedProviders providers;
+    protected final HostVM hostVM;
+    protected final ForkJoinPool executorService;
+    private final Runnable heartbeatCallback;
+    protected final UnsupportedFeatures unsupportedFeatures;
+    protected final DebugContext debug;
+    protected final OptionValues options;
+    protected final AnalysisUniverse universe;
+    private final List<DebugHandlersFactory> debugHandlerFactories;
+    private final HeapScanningPolicy heapScanningPolicy;
+    private final Replacements replacements;
+    protected final CompletionExecutor executor;
+    protected final AnalysisTiming timing;
+
+    public AbstractAnalysisEngine(OptionValues options, AnalysisUniverse universe, HostedProviders providers, HostVM hostVM, ForkJoinPool executorService, Runnable heartbeatCallback,
+                    UnsupportedFeatures unsupportedFeatures) {
+        this.options = options;
+        this.universe = universe;
+        this.debugHandlerFactories = Collections.singletonList(new GraalDebugHandlersFactory(providers.getSnippetReflection()));
+        this.debug = new org.graalvm.compiler.debug.DebugContext.Builder(options, debugHandlerFactories).build();
+        this.metaAccess = (AnalysisMetaAccess) providers.getMetaAccess();
+        this.providers = providers;
+        this.hostVM = hostVM;
+        this.executorService = executorService;
+        this.executor = new CompletionExecutor(this, executorService, heartbeatCallback);
+        // todo specify timing via option
+        this.timing = null;
+        this.executor.init(timing);
+        this.heartbeatCallback = heartbeatCallback;
+        this.unsupportedFeatures = unsupportedFeatures;
+        this.replacements = providers.getReplacements();
+
+        String imageName = hostVM.getImageName();
+        this.processFeaturesTimer = new Timer(imageName, "(features)", false);
+        this.checkObjectsTimer = new Timer(imageName, "(objects)", false);
+        this.reachabilityTimer = new Timer(imageName, "(reachability)", false);
+        this.analysisTimer = new Timer(imageName, "analysis", true);
+
+        this.extendedAsserts = PointstoOptions.ExtendedAsserts.getValue(options);
+
+        this.heapScanningPolicy = PointstoOptions.ExhaustiveHeapScan.getValue(options)
+                        ? HeapScanningPolicy.scanAll()
+                        : HeapScanningPolicy.skipTypes(skippedHeapTypes());
+    }
+
+    @Override
+    public void cleanupAfterAnalysis() {
+        universe.getTypes().forEach(AnalysisType::cleanupAfterAnalysis);
+        universe.getFields().forEach(AnalysisField::cleanupAfterAnalysis);
+        universe.getMethods().forEach(AnalysisMethod::cleanupAfterAnalysis);
+    }
+
+    @Override
+    public Timer getAnalysisTimer() {
+        return analysisTimer;
+    }
+
+    @Override
+    public Timer getProcessFeaturesTimer() {
+        return processFeaturesTimer;
+    }
+
+    @Override
+    public void printTimers() {
+        reachabilityTimer.print();
+        checkObjectsTimer.print();
+        processFeaturesTimer.print();
+    }
+
+    @Override
+    public void printTimerStatistics(PrintWriter out) {
+        // todo print reachability here
+        StatisticsPrinter.print(out, "features_time_ms", processFeaturesTimer.getTotalTime());
+        StatisticsPrinter.print(out, "total_analysis_time_ms", analysisTimer.getTotalTime());
+
+        StatisticsPrinter.printLast(out, "total_memory_bytes", analysisTimer.getTotalMemory());
+    }
+
+    @Override
+    public AnalysisType[] skippedHeapTypes() {
+        return new AnalysisType[]{metaAccess.lookupJavaType(String.class)};
+    }
+
+    @Override
+    public boolean extendedAsserts() {
+        return extendedAsserts;
+    }
+
+    @Override
+    public OptionValues getOptions() {
+        return options;
+    }
+
+    @Override
+    public Runnable getHeartbeatCallback() {
+        return heartbeatCallback;
+    }
+
+    @Override
+    public DebugContext getDebug() {
+        return debug;
+    }
+
+    @Override
+    public List<DebugHandlersFactory> getDebugHandlerFactories() {
+        return debugHandlerFactories;
+    }
+
+    @Override
+    public AnalysisPolicy analysisPolicy() {
+        return universe.analysisPolicy();
+    }
+
+    @Override
+    public AnalysisUniverse getUniverse() {
+        return universe;
+    }
+
+    @Override
+    public HostedProviders getProviders() {
+        return providers;
+    }
+
+    @Override
+    public AnalysisMetaAccess getMetaAccess() {
+        return metaAccess;
+    }
+
+    @Override
+    public UnsupportedFeatures getUnsupportedFeatures() {
+        return unsupportedFeatures;
+    }
+
+    @Override
+    public final SnippetReflectionProvider getSnippetReflectionProvider() {
+        return providers.getSnippetReflection();
+    }
+
+    @Override
+    public final ConstantReflectionProvider getConstantReflectionProvider() {
+        return providers.getConstantReflection();
+    }
+
+    @Override
+    public HeapScanningPolicy scanningPolicy() {
+        return heapScanningPolicy;
+    }
+
+    @Override
+    public HostVM getHostVM() {
+        return hostVM;
+    }
+
+    protected void schedule(Runnable task) {
+        executor.execute((d) -> task.run());
+    }
+
+    @Override
+    public Replacements getReplacements() {
+        return replacements;
+    }
+
+    private class AnalysisTiming extends PointsToAnalysis.BucketTiming {
+
+        @Override
+        public void printHeader() {
+            super.printHeader();
+            System.out.println();
+        }
+
+        @Override
+        public void print() {
+            super.print();
+            System.out.println();
+        }
+    }
+}

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/AbstractReachabilityAnalysis.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2021, 2021, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.pointsto;
+
+import com.oracle.graal.pointsto.api.HostVM;
+import com.oracle.graal.pointsto.constraints.UnsupportedFeatures;
+import com.oracle.graal.pointsto.meta.AnalysisMethod;
+import com.oracle.graal.pointsto.meta.AnalysisType;
+import com.oracle.graal.pointsto.meta.AnalysisUniverse;
+import com.oracle.graal.pointsto.meta.HostedProviders;
+import org.graalvm.compiler.options.OptionValues;
+
+import java.lang.reflect.Executable;
+import java.lang.reflect.Method;
+import java.util.concurrent.ForkJoinPool;
+
+import static jdk.vm.ci.common.JVMCIError.shouldNotReachHere;
+
+public abstract class AbstractReachabilityAnalysis extends AbstractAnalysisEngine {
+    public AbstractReachabilityAnalysis(OptionValues options, AnalysisUniverse universe, HostedProviders providers, HostVM hostVM, ForkJoinPool executorService, Runnable heartbeatCallback,
+                    UnsupportedFeatures unsupportedFeatures) {
+        super(options, universe, providers, hostVM, executorService, heartbeatCallback, unsupportedFeatures);
+    }
+
+    @Override
+    public AnalysisType addRootClass(Class<?> clazz, boolean addFields, boolean addArrayClass) {
+        AnalysisType type = metaAccess.lookupJavaType(clazz);
+        type.registerAsReachable();
+        return addRootClass(type, addFields, addArrayClass);
+    }
+
+    @Override
+    public AnalysisMethod addRootMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) {
+        try {
+            Method method = clazz.getDeclaredMethod(methodName, parameterTypes);
+            return addRootMethod(method);
+        } catch (NoSuchMethodException ex) {
+            throw shouldNotReachHere(ex);
+        }
+    }
+
+    @Override
+    public AnalysisMethod addRootMethod(Executable method) {
+        AnalysisMethod aMethod = metaAccess.lookupJavaMethod(method);
+        addRootMethod(aMethod);
+        return aMethod;
+    }
+}

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/BigBang.java

@@ -41,10 +41,22 @@
 import com.oracle.graal.pointsto.meta.AnalysisType;
 import com.oracle.graal.pointsto.meta.AnalysisType.UsageKind;
 import com.oracle.graal.pointsto.meta.AnalysisUniverse;
+import com.oracle.graal.pointsto.meta.AnalysisUniverse;
 import com.oracle.graal.pointsto.meta.HostedProviders;
 import com.oracle.graal.pointsto.util.Timer;
 
 import jdk.vm.ci.meta.ConstantReflectionProvider;
+import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
+import org.graalvm.compiler.debug.DebugContext;
+import org.graalvm.compiler.debug.DebugHandlersFactory;
+import org.graalvm.compiler.graph.NodeSourcePosition;
+import org.graalvm.compiler.nodes.spi.Replacements;
+import org.graalvm.compiler.options.OptionValues;
+
+import java.io.PrintWriter;
+import java.util.List;
+import java.util.function.Function;
+
 
 /**
  * Central static analysis interface that groups together the functionality of reachability analysis
@@ -104,6 +116,10 @@ public interface BigBang extends ReachabilityAnalysis, HeapScanning {
 
     void runAnalysis(DebugContext debug, Function<AnalysisUniverse, Boolean> duringAnalysisAction) throws InterruptedException;
 
+    boolean strengthenGraalGraphs();
+
+    Replacements getReplacements();
+
     /** You can blacklist certain callees here. */
     @SuppressWarnings("unused")
     default boolean isCallAllowed(PointsToAnalysis bb, AnalysisMethod caller, AnalysisMethod target, NodeSourcePosition srcPosition) {