Add JFR GCTLABConfiguration Event

adpopescu · adpopescu · commit a44a2ccb3bd6 · 2026-07-14T10:47:17.000-04:00
This change add support for the JFR GC TLAB Configuration Event.

Signed-off-by: Adrian Popescu &lt;adpopescu@ibm.com&gt;
diff --git a/runtime/gc/gctable.c b/runtime/gc/gctable.c
@@ -118,6 +118,9 @@ J9MemoryManagerFunctions MemoryManagerFunctions = {
 	j9gc_get_softmx,
 	j9gc_get_initial_heap_size,
 	j9gc_get_maximum_heap_size,
+	j9gc_get_tlh_minimum_size,
+	j9gc_get_tlh_initial_size,
+	j9gc_is_tlab_enabled,
 	j9gc_get_minimum_young_generation_size,
 	j9gc_get_maximum_young_generation_size,
 	j9gc_objaccess_checkClassLive,
diff --git a/runtime/gc_base/gc_internal.h b/runtime/gc_base/gc_internal.h
@@ -139,6 +139,9 @@ extern J9_CFUNC jint  JNICALL queryGCStatus(JavaVM *vm, jint *nHeaps, GCStatus *
 extern J9_CFUNC int j9gc_finalizer_startup(J9JavaVM * vm);
 extern J9_CFUNC UDATA j9gc_wait_for_reference_processing(J9JavaVM *vm);
 extern J9_CFUNC UDATA j9gc_get_maximum_heap_size(J9JavaVM *javaVM);
+extern J9_CFUNC UDATA j9gc_get_tlh_minimum_size(J9JavaVM *javaVM);
+extern J9_CFUNC UDATA j9gc_get_tlh_initial_size(J9JavaVM *javaVM);
+extern J9_CFUNC BOOLEAN j9gc_is_tlab_enabled(J9JavaVM *javaVM);
 extern J9_CFUNC void* j9gc_get_heap_base(J9JavaVM *javaVM);
 extern J9_CFUNC void* j9gc_get_heap_top(J9JavaVM *javaVM);
 extern J9_CFUNC UDATA j9gc_get_minimum_young_generation_size(J9JavaVM *javaVM);
diff --git a/runtime/gc_base/modronapi.cpp b/runtime/gc_base/modronapi.cpp
@@ -856,6 +856,35 @@ j9gc_get_maximum_heap_size(J9JavaVM *javaVM)
 	return size;
 }
 
+/**
+ * API to return the minimum TLH (Thread Local Heap) size.
+ */
+UDATA
+j9gc_get_tlh_minimum_size(J9JavaVM *javaVM)
+{
+	return MM_GCExtensions::getExtensions(javaVM)->tlhMinimumSize;
+}
+
+/**
+ * API to return the initial TLH (Thread Local Heap) size.
+ */
+UDATA
+j9gc_get_tlh_initial_size(J9JavaVM *javaVM)
+{
+	return MM_GCExtensions::getExtensions(javaVM)->tlhInitialSize;
+}
+
+/**
+ * API to return whether TLH allocation is enabled.
+ */
+BOOLEAN
+j9gc_is_tlab_enabled(J9JavaVM *javaVM)
+{
+	uintptr_t allocType = 0;
+	UDATA found = javaVM->memoryManagerFunctions->j9gc_modron_getConfigurationValueForKey(javaVM, j9gc_modron_configuration_allocationType, &allocType);
+	return (found && (j9gc_modron_allocation_type_tlh == allocType)) ? TRUE : FALSE;
+}
+
 /**
  * API to return the heap base address
  */
diff --git a/runtime/gc_base/modronapi.hpp b/runtime/gc_base/modronapi.hpp
@@ -85,6 +85,9 @@ UDATA j9gc_set_softmx(J9JavaVM *javaVM, UDATA newsoftMx);
 UDATA j9gc_get_softmx(J9JavaVM *javaVM);
 UDATA j9gc_get_initial_heap_size(J9JavaVM *javaVM);
 UDATA j9gc_get_maximum_heap_size(J9JavaVM *javaVM);
+UDATA j9gc_get_tlh_minimum_size(J9JavaVM *javaVM);
+UDATA j9gc_get_tlh_initial_size(J9JavaVM *javaVM);
+BOOLEAN j9gc_is_tlab_enabled(J9JavaVM *javaVM);
 void *j9gc_get_heap_base(J9JavaVM *javaVM);
 void *j9gc_get_heap_top(J9JavaVM *javaVM);
 UDATA j9gc_get_minimum_young_generation_size(J9JavaVM *javaVM);
diff --git a/runtime/oti/j9consts.h b/runtime/oti/j9consts.h
@@ -1012,6 +1012,7 @@ extern "C" {
 #define J9JFR_EVENT_TYPE_NATIVE_LIBRARY 32
 #define J9JFR_EVENT_TYPE_THREAD_DUMP 33
 #define J9JFR_EVENT_TYPE_THREAD_ALLOCATION_STATISTICS 34
+#define J9JFR_EVENT_TYPE_GC_TLAB_CONFIGURATION 36
 
 /* JFR thread states. */
 
diff --git a/runtime/oti/j9nonbuilder.h b/runtime/oti/j9nonbuilder.h
@@ -590,6 +590,13 @@ typedef struct J9JFRThreadAllocationStatistics {
 	U_64 allocated;
 } J9JFRThreadAllocationStatistics;
 
+typedef struct J9JFRGCTLABConfiguration {
+	J9JFR_EVENT_COMMON_FIELDS
+	BOOLEAN usesTLABs;
+	U_64 minTLABSize;
+	U_64 tlabRefillWasteLimit;
+} J9JFRGCTLABConfiguration;
+
 #endif /* defined(J9VM_OPT_JFR) */
 
 /* @ddr_namespace: map_to_type=J9CfrError */
@@ -5044,6 +5051,9 @@ typedef struct J9MemoryManagerFunctions {
 	UDATA  ( *j9gc_get_softmx)(struct J9JavaVM *javaVM) ;
 	UDATA  ( *j9gc_get_initial_heap_size)(struct J9JavaVM *javaVM) ;
 	UDATA  ( *j9gc_get_maximum_heap_size)(struct J9JavaVM *javaVM) ;
+	UDATA  ( *j9gc_get_tlh_minimum_size)(struct J9JavaVM *javaVM) ;
+	UDATA  ( *j9gc_get_tlh_initial_size)(struct J9JavaVM *javaVM) ;
+	BOOLEAN  ( *j9gc_is_tlab_enabled)(struct J9JavaVM *javaVM) ;
 	UDATA  ( *j9gc_get_minimum_young_generation_size)(struct J9JavaVM *javaVM) ;
 	UDATA  ( *j9gc_get_maximum_young_generation_size)(struct J9JavaVM *javaVM) ;
 	UDATA  ( *j9gc_objaccess_checkClassLive)(struct J9JavaVM *javaVM, J9Class *classPtr) ;
diff --git a/runtime/vm/JFRChunkWriter.cpp b/runtime/vm/JFRChunkWriter.cpp
@@ -1004,6 +1004,33 @@ VM_JFRChunkWriter::writeYoungGenerationConfigurationEvent()
 	writeEventSize(dataStart);
 }
 
+void
+VM_JFRChunkWriter::writeGCTLABConfigurationEvent()
+{
+	GCTLABConfigurationEntry *tlabConfig = &(VM_JFRConstantPoolTypes::getJFRConstantEvents(_vm)->GCTLABConfigEntry);
+
+	/* reserve size field */
+	U_8 *dataStart = reserveEventSize();
+
+	/* write event type */
+	_bufferWriter->writeLEB128(GCTLABConfigurationID);
+
+	/* write event start time */
+	_bufferWriter->writeLEB128(j9time_nano_time());
+
+	/* write whether TLABs are in use */
+	_bufferWriter->writeBoolean(tlabConfig->usesTLABs);
+
+	/* write minimum TLAB size */
+	_bufferWriter->writeLEB128(tlabConfig->minTLABSize);
+
+	/* write TLAB refill waste limit */
+	_bufferWriter->writeLEB128(tlabConfig->tlabRefillWasteLimit);
+
+	/* write event size */
+	writeEventSize(dataStart);
+}
+
 void
 VM_JFRChunkWriter::writeInitialSystemPropertyEvents(J9JavaVM *vm)
 {
diff --git a/runtime/vm/JFRChunkWriter.hpp b/runtime/vm/JFRChunkWriter.hpp
@@ -122,6 +122,7 @@ enum MetadataTypeID {
 	NativeLibraryID = 112,
 	ModuleRequireID = 113,
 	ModuleExportID = 114,
+	GCTLABConfigurationID = 132,
 	GCHeapConfigID = 133,
 	YoungGenerationConfigID = 134,
 	VirtualSpaceID = 149,
@@ -509,6 +510,8 @@ class VM_JFRChunkWriter {
 					writeGCHeapConfigurationEvent();
 
 					writeYoungGenerationConfigurationEvent();
+
+					writeGCTLABConfigurationEvent();
 				}
 
 				writePhysicalMemoryEvent();
@@ -545,6 +548,10 @@ class VM_JFRChunkWriter {
 					writeYoungGenerationConfigurationEvent();
 				}
 
+				if (_constantPoolTypes.shouldWriteGCTLABConfigurationEvent()) {
+					writeGCTLABConfigurationEvent();
+				}
+
 				if (_constantPoolTypes.shouldWritePhysicalMemory()) {
 					writePhysicalMemoryEvent();
 				}
@@ -953,6 +960,8 @@ class VM_JFRChunkWriter {
 
 	void writeYoungGenerationConfigurationEvent();
 
+	void writeGCTLABConfigurationEvent();
+
 	void writeInitialSystemPropertyEvents(J9JavaVM *vm);
 
 	void writeInitialEnvironmentVariableEvents();
diff --git a/runtime/vm/JFRConstantPoolTypes.hpp b/runtime/vm/JFRConstantPoolTypes.hpp
@@ -439,6 +439,12 @@ struct YoungGenerationConfigurationEntry {
 	U_64 newRatio;
 };
 
+struct GCTLABConfigurationEntry {
+	BOOLEAN usesTLABs;
+	U_64 minTLABSize;
+	U_64 tlabRefillWasteLimit;
+};
+
 struct VirtualizationInformationEntry {
 	const char *name;
 };
@@ -474,6 +480,7 @@ struct JFRConstantEvents {
 	OSInformationEntry OSInfoEntry;
 	GCHeapConfigurationEntry GCHeapConfigEntry;
 	YoungGenerationConfigurationEntry YoungGenConfigEntry;
+	GCTLABConfigurationEntry GCTLABConfigEntry;
 };
 
 class VM_JFRConstantPoolTypes {
@@ -579,6 +586,7 @@ class VM_JFRConstantPoolTypes {
 	bool _shouldWriteModuleRequire;
 	bool _shouldWriteModuleExport;
 	bool _shouldWriteClassLoaderStatistics;
+	bool _shouldWriteGCTLABConfigurationEvent;
 
 	/* Processing buffers */
 	StackFrame *_currentStackFrameBuffer;
@@ -1314,6 +1322,11 @@ class VM_JFRConstantPoolTypes {
 		return _shouldWriteYoungGenerationConfigurationEvent;
 	}
 
+	bool shouldWriteGCTLABConfigurationEvent()
+	{
+		return _shouldWriteGCTLABConfigurationEvent;
+	}
+
 	bool shouldWritePhysicalMemory()
 	{
 		return _shouldWritePhysicalMemory;
@@ -1474,6 +1487,9 @@ class VM_JFRConstantPoolTypes {
 			case J9JFR_EVENT_TYPE_THREAD_ALLOCATION_STATISTICS:
 				addThreadAllocationStatistics((J9JFRThreadAllocationStatistics *)event);
 				break;
+			case J9JFR_EVENT_TYPE_GC_TLAB_CONFIGURATION:
+				_shouldWriteGCTLABConfigurationEvent = true;
+				break;
 			default:
 				Assert_VM_unreachable();
 				break;
@@ -1569,6 +1585,7 @@ class VM_JFRConstantPoolTypes {
 		initializeOSInformation(vm, result);
 		initializeGCHeapConfigurationEvent(vm);
 		initializeYoungGenerationConfigurationEvent(vm);
+		initializeGCTLABConfigurationEvent(vm);
 	}
 
 	/**
@@ -1828,6 +1845,26 @@ class VM_JFRConstantPoolTypes {
 		}
 	}
 
+	/**
+	 * Initialize GCTLABConfigurationEntry
+	 *
+	 * @param vm[in] the J9JavaVM
+	 */
+	static void initializeGCTLABConfigurationEvent(J9JavaVM *vm)
+	{
+		J9MemoryManagerFunctions *mmFuncs = vm->memoryManagerFunctions;
+		GCTLABConfigurationEntry *tlabConfiguration = &(getJFRConstantEvents(vm)->GCTLABConfigEntry);
+
+		tlabConfiguration->usesTLABs = mmFuncs->j9gc_is_tlab_enabled(vm);
+		tlabConfiguration->minTLABSize = mmFuncs->j9gc_get_tlh_minimum_size(vm);
+		/* The closest OMR equivalent to tlabRefillWasteLimit is the
+		 * initial value of abandonSize in TLHAllocationSupport::refresh(), which
+		 * evaluates to max(tlhMinimumSize, tlhInitialSize / 2) on a fresh thread.
+		 * We report tlhInitialSize / 2 as it dominates once refreshSize >= tlhInitialSize.
+		 */
+		tlabConfiguration->tlabRefillWasteLimit = mmFuncs->j9gc_get_tlh_initial_size(vm) / 2;
+	}
+
 	static uintptr_t recordSystemProcessEvent(uintptr_t pid, const char *commandLine, void *userData)
 	{
 		VM_JFRConstantPoolTypes *constantPoolTypes = reinterpret_cast<VM_JFRConstantPoolTypes *>(userData);
@@ -2246,6 +2283,7 @@ class VM_JFRConstantPoolTypes {
 		, _shouldWriteModuleRequire(false)
 		, _shouldWriteModuleExport(false)
 		, _shouldWriteClassLoaderStatistics(false)
+		, _shouldWriteGCTLABConfigurationEvent(false)
 		, _previousStackTraceEntry(NULL)
 		, _firstStackTraceEntry(NULL)
 		, _previousThreadEntry(NULL)
diff --git a/runtime/vm/JFRPeriodic.hpp b/runtime/vm/JFRPeriodic.hpp
@@ -53,6 +53,7 @@ class JfrPeriodicEventSet {
 	static void requestThreadDump(J9VMThread *currentThread);
 	static void requestVirtualizationInformation(J9VMThread *currentThread);
 	static void requestYoungGenerationConfiguration(J9VMThread *currentThread);
+	static void requestGCTLABConfiguration(J9VMThread *currentThread);
 };
 
 #endif /* !defined(JFRPERIODIC_HPP_) */
diff --git a/runtime/vm/jfr.cpp b/runtime/vm/jfr.cpp
@@ -203,6 +203,7 @@ jfrEventSize(J9JFREvent *jfrEvent)
 	case J9JFR_EVENT_TYPE_MODULE_EXPORT:
 	case J9JFR_EVENT_TYPE_CLASS_LOADER_STATISTICS:
 	case J9JFR_EVENT_TYPE_NATIVE_LIBRARY:
+	case J9JFR_EVENT_TYPE_GC_TLAB_CONFIGURATION:
 		size = sizeof(J9JFREvent);
 		break;
 	default:
@@ -2234,6 +2235,9 @@ JfrPeriodicEventSet::requestEvent(J9VMThread *currentThread, jlong id)
 	case JfrYoungGenerationConfigurationEvent:
 		requestYoungGenerationConfiguration(currentThread);
 		break;
+	case JfrGCTLABConfigurationEvent:
+		requestGCTLABConfiguration(currentThread);
+		break;
 	default:
 		return JNI_FALSE;
 	}
@@ -2469,6 +2473,15 @@ jfrThreadAllocationStatisticsCallback(J9VMThread *currentThread, IDATA handlerKe
 	}
 
 }
+
+void
+JfrPeriodicEventSet::requestGCTLABConfiguration(J9VMThread *currentThread)
+{
+	J9JFREvent *jfrEvent = (J9JFREvent *)reserveBuffer(currentThread, currentThread, sizeof(J9JFREvent));
+	if (NULL != jfrEvent) {
+		initializeEventFields(currentThread, currentThread, jfrEvent, J9JFR_EVENT_TYPE_GC_TLAB_CONFIGURATION);
+	}
+}
 #endif /* JAVA_SPEC_VERSION >= 17 */
 
 void
diff --git a/test/functional/cmdLineTests/jfr/jfrevents.xml b/test/functional/cmdLineTests/jfr/jfrevents.xml
@@ -87,6 +87,15 @@ SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-ex
 		<output type="success" caseSensitive="yes" regex="no">jdk.YoungGenerationConfiguration</output>
 		<output type="failure" caseSensitive="yes" regex="no">jfr print: could not read recording</output>
 	</test>
+	<test id="test jfr GC TLAB configuration - approx 30seconds">
+		<command>$JFR_EXE$ print --xml --events "GCTLABConfiguration" defaultJ9recording.jfr</command>
+		<output type="required" caseSensitive="yes" regex="no">http://www.w3.org/2001/XMLSchema-instance</output>
+		<output type="success" caseSensitive="yes" regex="no">jdk.GCTLABConfiguration</output>
+		<output type="required" caseSensitive="yes" regex="no">usesTLABs</output>
+		<output type="required" caseSensitive="yes" regex="no">minTLABSize</output>
+		<output type="required" caseSensitive="yes" regex="no">tlabRefillWasteLimit</output>
+		<output type="failure" caseSensitive="yes" regex="no">jfr print: could not read recording</output>
+	</test>
 	<test id="test jfr system process - approx 30 seconds">
 		<command>$JFR_EXE$ print --xml --events "SystemProcess" defaultJ9recording.jfr</command>
 		<output type="required" caseSensitive="yes" regex="no">http://www.w3.org/2001/XMLSchema-instance</output>
