[GR-51654] Add support for JFR jdk.ObjectCount and jdk.ObjectCountAfterGC events.

substratevm/mx.substratevm/suite.py

@@ -336,6 +336,7 @@
             ],
             "requires" : [
                 "jdk.management",
+                "jdk.jfr",
             ],
             "requiresConcealed" : {
                 "java.base": [

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/EveryChunkNativeGCPeriodicEvents.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2023, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, 2023, Red Hat Inc. 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.svm.core.genscavenge;
+
+import com.oracle.svm.core.Uninterruptible;
+import com.oracle.svm.core.heap.GCCause;
+import com.oracle.svm.core.heap.Heap;
+import com.oracle.svm.core.jfr.JfrEvent;
+import jdk.jfr.Event;
+import jdk.jfr.Name;
+import jdk.jfr.Period;
+
+@Name("EveryChunkPeriodicGCEvents")
+@Period(value = "everyChunk")
+public class EveryChunkNativeGCPeriodicEvents extends Event {
+
+    public static void emit() {
+        emitObjectCount();
+    }
+
+    private static void emitObjectCount() {
+        if (shouldEmitObjectCount()) {
+            Heap.getHeap().getGC().collectCompletely(GCCause.JfrObjectCount);
+        }
+    }
+
+    /**
+     * ShouldEmit will be checked again later. This is merely an optimization to avoid a potentially
+     * unnecessary GC.
+     */
+    @Uninterruptible(reason = "Caller of JfrEvent#shouldEmit must be uninterruptible.")
+    private static boolean shouldEmitObjectCount() {
+        return JfrEvent.ObjectCount.shouldEmit();
+    }
+}

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/GCImpl.java

@@ -82,6 +82,7 @@
 import com.oracle.svm.core.jfr.JfrGCWhen;
 import com.oracle.svm.core.jfr.JfrTicks;
 import com.oracle.svm.core.jfr.events.AllocationRequiringGCEvent;
+import com.oracle.svm.core.jfr.events.ObjectCountEventSupport;
 import com.oracle.svm.core.log.Log;
 import com.oracle.svm.core.os.CommittedMemoryProvider;
 import com.oracle.svm.core.snippets.ImplicitExceptions;
@@ -244,6 +245,7 @@ private boolean collectImpl(GCCause cause, long requestingNanoTime, boolean forc
             }
         } finally {
             JfrGCEvents.emitGarbageCollectionEvent(getCollectionEpoch(), cause, startTicks);
+            ObjectCountEventSupport.emitEvents(getCollectionEpoch(), startTicks, cause);
         }
         return outOfMemory;
     }

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/JfrGCEventSupport.java

@@ -25,10 +25,12 @@
  */
 package com.oracle.svm.core.genscavenge;
 
+import jdk.jfr.FlightRecorder;
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.StackValue;
 import org.graalvm.word.UnsignedWord;
 
+import com.oracle.svm.core.jdk.RuntimeSupport;
 import com.oracle.svm.core.SubstrateOptions;
 import com.oracle.svm.core.Uninterruptible;
 import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature;
@@ -136,6 +138,18 @@ private int popPhase() {
         assert currentPhase > 0;
         return --currentPhase;
     }
+
+    public static RuntimeSupport.Hook startupHook() {
+        return isFirstIsolate -> {
+            FlightRecorder.addPeriodicEvent(EveryChunkNativeGCPeriodicEvents.class, EveryChunkNativeGCPeriodicEvents::emit);
+        };
+    }
+
+    public static RuntimeSupport.Hook shutdownHook() {
+        return isFirstIsolate -> {
+            FlightRecorder.removePeriodicEvent(EveryChunkNativeGCPeriodicEvents::emit);
+        };
+    }
 }
 
 @AutomaticallyRegisteredFeature
@@ -150,6 +164,10 @@ public void beforeAnalysis(BeforeAnalysisAccess access) {
         if (HasJfrSupport.get()) {
             JfrGCName name = JfrGCNames.singleton().addGCName("serial");
             ImageSingletons.add(JfrGCEventSupport.class, new JfrGCEventSupport(name));
+
+            RuntimeSupport runtime = RuntimeSupport.getRuntimeSupport();
+            runtime.addStartupHook(JfrGCEventSupport.startupHook());
+            runtime.addShutdownHook(JfrGCEventSupport.shutdownHook());
         }
     }
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/heap/GCCause.java

@@ -49,6 +49,11 @@ public class GCCause {
     @DuplicatedInNativeCode public static final GCCause HintedGC = new GCCause("Hinted GC", 3);
     @DuplicatedInNativeCode public static final GCCause JvmtiForceGC = new GCCause("JvmtiEnv ForceGarbageCollection", 4);
     @DuplicatedInNativeCode public static final GCCause HeapDump = new GCCause("Heap Dump Initiated GC ", 5);
+    /**
+     * {@link GCCause#JfrObjectCount} is a GC cause hotspot does not have. It indicates the GC was
+     * invoked in order to emit JFR ObjectCount periodic events.
+     */
+    @DuplicatedInNativeCode public static final GCCause JfrObjectCount = new GCCause("JFR object counting", 6);
 
     @UnknownObjectField(availability = ReadyForCompilation.class) protected static GCCause[] GCCauses;
 

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/DynamicHubSupport.java

@@ -50,7 +50,6 @@ public void setMaxTypeId(int maxTypeId) {
         this.maxTypeId = maxTypeId;
     }
 
-    @Platforms(Platform.HOSTED_ONLY.class)
     public int getMaxTypeId() {
         return maxTypeId;
     }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jfr/JfrEvent.java

@@ -65,6 +65,8 @@ public final class JfrEvent {
     public static final JfrEvent ThreadAllocationStatistics = create("jdk.ThreadAllocationStatistics", false);
     public static final JfrEvent SystemGC = create("jdk.SystemGC", true);
     public static final JfrEvent AllocationRequiringGC = create("jdk.AllocationRequiringGC", false);
+    public static final JfrEvent ObjectCount = create("jdk.ObjectCount", false);
+    public static final JfrEvent ObjectCountAfterGC = create("jdk.ObjectCountAfterGC", false);
 
     private final long id;
     private final String name;

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jfr/JfrSymbolRepository.java

@@ -38,7 +38,6 @@
 import com.oracle.svm.core.c.struct.PinnedObjectField;
 import com.oracle.svm.core.collections.AbstractUninterruptibleHashtable;
 import com.oracle.svm.core.collections.UninterruptibleEntry;
-import com.oracle.svm.core.heap.Heap;
 import com.oracle.svm.core.jdk.UninterruptibleUtils;
 import com.oracle.svm.core.jdk.UninterruptibleUtils.CharReplacer;
 import com.oracle.svm.core.jfr.traceid.JfrTraceIdEpoch;
@@ -77,8 +76,6 @@ public long getSymbolId(String imageHeapString, boolean previousEpoch, boolean r
             return 0;
         }
 
-        assert Heap.getHeap().isInImageHeap(imageHeapString);
-
         JfrSymbol symbol = StackValue.get(JfrSymbol.class);
         symbol.setValue(imageHeapString);
         symbol.setReplaceDotWithSlash(replaceDotWithSlash);

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jfr/JfrTypeRepository.java

@@ -104,13 +104,14 @@ private TypeInfo collectTypeInfo(boolean flushpoint) {
 
     private void visitClass(TypeInfo typeInfo, Class<?> clazz) {
         if (clazz != null && addClass(typeInfo, clazz)) {
-            visitPackage(typeInfo, clazz.getPackage(), clazz.getModule());
+            visitPackage(typeInfo, clazz.getPackage(), clazz.getModule(), getPackageKey(clazz));
             visitClass(typeInfo, clazz.getSuperclass());
+            visitClassLoader(typeInfo, clazz.getClassLoader());
         }
     }
 
-    private void visitPackage(TypeInfo typeInfo, Package pkg, Module module) {
-        if (pkg != null && addPackage(typeInfo, pkg, module)) {
+    private void visitPackage(TypeInfo typeInfo, Package pkg, Module module, String pkgKey) {
+        if (pkg != null && addPackage(typeInfo, pkg, module, pkgKey)) {
             visitModule(typeInfo, module);
         }
     }
@@ -145,7 +146,7 @@ private void writeClass(TypeInfo typeInfo, JfrChunkWriter writer, Class<?> clazz
         writer.writeCompressedLong(JfrTraceId.getTraceId(clazz));
         writer.writeCompressedLong(getClassLoaderId(typeInfo, clazz.getClassLoader()));
         writer.writeCompressedLong(getSymbolId(writer, clazz.getName(), flushpoint, true));
-        writer.writeCompressedLong(getPackageId(typeInfo, clazz.getPackage()));
+        writer.writeCompressedLong(getPackageId(typeInfo, clazz));
         writer.writeCompressedLong(clazz.getModifiers());
         writer.writeBoolean(clazz.isHidden());
     }
@@ -168,14 +169,14 @@ private int writePackages(JfrChunkWriter writer, TypeInfo typeInfo, boolean flus
         writer.writeCompressedInt(typeInfo.packages.size());
 
         for (Map.Entry<String, PackageInfo> pkgInfo : typeInfo.packages.entrySet()) {
-            writePackage(typeInfo, writer, pkgInfo.getKey(), pkgInfo.getValue(), flushpoint);
+            writePackage(typeInfo, writer, pkgInfo.getValue(), flushpoint);
         }
         return NON_EMPTY;
     }
 
-    private void writePackage(TypeInfo typeInfo, JfrChunkWriter writer, String pkgName, PackageInfo pkgInfo, boolean flushpoint) {
+    private void writePackage(TypeInfo typeInfo, JfrChunkWriter writer, PackageInfo pkgInfo, boolean flushpoint) {
         writer.writeCompressedLong(pkgInfo.id);  // id
-        writer.writeCompressedLong(getSymbolId(writer, pkgName, flushpoint, true));
+        writer.writeCompressedLong(getSymbolId(writer, pkgInfo.pkgName, flushpoint, true));
         writer.writeCompressedLong(getModuleId(typeInfo, pkgInfo.module));
         writer.writeBoolean(false); // exported
     }
@@ -228,10 +229,12 @@ private static void writeClassLoader(JfrChunkWriter writer, ClassLoader cl, long
     private static class PackageInfo {
         private final long id;
         private final Module module;
+        private final String pkgName;
 
-        PackageInfo(long id, Module module) {
+        PackageInfo(long id, Module module, String pkgName) {
             this.id = id;
             this.module = module;
+            this.pkgName = pkgName;
         }
     }
 
@@ -246,27 +249,47 @@ private boolean isClassVisited(TypeInfo typeInfo, Class<?> clazz) {
         return typeInfo.classes.contains(clazz) || flushedClasses.contains(clazz);
     }
 
-    private boolean addPackage(TypeInfo typeInfo, Package pkg, Module module) {
-        if (isPackageVisited(typeInfo, pkg)) {
-            assert module == (flushedPackages.containsKey(pkg.getName()) ? flushedPackages.get(pkg.getName()).module : typeInfo.packages.get(pkg.getName()).module);
+    /**
+     * It is possible that generated classes may have the same package as ordinary non-generated
+     * classes, however their module may be different (the unnamed module). We must deduplicate
+     * packages during serialization, but since a single package name may correspond to multiple
+     * modules, we make the deduplication key the concatenation of the package and module name. This
+     * allows each package module combination to be represented in the serialized data.
+     */
+    private static String getPackageKey(Class<?> clazz) {
+        if (clazz.getPackage() == null) {
+            return null;
+        }
+        String packageKey = clazz.getPackage().getName();
+        if (clazz.getModule() != null && clazz.getModule().getName() != null) {
+            packageKey += clazz.getModule().getName();
+        }
+        return packageKey;
+    }
+
+    private boolean addPackage(TypeInfo typeInfo, Package pkg, Module module, String pkgKey) {
+
+        if (isPackageVisited(typeInfo, pkgKey)) {
+            assert module == (flushedPackages.containsKey(pkgKey) ? flushedPackages.get(pkgKey).module : typeInfo.packages.get(pkgKey).module);
             return false;
         }
         // The empty package represented by "" is always traced with id 0
         long id = pkg.getName().isEmpty() ? 0 : ++currentPackageId;
-        typeInfo.packages.put(pkg.getName(), new PackageInfo(id, module));
+        typeInfo.packages.put(pkgKey, new PackageInfo(id, module, pkg.getName()));
         return true;
     }
 
-    private boolean isPackageVisited(TypeInfo typeInfo, Package pkg) {
-        return flushedPackages.containsKey(pkg.getName()) || typeInfo.packages.containsKey(pkg.getName());
+    private boolean isPackageVisited(TypeInfo typeInfo, String packageKey) {
+        return flushedPackages.containsKey(packageKey) || typeInfo.packages.containsKey(packageKey);
     }
 
-    private long getPackageId(TypeInfo typeInfo, Package pkg) {
-        if (pkg != null) {
-            if (flushedPackages.containsKey(pkg.getName())) {
-                return flushedPackages.get(pkg.getName()).id;
+    private long getPackageId(TypeInfo typeInfo, Class<?> clazz) {
+        String packageKey = getPackageKey(clazz);
+        if (packageKey != null) {
+            if (flushedPackages.containsKey(packageKey)) {
+                return flushedPackages.get(packageKey).id;
             }
-            return typeInfo.packages.get(pkg.getName()).id;
+            return typeInfo.packages.get(packageKey).id;
         } else {
             return 0;
         }