Optimize reachability handlers memory footprint.

Author: cstancu

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/AnalysisElement.java

@@ -28,9 +28,11 @@
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 
+import com.oracle.graal.pointsto.util.ConcurrentLightHashSet;
 import org.graalvm.nativeimage.hosted.Feature.DuringAnalysisAccess;
 
 import com.oracle.graal.pointsto.PointsToAnalysis;
@@ -41,20 +43,24 @@ public abstract class AnalysisElement {
      * Contains reachability handlers that are notified when the element is marked as reachable.
      * Each handler is notified only once, and then it is removed from the set.
      */
-    private final Set<ElementReachableNotification> elementReachableNotifications = ConcurrentHashMap.newKeySet();
+
+    private static final AtomicReferenceFieldUpdater<AnalysisElement, Object> reachableNotificationsUpdater = AtomicReferenceFieldUpdater
+                    .newUpdater(AnalysisElement.class, Object.class, "elementReachableNotifications");
+
+    @SuppressWarnings("unused") private volatile Object elementReachableNotifications;
 
     public void registerReachabilityNotification(ElementReachableNotification notification) {
-        elementReachableNotifications.add(notification);
+        ConcurrentLightHashSet.addElement(this, reachableNotificationsUpdater, notification);
     }
 
     public void notifyReachabilityCallback(AnalysisUniverse universe, ElementReachableNotification notification) {
         notification.notifyCallback(universe, this);
-        elementReachableNotifications.remove(notification);
+        ConcurrentLightHashSet.removeElement(this, reachableNotificationsUpdater, notification);
     }
 
     protected void notifyReachabilityCallbacks(AnalysisUniverse universe) {
-        elementReachableNotifications.forEach(c -> c.notifyCallback(universe, this));
-        elementReachableNotifications.removeIf(ElementReachableNotification::isNotified);
+        ConcurrentLightHashSet.forEach(this, reachableNotificationsUpdater, (ElementReachableNotification c) -> c.notifyCallback(universe, this));
+        ConcurrentLightHashSet.removeElementIf(this, reachableNotificationsUpdater, ElementReachableNotification::isNotified);
     }
 
     public abstract boolean isReachable();

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/AnalysisType.java

@@ -40,6 +40,7 @@
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 import java.util.function.Consumer;
 
+import com.oracle.graal.pointsto.util.ConcurrentLightHashMap;
 import org.graalvm.compiler.debug.GraalError;
 import org.graalvm.compiler.graph.Node;
 import org.graalvm.util.GuardedAnnotationAccess;
@@ -87,6 +88,12 @@ public abstract class AnalysisType extends AnalysisElement implements WrappedJav
     private static final AtomicReferenceFieldUpdater<AnalysisType, Object> INTERCEPTORS_UPDATER = //
                     AtomicReferenceFieldUpdater.newUpdater(AnalysisType.class, Object.class, "interceptors");
 
+    private static final AtomicReferenceFieldUpdater<AnalysisType, Object> subtypeReachableNotificationsUpdater = AtomicReferenceFieldUpdater
+                    .newUpdater(AnalysisType.class, Object.class, "subtypeReachableNotifications");
+
+    private static final AtomicReferenceFieldUpdater<AnalysisType, Object> overrideReachableNotificationsUpdater = AtomicReferenceFieldUpdater
+                    .newUpdater(AnalysisType.class, Object.class, "overrideReachableNotifications");
+
     protected final AnalysisUniverse universe;
     private final ResolvedJavaType wrapped;
 
@@ -168,14 +175,14 @@ public enum UsageKind {
      * Contains reachability handlers that are notified when any of the subtypes are marked as
      * reachable. Each handler is notified only once per subtype.
      */
-    private final Set<SubtypeReachableNotification> subtypeReachableNotifications = ConcurrentHashMap.newKeySet();
+    @SuppressWarnings("unused") private volatile Object subtypeReachableNotifications;
 
     /**
      * Contains reachability handlers that are notified when any of the method override becomes
      * reachable *and* the declaring class of the override (or any subtype) is instantiated. Each
      * handler is notified only once per method override.
      */
-    private final Map<AnalysisMethod, Set<MethodOverrideReachableNotification>> overrideReachableNotifications = new ConcurrentHashMap<>();
+    @SuppressWarnings("unused") private volatile Object overrideReachableNotifications;
 
     AnalysisType(AnalysisUniverse universe, ResolvedJavaType javaType, JavaKind storageKind, AnalysisType objectType, AnalysisType cloneableType) {
         this.universe = universe;
@@ -476,7 +483,8 @@ private void processMethodOverrides() {
         forAllSuperTypes(superType -> {
             AtomicUtils.atomicMark(superType.isAnySubtypeInstantiated);
             seenSubtypes.add(superType);
-            for (var entry : superType.overrideReachableNotifications.entrySet()) {
+            Map<AnalysisMethod, Set<MethodOverrideReachableNotification>> overrides = ConcurrentLightHashMap.getEntries(superType, overrideReachableNotificationsUpdater);
+            for (var entry : overrides.entrySet()) {
                 AnalysisMethod baseMethod = entry.getKey();
                 Set<MethodOverrideReachableNotification> overrideNotifications = entry.getValue();
                 for (AnalysisType subType : seenSubtypes) {
@@ -517,7 +525,8 @@ public boolean registerAsReachable() {
     @Override
     protected void onReachable() {
         notifyReachabilityCallbacks(universe);
-        forAllSuperTypes(type -> type.subtypeReachableNotifications.forEach(n -> n.notifyCallback(universe, this)));
+        forAllSuperTypes(type -> ConcurrentLightHashSet.forEach(type, subtypeReachableNotificationsUpdater,
+                        (SubtypeReachableNotification n) -> n.notifyCallback(universe, this)));
         universe.notifyReachableType();
         universe.hostVM.checkForbidden(this, UsageKind.Reachable);
         if (isArray()) {
@@ -533,16 +542,18 @@ protected void onReachable() {
     }
 
     public void registerSubtypeReachabilityNotification(SubtypeReachableNotification notification) {
-        subtypeReachableNotifications.add(notification);
+        ConcurrentLightHashSet.addElement(this, subtypeReachableNotificationsUpdater, notification);
     }
 
     public void registerOverrideReachabilityNotification(AnalysisMethod declaredMethod, MethodOverrideReachableNotification notification) {
         assert declaredMethod.getDeclaringClass() == this;
-        overrideReachableNotifications.computeIfAbsent(declaredMethod, m -> ConcurrentHashMap.newKeySet()).add(notification);
+        Set<MethodOverrideReachableNotification> overrideNotifications = ConcurrentLightHashMap.computeIfAbsent(this,
+                        overrideReachableNotificationsUpdater, declaredMethod, m -> ConcurrentHashMap.newKeySet());
+        overrideNotifications.add(notification);
     }
 
     public Set<MethodOverrideReachableNotification> getOverrideReachabilityNotifications(AnalysisMethod method) {
-        return overrideReachableNotifications.getOrDefault(method, Collections.emptySet());
+        return ConcurrentLightHashMap.getOrDefault(this, overrideReachableNotificationsUpdater, method, Collections.emptySet());
     }
 
     /**