[GR-42740] [GR-44248] Experimental support for JFR event streaming.

substratevm/CHANGELOG.md

@@ -25,6 +25,7 @@ This changelog summarizes major changes to GraalVM Native Image.
 * (GR-38414) BellSoft implemented the `MemoryPoolMXBean` for the serial and epsilon GCs.
 * (GR-40641) Dynamic linking of AWT libraries on Linux.
 * (GR-40463) Red Hat added experimental support for JMX, which can be enabled with the `--enable-monitoring` option (e.g. `--enable-monitoring=jmxclient,jmxserver`).
+* (GR-42740) Together with Red Hat, we added experimental support for JFR event streaming.
 * (GR-44110) Native Image now targets `x86-64-v3` by default on AMD64 and supports a new `-march` option. Use `-march=compatibility` for best compatibility (previous default) or `-march=native` for best performance if the native executable is deployed on the same machine or on a machine with the same CPU features. To list all available machine types, use `-march=list`.
 * (GR-43971) Add native-image option `-E<env-var-key>[=<env-var-value>]` and support environment variable capturing in bundles. Previously almost all environment variables were available in the builder. To temporarily revert back to the old behaviour, env setting `NATIVE_IMAGE_SLOPPY_BUILDER_SANITATION=true` can be used. The old behaviour will be removed in a future release.
 

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/AbstractUninterruptibleHashtable.java → substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/collections/AbstractUninterruptibleHashtable.java

@@ -22,7 +22,7 @@
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
-package com.oracle.svm.core.jdk;
+package com.oracle.svm.core.collections;
 
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.Platform;
@@ -147,6 +147,14 @@ public boolean putIfAbsent(UninterruptibleEntry valueOnStack) {
         }
     }
 
+    @Override
+    @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
+    public UninterruptibleEntry putNew(UninterruptibleEntry valueOnStack) {
+        assert valueOnStack.isNonNull();
+        assert get(valueOnStack).isNull();
+        return insertEntry(valueOnStack);
+    }
+
     @Override
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     public void clear() {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/UninterruptibleEntry.java → substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/collections/UninterruptibleEntry.java

@@ -22,7 +22,7 @@
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
-package com.oracle.svm.core.jdk;
+package com.oracle.svm.core.collections;
 
 import org.graalvm.nativeimage.c.struct.RawField;
 import org.graalvm.nativeimage.c.struct.RawStructure;

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/UninterruptibleHashtable.java → substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/collections/UninterruptibleHashtable.java

@@ -22,14 +22,13 @@
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
-package com.oracle.svm.core.jdk;
+package com.oracle.svm.core.collections;
 
 import com.oracle.svm.core.Uninterruptible;
 
 /**
  * Common interface for all uninterruptible hashtable implementations. Please note that we don't use
- * generics as this sometimes breaks the {@link Uninterruptible} annotation when ECJ is used for
- * compiling the Java sources.
+ * generics as this may break the {@link Uninterruptible} annotations.
  */
 public interface UninterruptibleHashtable {
     /**
@@ -59,6 +58,14 @@ public interface UninterruptibleHashtable {
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     boolean putIfAbsent(UninterruptibleEntry valueOnStack);
 
+    /**
+     * Inserts {@code valueOnStack} into the hashtable. May only be called if it is guaranteed that
+     * there is no matching entry in the table. Returns the inserted entry. If an error occurred
+     * while inserting the entry, a null pointer is returned instead.
+     */
+    @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
+    UninterruptibleEntry putNew(UninterruptibleEntry valueOnStack);
+
     /**
      * If the hashtable contains an existing entry that matches {@code valueOnStack}, then this
      * existing entry will be returned and no value will be inserted.

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/JDKContainerSubstitutions.java

@@ -25,18 +25,18 @@
 
 package com.oracle.svm.core.jdk;
 
-import org.graalvm.nativeimage.Platform.LINUX;
-
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.locks.ReentrantLock;
 
+import org.graalvm.nativeimage.Platform.LINUX;
 import org.graalvm.nativeimage.Platforms;
 
 import com.oracle.svm.core.annotate.Alias;
 import com.oracle.svm.core.annotate.RecomputeFieldValue;
 import com.oracle.svm.core.annotate.RecomputeFieldValue.Kind;
-
 import com.oracle.svm.core.annotate.TargetClass;
+import com.oracle.svm.core.annotate.TargetElement;
 
 @TargetClass(className = "jdk.internal.platform.cgroupv1.CgroupV1Subsystem", onlyWith = JDK17OrLater.class)
 @Platforms(LINUX.class)
@@ -69,6 +69,11 @@ final class Target_jdk_jfr_internal_instrument_JDKEvents {
 @TargetClass(className = "jdk.jfr.internal.RequestEngine", onlyWith = JDK17OrLater.class)
 @Platforms(LINUX.class)
 final class Target_jdk_jfr_internal_RequestEngine {
+    @Alias //
+    @TargetElement(onlyWith = JDK20OrLater.class) //
+    @RecomputeFieldValue(kind = Kind.NewInstance, declClass = ReentrantLock.class) //
+    private static ReentrantLock lock;
+
     @Alias //
     @RecomputeFieldValue(kind = Kind.NewInstance, declClass = CopyOnWriteArrayList.class) //
     private static List<?> entries;

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/UninterruptibleUtils.java

@@ -456,6 +456,11 @@ public static int numberOfLeadingZeros(long i) {
            // @formatter:on
         }
         // Checkstyle: resume
+
+        @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
+        public static int hashCode(long value) {
+            return (int) (value ^ (value >>> 32));
+        }
     }
 
     public static class Integer {
@@ -530,23 +535,19 @@ private static int modifiedUTF8Length(char c) {
          * Write a char in modified UTF8 format into the buffer.
          */
         @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
-        private static Pointer writeModifiedUTF8(Pointer buffer, char c, boolean replaceDotWithSlash) {
+        private static Pointer writeModifiedUTF8(Pointer buffer, char c) {
             Pointer pos = buffer;
-            char replacedChar = c;
-            if (replaceDotWithSlash && replacedChar == '.') {
-                replacedChar = '/';
-            }
-            if (replacedChar >= 0x0001 && replacedChar <= 0x007F) {
-                pos.writeByte(0, (byte) replacedChar);
+            if (c >= 0x0001 && c <= 0x007F) {
+                pos.writeByte(0, (byte) c);
                 pos = pos.add(1);
-            } else if (replacedChar <= 0x07FF) {
-                pos.writeByte(0, (byte) (0xC0 | (replacedChar >> 6)));
-                pos.writeByte(1, (byte) (0x80 | (replacedChar & 0x3F)));
+            } else if (c <= 0x07FF) {
+                pos.writeByte(0, (byte) (0xC0 | (c >> 6)));
+                pos.writeByte(1, (byte) (0x80 | (c & 0x3F)));
                 pos = pos.add(2);
             } else {
-                pos.writeByte(0, (byte) (0xE0 | (replacedChar >> 12)));
-                pos.writeByte(1, (byte) (0x80 | ((replacedChar >> 6) & 0x3F)));
-                pos.writeByte(2, (byte) (0x80 | (replacedChar & 0x3F)));
+                pos.writeByte(0, (byte) (0xE0 | (c >> 12)));
+                pos.writeByte(1, (byte) (0x80 | ((c >> 6) & 0x3F)));
+                pos.writeByte(2, (byte) (0x80 | (c & 0x3F)));
                 pos = pos.add(3);
             }
             return pos;
@@ -559,9 +560,17 @@ private static Pointer writeModifiedUTF8(Pointer buffer, char c, boolean replace
          */
         @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
         public static int modifiedUTF8Length(java.lang.String string, boolean addNullTerminator) {
+            return modifiedUTF8Length(string, addNullTerminator, null);
+        }
+
+        @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
+        public static int modifiedUTF8Length(java.lang.String string, boolean addNullTerminator, CharReplacer replacer) {
             int result = 0;
             for (int index = 0; index < string.length(); index++) {
                 char ch = StringUtil.charAt(string, index);
+                if (replacer != null) {
+                    ch = replacer.replace(ch);
+                }
                 result += modifiedUTF8Length(ch);
             }
 
@@ -577,15 +586,18 @@ public static int modifiedUTF8Length(java.lang.String string, boolean addNullTer
          */
         @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
         public static Pointer toModifiedUTF8(java.lang.String string, Pointer buffer, Pointer bufferEnd, boolean addNullTerminator) {
-
-            return toModifiedUTF8(string, buffer, bufferEnd, addNullTerminator, false);
+            return toModifiedUTF8(string, buffer, bufferEnd, addNullTerminator, null);
         }
 
         @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
-        public static Pointer toModifiedUTF8(java.lang.String string, Pointer buffer, Pointer bufferEnd, boolean addNullTerminator, boolean replaceDotWithSlash) {
+        public static Pointer toModifiedUTF8(java.lang.String string, Pointer buffer, Pointer bufferEnd, boolean addNullTerminator, CharReplacer replacer) {
             Pointer pos = buffer;
             for (int index = 0; index < string.length(); index++) {
-                pos = writeModifiedUTF8(pos, StringUtil.charAt(string, index), replaceDotWithSlash);
+                char ch = StringUtil.charAt(string, index);
+                if (replacer != null) {
+                    ch = replacer.replace(ch);
+                }
+                pos = writeModifiedUTF8(pos, ch);
             }
 
             if (addNullTerminator) {
@@ -596,4 +608,10 @@ public static Pointer toModifiedUTF8(java.lang.String string, Pointer buffer, Po
             return pos;
         }
     }
+
+    @FunctionalInterface
+    public interface CharReplacer {
+        @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
+        char replace(char val);
+    }
 }

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

@@ -33,23 +33,50 @@
 
 import com.oracle.svm.core.c.struct.PinnedObjectField;
 import com.oracle.svm.core.util.VMError;
-import org.graalvm.nativeimage.IsolateThread;
 
 /**
  * A {@link JfrBuffer} is a block of native memory (either thread-local or global) into which JFR
- * events are written. {@link JfrBuffer#getFlushedPos()} returns the point up to which data has been
- * flushed. {@link JfrBuffer#getCommittedPos()} returns the point up to which data has been
- * committed. This means that data between the these two positions is unflushed data that is ready
- * to be flushed. This also means that {@link JfrBuffer#getFlushedPos()} should never exceed
- * {@link JfrBuffer#getCommittedPos()}. New emitted events are written after the
- * {@link JfrBuffer#getCommittedPos()}. The new events are committed by advancing the committed
- * position.
+ * data (e.g., events) are written. It has the following layout:
+ *
+ * <pre>
+ * Buffer: --------------------------------------------------------------------
+ *         | header | flushed data | committed data | unflushed data | unused |
+ *         --------------------------------------------------------------------
+ *                  |              |                |                         |
+ *              data start    flushed pos     committed pos                data end
+ * </pre>
+ *
+ * The header contains the fields that are defined in the {@link RawStructure} below. The data part
+ * consists of several sections:
+ * <ul>
+ * <li>Flushed data has already been flushed to the {@link JfrGlobalMemory global memory} or to the
+ * disk.</li>
+ * <li>Committed data refers to fully written, valid event data that can be flushed at any
+ * time.</li>
+ * <li>Unflushed data refers to the data of a JFR event that is currently being written.</li>
+ * </ul>
+ *
+ * Multiple threads may access the same {@link JfrBuffer} concurrently:
+ * <li>If a thread owns/created a thread-local buffer, then it may access and modify most of that
+ * buffer's data at any time, without the need for any locking. Only the following operations
+ * require that the {@link JfrBufferNode} is locked:
+ * <ul>
+ * <li>accessing or modifying the flushed position (see {@link JfrBufferAccess#setFlushedPos}</li>
+ * <li>freeing the buffer</li>
+ * </ul>
+ * <li>Accessing a thread-local buffer of another thread is only allowed after locking the
+ * corresponding {@link JfrBufferNode} (see {@link #getNode()}). This prevents other threads from
+ * freeing the buffer in meanwhile. The thread that holds the lock may read any field in the buffer
+ * header and it may also access flushed or committed data (i.e., everything below
+ * {@link #getCommittedPos()}). It must not modify any header fields, except for the flushed
+ * position.</li>
  */
 @RawStructure
 public interface JfrBuffer extends PointerBase {
 
     /**
-     * Returns the size of the buffer. This excludes the header of the buffer.
+     * Returns the size of the buffer. This excludes the header of the buffer. This field is
+     * effectively final.
      */
     @RawField
     UnsignedWord getSize();
@@ -61,7 +88,7 @@ public interface JfrBuffer extends PointerBase {
     void setSize(UnsignedWord value);
 
     /**
-     * Returns the committed position. Any data before this position is valid event data.
+     * Any data before this position was committed and is therefore valid event data.
      */
     @RawField
     Pointer getCommittedPos();
@@ -78,20 +105,20 @@ static int offsetOfCommittedPos() {
     }
 
     /**
-     * Returns the position of unflushed data. Any data before this position was already flushed to
-     * some other buffer or to the disk.
+     * Any data before this position was already flushed to some other buffer or to the disk. Needs
+     * locking, see JavaDoc at the class level.
      */
     @RawField
     Pointer getFlushedPos();
 
     /**
-     * Sets the position of unflushed data.
+     * Sets the flushed position. Needs locking, see JavaDoc at the class level.
      */
     @RawField
     void setFlushedPos(Pointer value);
 
     /**
-     * Returns the type of the buffer.
+     * Returns the type of the buffer. This field is effectively final.
      */
     @RawField
     @PinnedObjectField
@@ -102,16 +129,19 @@ static int offsetOfCommittedPos() {
      */
     @RawField
     @PinnedObjectField
-    void setBufferType(JfrBufferType bufferType);
+    void setBufferType(JfrBufferType value);
 
+    /**
+     * Returns the {@link JfrBufferNode} that references this {@link JfrBuffer}. This field is only
+     * set when a {@link JfrBuffer} was added to a {@link JfrBufferList} (i.e., for
+     * {@link JfrBufferType#C_HEAP} buffers, this field is usually null).
+     */
     @RawField
-    void setLockOwner(IsolateThread thread);
+    JfrBufferNode getNode();
 
+    /**
+     * Sets the {@link JfrBufferNode}.
+     */
     @RawField
-    IsolateThread getLockOwner();
-
-    @RawFieldOffset
-    static int offsetOfLockOwner() {
-        throw VMError.unimplemented(); // replaced
-    }
+    void setNode(JfrBufferNode value);
 }