Clean up. Group allocation events. Add testing back door static class.

Author: roberttoyonaga

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

@@ -62,7 +62,7 @@
 import com.oracle.svm.core.hub.DynamicHub;
 import com.oracle.svm.core.hub.LayoutEncoding;
 import com.oracle.svm.core.jfr.JfrTicks;
-import com.oracle.svm.core.jfr.events.ObjectAllocationInNewTLABEvent;
+import com.oracle.svm.core.jfr.events.JfrAllocationEvents;
 import com.oracle.svm.core.log.Log;
 import com.oracle.svm.core.snippets.KnownIntrinsics;
 import com.oracle.svm.core.snippets.SubstrateForeignCallTarget;
@@ -75,7 +75,6 @@
 import com.oracle.svm.core.threadlocal.FastThreadLocalFactory;
 import com.oracle.svm.core.threadlocal.FastThreadLocalWord;
 import com.oracle.svm.core.util.VMError;
-import com.oracle.svm.core.jfr.events.ObjectAllocationSampleEvent;
 
 /**
  * Bump-pointer allocation from thread-local top and end Pointers. Many of these methods are called
@@ -238,8 +237,7 @@ private static Object slowPathNewInstanceWithoutAllocating(DynamicHub hub) {
             AlignedHeader newTlab = HeapImpl.getChunkProvider().produceAlignedChunk();
             return allocateInstanceInNewTlab(hub, newTlab);
         } finally {
-            ObjectAllocationInNewTLABEvent.emit(startTicks, hub, LayoutEncoding.getPureInstanceAllocationSize(hub.getLayoutEncoding()), HeapParameters.getAlignedHeapChunkSize());
-            ObjectAllocationSampleEvent.emit(startTicks, DynamicHub.toClass(hub));
+            JfrAllocationEvents.emit(startTicks, DynamicHub.toClass(hub), LayoutEncoding.getPureInstanceAllocationSize(hub.getLayoutEncoding()), HeapParameters.getAlignedHeapChunkSize());
             DeoptTester.enableDeoptTesting();
         }
     }
@@ -318,8 +316,7 @@ private static Object slowPathNewArrayLikeObject0(DynamicHub hub, int length, Un
             }
             return array;
         } finally {
-            ObjectAllocationInNewTLABEvent.emit(startTicks, hub, size, tlabSize);
-            ObjectAllocationSampleEvent.emit(startTicks, DynamicHub.toClass(hub));
+            JfrAllocationEvents.emit(startTicks, DynamicHub.toClass(hub), size, tlabSize);
             DeoptTester.enableDeoptTesting();
         }
     }

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

@@ -33,14 +33,14 @@
 
 /**
  * Each event that supports throttling has its own throttler that can be accessed through this class.
- * TODO: Consider making this a proper singleton later
- * When more events support throttling, some sort of allocation free hashmap should be used.
  */
 public class JfrThrottlerSupport {
     JfrThrottler objectAllocationSampleThrottler;
     @Platforms(Platform.HOSTED_ONLY.class)
     JfrThrottlerSupport() {
-        objectAllocationSampleThrottler = new JfrThrottler(new VMMutex("jfrThrottler"));
+        if (HasJfrSupport.get()) {
+            objectAllocationSampleThrottler = new JfrThrottler(new VMMutex("jfrThrottler"));
+        }
     }
 
     private JfrThrottler getThrottler(long eventId) {
@@ -53,7 +53,7 @@ private JfrThrottler getThrottler(long eventId) {
     public boolean setThrottle(long eventTypeId, long eventSampleSize, long periodMs) {
         JfrThrottler throttler = getThrottler(eventTypeId);
         if (throttler == null) {
-            //event doesn't support throttling
+            // This event doesn't support throttling
             return false;
         }
         throttler.setThrottle(eventSampleSize, periodMs);
@@ -63,7 +63,7 @@ public boolean setThrottle(long eventTypeId, long eventSampleSize, long periodMs
     public boolean shouldCommit(long eventTypeId) {
         JfrThrottler throttler = getThrottler(eventTypeId);
         if (throttler == null) {
-            //event doesn't support throttling
+            // This event doesn't support throttling
             return true;
         }
         return throttler.sample();

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

@@ -31,22 +31,22 @@
 
 public class JfrThrottlerWindow {
     // reset every rotation
-    public UninterruptibleUtils.AtomicLong measuredPopSize; // already volatile
-    public UninterruptibleUtils.AtomicLong endTicks; // already volatile
+    public UninterruptibleUtils.AtomicLong measuredPopSize;
+    public UninterruptibleUtils.AtomicLong endTicks;
 
     // Calculated every rotation based on params set by user and results from previous windows
     public volatile long samplingInterval;
-    public volatile double activeWindowSampleLimit;
+    public volatile double maxSampleablePopulation;
 
-    // params set by user
+    // Set by user
     public volatile long samplesPerWindow;
     public volatile long windowDurationNs;
     public volatile long debt;
 
     public JfrThrottlerWindow() {
         windowDurationNs = 0;
         samplesPerWindow = 0;
-        activeWindowSampleLimit = 0;
+        maxSampleablePopulation = 0;
         measuredPopSize = new UninterruptibleUtils.AtomicLong(0);
         endTicks = new UninterruptibleUtils.AtomicLong(JfrTicks.currentTimeNanos() + windowDurationNs);
         samplingInterval = 1;
@@ -63,17 +63,17 @@ public boolean sample() {
         // Guarantees only one thread can record the last event of the window
         long prevMeasuredPopSize = measuredPopSize.getAndIncrement();
 
-        // Stop sampling if we're already over the projected population size, and we're over the
-        // samples per window
+        // Stop sampling if we're already over maxSampleablePopulation and we're over the expected
+        // samples per window.
         if (prevMeasuredPopSize % samplingInterval == 0 &&
-                        (prevMeasuredPopSize < activeWindowSampleLimit)) {
+                        (prevMeasuredPopSize < maxSampleablePopulation)) {
             return true;
         }
         return false;
     }
 
     public long samplesTaken() {
-        if (measuredPopSize.get() > activeWindowSampleLimit) {
+        if (measuredPopSize.get() > maxSampleablePopulation) {
             return samplesExpected();
         }
         return measuredPopSize.get() / samplingInterval;
@@ -88,15 +88,13 @@ public void configure(long debt, double projectedPopSize) {
         if (projectedPopSize <= samplesExpected()) {
             samplingInterval = 1;
         } else {
-            // It's important to round *up* otherwise we risk violating the upper bound
-            // TODO geometric
-// samplingInterval = (long) Math.ceil(projectedPopSize / (double) samplesExpected());
+
             double projectedProbability = (double) samplesExpected() / projectedPopSize;
             samplingInterval = nextGeometric(projectedProbability, Math.random());
         }
-        // activeWindowSampleLimit is either projectedPopSize or samplesExpected() (if
-        // projectedPopSize < samplesPerWindow)
-        this.activeWindowSampleLimit = samplesExpected() * samplingInterval;
+
+        this.maxSampleablePopulation = samplesExpected() * samplingInterval;
+
         // reset
         measuredPopSize.set(0);
 
@@ -106,11 +104,13 @@ public void configure(long debt, double projectedPopSize) {
         } else {
             endTicks.set(JfrTicks.currentTimeNanos() + windowDurationNs);
         }
-
     }
 
-    long nextGeometric(double p, double u) { // *** is P is larger, then its more likely sampling
-                                             // interval is smaller
+    /**
+     * This method is essentially the same as jfrAdaptiveSampler::next_geometric(double, double) in
+     * the OpenJDK.
+     */
+    private long nextGeometric(double p, double u) {
         if (u == 0.0) {
             u = 0.01;
         }

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

@@ -645,17 +645,12 @@ public boolean isEnabled(JfrEvent event) {
     }
 
     public boolean shouldCommit(JfrEvent event) {
-        // find the right throttler for the event (each event should have its own)like in hotspot
-        // if none found, return true.
-        // call into throttler code
         return jfrThrottlerSupport.shouldCommit(event.getId());
     }
 
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     public boolean setThrottle(long eventTypeId, long eventSampleSize, long periodMs) {
-        // find the right throttler for the event and set the new params there
         return jfrThrottlerSupport.setThrottle(eventTypeId, eventSampleSize, periodMs);
-        // TODO: why would it ever return false? Maybe if the throttler doesn't exist?
     }
 
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)

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

@@ -26,33 +26,62 @@
 
 package com.oracle.svm.core.jfr.events;
 
+import org.graalvm.nativeimage.StackValue;
+import org.graalvm.word.UnsignedWord;
+
 import com.oracle.svm.core.Uninterruptible;
+import com.oracle.svm.core.jfr.HasJfrSupport;
 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.SubstrateJVM;
-import com.oracle.svm.core.jfr.HasJfrSupport;
-import org.graalvm.nativeimage.StackValue;
 import com.oracle.svm.core.threadlocal.FastThreadLocalFactory;
 import com.oracle.svm.core.threadlocal.FastThreadLocalLong;
 import com.oracle.svm.core.thread.PlatformThreads;
 import com.oracle.svm.core.thread.JavaThreads;
 
-public class ObjectAllocationSampleEvent {
+public class JfrAllocationEvents {
     private static final FastThreadLocalLong lastAllocationSize = FastThreadLocalFactory.createLong("ObjectAllocationSampleEvent.lastAllocationSize");
-    public static void emit(long startTicks, Class<?> clazz) {
+
+    public static void emit(long startTicks, Class<?> clazz, UnsignedWord allocationSize, UnsignedWord tlabSize) {
         if (HasJfrSupport.get()) {
-            // TODO: consider moving this to after the isRecording check in emit0 to avoid duplicate checks. Might be a pain to deal with uninterruptibility though. Also we want to minimize uninterruptible code usage.
-            // Doesn't hurt to check twice, might save us some time doing the sampling
-            if (SubstrateJVM.get().shouldCommit(JfrEvent.ObjectAllocationSample)) {
-                emit0(startTicks, clazz);
+            emitObjectAllocationInNewTLAB(startTicks, clazz, allocationSize, tlabSize);
+
+            if (shouldEmitObjectAllocationSample() && SubstrateJVM.get().shouldCommit(JfrEvent.ObjectAllocationSample)) {
+                emitObjectAllocationSample(startTicks, clazz);
             }
         }
     }
 
+    /**
+     * This method exists as a slight optimization to avoid entering the sampler code if
+     * unnecessary. We'll have to check {@link JfrEvent.shouldEmit()} again if a sample ends up
+     * being taken.
+     */
+    @Uninterruptible(reason = "Needed for JfrEvent.shouldEmit().")
+    private static boolean shouldEmitObjectAllocationSample() {
+        return JfrEvent.ObjectAllocationSample.shouldEmit();
+    }
+
+    @Uninterruptible(reason = "Accesses a JFR buffer.")
+    private static void emitObjectAllocationInNewTLAB(long startTicks, Class<?> clazz, UnsignedWord allocationSize, UnsignedWord tlabSize) {
+        if (JfrEvent.ObjectAllocationInNewTLAB.shouldEmit()) {
+            JfrNativeEventWriterData data = StackValue.get(JfrNativeEventWriterData.class);
+            JfrNativeEventWriterDataAccess.initializeThreadLocalNativeBuffer(data);
+            JfrNativeEventWriter.beginSmallEvent(data, JfrEvent.ObjectAllocationInNewTLAB);
+            JfrNativeEventWriter.putLong(data, startTicks);
+            JfrNativeEventWriter.putEventThread(data);
+            JfrNativeEventWriter.putLong(data, SubstrateJVM.get().getStackTraceId(JfrEvent.ObjectAllocationInNewTLAB, 0));
+            JfrNativeEventWriter.putClass(data, clazz);
+            JfrNativeEventWriter.putLong(data, allocationSize.rawValue());
+            JfrNativeEventWriter.putLong(data, tlabSize.rawValue());
+            JfrNativeEventWriter.endSmallEvent(data);
+        }
+    }
+
     @Uninterruptible(reason = "Accesses a JFR buffer.")
-    private static void emit0(long startTicks, Class<?> clazz) {
+    private static void emitObjectAllocationSample(long startTicks, Class<?> clazz) {
         if (JfrEvent.ObjectAllocationSample.shouldEmit()) {
             long currentAllocationSize = PlatformThreads.getThreadAllocatedBytes(JavaThreads.getCurrentThreadId());
 
@@ -61,7 +90,7 @@ private static void emit0(long startTicks, Class<?> clazz) {
             JfrNativeEventWriter.beginSmallEvent(data, JfrEvent.ObjectAllocationSample);
             JfrNativeEventWriter.putLong(data, startTicks);
             JfrNativeEventWriter.putEventThread(data);
-            JfrNativeEventWriter.putLong(data, SubstrateJVM.get().getStackTraceId(JfrEvent.ObjectAllocationSample, 0)); //This causes problems during JFR shutdown
+            JfrNativeEventWriter.putLong(data, SubstrateJVM.get().getStackTraceId(JfrEvent.ObjectAllocationSample, 0));
             JfrNativeEventWriter.putClass(data, clazz);
             JfrNativeEventWriter.putLong(data, currentAllocationSize - lastAllocationSize.get());
             JfrNativeEventWriter.endSmallEvent(data);