1 /*
2 * Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package jdk.jfr.event.gc.heapsummary;
27
28 import java.time.Duration;
29 import java.util.List;
30
31 import jdk.jfr.Recording;
32 import jdk.jfr.consumer.RecordedEvent;
33 import jdk.test.lib.Asserts;
34 import jdk.test.lib.jfr.EventNames;
35 import jdk.test.lib.jfr.Events;
36 import jdk.test.lib.jfr.GCHelper;
37
38 public class HeapSummaryEventAllGcs {
39
40 public static void test(String expectedYoungCollector, String expectedOldCollector) throws Exception {
41 Recording recording = new Recording();
42 recording.enable(EventNames.GCConfiguration);
43 recording.enable(EventNames.GCHeapSummary);
44 recording.enable(EventNames.PSHeapSummary);
45 recording.enable(EventNames.MetaspaceSummary).withThreshold(Duration.ofMillis(0));
46
47 recording.start();
48 // To eliminate the risk of being in the middle of a GC when the recording starts/stops,
49 // we run 5 System.gc() and ignores the first and last GC.
50 GCHelper.callSystemGc(5, true);
51 recording.stop();
52
53 if (!checkCollectors(recording, expectedYoungCollector, expectedOldCollector)) {
54 return;
55 }
56 List<RecordedEvent> events = GCHelper.removeFirstAndLastGC(Events.fromRecording(recording));
57 for (RecordedEvent event : events) {
58 System.out.println("Event:" + event);
59 }
60
61 Asserts.assertFalse(events.isEmpty(), "Expected at least one event.");
62 Asserts.assertEquals(events.size() % 2, 0, "Events should come in pairs");
63
64 int lastHeapGcId = -1;
65 int lastPSGcId = -1;
66 int lastMetaspaceGcId = -1;
67
68 for (RecordedEvent event : events) {
69 final String eventName = event.getEventType().getName();
70 switch (eventName) {
71 case EventNames.GCHeapSummary:
72 lastHeapGcId = checkGcId(event, lastHeapGcId);
73 checkHeapEventContent(event);
74 break;
75 case EventNames.PSHeapSummary:
76 lastPSGcId = checkGcId(event, lastPSGcId);
77 checkPSEventContent(event);
78 break;
79 case EventNames.MetaspaceSummary:
80 lastMetaspaceGcId = checkGcId(event, lastMetaspaceGcId);
81 checkMetaspaceEventContent(event);
82 break;
83 default:
84 System.out.println("Failed event: " + event);
85 Asserts.fail("Unknown event type: " + eventName);
86 }
87 }
88
89 // Sanity check. Not complete.
90 Asserts.assertEquals(lastHeapGcId, lastMetaspaceGcId, "Should have gotten perm gen events for all GCs");
91 }
92
93 private static void checkMetaspaceEventContent(RecordedEvent event) {
94 long totalUsed = Events.assertField(event, "metaspace.used").atLeast(0L).getValue();
95 long totalCommitted = Events.assertField(event, "metaspace.committed").atLeast(totalUsed).getValue();
96 long totalReserved = Events.assertField(event, "metaspace.reserved").atLeast(totalCommitted).getValue();
97
98 long dataUsed = Events.assertField(event, "dataSpace.used").atLeast(0L).getValue();
99 long dataCommitted = Events.assertField(event, "dataSpace.committed").atLeast(dataUsed).getValue();
100 long dataReserved = Events.assertField(event, "dataSpace.reserved").atLeast(dataCommitted).getValue();
101
102 long classUsed = Events.assertField(event, "classSpace.used").atLeast(0L).getValue();
103 long classCommitted = Events.assertField(event, "classSpace.committed").atLeast(classUsed).getValue();
104 long classReserved = Events.assertField(event, "classSpace.reserved").atLeast(classCommitted).getValue();
105
106 Asserts.assertEquals(dataCommitted + classCommitted, totalCommitted, "Wrong committed memory");
107 Asserts.assertEquals(dataUsed + classUsed, totalUsed, "Wrong used memory");
108 Asserts.assertEquals(dataReserved + classReserved, totalReserved, "Wrong reserved memory");
109 }
110
111 private static int checkGcId(RecordedEvent event, int currGcId) {
112 int gcId = Events.assertField(event, "gcId").getValue();
113 String when = Events.assertField(event, "when").notEmpty().getValue();
114 if ("Before GC".equals(when)) {
115 Asserts.assertGreaterThan(gcId, currGcId, "gcId should be increasing");
116 } else {
117 Asserts.assertEquals(gcId, currGcId, "After should have same gcId as last Before event");
118 }
119 return gcId;
120 }
121
122 private static void checkHeapEventContent(RecordedEvent event) {
123 checkVirtualSpace(event, "heapSpace");
124 long heapUsed = Events.assertField(event, "heapUsed").atLeast(0L).getValue();
125 long start = Events.assertField(event, "heapSpace.start").atLeast(0L).getValue();
126 long committedEnd = Events.assertField(event, "heapSpace.committedEnd").above(start).getValue();
127 Asserts.assertLessThanOrEqual(heapUsed, committedEnd- start, "used can not exceed size");
128 }
129
130 private static void checkPSEventContent(RecordedEvent event) {
131 checkVirtualSpace(event, "oldSpace");
132 checkVirtualSpace(event, "youngSpace");
133 checkSpace(event, "oldObjectSpace");
134 checkSpace(event, "edenSpace");
135 checkSpace(event, "fromSpace");
136 checkSpace(event, "toSpace");
137
138 checkPSYoungSizes(event);
139 checkPSYoungStartEnd(event);
140 }
141
142 private static void checkPSYoungSizes(RecordedEvent event) {
143 long youngSize = (long)Events.assertField(event, "youngSpace.committedEnd").getValue() -
144 (long)Events.assertField(event, "youngSpace.start").getValue();
145 long edenSize = (long)Events.assertField(event, "edenSpace.end").getValue() -
146 (long)Events.assertField(event, "edenSpace.start").getValue();
147 long fromSize = (long)Events.assertField(event, "fromSpace.end").getValue() -
148 (long)Events.assertField(event, "fromSpace.start").getValue();
149 long toSize = (long)Events.assertField(event, "toSpace.end").getValue() -
150 (long)Events.assertField(event, "toSpace.start").getValue();
151 Asserts.assertGreaterThanOrEqual(youngSize, edenSize + fromSize + toSize, "Young sizes don't match");
152 }
153
154 private static void checkPSYoungStartEnd(RecordedEvent event) {
155 long oldEnd = Events.assertField(event, "oldSpace.reservedEnd").getValue();
156 long youngStart = Events.assertField(event, "youngSpace.start").getValue();
157 long youngEnd = Events.assertField(event, "youngSpace.committedEnd").getValue();
158 long edenStart = Events.assertField(event, "edenSpace.start").getValue();
159 long edenEnd = Events.assertField(event, "edenSpace.end").getValue();
160 long fromStart = Events.assertField(event, "fromSpace.start").getValue();
161 long fromEnd = Events.assertField(event, "fromSpace.end").getValue();
162 long toStart = Events.assertField(event, "toSpace.start").getValue();
163 long toEnd = Events.assertField(event, "toSpace.end").getValue();
164 Asserts.assertEquals(oldEnd, youngStart, "Young should start where old ends");
165 Asserts.assertEquals(youngStart, edenStart, "Eden should be placed first in young");
166 if (fromStart < toStart) {
167 // [eden][from][to]
168 Asserts.assertGreaterThanOrEqual(fromStart, edenEnd, "From should start after eden");
169 Asserts.assertLessThanOrEqual(fromEnd, toStart, "To should start after From");
170 Asserts.assertLessThanOrEqual(toEnd, youngEnd, "To should start after From");
171 } else {
172 // [eden][to][from]
173 Asserts.assertGreaterThanOrEqual(toStart, edenEnd, "From should start after eden");
174 Asserts.assertLessThanOrEqual(toEnd, fromStart, "To should start after From");
175 Asserts.assertLessThanOrEqual(fromEnd, youngEnd, "To should start after From");
176 }
177 }
178
179 private static void checkVirtualSpace(RecordedEvent event, String structName) {
180 long start = Events.assertField(event, structName + ".start").atLeast(0L).getValue();
181 long committedEnd = Events.assertField(event, structName + ".committedEnd").above(start).getValue();
182 Events.assertField(event, structName + ".reservedEnd").atLeast(committedEnd);
183 long committedSize = Events.assertField(event, structName + ".committedSize").atLeast(0L).getValue();
184 Events.assertField(event, structName + ".reservedSize").atLeast(committedSize);
185 }
186
187 private static void checkSpace(RecordedEvent event, String structName) {
188 long start = Events.assertField(event, structName + ".start").atLeast(0L).getValue();
189 long end = Events.assertField(event, structName + ".end").above(start).getValue();
190 long used = Events.assertField(event, structName + ".used").atLeast(0L).getValue();
191 long size = Events.assertField(event, structName + ".size").atLeast(used).getValue();
192 Asserts.assertEquals(size, end - start, "Size mismatch");
193 }
194
195 private static boolean checkCollectors(Recording recording, String expectedYoung, String expectedOld) throws Exception {
196 for (RecordedEvent event : Events.fromRecording(recording)) {
197 if (Events.isEventType(event, EventNames.GCConfiguration)) {
198 final String young = Events.assertField(event, "youngCollector").notEmpty().getValue();
199 final String old = Events.assertField(event, "oldCollector").notEmpty().getValue();
200 if (young.equals(expectedYoung) && old.equals(expectedOld)) {
201 return true;
202 }
203 // TODO: We treat wrong collector types as an error. Old test only warned. Not sure what is correct.
204 Asserts.fail(String.format("Wrong collector types: got('%s','%s'), expected('%s','%s')",
205 young, old, expectedYoung, expectedOld));
206 }
207 }
208 Asserts.fail("Missing event type " + EventNames.GCConfiguration);
209 return false;
210 }
211 }