Refactor heap scanning.

Author: cstancu

sdk/src/org.graalvm.nativeimage/snapshot.sigtest

@@ -878,6 +878,7 @@ CLSS public abstract interface static org.graalvm.nativeimage.hosted.Feature$Dur
 intf org.graalvm.nativeimage.hosted.Feature$BeforeAnalysisAccess
 intf org.graalvm.nativeimage.hosted.Feature$QueryReachabilityAccess
 meth public abstract void requireAnalysisIteration()
+meth public abstract void rescanObject(java.lang.Object)
 
 CLSS public abstract interface static org.graalvm.nativeimage.hosted.Feature$DuringSetupAccess
  outer org.graalvm.nativeimage.hosted.Feature

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/Feature.java

@@ -277,6 +277,13 @@ interface DuringAnalysisAccess extends BeforeAnalysisAccess, QueryReachabilityAc
          * @since 19.0
          */
         void requireAnalysisIteration();
+
+        /**
+         * Rescan an object to be included in the image heap.
+         *
+         * @since 22.0
+         */
+        void rescanObject(Object obj);
     }
 
     /**

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

@@ -32,6 +32,7 @@
 
 import org.graalvm.compiler.options.OptionValues;
 
+import com.oracle.graal.pointsto.constraints.UnsupportedFeatureException;
 import com.oracle.graal.pointsto.flow.AbstractSpecialInvokeTypeFlow;
 import com.oracle.graal.pointsto.flow.AbstractVirtualInvokeTypeFlow;
 import com.oracle.graal.pointsto.flow.ActualReturnTypeFlow;
@@ -207,7 +208,13 @@ public void onObservedUpdate(PointsToAnalysis bb) {
                     continue;
                 }
 
-                AnalysisMethod method = type.resolveConcreteMethod(getTargetMethod());
+                AnalysisMethod method = null;
+                try {
+                    method = type.resolveConcreteMethod(targetMethod);
+                } catch (UnsupportedFeatureException ex) {
+                    bb.getUnsupportedFeatures().addMessage("resolve" + targetMethod.format("%H.%n(%p)"), targetMethod, ex.getMessage());
+                }
+
                 if (method == null || Modifier.isAbstract(method.getModifiers())) {
                     /*
                      * Type states can be conservative, i.e., we can have receiver types that do not

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

@@ -58,7 +58,6 @@
 import org.graalvm.compiler.printer.GraalDebugHandlersFactory;
 import org.graalvm.nativeimage.hosted.Feature;
 
-import com.oracle.graal.pointsto.ObjectScanner.ReusableSet;
 import com.oracle.graal.pointsto.api.HostVM;
 import com.oracle.graal.pointsto.api.PointstoOptions;
 import com.oracle.graal.pointsto.constraints.UnsupportedFeatures;
@@ -128,7 +127,6 @@ public abstract class PointsToAnalysis implements BigBang {
     private final CompletionExecutor.Timing timing;
 
     public final Timer typeFlowTimer;
-    public final Timer checkObjectsTimer;
     public final Timer processFeaturesTimer;
     public final Timer analysisTimer;
 
@@ -142,7 +140,6 @@ public PointsToAnalysis(OptionValues options, AnalysisUniverse universe, HostedP
         this.hostVM = hostVM;
         String imageName = hostVM.getImageName();
         this.typeFlowTimer = new Timer(imageName, "(typeflow)", false);
-        this.checkObjectsTimer = new Timer(imageName, "(objects)", false);
         this.processFeaturesTimer = new Timer(imageName, "(features)", false);
         this.analysisTimer = new Timer(imageName, "analysis", true);
 
@@ -152,6 +149,7 @@ public PointsToAnalysis(OptionValues options, AnalysisUniverse universe, HostedP
         this.unsupportedFeatures = unsupportedFeatures;
         this.providers = providers;
         this.strengthenGraalGraphs = strengthenGraalGraphs;
+        providers.setBigBang(this);
 
         this.objectType = metaAccess.lookupJavaType(Object.class);
         /*
@@ -194,14 +192,12 @@ public Timer getProcessFeaturesTimer() {
     @Override
     public void printTimers() {
         typeFlowTimer.print();
-        checkObjectsTimer.print();
         processFeaturesTimer.print();
     }
 
     @Override
     public void printTimerStatistics(PrintWriter out) {
         StatisticsPrinter.print(out, "typeflow_time_ms", typeFlowTimer.getTotalTime());
-        StatisticsPrinter.print(out, "objects_time_ms", checkObjectsTimer.getTotalTime());
         StatisticsPrinter.print(out, "features_time_ms", processFeaturesTimer.getTotalTime());
         StatisticsPrinter.print(out, "total_analysis_time_ms", analysisTimer.getTotalTime());
 
@@ -329,13 +325,14 @@ public void cleanupAfterAnalysis() {
         allSynchronizedTypeFlow = null;
         unsafeLoads = null;
         unsafeStores = null;
-        scannedObjects = null;
 
         ConstantObjectsProfiler.constantTypes.clear();
 
         universe.getTypes().forEach(AnalysisType::cleanupAfterAnalysis);
         universe.getFields().forEach(AnalysisField::cleanupAfterAnalysis);
         universe.getMethods().forEach(AnalysisMethod::cleanupAfterAnalysis);
+
+        universe.getHeapScanner().cleanupAfterAnalysis();
     }
 
     @Override
@@ -579,6 +576,10 @@ public CompletionExecutor getExecutor() {
     public void checkUserLimitations() {
     }
 
+    public void handleUnknownValueField(@SuppressWarnings("unused") AnalysisField field) {
+
+    }
+
     public interface TypeFlowRunnable extends DebugContextRunnable {
         TypeFlow<?> getTypeFlow();
     }
@@ -643,10 +644,6 @@ public boolean finish() throws InterruptedException {
                  */
                 assert executor.getPostedOperations() == 0;
                 numTypes = universe.getTypes().size();
-                try (StopTimer t = checkObjectsTimer.start()) {
-                    // track static fields
-                    checkObjectGraph();
-                }
             } while (executor.getPostedOperations() != 0 || numTypes != universe.getTypes().size());
 
             universe.setAnalysisDataValid(true);
@@ -669,39 +666,11 @@ public boolean doTypeflow() throws InterruptedException {
         return didSomeWork;
     }
 
-    private ReusableSet scannedObjects = new ReusableSet();
-
-    @SuppressWarnings("try")
-    private void checkObjectGraph() throws InterruptedException {
-        scannedObjects.reset();
-        // scan constants
-        boolean isParallel = PointstoOptions.ScanObjectsParallel.getValue(options);
-        ObjectScanner objectScanner = new AnalysisObjectScanner(this, isParallel ? executor : null, scannedObjects);
-        checkObjectGraph(objectScanner);
-        if (isParallel) {
-            executor.start();
-            objectScanner.scanBootImageHeapRoots(null, null);
-            executor.complete();
-            executor.shutdown();
-            executor.init(timing);
-        } else {
-            objectScanner.scanBootImageHeapRoots(null, null);
-        }
-    }
-
     @Override
     public HeapScanningPolicy scanningPolicy() {
         return heapScanningPolicy;
     }
 
-    /**
-     * Traverses the object graph to discover references to new types.
-     *
-     * @param objectScanner
-     */
-    protected void checkObjectGraph(ObjectScanner objectScanner) {
-    }
-
     @Override
     public HostVM getHostVM() {
         return hostVM;

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/MethodTypeFlowBuilder.java

@@ -277,13 +277,14 @@ public void registerUsedElements(boolean registerEmbeddedRoots) {
     }
 
     private void registerEmbeddedRoot(ConstantNode cn) {
+        BytecodePosition position = cn.getNodeSourcePosition();
+        if (position == null) {
+            position = new BytecodePosition(null, method, 0);
+        }
         if (bb.scanningPolicy().trackConstant(bb, cn.asJavaConstant())) {
-            BytecodePosition position = cn.getNodeSourcePosition();
-            if (position == null) {
-                position = new BytecodePosition(null, method, 0);
-            }
             bb.getUniverse().registerEmbeddedRoot(cn.asJavaConstant(), position);
         }
+        bb.getUniverse().getHeapScanner().scanEmbeddedRoot(cn.asJavaConstant(), position);
     }
 
     private static void registerForeignCall(PointsToAnalysis bb, ForeignCallDescriptor foreignCallDescriptor) {

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageHeap.java

@@ -0,0 +1,165 @@
+/*
+ * 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.heap;
+
+import static com.oracle.graal.pointsto.heap.ImageHeapScanner.Reason;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.oracle.graal.pointsto.meta.AnalysisField;
+import com.oracle.graal.pointsto.meta.AnalysisType;
+import com.oracle.graal.pointsto.util.AnalysisFuture;
+
+import jdk.vm.ci.meta.JavaConstant;
+import jdk.vm.ci.meta.ResolvedJavaField;
+
+public class ImageHeap {
+
+    /** Map the original object *and* the replaced object to the HeapObject snapshot. */
+    protected final ConcurrentHashMap<JavaConstant, AnalysisFuture<ImageHeapObject>> heapObjects;
+    /** Store a mapping from types to all scanned objects. */
+    private final Map<AnalysisType, Set<ImageHeapObject>> typesToObjects;
+
+    public ImageHeap() {
+        heapObjects = new ConcurrentHashMap<>();
+        typesToObjects = new ConcurrentHashMap<>();
+    }
+
+    public AnalysisFuture<ImageHeapObject> getTask(JavaConstant constant) {
+        return heapObjects.get(constant);
+    }
+
+    public ImageHeapObject get(JavaConstant constant) {
+        return getTask(constant).ensureDone();
+    }
+
+    public Set<ImageHeapObject> getObjects(AnalysisType type) {
+        return typesToObjects.getOrDefault(type, Collections.emptySet());
+    }
+
+    public void remove(JavaConstant original) {
+        heapObjects.remove(original);
+    }
+
+    public void remove(AnalysisType type, ImageHeapObject heapObj) {
+        heapObjects(type).remove(heapObj);
+    }
+
+    public boolean add(JavaConstant original, JavaConstant replaced, AnalysisFuture<ImageHeapObject> heapObj) {
+        boolean r = heapObjects.putIfAbsent(replaced, heapObj) == null;
+        boolean o = heapObjects.putIfAbsent(original, heapObj) == null;
+        return r || o;
+    }
+
+    public boolean add(AnalysisType type, ImageHeapObject heapObj) {
+        return heapObjects(type).add(heapObj);
+    }
+
+    private Set<ImageHeapObject> heapObjects(AnalysisType type) {
+        return typesToObjects.computeIfAbsent(type, t -> Collections.newSetFromMap(new ConcurrentHashMap<>()));
+    }
+
+    /**
+     * Model for snapshotted objects. It stores the replaced object, i.e., the result of applying
+     * object replacers on the original object, and the instance field values of this object. The
+     * field values are stored as JavaConstant to also encode primitive values. ImageHeapObject are
+     * created only after an object is processed through the object replacers.
+     */
+    public static class ImageHeapObject implements Reason {
+        final AnalysisType type;
+        /** Store the object, already processed by the object transformers. */
+        final JavaConstant object;
+
+        ImageHeapObject(JavaConstant object, AnalysisType type) {
+            this.object = object;
+            this.type = type;
+        }
+
+        public JavaConstant getObject() {
+            return object;
+        }
+
+        /*
+         * Equals and hascode just compare the replaced constant. Thus two HeapObject insantaces are
+         * considered equal if they snapshot the same constant, even if the instanceFieldValues are
+         * different, i.e., they were snapshotted at different times during analysis and one of them
+         * mutated. This is necessary for the removal of the old snapshotted value on forced
+         * updates. Alternativelly each AnalysisType needs a mapping from JavaConstant to HeapObject
+         * instead of just a set of HeapObject.
+         */
+
+        @Override
+        public boolean equals(Object o) {
+            // TODO ==
+            if (o instanceof ImageHeapObject) {
+                ImageHeapObject other = (ImageHeapObject) o;
+                return this.object.equals(other.object);
+            }
+            return false;
+        }
+
+        @Override
+        public int hashCode() {
+            return object.hashCode();
+        }
+    }
+
+    public static final class ImageHeapInstance extends ImageHeapObject {
+
+        /** Store original field values of the object. */
+        final Map<ResolvedJavaField, AnalysisFuture<JavaConstant>> rawObjectFieldValues;
+
+        ImageHeapInstance(JavaConstant object, AnalysisType type, Map<ResolvedJavaField, AnalysisFuture<JavaConstant>> rawObjectFieldValues) {
+            super(object, type);
+            this.rawObjectFieldValues = rawObjectFieldValues;
+        }
+
+        public JavaConstant readFieldValue(AnalysisField field) {
+            return rawObjectFieldValues.get(field).ensureDone();
+        }
+
+        public AnalysisFuture<JavaConstant> getFieldTask(AnalysisField field) {
+            return rawObjectFieldValues.get(field);
+        }
+    }
+
+    static final class ImageHeapArray extends ImageHeapObject {
+        final JavaConstant[] rawArrayElementValues;
+
+        ImageHeapArray(JavaConstant object, AnalysisType type, JavaConstant[] rawArrayElementValues) {
+            super(object, type);
+            this.rawArrayElementValues = rawArrayElementValues;
+        }
+
+        int getLength() {
+            return rawArrayElementValues.length;
+        }
+
+    }
+
+}