From 6b7a3713c4a144b9b59350732aadf98b6dc1830e Mon Sep 17 00:00:00 2001 From: Aleksey Shipilev Date: Tue, 4 Mar 2025 10:58:56 +0100 Subject: [PATCH 01/10] Fix --- src/hotspot/share/jfr/metadata/metadata.xml | 5 + src/hotspot/share/runtime/objectMonitor.cpp | 14 +++ src/jdk.jfr/share/conf/jfr/default.jfc | 4 + src/jdk.jfr/share/conf/jfr/profile.jfc | 4 + .../runtime/TestJavaMonitorDeflateEvent.java | 108 ++++++++++++++++++ test/lib/jdk/test/lib/jfr/EventNames.java | 1 + 6 files changed, 136 insertions(+) create mode 100644 test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java diff --git a/src/hotspot/share/jfr/metadata/metadata.xml b/src/hotspot/share/jfr/metadata/metadata.xml index a4b9bc7890007..6876e66d090f1 100644 --- a/src/hotspot/share/jfr/metadata/metadata.xml +++ b/src/hotspot/share/jfr/metadata/metadata.xml @@ -116,6 +116,11 @@ + + + + + diff --git a/src/hotspot/share/runtime/objectMonitor.cpp b/src/hotspot/share/runtime/objectMonitor.cpp index 42b20b27d28ff..4b63102415f83 100644 --- a/src/hotspot/share/runtime/objectMonitor.cpp +++ b/src/hotspot/share/runtime/objectMonitor.cpp @@ -657,6 +657,14 @@ ObjectMonitor::TryLockResult ObjectMonitor::TryLock(JavaThread* current) { return first_own == own ? TryLockResult::HasOwner : TryLockResult::Interference; } +static void post_monitor_deflate_event(EventJavaMonitorDeflate* event, + const oop obj) { + assert(event != nullptr, "invariant"); + event->set_monitorClass(obj->klass()); + event->set_address((uintptr_t)(void*)obj); + event->commit(); +} + // Deflate the specified ObjectMonitor if not in-use. Returns true if it // was deflated and false otherwise. // @@ -676,6 +684,8 @@ bool ObjectMonitor::deflate_monitor(Thread* current) { return false; } + EventJavaMonitorDeflate event; + const oop obj = object_peek(); if (obj == nullptr) { @@ -750,6 +760,10 @@ bool ObjectMonitor::deflate_monitor(Thread* current) { install_displaced_markword_in_object(obj); } + if (event.should_commit()) { + post_monitor_deflate_event(&event, obj); + } + // We leave owner == DEFLATER_MARKER and contentions < 0 // to force any racing threads to retry. return true; // Success, ObjectMonitor has been deflated. diff --git a/src/jdk.jfr/share/conf/jfr/default.jfc b/src/jdk.jfr/share/conf/jfr/default.jfc index 231ecc494a956..8084a43ebf410 100644 --- a/src/jdk.jfr/share/conf/jfr/default.jfc +++ b/src/jdk.jfr/share/conf/jfr/default.jfc @@ -101,6 +101,10 @@ 20 ms + + false + + true true diff --git a/src/jdk.jfr/share/conf/jfr/profile.jfc b/src/jdk.jfr/share/conf/jfr/profile.jfc index e7996689354a7..2930dffad2c35 100644 --- a/src/jdk.jfr/share/conf/jfr/profile.jfc +++ b/src/jdk.jfr/share/conf/jfr/profile.jfc @@ -101,6 +101,10 @@ 10 ms + + true + + true true diff --git a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java new file mode 100644 index 0000000000000..009fa308fb1e9 --- /dev/null +++ b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2016, 2025, 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. + * + * 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 jdk.jfr.event.runtime; + +import static jdk.test.lib.Asserts.assertTrue; + +import java.nio.file.Paths; +import java.time.Duration; +import java.util.concurrent.CountDownLatch; + +import jdk.jfr.Recording; +import jdk.jfr.consumer.RecordedEvent; +import jdk.test.lib.jfr.EventNames; +import jdk.test.lib.jfr.Events; +import jdk.test.lib.thread.TestThread; +import jdk.test.lib.thread.XRun; + +/** + * @test TestJavaMonitorDeflateEvent + * @requires vm.flagless + * @requires vm.hasJFR + * @library /test/lib + * @run main/othervm -XX:GuaranteedAsyncDeflationInterval=100 jdk.jfr.event.runtime.TestJavaMonitorDeflateEvent + */ +public class TestJavaMonitorDeflateEvent { + + private static final String FIELD_KLASS_NAME = "monitorClass.name"; + private static final String FIELD_ADDRESS = "address"; + + private static final String EVENT_NAME = EventNames.JavaMonitorDeflate; + private static final long WAIT_TIME = 123456; + + static class Lock { + } + + public static void main(String[] args) throws Exception { + Recording recording = new Recording(); + recording.enable(EVENT_NAME).withThreshold(Duration.ofMillis(0)); + final Lock lock = new Lock(); + final CountDownLatch latch = new CountDownLatch(1); + // create a thread that waits + TestThread waitThread = new TestThread(new XRun() { + @Override + public void xrun() throws Throwable { + synchronized (lock) { + latch.countDown(); + lock.wait(WAIT_TIME); + } + } + }); + try { + recording.start(); + waitThread.start(); + latch.await(); + synchronized (lock) { + lock.notifyAll(); + } + } finally { + waitThread.join(); + Thread.sleep(1000); + recording.stop(); + } + final String lockClassName = lock.getClass().getName().replace('.', '/'); + boolean isAnyFound = false; + try { + // Find at least one event with the correct monitor class and check the other fields + for (RecordedEvent event : Events.fromRecording(recording)) { + assertTrue(EVENT_NAME.equals(event.getEventType().getName()), "mismatched event types?"); + // Check recorded inflation event is associated with the Lock class used in the test + final String recordedMonitorClassName = Events.assertField(event, FIELD_KLASS_NAME).getValue(); + if (!lockClassName.equals(recordedMonitorClassName)) { + continue; + } + // Check recorded thread matches one of the threads in the test + Events.assertField(event, FIELD_ADDRESS).notEqual(0L); + isAnyFound = true; + break; + } + assertTrue(isAnyFound, "Expected an deflation event from test"); + } catch (Throwable e) { + recording.dump(Paths.get("failed.jfr")); + throw e; + } finally { + recording.close(); + } + } +} diff --git a/test/lib/jdk/test/lib/jfr/EventNames.java b/test/lib/jdk/test/lib/jfr/EventNames.java index 0ef1b5e6d3f92..9cf8fa6904e0e 100644 --- a/test/lib/jdk/test/lib/jfr/EventNames.java +++ b/test/lib/jdk/test/lib/jfr/EventNames.java @@ -59,6 +59,7 @@ public class EventNames { public static final String JavaMonitorEnter = PREFIX + "JavaMonitorEnter"; public static final String JavaMonitorWait = PREFIX + "JavaMonitorWait"; public static final String JavaMonitorInflate = PREFIX + "JavaMonitorInflate"; + public static final String JavaMonitorDeflate = PREFIX + "JavaMonitorDeflate"; public static final String SyncOnValueBasedClass = PREFIX + "SyncOnValueBasedClass"; public static final String ClassLoad = PREFIX + "ClassLoad"; public static final String ClassDefine = PREFIX + "ClassDefine"; From 0cbb9f5395ce81f9afa467950626f9aac07554ee Mon Sep 17 00:00:00 2001 From: Aleksey Shipilev Date: Tue, 4 Mar 2025 15:45:09 +0100 Subject: [PATCH 02/10] Separate statistics event as well --- src/hotspot/share/jfr/metadata/metadata.xml | 5 + src/hotspot/share/runtime/synchronizer.cpp | 8 ++ src/jdk.jfr/share/conf/jfr/default.jfc | 5 + src/jdk.jfr/share/conf/jfr/profile.jfc | 5 + .../runtime/TestJavaMonitorDeflateEvent.java | 3 +- .../TestJavaMonitorStatisticsEvent.java | 106 ++++++++++++++++++ test/lib/jdk/test/lib/jfr/EventNames.java | 1 + 7 files changed, 132 insertions(+), 1 deletion(-) create mode 100644 test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java diff --git a/src/hotspot/share/jfr/metadata/metadata.xml b/src/hotspot/share/jfr/metadata/metadata.xml index 6876e66d090f1..aefbd9ad28790 100644 --- a/src/hotspot/share/jfr/metadata/metadata.xml +++ b/src/hotspot/share/jfr/metadata/metadata.xml @@ -121,6 +121,11 @@ + + + + + diff --git a/src/hotspot/share/runtime/synchronizer.cpp b/src/hotspot/share/runtime/synchronizer.cpp index 0ee3e24760d18..7938c3dddbffb 100644 --- a/src/hotspot/share/runtime/synchronizer.cpp +++ b/src/hotspot/share/runtime/synchronizer.cpp @@ -1807,6 +1807,8 @@ size_t ObjectSynchronizer::deflate_idle_monitors() { _last_async_deflation_time_ns = os::javaTimeNanos(); set_is_async_deflation_requested(false); + EventJavaMonitorStatistics event; + ObjectMonitorDeflationLogging log; ObjectMonitorDeflationSafepointer safepointer(current, &log); @@ -1868,6 +1870,12 @@ size_t ObjectSynchronizer::deflate_idle_monitors() { _no_progress_cnt++; } + if (event.should_commit()) { + event.set_totalCount(_in_use_list.count()); + event.set_deflatedCount(deflated_count); + event.commit(); + } + return deflated_count; } diff --git a/src/jdk.jfr/share/conf/jfr/default.jfc b/src/jdk.jfr/share/conf/jfr/default.jfc index 8084a43ebf410..5ee6f353c8b46 100644 --- a/src/jdk.jfr/share/conf/jfr/default.jfc +++ b/src/jdk.jfr/share/conf/jfr/default.jfc @@ -103,6 +103,11 @@ false + 0 ms + + + + true diff --git a/src/jdk.jfr/share/conf/jfr/profile.jfc b/src/jdk.jfr/share/conf/jfr/profile.jfc index 2930dffad2c35..c1867d477a264 100644 --- a/src/jdk.jfr/share/conf/jfr/profile.jfc +++ b/src/jdk.jfr/share/conf/jfr/profile.jfc @@ -102,6 +102,11 @@ + false + 0 ms + + + true diff --git a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java index 009fa308fb1e9..92fb365f8a400 100644 --- a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java +++ b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java @@ -78,7 +78,8 @@ public void xrun() throws Throwable { } } finally { waitThread.join(); - Thread.sleep(1000); + // Let deflater thread run. + Thread.sleep(3000); recording.stop(); } final String lockClassName = lock.getClass().getName().replace('.', '/'); diff --git a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java new file mode 100644 index 0000000000000..039473bb4e610 --- /dev/null +++ b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2016, 2025, 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. + * + * 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 jdk.jfr.event.runtime; + +import static jdk.test.lib.Asserts.assertTrue; + +import java.nio.file.Paths; +import java.time.Duration; +import java.util.concurrent.CountDownLatch; + +import jdk.jfr.Recording; +import jdk.jfr.consumer.RecordedEvent; +import jdk.test.lib.jfr.EventNames; +import jdk.test.lib.jfr.Events; +import jdk.test.lib.thread.TestThread; +import jdk.test.lib.thread.XRun; + +/** + * @test TestJavaMonitorStatisticsEvent + * @requires vm.flagless + * @requires vm.hasJFR + * @library /test/lib + * @run main/othervm -XX:GuaranteedAsyncDeflationInterval=100 jdk.jfr.event.runtime.TestJavaMonitorStatisticsEvent + */ +public class TestJavaMonitorStatisticsEvent { + + private static final String FIELD_TOTAL_COUNT = "totalCount"; + private static final String FIELD_DEFLATED_COUNT = "deflatedCount"; + + private static final String EVENT_NAME = EventNames.JavaMonitorStatistics; + private static final long WAIT_TIME = 123456; + + static class Lock { + } + + public static void main(String[] args) throws Exception { + Recording recording = new Recording(); + recording.enable(EVENT_NAME).withThreshold(Duration.ofMillis(0)); + final Lock lock = new Lock(); + final CountDownLatch latch = new CountDownLatch(1); + // create a thread that waits + TestThread waitThread = new TestThread(new XRun() { + @Override + public void xrun() throws Throwable { + synchronized (lock) { + latch.countDown(); + lock.wait(WAIT_TIME); + } + } + }); + try { + recording.start(); + waitThread.start(); + latch.await(); + synchronized (lock) { + lock.notifyAll(); + } + } finally { + waitThread.join(); + // Let deflater thread run. + Thread.sleep(3000); + recording.stop(); + } + boolean isAnyFound = false; + try { + // Find at least one event with the correct monitor class and check the other fields + for (RecordedEvent event : Events.fromRecording(recording)) { + assertTrue(EVENT_NAME.equals(event.getEventType().getName()), "mismatched event types?"); + long totalCount = Events.assertField(event, FIELD_TOTAL_COUNT).getValue(); + long deflatedCount = Events.assertField(event, FIELD_DEFLATED_COUNT).getValue(); + assertTrue(totalCount >= 0, "Should be positive"); + assertTrue(deflatedCount >= 0, "Should be positive"); + assertTrue(totalCount + deflatedCount > 0, "Should be non-zero"); + isAnyFound = true; + break; + } + assertTrue(isAnyFound, "Expected a statistics event from test"); + } catch (Throwable e) { + recording.dump(Paths.get("failed.jfr")); + throw e; + } finally { + recording.close(); + } + } +} diff --git a/test/lib/jdk/test/lib/jfr/EventNames.java b/test/lib/jdk/test/lib/jfr/EventNames.java index 9cf8fa6904e0e..9aaa231b8a832 100644 --- a/test/lib/jdk/test/lib/jfr/EventNames.java +++ b/test/lib/jdk/test/lib/jfr/EventNames.java @@ -60,6 +60,7 @@ public class EventNames { public static final String JavaMonitorWait = PREFIX + "JavaMonitorWait"; public static final String JavaMonitorInflate = PREFIX + "JavaMonitorInflate"; public static final String JavaMonitorDeflate = PREFIX + "JavaMonitorDeflate"; + public static final String JavaMonitorStatistics = PREFIX + "JavaMonitorStatistics"; public static final String SyncOnValueBasedClass = PREFIX + "SyncOnValueBasedClass"; public static final String ClassLoad = PREFIX + "ClassLoad"; public static final String ClassDefine = PREFIX + "ClassDefine"; From fa04589fd7bde421d5146a9054561b0d00a3822d Mon Sep 17 00:00:00 2001 From: Aleksey Shipilev Date: Wed, 5 Mar 2025 10:25:27 +0100 Subject: [PATCH 03/10] Event metadata touchups --- src/hotspot/share/jfr/metadata/metadata.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hotspot/share/jfr/metadata/metadata.xml b/src/hotspot/share/jfr/metadata/metadata.xml index aefbd9ad28790..18282f8ac2b84 100644 --- a/src/hotspot/share/jfr/metadata/metadata.xml +++ b/src/hotspot/share/jfr/metadata/metadata.xml @@ -121,8 +121,8 @@ - - + + From c768bf6f9dda280e3fbd64f0af04f57b7fe2cfa8 Mon Sep 17 00:00:00 2001 From: Aleksey Shipilev Date: Wed, 5 Mar 2025 11:00:05 +0100 Subject: [PATCH 04/10] Filter JFR HiddenWait consistently --- .../share/runtime/lightweightSynchronizer.cpp | 6 +++++- src/hotspot/share/runtime/objectMonitor.cpp | 14 ++++++-------- src/hotspot/share/runtime/objectMonitor.hpp | 4 ++++ src/hotspot/share/runtime/objectMonitor.inline.hpp | 7 +++++++ src/hotspot/share/runtime/synchronizer.cpp | 6 +++++- 5 files changed, 27 insertions(+), 10 deletions(-) diff --git a/src/hotspot/share/runtime/lightweightSynchronizer.cpp b/src/hotspot/share/runtime/lightweightSynchronizer.cpp index 55d4a0c30f3d5..44d0cb32b5693 100644 --- a/src/hotspot/share/runtime/lightweightSynchronizer.cpp +++ b/src/hotspot/share/runtime/lightweightSynchronizer.cpp @@ -369,7 +369,11 @@ static void post_monitor_inflate_event(EventJavaMonitorInflate* event, const oop obj, ObjectSynchronizer::InflateCause cause) { assert(event != nullptr, "invariant"); - event->set_monitorClass(obj->klass()); + const Klass* monitor_klass = obj->klass(); + if (ObjectMonitor::is_jfr_excluded(monitor_klass)) { + return; + } + event->set_monitorClass(monitor_klass); event->set_address((uintptr_t)(void*)obj); event->set_cause((u1)cause); event->commit(); diff --git a/src/hotspot/share/runtime/objectMonitor.cpp b/src/hotspot/share/runtime/objectMonitor.cpp index 4b63102415f83..14f6c2455efe3 100644 --- a/src/hotspot/share/runtime/objectMonitor.cpp +++ b/src/hotspot/share/runtime/objectMonitor.cpp @@ -660,7 +660,11 @@ ObjectMonitor::TryLockResult ObjectMonitor::TryLock(JavaThread* current) { static void post_monitor_deflate_event(EventJavaMonitorDeflate* event, const oop obj) { assert(event != nullptr, "invariant"); - event->set_monitorClass(obj->klass()); + const Klass* monitor_klass = obj->klass(); + if (ObjectMonitor::is_jfr_excluded(monitor_klass)) { + return; + } + event->set_monitorClass(monitor_klass); event->set_address((uintptr_t)(void*)obj); event->commit(); } @@ -1609,12 +1613,6 @@ bool ObjectMonitor::check_owner(TRAPS) { "current thread is not owner", false); } -static inline bool is_excluded(const Klass* monitor_klass) { - assert(monitor_klass != nullptr, "invariant"); - NOT_JFR_RETURN_(false); - JFR_ONLY(return vmSymbols::jdk_jfr_internal_management_HiddenWait() == monitor_klass->name();) -} - static void post_monitor_wait_event(EventJavaMonitorWait* event, ObjectMonitor* monitor, uint64_t notifier_tid, @@ -1623,7 +1621,7 @@ static void post_monitor_wait_event(EventJavaMonitorWait* event, assert(event != nullptr, "invariant"); assert(monitor != nullptr, "invariant"); const Klass* monitor_klass = monitor->object()->klass(); - if (is_excluded(monitor_klass)) { + if (ObjectMonitor::is_jfr_excluded(monitor_klass)) { return; } event->set_monitorClass(monitor_klass); diff --git a/src/hotspot/share/runtime/objectMonitor.hpp b/src/hotspot/share/runtime/objectMonitor.hpp index 94c4c242f8271..a2d13e22dee62 100644 --- a/src/hotspot/share/runtime/objectMonitor.hpp +++ b/src/hotspot/share/runtime/objectMonitor.hpp @@ -445,6 +445,10 @@ class ObjectMonitor : public CHeapObj { bool deflate_monitor(Thread* current); private: void install_displaced_markword_in_object(const oop obj); + + // JFR support +public: + static bool is_jfr_excluded(const Klass* monitor_klass); }; // RAII object to ensure that ObjectMonitor::is_being_async_deflated() is diff --git a/src/hotspot/share/runtime/objectMonitor.inline.hpp b/src/hotspot/share/runtime/objectMonitor.inline.hpp index ed34af8dca3ad..1073d00ce031a 100644 --- a/src/hotspot/share/runtime/objectMonitor.inline.hpp +++ b/src/hotspot/share/runtime/objectMonitor.inline.hpp @@ -27,6 +27,7 @@ #include "runtime/objectMonitor.hpp" +#include "classfile/vmSymbols.hpp" #include "logging/log.hpp" #include "oops/access.inline.hpp" #include "oops/markWord.hpp" @@ -286,4 +287,10 @@ inline bool ObjectMonitor::object_refers_to(oop obj) const { return _object.peek() == obj; } +inline bool ObjectMonitor::is_jfr_excluded(const Klass* monitor_klass) { + assert(monitor_klass != nullptr, "invariant"); + NOT_JFR_RETURN_(false); + JFR_ONLY(return vmSymbols::jdk_jfr_internal_management_HiddenWait() == monitor_klass->name();) +} + #endif // SHARE_RUNTIME_OBJECTMONITOR_INLINE_HPP diff --git a/src/hotspot/share/runtime/synchronizer.cpp b/src/hotspot/share/runtime/synchronizer.cpp index 7938c3dddbffb..2f99c4ae511e9 100644 --- a/src/hotspot/share/runtime/synchronizer.cpp +++ b/src/hotspot/share/runtime/synchronizer.cpp @@ -1419,7 +1419,11 @@ static void post_monitor_inflate_event(EventJavaMonitorInflate* event, const oop obj, ObjectSynchronizer::InflateCause cause) { assert(event != nullptr, "invariant"); - event->set_monitorClass(obj->klass()); + const Klass* monitor_klass = obj->klass(); + if (ObjectMonitor::is_jfr_excluded(monitor_klass)) { + return; + } + event->set_monitorClass(monitor_klass); event->set_address((uintptr_t)(void*)obj); event->set_cause((u1)cause); event->commit(); From bf3f75860e6240f781e7779e846b05a8e3005c03 Mon Sep 17 00:00:00 2001 From: Aleksey Shipilev Date: Wed, 5 Mar 2025 11:49:10 +0100 Subject: [PATCH 05/10] Rework statistics event to be actually statistics --- src/hotspot/share/jfr/metadata/metadata.xml | 6 +++--- .../share/jfr/periodic/jfrPeriodic.cpp | 7 +++++++ src/hotspot/share/runtime/synchronizer.cpp | 20 +++++++++---------- src/hotspot/share/runtime/synchronizer.hpp | 2 ++ src/jdk.jfr/share/conf/jfr/default.jfc | 1 + src/jdk.jfr/share/conf/jfr/profile.jfc | 1 + .../TestJavaMonitorStatisticsEvent.java | 8 ++++---- 7 files changed, 28 insertions(+), 17 deletions(-) diff --git a/src/hotspot/share/jfr/metadata/metadata.xml b/src/hotspot/share/jfr/metadata/metadata.xml index 18282f8ac2b84..39e37ce06540e 100644 --- a/src/hotspot/share/jfr/metadata/metadata.xml +++ b/src/hotspot/share/jfr/metadata/metadata.xml @@ -121,9 +121,9 @@ - - - + + + diff --git a/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp b/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp index f22098bb52e18..ad4d0b385818b 100644 --- a/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp +++ b/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp @@ -739,3 +739,10 @@ TRACE_REQUEST_FUNC(NativeMemoryUsage) { TRACE_REQUEST_FUNC(NativeMemoryUsageTotal) { JfrNativeMemoryEvent::send_total_event(timestamp()); } + +TRACE_REQUEST_FUNC(JavaMonitorStatistics) { + EventJavaMonitorStatistics event; + event.set_count(ObjectSynchronizer::in_use_list_count()); + event.set_maxCount(ObjectSynchronizer::in_use_list_max()); + event.commit(); +} diff --git a/src/hotspot/share/runtime/synchronizer.cpp b/src/hotspot/share/runtime/synchronizer.cpp index 2f99c4ae511e9..57bab7e7c7e00 100644 --- a/src/hotspot/share/runtime/synchronizer.cpp +++ b/src/hotspot/share/runtime/synchronizer.cpp @@ -1312,6 +1312,14 @@ static bool monitors_used_above_threshold(MonitorList* list) { return false; } +size_t ObjectSynchronizer::in_use_list_count() { + return _in_use_list.count(); +} + +size_t ObjectSynchronizer::in_use_list_max() { + return _in_use_list.max(); +} + size_t ObjectSynchronizer::in_use_list_ceiling() { return _in_use_list_ceiling; } @@ -1714,8 +1722,8 @@ class ObjectMonitorDeflationLogging: public StackObj { elapsedTimer _timer; size_t ceiling() const { return ObjectSynchronizer::in_use_list_ceiling(); } - size_t count() const { return ObjectSynchronizer::_in_use_list.count(); } - size_t max() const { return ObjectSynchronizer::_in_use_list.max(); } + size_t count() const { return ObjectSynchronizer::in_use_list_count(); } + size_t max() const { return ObjectSynchronizer::in_use_list_max(); } public: ObjectMonitorDeflationLogging() @@ -1811,8 +1819,6 @@ size_t ObjectSynchronizer::deflate_idle_monitors() { _last_async_deflation_time_ns = os::javaTimeNanos(); set_is_async_deflation_requested(false); - EventJavaMonitorStatistics event; - ObjectMonitorDeflationLogging log; ObjectMonitorDeflationSafepointer safepointer(current, &log); @@ -1874,12 +1880,6 @@ size_t ObjectSynchronizer::deflate_idle_monitors() { _no_progress_cnt++; } - if (event.should_commit()) { - event.set_totalCount(_in_use_list.count()); - event.set_deflatedCount(deflated_count); - event.commit(); - } - return deflated_count; } diff --git a/src/hotspot/share/runtime/synchronizer.hpp b/src/hotspot/share/runtime/synchronizer.hpp index d3d1f4ee4ce39..1130a087e2805 100644 --- a/src/hotspot/share/runtime/synchronizer.hpp +++ b/src/hotspot/share/runtime/synchronizer.hpp @@ -187,6 +187,8 @@ class ObjectSynchronizer : AllStatic { // Deflate idle monitors: static size_t deflate_monitor_list(ObjectMonitorDeflationSafepointer* safepointer); + static size_t in_use_list_count(); + static size_t in_use_list_max(); static size_t in_use_list_ceiling(); static void dec_in_use_list_ceiling(); static void inc_in_use_list_ceiling(); diff --git a/src/jdk.jfr/share/conf/jfr/default.jfc b/src/jdk.jfr/share/conf/jfr/default.jfc index 5ee6f353c8b46..6fe8b0515364e 100644 --- a/src/jdk.jfr/share/conf/jfr/default.jfc +++ b/src/jdk.jfr/share/conf/jfr/default.jfc @@ -108,6 +108,7 @@ true + everyChunk diff --git a/src/jdk.jfr/share/conf/jfr/profile.jfc b/src/jdk.jfr/share/conf/jfr/profile.jfc index c1867d477a264..2c680944d929f 100644 --- a/src/jdk.jfr/share/conf/jfr/profile.jfc +++ b/src/jdk.jfr/share/conf/jfr/profile.jfc @@ -108,6 +108,7 @@ true + everyChunk diff --git a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java index 039473bb4e610..4d5addb9f80b7 100644 --- a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java +++ b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java @@ -45,8 +45,8 @@ */ public class TestJavaMonitorStatisticsEvent { - private static final String FIELD_TOTAL_COUNT = "totalCount"; - private static final String FIELD_DEFLATED_COUNT = "deflatedCount"; + private static final String FIELD_COUNT = "count"; + private static final String FIELD_MAX_COUNT = "maxCount"; private static final String EVENT_NAME = EventNames.JavaMonitorStatistics; private static final long WAIT_TIME = 123456; @@ -87,8 +87,8 @@ public void xrun() throws Throwable { // Find at least one event with the correct monitor class and check the other fields for (RecordedEvent event : Events.fromRecording(recording)) { assertTrue(EVENT_NAME.equals(event.getEventType().getName()), "mismatched event types?"); - long totalCount = Events.assertField(event, FIELD_TOTAL_COUNT).getValue(); - long deflatedCount = Events.assertField(event, FIELD_DEFLATED_COUNT).getValue(); + long totalCount = Events.assertField(event, FIELD_COUNT).getValue(); + long deflatedCount = Events.assertField(event, FIELD_MAX_COUNT).getValue(); assertTrue(totalCount >= 0, "Should be positive"); assertTrue(deflatedCount >= 0, "Should be positive"); assertTrue(totalCount + deflatedCount > 0, "Should be non-zero"); From 3b08f0ba5b1aa0a4abedd3d38c050ff633b63946 Mon Sep 17 00:00:00 2001 From: Aleksey Shipilev Date: Wed, 5 Mar 2025 12:46:48 +0100 Subject: [PATCH 06/10] Test updates --- .../runtime/TestJavaMonitorDeflateEvent.java | 75 ++++++--------- .../TestJavaMonitorStatisticsEvent.java | 96 ++++++++++--------- 2 files changed, 77 insertions(+), 94 deletions(-) diff --git a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java index 92fb365f8a400..5527ca8116710 100644 --- a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java +++ b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java @@ -23,13 +23,16 @@ package jdk.jfr.event.runtime; -import static jdk.test.lib.Asserts.assertTrue; +import static jdk.test.lib.Asserts.assertFalse; import java.nio.file.Paths; import java.time.Duration; -import java.util.concurrent.CountDownLatch; +import java.util.List; +import java.util.concurrent.CopyOnWriteArrayList; import jdk.jfr.Recording; +import jdk.jfr.consumer.RecordingStream; +import jdk.jfr.consumer.RecordedClass; import jdk.jfr.consumer.RecordedEvent; import jdk.test.lib.jfr.EventNames; import jdk.test.lib.jfr.Events; @@ -49,61 +52,39 @@ public class TestJavaMonitorDeflateEvent { private static final String FIELD_ADDRESS = "address"; private static final String EVENT_NAME = EventNames.JavaMonitorDeflate; - private static final long WAIT_TIME = 123456; static class Lock { } public static void main(String[] args) throws Exception { - Recording recording = new Recording(); - recording.enable(EVENT_NAME).withThreshold(Duration.ofMillis(0)); final Lock lock = new Lock(); - final CountDownLatch latch = new CountDownLatch(1); - // create a thread that waits - TestThread waitThread = new TestThread(new XRun() { - @Override - public void xrun() throws Throwable { - synchronized (lock) { - latch.countDown(); - lock.wait(WAIT_TIME); + final String lockClassName = lock.getClass().getName().replace('.', '/'); + + List events = new CopyOnWriteArrayList<>(); + try (RecordingStream rs = new RecordingStream()) { + rs.enable(EVENT_NAME).withoutThreshold(); + rs.onEvent(EVENT_NAME, e -> { + Object clazz = e.getValue(FIELD_KLASS_NAME); + if (clazz.equals(lockClassName)) { + events.add(e); + rs.close(); } - } - }); - try { - recording.start(); - waitThread.start(); - latch.await(); + }); + rs.startAsync(); + synchronized (lock) { - lock.notifyAll(); + // Causes lock inflation. + lock.wait(1); } - } finally { - waitThread.join(); - // Let deflater thread run. - Thread.sleep(3000); - recording.stop(); - } - final String lockClassName = lock.getClass().getName().replace('.', '/'); - boolean isAnyFound = false; - try { - // Find at least one event with the correct monitor class and check the other fields - for (RecordedEvent event : Events.fromRecording(recording)) { - assertTrue(EVENT_NAME.equals(event.getEventType().getName()), "mismatched event types?"); - // Check recorded inflation event is associated with the Lock class used in the test - final String recordedMonitorClassName = Events.assertField(event, FIELD_KLASS_NAME).getValue(); - if (!lockClassName.equals(recordedMonitorClassName)) { - continue; - } - // Check recorded thread matches one of the threads in the test - Events.assertField(event, FIELD_ADDRESS).notEqual(0L); - isAnyFound = true; - break; + + // Wait for deflater thread to act. + rs.awaitTermination(); + + System.out.println(events); + assertFalse(events.isEmpty()); + for (RecordedEvent ev : events) { + Events.assertField(ev, FIELD_ADDRESS).notEqual(0L); } - assertTrue(isAnyFound, "Expected an deflation event from test"); - } catch (Throwable e) { - recording.dump(Paths.get("failed.jfr")); - throw e; - } finally { - recording.close(); } } } diff --git a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java index 4d5addb9f80b7..0b842ca5ce423 100644 --- a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java +++ b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java @@ -23,13 +23,17 @@ package jdk.jfr.event.runtime; +import static jdk.test.lib.Asserts.assertFalse; import static jdk.test.lib.Asserts.assertTrue; import java.nio.file.Paths; import java.time.Duration; -import java.util.concurrent.CountDownLatch; +import java.util.List; +import java.util.concurrent.CopyOnWriteArrayList; import jdk.jfr.Recording; +import jdk.jfr.consumer.RecordingStream; +import jdk.jfr.consumer.RecordedClass; import jdk.jfr.consumer.RecordedEvent; import jdk.test.lib.jfr.EventNames; import jdk.test.lib.jfr.Events; @@ -41,7 +45,7 @@ * @requires vm.flagless * @requires vm.hasJFR * @library /test/lib - * @run main/othervm -XX:GuaranteedAsyncDeflationInterval=100 jdk.jfr.event.runtime.TestJavaMonitorStatisticsEvent + * @run main/othervm jdk.jfr.event.runtime.TestJavaMonitorStatisticsEvent */ public class TestJavaMonitorStatisticsEvent { @@ -49,58 +53,56 @@ public class TestJavaMonitorStatisticsEvent { private static final String FIELD_MAX_COUNT = "maxCount"; private static final String EVENT_NAME = EventNames.JavaMonitorStatistics; - private static final long WAIT_TIME = 123456; + private static final int NUM_LOCKS = 512; static class Lock { } + static final Lock[] LOCKS = new Lock[NUM_LOCKS]; + + static void lockNext(int idx, Runnable action) throws InterruptedException { + if (idx >= NUM_LOCKS) { + action.run(); + return; + } + synchronized (LOCKS[idx]) { + LOCKS[idx].wait(1); + lockNext(idx + 1, action); + } + } + public static void main(String[] args) throws Exception { - Recording recording = new Recording(); - recording.enable(EVENT_NAME).withThreshold(Duration.ofMillis(0)); - final Lock lock = new Lock(); - final CountDownLatch latch = new CountDownLatch(1); - // create a thread that waits - TestThread waitThread = new TestThread(new XRun() { - @Override - public void xrun() throws Throwable { - synchronized (lock) { - latch.countDown(); - lock.wait(WAIT_TIME); - } - } - }); - try { - recording.start(); - waitThread.start(); - latch.await(); - synchronized (lock) { - lock.notifyAll(); + List events = new CopyOnWriteArrayList<>(); + try (RecordingStream rs = new RecordingStream()) { + rs.enable(EVENT_NAME).with("period", "everyChunk"); + rs.onEvent(EVENT_NAME, e -> events.add(e)); + rs.startAsync(); + + // Recursively lock all, causing NUM_LOCKS monitors to exist. + // Stop the recording when holding all the locks, so that we + // get at least one event with NUM_LOCKS max. + for (int c = 0; c < NUM_LOCKS; c++) { + LOCKS[c] = new Lock(); } - } finally { - waitThread.join(); - // Let deflater thread run. - Thread.sleep(3000); - recording.stop(); - } - boolean isAnyFound = false; - try { - // Find at least one event with the correct monitor class and check the other fields - for (RecordedEvent event : Events.fromRecording(recording)) { - assertTrue(EVENT_NAME.equals(event.getEventType().getName()), "mismatched event types?"); - long totalCount = Events.assertField(event, FIELD_COUNT).getValue(); - long deflatedCount = Events.assertField(event, FIELD_MAX_COUNT).getValue(); - assertTrue(totalCount >= 0, "Should be positive"); - assertTrue(deflatedCount >= 0, "Should be positive"); - assertTrue(totalCount + deflatedCount > 0, "Should be non-zero"); - isAnyFound = true; - break; + lockNext(0, () -> rs.stop()); + + System.out.println(events); + assertFalse(events.isEmpty()); + + long globalMax = Long.MIN_VALUE; + long globalCount = Long.MIN_VALUE; + for (RecordedEvent ev : events) { + long evMaxCount = Events.assertField(ev, FIELD_MAX_COUNT).getValue(); + long evCount = Events.assertField(ev, FIELD_COUNT).getValue(); + assertTrue(evCount <= evMaxCount, "Count should be below max: " + evCount + " <= " + evMaxCount); + assertTrue(evMaxCount >= 0, "Max should be non-negative: " + evMaxCount); + assertTrue(evCount >= 0, "Count should be non-negative: " + evCount); + globalMax = Math.max(globalMax, evMaxCount); + globalCount = Math.max(globalCount, evCount); } - assertTrue(isAnyFound, "Expected a statistics event from test"); - } catch (Throwable e) { - recording.dump(Paths.get("failed.jfr")); - throw e; - } finally { - recording.close(); + + assertTrue(globalMax >= NUM_LOCKS, "Global max should be at least " + NUM_LOCKS + ": " + globalMax); + assertTrue(globalCount >= NUM_LOCKS, "Global count should be at least " + NUM_LOCKS + ": " + globalCount); } } } From 09c82448dc3dbdccebb32589f1b1784b53dbb977 Mon Sep 17 00:00:00 2001 From: Aleksey Shipilev Date: Thu, 6 Mar 2025 13:04:46 +0100 Subject: [PATCH 07/10] Fix test in release builds --- test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java index 5527ca8116710..2c10911179b3d 100644 --- a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java +++ b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorDeflateEvent.java @@ -44,7 +44,7 @@ * @requires vm.flagless * @requires vm.hasJFR * @library /test/lib - * @run main/othervm -XX:GuaranteedAsyncDeflationInterval=100 jdk.jfr.event.runtime.TestJavaMonitorDeflateEvent + * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:GuaranteedAsyncDeflationInterval=100 jdk.jfr.event.runtime.TestJavaMonitorDeflateEvent */ public class TestJavaMonitorDeflateEvent { From 02293a802e7b8f6cb44c335aa314b1dde4c96b88 Mon Sep 17 00:00:00 2001 From: Aleksey Shipilev Date: Thu, 6 Mar 2025 13:05:58 +0100 Subject: [PATCH 08/10] Touch up descriptions --- src/hotspot/share/jfr/metadata/metadata.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hotspot/share/jfr/metadata/metadata.xml b/src/hotspot/share/jfr/metadata/metadata.xml index 39e37ce06540e..35c38d688bba8 100644 --- a/src/hotspot/share/jfr/metadata/metadata.xml +++ b/src/hotspot/share/jfr/metadata/metadata.xml @@ -122,8 +122,8 @@ - - + + From edd9beaf11ad08ad56fecc45e46c5f64eaebf052 Mon Sep 17 00:00:00 2001 From: Aleksey Shipilev Date: Wed, 12 Mar 2025 13:17:46 +0100 Subject: [PATCH 09/10] peakCount it is --- src/hotspot/share/jfr/metadata/metadata.xml | 2 +- src/hotspot/share/jfr/periodic/jfrPeriodic.cpp | 2 +- .../runtime/TestJavaMonitorStatisticsEvent.java | 14 +++++++------- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/hotspot/share/jfr/metadata/metadata.xml b/src/hotspot/share/jfr/metadata/metadata.xml index 35c38d688bba8..79013772d8512 100644 --- a/src/hotspot/share/jfr/metadata/metadata.xml +++ b/src/hotspot/share/jfr/metadata/metadata.xml @@ -123,7 +123,7 @@ - + diff --git a/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp b/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp index ad4d0b385818b..7229d31067425 100644 --- a/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp +++ b/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp @@ -743,6 +743,6 @@ TRACE_REQUEST_FUNC(NativeMemoryUsageTotal) { TRACE_REQUEST_FUNC(JavaMonitorStatistics) { EventJavaMonitorStatistics event; event.set_count(ObjectSynchronizer::in_use_list_count()); - event.set_maxCount(ObjectSynchronizer::in_use_list_max()); + event.set_peakCount(ObjectSynchronizer::in_use_list_max()); event.commit(); } diff --git a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java index 0b842ca5ce423..6bd8548d4847b 100644 --- a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java +++ b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java @@ -50,7 +50,7 @@ public class TestJavaMonitorStatisticsEvent { private static final String FIELD_COUNT = "count"; - private static final String FIELD_MAX_COUNT = "maxCount"; + private static final String FIELD_PEAK_COUNT = "peakCount"; private static final String EVENT_NAME = EventNames.JavaMonitorStatistics; private static final int NUM_LOCKS = 512; @@ -89,19 +89,19 @@ public static void main(String[] args) throws Exception { System.out.println(events); assertFalse(events.isEmpty()); - long globalMax = Long.MIN_VALUE; + long globalPeakCount = Long.MIN_VALUE; long globalCount = Long.MIN_VALUE; for (RecordedEvent ev : events) { - long evMaxCount = Events.assertField(ev, FIELD_MAX_COUNT).getValue(); + long evPeakCount = Events.assertField(ev, FIELD_PEAK_COUNT).getValue(); long evCount = Events.assertField(ev, FIELD_COUNT).getValue(); - assertTrue(evCount <= evMaxCount, "Count should be below max: " + evCount + " <= " + evMaxCount); - assertTrue(evMaxCount >= 0, "Max should be non-negative: " + evMaxCount); + assertTrue(evCount <= evPeakCount, "Count should be less or equal to peak: " + evCount + " <= " + evPeakCount); + assertTrue(evPeakCount >= 0, "Peak should be non-negative: " + evPeakCount); assertTrue(evCount >= 0, "Count should be non-negative: " + evCount); - globalMax = Math.max(globalMax, evMaxCount); + globalPeakCount = Math.max(globalPeakCount, evPeakCount); globalCount = Math.max(globalCount, evCount); } - assertTrue(globalMax >= NUM_LOCKS, "Global max should be at least " + NUM_LOCKS + ": " + globalMax); + assertTrue(globalPeakCount >= NUM_LOCKS, "Global peak should be at least " + NUM_LOCKS + ": " + globalPeakCount); assertTrue(globalCount >= NUM_LOCKS, "Global count should be at least " + NUM_LOCKS + ": " + globalCount); } } From 0caf4b3ad04419e5a9a346554089c223e3b86c0d Mon Sep 17 00:00:00 2001 From: Aleksey Shipilev Date: Wed, 12 Mar 2025 15:08:11 +0100 Subject: [PATCH 10/10] Drop peak count completely --- src/hotspot/share/jfr/metadata/metadata.xml | 1 - src/hotspot/share/jfr/periodic/jfrPeriodic.cpp | 1 - .../jfr/event/runtime/TestJavaMonitorStatisticsEvent.java | 7 ------- 3 files changed, 9 deletions(-) diff --git a/src/hotspot/share/jfr/metadata/metadata.xml b/src/hotspot/share/jfr/metadata/metadata.xml index 79013772d8512..3151ad72af187 100644 --- a/src/hotspot/share/jfr/metadata/metadata.xml +++ b/src/hotspot/share/jfr/metadata/metadata.xml @@ -123,7 +123,6 @@ - diff --git a/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp b/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp index 7229d31067425..91a696c6aa56b 100644 --- a/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp +++ b/src/hotspot/share/jfr/periodic/jfrPeriodic.cpp @@ -743,6 +743,5 @@ TRACE_REQUEST_FUNC(NativeMemoryUsageTotal) { TRACE_REQUEST_FUNC(JavaMonitorStatistics) { EventJavaMonitorStatistics event; event.set_count(ObjectSynchronizer::in_use_list_count()); - event.set_peakCount(ObjectSynchronizer::in_use_list_max()); event.commit(); } diff --git a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java index 6bd8548d4847b..baf549bead081 100644 --- a/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java +++ b/test/jdk/jdk/jfr/event/runtime/TestJavaMonitorStatisticsEvent.java @@ -50,7 +50,6 @@ public class TestJavaMonitorStatisticsEvent { private static final String FIELD_COUNT = "count"; - private static final String FIELD_PEAK_COUNT = "peakCount"; private static final String EVENT_NAME = EventNames.JavaMonitorStatistics; private static final int NUM_LOCKS = 512; @@ -89,19 +88,13 @@ public static void main(String[] args) throws Exception { System.out.println(events); assertFalse(events.isEmpty()); - long globalPeakCount = Long.MIN_VALUE; long globalCount = Long.MIN_VALUE; for (RecordedEvent ev : events) { - long evPeakCount = Events.assertField(ev, FIELD_PEAK_COUNT).getValue(); long evCount = Events.assertField(ev, FIELD_COUNT).getValue(); - assertTrue(evCount <= evPeakCount, "Count should be less or equal to peak: " + evCount + " <= " + evPeakCount); - assertTrue(evPeakCount >= 0, "Peak should be non-negative: " + evPeakCount); assertTrue(evCount >= 0, "Count should be non-negative: " + evCount); - globalPeakCount = Math.max(globalPeakCount, evPeakCount); globalCount = Math.max(globalCount, evCount); } - assertTrue(globalPeakCount >= NUM_LOCKS, "Global peak should be at least " + NUM_LOCKS + ": " + globalPeakCount); assertTrue(globalCount >= NUM_LOCKS, "Global count should be at least " + NUM_LOCKS + ": " + globalCount); } }