1 /*
2 * Copyright (c) 2013, 2019, 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.runtime;
27
28 import java.util.List;
29
30 import jdk.jfr.Recording;
31 import jdk.jfr.consumer.RecordedEvent;
32 import jdk.test.lib.Asserts;
33 import jdk.test.lib.jfr.EventNames;
34 import jdk.test.lib.jfr.Events;
35 import jdk.test.lib.jfr.TestClassLoader;
36
37 /**
38 * @test
39 * @key jfr
40 * @requires vm.hasJFR
41 * @library /test/lib /test/jdk
42 * @build jdk.jfr.event.runtime.TestClasses
43 * @run main/othervm jdk.jfr.event.runtime.TestClassLoadingStatisticsEvent
44 */
45 /**
46 * This test will load a number of classes. After each load step we verify that
47 * the loadedClassCount and unloadedClassCount attributes are correct.
48 *
49 * System.gc() will trigger class unloading if -XX:+ExplicitGCInvokesConcurrent
50 * is NOT set. If this flag is set G1 will never unload classes on System.gc().
51 * As far as the "jfr" key guarantees no VM flags are set from the
52 * outside it should be enough with System.gc().
53 */
54 public class TestClassLoadingStatisticsEvent {
55
56 private final static String EVENT_PATH = EventNames.ClassLoadingStatistics;
57 private final static String TESTCLASS_PUBLIC_STATIC =
58 "jdk.jfr.event.runtime.TestClasses$TestClassPublicStatic";
59 private final static String TESTCLASS_PUBLIC_STATIC_INNER =
60 "jdk.jfr.event.runtime.TestClasses$TestClassPublicStatic$TestClassPublicStaticInner";
61
62 // Declare unloadableClassLoader as "public static"
63 // to prevent the compiler to optimize away all unread writes
64 public static TestClassLoader unloadableClassLoader;
65
66 public static void main(String[] args) throws Throwable {
67 // Load twice to get more stable result.
68 RecordedEvent event = getCurrentEvent();
69 event = getCurrentEvent();
70
71 // Declare class ClassLoadingStatisticsHelper.
72 TestClasses[] helpers = new TestClasses[10];
73 event = verifyCountDelta(event, 1, 0);
74
75 // Should load classes TestClassPrivate and TestClassPrivateStatic.
76 for (int c = 0; c < helpers.length; c++) {
77 helpers[c] = new TestClasses();
78 }
79 event = verifyCountDelta(event, 2, 0);
80
81 // Load classes TestClassProtected and B2.
82 helpers[0].new TestClassProtected();
83 helpers[1].new TestClassProtected(); // This class is already loaded.
84 new TestClasses.TestClassProtectedStatic();
85 event = verifyCountDelta(event, 2, 0);
86
87 // Load classes TestClassProtected1 and TestClassProtectedStatic1.
88 for (int c = 0; c < helpers.length; c++) {
89 helpers[c].loadClasses();
90 }
91 event = verifyCountDelta(event, 2, 0);
92
93 // Load the classes with separate class loader. Will be unloaded later.
94 unloadableClassLoader = new TestClassLoader();
95
96 unloadableClassLoader.loadClass(TESTCLASS_PUBLIC_STATIC_INNER);
97 event = verifyCountDelta(event, 1, 0);
98
99 unloadableClassLoader.loadClass(TESTCLASS_PUBLIC_STATIC);
100 event = verifyCountDelta(event, 1, 0);
101
102 // This System.gc() should not unload classes, since the
103 // unloadableClassLoader object is still active.
104 System.gc();
105 event = verifyCountDelta(event, 0, 0);
106
107 // make classes are unloaded.
108 unloadableClassLoader = null;
109 System.gc();
110 event = verifyCountDelta(event, 0, 2);
111 }
112
113 private static RecordedEvent getCurrentEvent() throws Throwable {
114 Recording recording = new Recording();
115 recording.enable(EVENT_PATH);
116 recording.start();
117 recording.stop();
118 List<RecordedEvent> events = Events.fromRecording(recording);
119 Asserts.assertFalse(events.isEmpty(), "No events in recording");
120 RecordedEvent event = events.get(0);
121 return event;
122 }
123
124 private static RecordedEvent verifyCountDelta(
125 RecordedEvent prevEvent, int loadDelta, int unloadDelta) throws Throwable {
126 RecordedEvent currEvent = null;
127 try {
128 long prevLoad = Events.assertField(prevEvent, "loadedClassCount").getValue();
129 long prevUnload = Events.assertField(prevEvent, "unloadedClassCount").getValue();
130
131 currEvent = getCurrentEvent();
132 Events.assertField(currEvent, "loadedClassCount").atLeast(prevLoad + loadDelta);
133 Events.assertField(currEvent, "unloadedClassCount").atLeast(prevUnload + unloadDelta);
134 return currEvent;
135 } catch (Throwable t) {
136 System.out.println("verifyCountDelta failed. prevEvent=" + prevEvent + ", currEvent=" + currEvent);
137 throw t;
138 }
139 }
140
141 }