[GR-26814] [GR-36764] Implementation of JFR phase pause events for the serial GC, cleanups, and bugfixes.

PullRequest: graal/10983

Author: christianhaeubl

substratevm/CHANGELOG.md

@@ -5,6 +5,7 @@ This changelog summarizes major changes to GraalVM Native Image.
 ## Version 22.1.0
 * (GR-35898) Improved handling of static synchronized methods: the lock is no longer stored in the secondary monitor map, but in the mutable DynamicHubCompanion object.
 * Remove support for JDK8. As a result, `JDK8OrEarlier` and `JDK11OrLater` have been deprecated and will be removed in a future release.
+* (GR-26814) Red Hat added support for the GC pause-related JFR events (`GCPhasePause`, `GCPhasePauseLevel*`) to the serial GC.
 
 ## Version 22.0.0
 * (GR-33930) Decouple HostedOptionParser setup from classpath/modulepath scanning (use ServiceLoader for collecting options).

substratevm/mx.substratevm/suite.py

@@ -1107,7 +1107,7 @@
                     "com.oracle.svm.core", # Uses of com.oracle.svm.core.TypeResult
                     "com.oracle.svm.core.util", # Uses of com.oracle.svm.core.util.VMError
                     "com.oracle.svm.core.jni", # Uses of com.oracle.svm.core.jni.JNIRuntimeAccess
-                    "com.oracle.svm.core.jfr", # Uses of com.oracle.svm.core.jfr.JfrEnabled
+                    "com.oracle.svm.core.jfr", # Uses of com.oracle.svm.core.jfr.HasJfrSupport
                     "com.oracle.svm.hosted                        to java.base",
                     "com.oracle.svm.hosted.agent                  to java.instrument",
                     "com.oracle.svm.truffle.api                   to org.graalvm.truffle",

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2022, 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
@@ -209,15 +209,21 @@ private boolean collectImpl(GCCause cause, long requestingNanoTime, boolean forc
 
         NoAllocationVerifier nav = noAllocationVerifier.open();
         try {
-            outOfMemory = doCollectImpl(cause, requestingNanoTime, forceFullGC, false);
-            if (outOfMemory) {
-                // Avoid running out of memory with a full GC that reclaims softly reachable objects
-                ReferenceObjectProcessing.setSoftReferencesAreWeak(true);
-                try {
-                    outOfMemory = doCollectImpl(cause, requestingNanoTime, true, true);
-                } finally {
-                    ReferenceObjectProcessing.setSoftReferencesAreWeak(false);
+            long startTicks = JfrGCEventSupport.startGCPhasePause();
+            try {
+                outOfMemory = doCollectImpl(cause, requestingNanoTime, forceFullGC, false);
+                if (outOfMemory) {
+                    // Avoid running out of memory with a full GC that reclaims softly reachable
+                    // objects
+                    ReferenceObjectProcessing.setSoftReferencesAreWeak(true);
+                    try {
+                        outOfMemory = doCollectImpl(cause, requestingNanoTime, true, true);
+                    } finally {
+                        ReferenceObjectProcessing.setSoftReferencesAreWeak(false);
+                    }
                 }
+            } finally {
+                JfrGCEventSupport.emitGCPhasePauseEvent(getCollectionEpoch(), cause.getName(), startTicks);
             }
         } finally {
             nav.close();
@@ -232,14 +238,25 @@ private boolean doCollectImpl(GCCause cause, long requestingNanoTime, boolean fo
 
         boolean incremental = !forceNoIncremental && !policy.shouldCollectCompletely(false);
         boolean outOfMemory = false;
+
         if (incremental) {
-            outOfMemory = doCollectOnce(cause, requestingNanoTime, false, false);
+            long startTicks = JfrGCEventSupport.startGCPhasePause();
+            try {
+                outOfMemory = doCollectOnce(cause, requestingNanoTime, false, false);
+            } finally {
+                JfrGCEventSupport.emitGCPhasePauseEvent(getCollectionEpoch(), "Incremental GC", startTicks);
+            }
         }
         if (!incremental || outOfMemory || forceFullGC || policy.shouldCollectCompletely(incremental)) {
             if (incremental) { // uncommit unaligned chunks
                 CommittedMemoryProvider.get().afterGarbageCollection();
             }
-            outOfMemory = doCollectOnce(cause, requestingNanoTime, true, incremental);
+            long startTicks = JfrGCEventSupport.startGCPhasePause();
+            try {
+                outOfMemory = doCollectOnce(cause, requestingNanoTime, true, incremental);
+            } finally {
+                JfrGCEventSupport.emitGCPhasePauseEvent(getCollectionEpoch(), "Full GC", startTicks);
+            }
         }
 
         HeapImpl.getChunkProvider().freeExcessAlignedChunks();
@@ -496,13 +513,19 @@ public boolean isCompleteCollection() {
     /** Scavenge, either from dirty roots or from all roots, and process discovered references. */
     private void scavenge(boolean incremental) {
         GreyToBlackObjRefVisitor.Counters counters = greyToBlackObjRefVisitor.openCounters();
+        long startTicks;
         try {
             Timer rootScanTimer = timers.rootScan.open();
             try {
-                if (incremental) {
-                    cheneyScanFromDirtyRoots();
-                } else {
-                    cheneyScanFromRoots();
+                startTicks = JfrGCEventSupport.startGCPhasePause();
+                try {
+                    if (incremental) {
+                        cheneyScanFromDirtyRoots();
+                    } else {
+                        cheneyScanFromRoots();
+                    }
+                } finally {
+                    JfrGCEventSupport.emitGCPhasePauseEvent(getCollectionEpoch(), incremental ? "Incremental Scan Roots" : "Scan Roots", startTicks);
                 }
             } finally {
                 rootScanTimer.close();
@@ -516,37 +539,58 @@ private void scavenge(boolean incremental) {
                      * operation. To avoid side-effects between the code cache cleaning and the GC
                      * core, it is crucial that all the GC core work finished before.
                      */
-                    cleanRuntimeCodeCache();
+                    startTicks = JfrGCEventSupport.startGCPhasePause();
+                    try {
+                        cleanRuntimeCodeCache();
+                    } finally {
+                        JfrGCEventSupport.emitGCPhasePauseEvent(getCollectionEpoch(), "Clean Runtime CodeCache", startTicks);
+                    }
                 } finally {
                     cleanCodeCacheTimer.close();
                 }
             }
 
             Timer referenceObjectsTimer = timers.referenceObjects.open();
             try {
-                Reference<?> newlyPendingList = ReferenceObjectProcessing.processRememberedReferences();
-                HeapImpl.getHeapImpl().addToReferencePendingList(newlyPendingList);
+                startTicks = JfrGCEventSupport.startGCPhasePause();
+                try {
+                    Reference<?> newlyPendingList = ReferenceObjectProcessing.processRememberedReferences();
+                    HeapImpl.getHeapImpl().addToReferencePendingList(newlyPendingList);
+                } finally {
+                    JfrGCEventSupport.emitGCPhasePauseEvent(getCollectionEpoch(), "Process Remembered References", startTicks);
+                }
             } finally {
                 referenceObjectsTimer.close();
             }
 
             Timer releaseSpacesTimer = timers.releaseSpaces.open();
             try {
                 assert chunkReleaser.isEmpty();
-                releaseSpaces();
+                startTicks = JfrGCEventSupport.startGCPhasePause();
+                try {
+                    releaseSpaces();
 
-                /*
-                 * Do not uncommit any aligned chunks yet if we just did an incremental GC so if we
-                 * decide to do a full GC next, we can reuse the chunks for copying live old objects
-                 * with fewer chunk allocations. In either case, excess chunks are released later.
-                 */
-                boolean keepAllAlignedChunks = incremental;
-                chunkReleaser.release(keepAllAlignedChunks);
+                    /*
+                     * Do not uncommit any aligned chunks yet if we just did an incremental GC so if
+                     * we decide to do a full GC next, we can reuse the chunks for copying live old
+                     * objects with fewer chunk allocations. In either case, excess chunks are
+                     * released later.
+                     */
+                    boolean keepAllAlignedChunks = incremental;
+                    chunkReleaser.release(keepAllAlignedChunks);
+                } finally {
+                    JfrGCEventSupport.emitGCPhasePauseEvent(getCollectionEpoch(), "Release Spaces", startTicks);
+                }
             } finally {
                 releaseSpacesTimer.close();
             }
 
-            swapSpaces();
+            startTicks = JfrGCEventSupport.startGCPhasePause();
+            try {
+                swapSpaces();
+            } finally {
+                JfrGCEventSupport.emitGCPhasePauseEvent(getCollectionEpoch(), "Swap Spaces", startTicks);
+            }
         } finally {
             counters.close();
         }

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

@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2022, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 2022, 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.jfr.HasJfrSupport;
+import org.graalvm.nativeimage.StackValue;
+import org.graalvm.word.UnsignedWord;
+
+import com.oracle.svm.core.annotate.Uninterruptible;
+import com.oracle.svm.core.jfr.JfrBuffer;
+import com.oracle.svm.core.jfr.JfrEvent;
+import com.oracle.svm.core.jfr.JfrNativeEventWriter;
+import com.oracle.svm.core.jfr.JfrNativeEventWriterData;
+import com.oracle.svm.core.jfr.JfrNativeEventWriterDataAccess;
+import com.oracle.svm.core.jfr.JfrThreadLocal;
+import com.oracle.svm.core.jfr.JfrTicks;
+import com.oracle.svm.core.jfr.SubstrateJVM;
+import com.oracle.svm.core.util.VMError;
+
+class JfrGCEventSupport {
+    private static final int MAX_PHASE_LEVEL = 4;
+    private static int currentPhase;
+
+    public static long startGCPhasePause() {
+        if (!HasJfrSupport.get()) {
+            return 0;
+        }
+        pushPhase();
+        return JfrTicks.elapsedTicks();
+    }
+
+    @Uninterruptible(reason = "Accesses a JFR buffer.")
+    public static void emitGCPhasePauseEvent(UnsignedWord gcEpoch, String name, long startTicks) {
+        if (!HasJfrSupport.get()) {
+            return;
+        }
+
+        int level = popPhase();
+        JfrEvent event = getGCPhasePauseEvent(level);
+        if (SubstrateJVM.isRecording() && SubstrateJVM.get().isEnabled(event)) {
+            long end = JfrTicks.elapsedTicks();
+            JfrBuffer buffer = ((JfrThreadLocal) SubstrateJVM.getThreadLocal()).getNativeBuffer();
+            JfrNativeEventWriterData data = StackValue.get(JfrNativeEventWriterData.class);
+            JfrNativeEventWriterDataAccess.initialize(data, buffer);
+
+            JfrNativeEventWriter.beginEventWrite(data, false);
+            JfrNativeEventWriter.putLong(data, event.getId());
+            JfrNativeEventWriter.putLong(data, startTicks);
+            JfrNativeEventWriter.putLong(data, end - startTicks);
+            JfrNativeEventWriter.putEventThread(data);
+            JfrNativeEventWriter.putLong(data, gcEpoch.rawValue());
+            JfrNativeEventWriter.putString(data, name);
+            JfrNativeEventWriter.endEventWrite(data, false);
+        }
+    }
+
+    /**
+     * GCPhasePause events are used to group GC phases into a hierarchy. They don't have any
+     * predefined meaning as they are used in a GC-specific way. The most descriptive part is the
+     * phase name that the GC emits as part of those JFR events.
+     */
+    @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
+    private static JfrEvent getGCPhasePauseEvent(int level) {
+        switch (level) {
+            case 0:
+                return JfrEvent.GCPhasePauseEvent;
+            case 1:
+                return JfrEvent.GCPhasePauseLevel1Event;
+            case 2:
+                return JfrEvent.GCPhasePauseLevel2Event;
+            case 3:
+                return JfrEvent.GCPhasePauseLevel3Event;
+            case 4:
+                return JfrEvent.GCPhasePauseLevel4Event;
+            default:
+                throw VMError.shouldNotReachHere("GC phase pause level must be between 0 and 4.");
+        }
+    }
+
+    private static void pushPhase() {
+        assert currentPhase < MAX_PHASE_LEVEL;
+        currentPhase++;
+    }
+
+    @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
+    private static int popPhase() {
+        assert currentPhase > 0;
+        return --currentPhase;
+    }
+}

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jfr/JfrEnabled.java renamed to substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jfr/HasJfrSupport.java

@@ -28,11 +28,14 @@
 
 import org.graalvm.compiler.api.replacements.Fold;
 import org.graalvm.nativeimage.ImageSingletons;
+import org.graalvm.nativeimage.Platform;
+import org.graalvm.nativeimage.Platforms;
 
 /**
- * Used to include/exclude JFR feature and substitutions.
+ * Returns {@code true} if the Native Image is built with JFR support. This does not necessarily
+ * mean that JFR is really enabled at runtime.
  */
-public class JfrEnabled implements BooleanSupplier {
+public class HasJfrSupport implements BooleanSupplier {
     @Override
     public boolean getAsBoolean() {
         return get();
@@ -44,6 +47,11 @@ public static boolean get() {
     }
 }
 
+/**
+ * Returns {@code true} if the HotSpot JVM is recording and emitting JFR events while doing the
+ * Native Image build.
+ */
+@Platforms(Platform.HOSTED_ONLY.class)
 class JfrHostedEnabled implements BooleanSupplier {
     @Override
     public boolean getAsBoolean() {

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

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2020, 2022, 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.svm.core.jfr;
+
+import org.graalvm.nativeimage.Platform;
+import org.graalvm.nativeimage.Platforms;
+
+import com.oracle.svm.core.annotate.Uninterruptible;
+
+/**
+ * The event IDs depend on the metadata.xml and therefore vary between JDK versions.
+ */
+public enum JfrEvent {
+    ThreadStart("jdk.ThreadStart"),
+    ThreadEnd("jdk.ThreadEnd"),
+    DataLoss("jdk.DataLoss"),
+    ClassLoadingStatistics("jdk.ClassLoadingStatistics"),
+    InitialEnvironmentVariable("jdk.InitialEnvironmentVariable"),
+    InitialSystemProperty("jdk.InitialSystemProperty"),
+    JavaThreadStatistics("jdk.JavaThreadStatistics"),
+    JVMInformation("jdk.JVMInformation"),
+    OSInformation("jdk.OSInformation"),
+    PhysicalMemory("jdk.PhysicalMemory"),
+    ExecutionSample("jdk.ExecutionSample"),
+    NativeMethodSample("jdk.NativeMethodSample"),
+    GCPhasePauseEvent("jdk.GCPhasePause"),
+    GCPhasePauseLevel1Event("jdk.GCPhasePauseLevel1"),
+    GCPhasePauseLevel2Event("jdk.GCPhasePauseLevel2"),
+    GCPhasePauseLevel3Event("jdk.GCPhasePauseLevel3"),
+    GCPhasePauseLevel4Event("jdk.GCPhasePauseLevel4");
+
+    private final long id;
+
+    @Platforms(Platform.HOSTED_ONLY.class)
+    JfrEvent(String name) {
+        this.id = JfrMetadataTypeLibrary.lookupPlatformEvent(name);
+    }
+
+    @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
+    public long getId() {
+        return id;
+    }
+}