Skip to content

Commit 8f65916

Browse files
roberttoyonagaroberttoyonaga
committed
Account for vmem in JFR events and NMT report. Improve NMT report format.
1 parent 555459b commit 8f65916

File tree

4 files changed

+101
-58
lines changed

4 files changed

+101
-58
lines changed

‎substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jfr/events/EveryChunkNativePeriodicEvents.java‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -124,20 +124,20 @@ private static void emitNativeMemoryTrackingEvents() {
124124
private static void emitNmtPeakEvents() {
125125
NativeMemoryUsageTotalPeakEvent nmtTotalPeakEvent = new NativeMemoryUsageTotalPeakEvent();
126126

127-
long totalPeakUsed = NativeMemoryTracking.singleton().getPeakTotalUsedMemory();
127+
long totalPeakUsed = NativeMemoryTracking.singleton().getPeakTotalMallocMemory();
128128
nmtTotalPeakEvent.peakCommitted = totalPeakUsed;
129129
nmtTotalPeakEvent.peakReserved = totalPeakUsed;
130-
nmtTotalPeakEvent.countAtPeak = NativeMemoryTracking.singleton().getCountAtTotalPeakUsage();
130+
nmtTotalPeakEvent.countAtPeak = NativeMemoryTracking.singleton().getCountAtPeakTotalMallocMemory();
131131
nmtTotalPeakEvent.commit();
132132

133133
for (NmtCategory nmtCategory : NmtCategory.values()) {
134134
NativeMemoryUsagePeakEvent nmtPeakEvent = new NativeMemoryUsagePeakEvent();
135135
nmtPeakEvent.type = nmtCategory.getName();
136136

137-
long peakUsed = NativeMemoryTracking.singleton().getPeakUsedMemory(nmtCategory);
137+
long peakUsed = NativeMemoryTracking.singleton().getPeakMallocMemory(nmtCategory);
138138
nmtPeakEvent.peakCommitted = peakUsed;
139139
nmtPeakEvent.peakReserved = peakUsed;
140-
nmtPeakEvent.countAtPeak = NativeMemoryTracking.singleton().getCountAtPeakUsage(nmtCategory);
140+
nmtPeakEvent.countAtPeak = NativeMemoryTracking.singleton().getCountAtPeakMallocMemory(nmtCategory);
141141
nmtPeakEvent.commit();
142142
}
143143
}
@@ -150,7 +150,7 @@ private static void emitJdkNmtEvents(NmtCategory[] nmtCategories) {
150150

151151
if (JfrEvent.NativeMemoryUsage.shouldEmit()) {
152152
for (NmtCategory nmtCategory : nmtCategories) {
153-
long usedMemory = NativeMemoryTracking.singleton().getUsedMemory(nmtCategory);
153+
long usedMemory = NativeMemoryTracking.singleton().getMallocMemory(nmtCategory);
154154

155155
JfrNativeEventWriter.beginSmallEvent(data, JfrEvent.NativeMemoryUsage);
156156
JfrNativeEventWriter.putLong(data, timestamp);
@@ -162,7 +162,7 @@ private static void emitJdkNmtEvents(NmtCategory[] nmtCategories) {
162162
}
163163

164164
if (JfrEvent.NativeMemoryUsageTotal.shouldEmit()) {
165-
long totalUsedMemory = NativeMemoryTracking.singleton().getTotalUsedMemory();
165+
long totalUsedMemory = NativeMemoryTracking.singleton().getTotalMallocMemory();
166166

167167
JfrNativeEventWriter.beginSmallEvent(data, JfrEvent.NativeMemoryUsageTotal);
168168
JfrNativeEventWriter.putLong(data, timestamp);

‎substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/nmt/NativeMemoryTracking.java‎

Lines changed: 76 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -57,6 +57,7 @@
5757
public class NativeMemoryTracking {
5858
private static final UnsignedWord ALIGNMENT = WordFactory.unsigned(16);
5959
private static final int MAGIC = 0xF0F1F2F3;
60+
private static final long KB = 1024;
6061

6162
private final NmtMallocMemoryInfo[] mallocCategories;
6263
private final NmtVirtualMemoryInfo[] virtualCategories;
@@ -208,54 +209,81 @@ void recordFree(UnsignedWord size, NmtCategory category) {
208209
}
209210

210211
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
211-
public long getUsedMemory(NmtCategory category) {
212+
public long getMallocMemory(NmtCategory category) {
212213
return getMallocInfo(category).getUsed();
213214
}
214215

215216
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
216-
public long getPeakUsedMemory(NmtCategory category) {
217+
public long getMallocCount(NmtCategory category) {
218+
return getMallocInfo(category).getCount();
219+
}
220+
221+
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
222+
public long getPeakMallocMemory(NmtCategory category) {
217223
return getMallocInfo(category).getPeakUsed();
218224
}
219225

220226
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
221-
public long getCountAtPeakUsage(NmtCategory category) {
227+
public long getCountAtPeakMallocMemory(NmtCategory category) {
222228
return getMallocInfo(category).getCountAtPeakUsage();
223229
}
224230

225231
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
226-
public long getTotalCount() {
232+
public long getTotalMallocCount() {
227233
return mallocTotal.getCount();
228234
}
229235

230236
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
231-
public long getTotalUsedMemory() {
237+
public long getTotalMallocMemory() {
232238
return mallocTotal.getUsed();
233239
}
234240

235241
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
236-
public long getPeakTotalUsedMemory() {
242+
public long getPeakTotalMallocMemory() {
237243
return mallocTotal.getPeakUsed();
238244
}
239245

240246
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
241-
public long getCountAtTotalPeakUsage() {
247+
public long getCountAtPeakTotalMallocMemory() {
242248
return mallocTotal.getCountAtPeakUsage();
243249
}
244250

245-
public long getReservedByCategory(NmtCategory category) {
251+
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
252+
public long getReservedVirtualMemory(NmtCategory category) {
246253
return NativeMemoryTracking.singleton().getVirtualInfo(category).getReservedSize();
247254
}
248255

249-
public long getCommittedByCategory(NmtCategory category) {
256+
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
257+
public long getCommittedVirtualMemory(NmtCategory category) {
250258
return getVirtualInfo(category).getCommittedSize();
251259
}
252260

253-
public long getPeakCommittedByCategory(NmtCategory category) {
261+
public long getPeakReservedVirtualMemory(NmtCategory category) {
262+
return getVirtualInfo(category).getPeakReservedSize();
263+
}
264+
265+
public long getPeakCommittedVirtualMemory(NmtCategory category) {
254266
return getVirtualInfo(category).getPeakCommittedSize();
255267
}
256268

257-
public long getPeakReservedByCategory(NmtCategory category) {
258-
return getVirtualInfo(category).getPeakReservedSize();
269+
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
270+
public long getTotalReservedVirtualMemory() {
271+
return virtualTotal.getReservedSize();
272+
}
273+
274+
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
275+
public long getTotalCommittedVirtualMemory() {
276+
return virtualTotal.getCommittedSize();
277+
}
278+
279+
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
280+
public long getPeakTotalReservedVirtualMemory() {
281+
return virtualTotal.getPeakReservedSize();
282+
}
283+
284+
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
285+
public long getPeakTotalCommittedVirtualMemory() {
286+
return virtualTotal.getPeakCommittedSize();
259287
}
260288

261289
@Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
@@ -289,32 +317,43 @@ public static RuntimeSupport.Hook shutdownHook() {
289317

290318
private void printStatistics() {
291319
if (VMInspectionOptions.PrintNMTStatistics.getValue()) {
292-
System.out.println();
293-
System.out.println("Native memory tracking");
294-
System.out.println(" Peak total used memory: " + getPeakTotalUsedMemory() + " bytes");
295-
System.out.println(" Peak Total committed memory: " + virtualTotal.getPeakCommittedSize() + " bytes");
296-
System.out.println(" Peak Total reserved memory: " + virtualTotal.getPeakReservedSize() + " bytes");
297-
System.out.println(" Total alive allocations at peak usage: " + getCountAtTotalPeakUsage());
298-
System.out.println(" Total used memory: " + getTotalUsedMemory() + " bytes");
299-
System.out.println(" Total alive allocations: " + getTotalCount());
300-
System.out.println(" Total committed memory: " + virtualTotal.getCommittedSize() + " bytes");
301-
System.out.println(" Total reserved memory: " + virtualTotal.getReservedSize() + " bytes");
302-
303-
for (int i = 0; i < NmtCategory.values().length; i++) {
304-
String name = NmtCategory.values()[i].getName();
305-
NmtMallocMemoryInfo info = getMallocInfo(i);
306-
NmtVirtualMemoryInfo vMemInfo = getVirtualInfo(i);
307-
308-
System.out.println(" " + name + " peak used memory: " + info.getPeakUsed() + " bytes");
309-
System.out.println(" " + name + " alive allocations at peak: " + info.getCountAtPeakUsage());
310-
System.out.println(" " + name + " currently used memory: " + info.getUsed() + " bytes");
311-
System.out.println(" " + name + " currently alive allocations: " + info.getCount());
312-
System.out.println(" " + name + " committed memory: " + vMemInfo.getCommittedSize());
313-
System.out.println(" " + name + " reserved memory: " + vMemInfo.getReservedSize());
314-
System.out.println(" " + name + " peak committed memory: " + vMemInfo.getPeakCommittedSize());
315-
System.out.println(" " + name + " peak reserved memory: " + vMemInfo.getPeakReservedSize());
316-
}
320+
System.out.println(generateReportString());
321+
}
322+
}
323+
324+
public String generateReportString() {
325+
326+
StringBuilder stringBuilder = new StringBuilder(3000);
327+
328+
stringBuilder.append("\n");
329+
stringBuilder.append("Native memory tracking").append("\n\n");
330+
331+
stringBuilder.append("Total").append("\n");
332+
long reservedTotal = (getTotalReservedVirtualMemory() + getTotalMallocMemory()) / KB;
333+
long committedTotal = (getTotalCommittedVirtualMemory() + getTotalMallocMemory()) / KB;
334+
stringBuilder.append("\t").append("(reserved=").append(reservedTotal).append("KB, committed=").append(committedTotal).append("KB)").append("\n");
335+
stringBuilder.append("\t").append("(malloc=").append(getTotalMallocMemory() / KB).append("KB, count=").append(getTotalMallocCount()).append(")").append("\n");
336+
stringBuilder.append("\t").append("(peak malloc=").append(getPeakTotalMallocMemory() / KB).append("KB, count at peak=").append(getCountAtPeakTotalMallocMemory()).append(")").append("\n");
337+
stringBuilder.append("\t").append("(mmap: reserved=").append(getTotalReservedVirtualMemory() / KB).append("KB, committed=").append(getTotalCommittedVirtualMemory() / KB).append("KB)")
338+
.append("\n");
339+
stringBuilder.append("\t").append("(mmap: peak reserved=").append(getPeakTotalReservedVirtualMemory() / KB).append("KB, peak committed=").append(getPeakTotalCommittedVirtualMemory() / KB)
340+
.append("KB)").append("\n");
341+
342+
for (int i = 0; i < NmtCategory.values().length; i++) {
343+
NmtCategory category = NmtCategory.values()[i];
344+
stringBuilder.append(category.getName()).append("\n");
345+
long reserved = (getReservedVirtualMemory(category) + getMallocMemory(category)) / KB;
346+
long committed = (getCommittedVirtualMemory(category) + getMallocMemory(category)) / KB;
347+
stringBuilder.append("\t").append("(reserved=").append(reserved).append("KB, committed=").append(committed).append("KB)").append("\n");
348+
stringBuilder.append("\t").append("(malloc=").append(getMallocMemory(category) / KB).append("KB, count=").append(getMallocCount(category)).append(")").append("\n");
349+
stringBuilder.append("\t").append("(peak malloc=").append(getPeakMallocMemory(category) / KB).append("KB, count at peak=").append(getCountAtPeakMallocMemory(category)).append(")")
350+
.append("\n");
351+
stringBuilder.append("\t").append("(mmap: reserved=").append(getReservedVirtualMemory(category) / KB).append("KB, committed=").append(getCommittedVirtualMemory(category) / KB)
352+
.append("KB)").append("\n");
353+
stringBuilder.append("\t").append("(mmap: peak reserved=").append(getPeakReservedVirtualMemory(category) / KB).append("KB, peak committed=")
354+
.append(getPeakCommittedVirtualMemory(category) / KB).append("KB)").append("\n");
317355
}
356+
return stringBuilder.toString();
318357
}
319358

320359
private static void teardown() {

‎substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/nmt/NmtVirtualMemoryInfo.java‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -81,18 +81,22 @@ private static void updatePeak(long newSize, AtomicLong peakToUpdate) {
8181
}
8282
}
8383

84+
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
8485
long getReservedSize() {
8586
return reservedSize.get();
8687
}
8788

89+
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
8890
long getCommittedSize() {
8991
return committedSize.get();
9092
}
9193

94+
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
9295
long getPeakReservedSize() {
9396
return peakReservedSize.get();
9497
}
9598

99+
@Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
96100
long getPeakCommittedSize() {
97101
return peakCommittedSize.get();
98102
}

‎substratevm/src/com.oracle.svm.test/src/com/oracle/svm/test/nmt/NativeMemoryTrackingTests.java‎

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -94,11 +94,11 @@ public void testPeakTracking() {
9494
assertEquals(0, getUsedMemory());
9595

9696
Pointer ptr1 = NativeMemory.malloc(M, NmtCategory.Code);
97-
long peakUsed = NativeMemoryTracking.singleton().getPeakUsedMemory(NmtCategory.Code);
97+
long peakUsed = NativeMemoryTracking.singleton().getPeakMallocMemory(NmtCategory.Code);
9898
assertEquals(M, peakUsed);
9999

100100
Pointer ptr2 = NativeMemory.malloc(M, NmtCategory.Code);
101-
peakUsed = NativeMemoryTracking.singleton().getPeakUsedMemory(NmtCategory.Code);
101+
peakUsed = NativeMemoryTracking.singleton().getPeakMallocMemory(NmtCategory.Code);
102102
assertEquals(2 * M, peakUsed);
103103

104104
NativeMemory.free(ptr1);
@@ -108,21 +108,21 @@ public void testPeakTracking() {
108108
ptr2 = WordFactory.nullPointer();
109109

110110
assertEquals(0, getUsedMemory());
111-
assertEquals(2 * M, NativeMemoryTracking.singleton().getPeakUsedMemory(NmtCategory.Code));
111+
assertEquals(2 * M, NativeMemoryTracking.singleton().getPeakMallocMemory(NmtCategory.Code));
112112

113113
Pointer ptr3 = NativeMemory.malloc(3 * M, NmtCategory.Code);
114-
peakUsed = NativeMemoryTracking.singleton().getPeakUsedMemory(NmtCategory.Code);
114+
peakUsed = NativeMemoryTracking.singleton().getPeakMallocMemory(NmtCategory.Code);
115115
assertEquals(3 * M, peakUsed);
116116

117117
NativeMemory.free(ptr3);
118118
ptr3 = WordFactory.nullPointer();
119119

120120
assertEquals(0, getUsedMemory());
121-
assertEquals(3 * M, NativeMemoryTracking.singleton().getPeakUsedMemory(NmtCategory.Code));
121+
assertEquals(3 * M, NativeMemoryTracking.singleton().getPeakMallocMemory(NmtCategory.Code));
122122
}
123123

124124
private static long getUsedMemory() {
125-
return NativeMemoryTracking.singleton().getUsedMemory(NmtCategory.Code);
125+
return NativeMemoryTracking.singleton().getMallocMemory(NmtCategory.Code);
126126
}
127127

128128
@Test
@@ -387,7 +387,7 @@ public void testReservedPeak() {
387387
assertEquals("Test should start with no memory already allocated in the test category.", 0, getReserved());
388388
assertEquals("Test should start with no memory already allocated in the test category.", 0, getCommitted());
389389

390-
long initialPeak = NativeMemoryTracking.singleton().getPeakReservedByCategory(NmtCategory.Code);
390+
long initialPeak = NativeMemoryTracking.singleton().getPeakReservedVirtualMemory(NmtCategory.Code);
391391

392392
Pointer reservePtr1 = VirtualMemoryProvider.get().reserve(WordFactory.unsigned(initialPeak), GRANULARITY, false,
393393
NmtCategory.Code);
@@ -396,34 +396,34 @@ public void testReservedPeak() {
396396
Pointer reservePtr2 = VirtualMemoryProvider.get().reserve(WordFactory.unsigned(initialPeak), GRANULARITY, false,
397397
NmtCategory.Code);
398398
long peakReserved = getReserved();
399-
assertEquals(peakReserved, NativeMemoryTracking.singleton().getPeakReservedByCategory(NmtCategory.Code));
399+
assertEquals(peakReserved, NativeMemoryTracking.singleton().getPeakReservedVirtualMemory(NmtCategory.Code));
400400

401401
free(reservePtr1, initialPeak);
402402
free(reservePtr2, initialPeak);
403403

404-
assertEquals(peakReserved, NativeMemoryTracking.singleton().getPeakReservedByCategory(NmtCategory.Code));
404+
assertEquals(peakReserved, NativeMemoryTracking.singleton().getPeakReservedVirtualMemory(NmtCategory.Code));
405405
assertEquals(0, getReserved());
406406
}
407407

408408
@Test
409409
public void testCommittedPeak() {
410-
long initialPeak = NativeMemoryTracking.singleton().getPeakCommittedByCategory(NmtCategory.Code);
410+
long initialPeak = NativeMemoryTracking.singleton().getPeakCommittedVirtualMemory(NmtCategory.Code);
411411
long largeReserveSize = initialPeak * 2;
412412
int largeCommitSize = (int) initialPeak;
413413
Pointer reservePtr = VirtualMemoryProvider.get().reserve(WordFactory.unsigned(largeReserveSize), HeapParameters.getAlignedHeapChunkSize(), false,
414414
NmtCategory.Code);
415415

416416
Pointer commitPtr1 = commit(reservePtr, largeCommitSize);
417-
assertEquals(getCommitted(), NativeMemoryTracking.singleton().getPeakCommittedByCategory(NmtCategory.Code));
417+
assertEquals(getCommitted(), NativeMemoryTracking.singleton().getPeakCommittedVirtualMemory(NmtCategory.Code));
418418

419419
Pointer commitPtr2 = commit(commitPtr1.add(largeCommitSize), largeCommitSize);
420420
long recordedCommittedSize2 = getCommitted();
421-
assertEquals(recordedCommittedSize2, NativeMemoryTracking.singleton().getPeakCommittedByCategory(NmtCategory.Code));
421+
assertEquals(recordedCommittedSize2, NativeMemoryTracking.singleton().getPeakCommittedVirtualMemory(NmtCategory.Code));
422422

423423
uncommit(commitPtr1, largeCommitSize);
424424
uncommit(commitPtr2, largeCommitSize);
425425
assertEquals(0, getCommitted());
426-
assertEquals(recordedCommittedSize2, NativeMemoryTracking.singleton().getPeakCommittedByCategory(NmtCategory.Code));
426+
assertEquals(recordedCommittedSize2, NativeMemoryTracking.singleton().getPeakCommittedVirtualMemory(NmtCategory.Code));
427427

428428
free(reservePtr, largeReserveSize);
429429
assertEquals(0, getReserved());
@@ -447,11 +447,11 @@ private static void free(PointerBase start, long nbytes) {
447447
}
448448

449449
private static long getReserved() {
450-
return NativeMemoryTracking.singleton().getReservedByCategory(NmtCategory.Code);
450+
return NativeMemoryTracking.singleton().getReservedVirtualMemory(NmtCategory.Code);
451451
}
452452

453453
private static long getCommitted() {
454-
return NativeMemoryTracking.singleton().getCommittedByCategory(NmtCategory.Code);
454+
return NativeMemoryTracking.singleton().getCommittedVirtualMemory(NmtCategory.Code);
455455
}
456456

457457
private static Pointer beginVirtualMemoryTestAndReserve() {

0 commit comments

Comments
 (0)