AOT MXBean

ms-patches/aotmxbean.yml

@@ -0,0 +1,10 @@
+title: AOT
+- work_item: 2497554
+- author: macarte
+- owner: macarte
+- contributors:
+  - macarte
+- details:
+  - Moving work over from Leyden/premain that didn't make jdk25
+  - AOTCache MX Bean
+- release_note: Adding AOTCache MX Bean

src/hotspot/share/cds/metaspaceShared.cpp

@@ -95,6 +95,7 @@
 #include "runtime/vmOperations.hpp"
 #include "runtime/vmThread.hpp"
 #include "sanitizers/leak.hpp"
+#include "services/management.hpp"
 #include "utilities/align.hpp"
 #include "utilities/bitMap.inline.hpp"
 #include "utilities/defaultStream.hpp"
@@ -114,6 +115,7 @@ char* MetaspaceShared::_requested_base_address;
 Array<Method*>* MetaspaceShared::_archived_method_handle_intrinsics = nullptr;
 bool MetaspaceShared::_use_optimized_module_handling = true;
 int volatile MetaspaceShared::_preimage_static_archive_dumped = 0;
+jlong MetaspaceShared::_preimage_static_archive_recording_duration = 0;
 FileMapInfo* MetaspaceShared::_output_mapinfo = nullptr;
 
 // The CDS archive is divided into the following regions:
@@ -937,6 +939,17 @@ bool MetaspaceShared::preimage_static_archive_dumped() {
   return Atomic::load_acquire(&_preimage_static_archive_dumped) == 1;
 }
 
+jlong MetaspaceShared::get_preimage_static_archive_recording_duration() {
+  if (CDSConfig::is_dumping_preimage_static_archive()) {
+    if (_preimage_static_archive_recording_duration == 0) {
+      // The recording has not yet finished so return the current elapsed time.
+      return Management::ticks_to_ms(os::elapsed_counter());
+    }
+    return _preimage_static_archive_recording_duration;
+  }
+  return 0;
+}
+
 void MetaspaceShared::preload_and_dump_impl(StaticArchiveBuilder& builder, TRAPS) {
   if (CDSConfig::is_dumping_preimage_static_archive()) {
     // When dumping to the AOT configuration file ensure this function is only executed once.
@@ -945,6 +958,7 @@ void MetaspaceShared::preload_and_dump_impl(StaticArchiveBuilder& builder, TRAPS
     if (Atomic::cmpxchg(&_preimage_static_archive_dumped, 0, 1) != 0) {
       return;
     }
+    _preimage_static_archive_recording_duration = Management::ticks_to_ms(os::elapsed_counter());
   }
 
   if (CDSConfig::is_dumping_classic_static_archive()) {

src/hotspot/share/cds/metaspaceShared.hpp

@@ -60,6 +60,7 @@ class MetaspaceShared : AllStatic {
   static bool _use_optimized_module_handling;
   static Array<Method*>* _archived_method_handle_intrinsics;
   static int volatile _preimage_static_archive_dumped;
+  static jlong _preimage_static_archive_recording_duration;
   static FileMapInfo* _output_mapinfo;
 
  public:
@@ -113,6 +114,7 @@ class MetaspaceShared : AllStatic {
   static bool is_shared_static(void* p) NOT_CDS_RETURN_(false);
 
   static bool preimage_static_archive_dumped() NOT_CDS_RETURN_(false);
+  static jlong get_preimage_static_archive_recording_duration() NOT_CDS_RETURN_(0);
 
   static void unrecoverable_loading_error(const char* message = "unrecoverable error");
   static void report_loading_error(const char* format, ...) ATTRIBUTE_PRINTF(1, 0);

src/hotspot/share/include/jvm.h

@@ -87,6 +87,18 @@ JVM_InternString(JNIEnv *env, jstring str);
 /*
  * java.lang.System
  */
+JNIEXPORT jboolean JNICALL
+JVM_AOTIsTraining(JNIEnv *env);
+
+JNIEXPORT jboolean JNICALL
+JVM_AOTEndTraining(JNIEnv *env);
+
+JNIEXPORT jstring JNICALL
+JVM_AOTGetMode(JNIEnv *env);
+
+JNIEXPORT jlong JNICALL
+JVM_AOTGetRecordingDuration(JNIEnv *env);
+
 JNIEXPORT jlong JNICALL
 JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored);
 

src/hotspot/share/prims/jvm.cpp

@@ -227,7 +227,69 @@ extern void trace_class_resolution(Klass* to_class) {
 }
 
 // java.lang.System //////////////////////////////////////////////////////////////////////
+JVM_LEAF(jboolean, JVM_AOTIsTraining(JNIEnv *env))
+#if INCLUDE_CDS
+
+  if (!CDSConfig::is_dumping_preimage_static_archive()) {
+    // not a recording session
+    return JNI_FALSE;
+  }
+
+  if (MetaspaceShared::preimage_static_archive_dumped()) {
+    // recording has already completed, so we're no longer "training"
+    return JNI_FALSE;
+  }
+
+  // is training
+  return JNI_TRUE;
+#else
+  return JNI_FALSE;
+#endif // INCLUDE_CDS
+JVM_END
+
+JVM_ENTRY(jboolean, JVM_AOTEndTraining(JNIEnv *env))
+#if INCLUDE_CDS
+  if (!CDSConfig::is_dumping_preimage_static_archive()) {
+    // not a recording session
+    return JNI_FALSE;
+  }
+
+  if (MetaspaceShared::preimage_static_archive_dumped()) {
+    // recording has already completed, so we're no longer "training"
+    return JNI_FALSE;
+  }
+
+  MetaspaceShared::preload_and_dump(THREAD);
+  if (!MetaspaceShared::preimage_static_archive_dumped()) {
+    // failed to complete recording and dumping the archive
+    return JNI_FALSE;
+  }
+
+  // success
+  return JNI_TRUE;
+#else
+  return JNI_FALSE;
+#endif // INCLUDE_CDS
+JVM_END
+
+JVM_ENTRY(jstring, JVM_AOTGetMode(JNIEnv *env))
+  HandleMark hm(THREAD);
+#if INCLUDE_CDS
+  const char* mode = AOTMode == nullptr ? "auto" : AOTMode;
+  Handle h = java_lang_String::create_from_platform_dependent_str(mode, CHECK_NULL);
+  return (jstring) JNIHandles::make_local(THREAD, h());
+#else
+  return nullptr;
+#endif // INCLUDE_CDS
+JVM_END
 
+JVM_LEAF(jlong, JVM_AOTGetRecordingDuration(JNIEnv *env))
+#if INCLUDE_CDS
+  return MetaspaceShared::get_preimage_static_archive_recording_duration();
+#else
+  return 0;
+#endif // INCLUDE_CDS
+JVM_END
 
 JVM_LEAF(jlong, JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored))
   return os::javaTimeMillis();

src/java.management/share/classes/sun/management/VMManagement.java

@@ -48,6 +48,12 @@ public interface VMManagement {
     public boolean isGcNotificationSupported();
     public boolean isRemoteDiagnosticCommandsSupported();
 
+    // AOT Subsytem
+    public String  getAOTMode();
+    public boolean isAOTRecording();
+    public long    getAOTRecordingDuration();
+    public boolean endAOTRecording();
+
     // Class Loading Subsystem
     public long    getTotalClassCount();
     public int     getLoadedClassCount();

src/java.management/share/classes/sun/management/VMManagementImpl.java

@@ -117,6 +117,12 @@ public boolean isRemoteDiagnosticCommandsSupported() {
     public native boolean isThreadCpuTimeEnabled();
     public native boolean isThreadAllocatedMemoryEnabled();
 
+    // AOT Subsystem
+    public native String  getAOTMode();
+    public native boolean isAOTRecording();
+    public native long    getAOTRecordingDuration();
+    public native boolean endAOTRecording();
+
     // Class Loading Subsystem
     public int    getLoadedClassCount() {
         long count = getTotalClassCount() - getUnloadedClassCount();

src/java.management/share/native/libmanagement/VMManagementImpl.c

@@ -100,6 +100,33 @@ Java_sun_management_VMManagementImpl_getVmArguments0
 {
     return JVM_GetVmArguments(env);
 }
+JNIEXPORT jstring JNICALL
+Java_sun_management_VMManagementImpl_getAOTMode
+  (JNIEnv *env, jobject dummy)
+{
+    return JVM_AOTGetMode(env);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_sun_management_VMManagementImpl_isAOTRecording
+  (JNIEnv *env, jobject dummy)
+{
+    return JVM_AOTIsTraining(env);
+}
+
+JNIEXPORT jlong JNICALL
+Java_sun_management_VMManagementImpl_getAOTRecordingDuration
+  (JNIEnv *env, jobject dummy)
+{
+    return JVM_AOTGetRecordingDuration(env);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_sun_management_VMManagementImpl_endAOTRecording
+  (JNIEnv *env, jobject dummy)
+{
+    return JVM_AOTEndTraining(env);
+}
 
 JNIEXPORT jlong JNICALL
 Java_sun_management_VMManagementImpl_getTotalClassCount

src/jdk.management/share/classes/com/sun/management/internal/AOTCacheImpl.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 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.  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.sun.management.internal;
+
+import javax.management.ObjectName;
+import jdk.management.AOTCacheMXBean;
+import sun.management.Util;
+import sun.management.VMManagement;
+
+/**
+  * Implementation class for the AOT Cache subsystem.
+  *
+  * ManagementFactory.getRuntimeMXBean() returns an instance
+  * of this class.
+  */
+public class AOTCacheImpl implements AOTCacheMXBean {
+
+    private final VMManagement jvm;
+    /**
+      * Constructor of AOTCacheImpl class.
+      */
+      AOTCacheImpl(VMManagement vm) {
+         this.jvm = vm;
+     }
+
+     public String getMode() {
+         return jvm.getAOTMode();
+     }
+
+     public boolean isRecording() {
+         return jvm.isAOTRecording();
+     }
+
+     public long getRecordingDuration(){
+         return jvm.getAOTRecordingDuration();
+     }
+
+     public boolean endRecording(){
+         return jvm.endAOTRecording();
+     }
+
+     public ObjectName getObjectName() {
+         return Util.newObjectName("jdk.management:type=AOTCache");
+     }
+}

src/jdk.management/share/classes/com/sun/management/internal/PlatformMBeanProviderImpl.java

@@ -39,6 +39,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import javax.management.DynamicMBean;
+import jdk.management.AOTCacheMXBean;
 import jdk.management.VirtualThreadSchedulerMXBean;
 import sun.management.ManagementFactoryHelper;
 import sun.management.spi.PlatformMBeanProvider;
@@ -159,6 +160,41 @@ public synchronized Map<String, java.lang.management.ThreadMXBean> nameToMBeanMa
             }
         });
 
+        /**
+        * AOTCacheMXBean.
+        */
+        initMBeanList.add(new PlatformComponent<AOTCacheMXBean>() {
+            private final Set<Class<? extends AOTCacheMXBean>> mbeanInterfaces =
+                    Set.of(AOTCacheMXBean.class);
+            private final Set<String> mbeanInterfaceNames =
+                    Set.of(AOTCacheMXBean.class.getName());
+            private AOTCacheMXBean impl;
+
+            @Override
+            public Set<Class<? extends AOTCacheMXBean>> mbeanInterfaces() {
+                return mbeanInterfaces;
+            }
+
+            @Override
+            public Set<String> mbeanInterfaceNames() {
+                return mbeanInterfaceNames;
+            }
+
+            @Override
+            public String getObjectNamePattern() {
+                return "jdk.management:type=AOTCache";
+            }
+
+            @Override
+            public Map<String, AOTCacheMXBean> nameToMBeanMap() {
+                AOTCacheMXBean impl = this.impl;
+                if (impl == null) {
+                    this.impl = impl = new AOTCacheImpl(ManagementFactoryHelper.getVMManagement());
+                }
+                return Map.of("jdk.management:type=AOTCache", impl);
+            }
+        });
+
         /**
          * VirtualThreadSchedulerMXBean.
          */