1 /*
2 * Copyright (c) 2016, 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.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 package gc.g1.humongousObjects;
26
27 import gc.testlibrary.Helpers;
28 import jdk.test.lib.Asserts;
29 import sun.hotspot.WhiteBox;
30
31 import java.io.IOException;
32 import java.lang.reflect.InvocationTargetException;
33 import java.net.URL;
34 import java.net.URLClassLoader;
35 import java.nio.file.Path;
36 import java.nio.file.Paths;
37
38 /**
39 * @test gc.g1.humongousObjects.TestHumongousClassLoader
40 * @summary Checks that unreachable classes and unreachable humongous class loader are unloaded after GC
41 * @requires vm.gc.G1
42 * @requires vm.opt.G1HeapRegionSize == "null" | vm.opt.G1HeapRegionSize == "1M"
43 * @requires vm.opt.ExplicitGCInvokesConcurrent != true
44 * @library /testlibrary /test/lib /
45 * @modules java.base/jdk.internal.misc
46 * @modules java.management
47 * @build sun.hotspot.WhiteBox
48 * gc.testlibrary.Helpers
49 * gc.g1.humongousObjects.G1SampleClass
50 * gc.g1.humongousObjects.ClassLoaderGenerator
51 * gc.g1.humongousObjects.TestHumongousClassLoader
52 *
53 * @run driver ClassFileInstaller sun.hotspot.WhiteBox
54 * sun.hotspot.WhiteBox$WhiteBoxPermission
55 *
56 * @run main/othervm/timeout=240 -Xms256M -Xmx256M -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
57 * gc.g1.humongousObjects.ClassLoaderGenerator 1
58 *
59 * @run main/othervm -Xms256M -Xmx256M -XX:+UseG1GC -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
60 * -Xlog:class+load,class+unload=debug:file=TestHumongousClassLoader_Full_GC.log
61 * -XX:G1HeapRegionSize=1M
62 * gc.g1.humongousObjects.TestHumongousClassLoader FULL_GC
63 *
64 * @run main/othervm -Xms256M -Xmx256M -XX:+UseG1GC -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
65 * -Xlog:class+load,class+unload=debug:file=TestHumongousClassLoader_Full_GC_Mem_Pressure.log
66 * -XX:G1HeapRegionSize=1M
67 * gc.g1.humongousObjects.TestHumongousClassLoader FULL_GC_MEMORY_PRESSURE
68 *
69 *@run main/othervm -Xms256M -Xmx256M -XX:+UseG1GC -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
70 * -Xlog:class+load,class+unload=debug:file=TestHumongousClassLoader_CMC.log
71 * -XX:G1HeapRegionSize=1M -XX:MaxTenuringThreshold=1
72 * gc.g1.humongousObjects.TestHumongousClassLoader CMC
73 *
74 */
75
76 public class TestHumongousClassLoader {
77
78 private static final WhiteBox WB = WhiteBox.getWhiteBox();
79 private static final String SAMPLE_CLASS_NAME_PREFIX = "SampleClassFiller";
80 public static final String SIMPLE_CLASSLOADER_NAME = "SimpleClassLoader";
81 public static final String HUMONGOUS_CLASSLOADER_NAME = "HumongousClassLoader";
82
83
84 public static final String LOAD_CLASS_METHOD_PROTOTYPE =
85 " @Override\n"
86 + " public Class loadClass(String fileName) throws ClassNotFoundException {\n"
87 + " if (${ClassLoadFilter}) {\n"
88 + " System.out.println(\"Loading class \" + fileName);\n"
89 + " byte[] b = null;\n"
90 + " try {\n"
91 + " b = Files.readAllBytes(new File(fileName + \".class\").toPath());\n"
92 + " } catch (IOException e) {\n"
93 + " e.printStackTrace();\n"
94 + " }\n"
95 + " Class c = defineClass(fileName, b, 0, b.length);\n"
96 + " resolveClass(c);\n"
97 + " return c;\n"
98 + " } else {\n"
99 + " return super.loadClass(fileName);\n"
100 + " }\n"
101 + "\n"
102 + "\n"
103 + " }\n";
104
105 public static final String CLASS_HEADER = "import java.io.File;\n"
106 + "import java.io.IOException;\n"
107 + "import java.nio.file.Files;\n"
108 + "import java.nio.file.Paths;\n";
109
110 public static final String GENERIC_PROTOTYPE = "${ClassHeader}\n"
111 + "public class ${ClassName} extends ${BaseClass}{\n"
112 + " ${ConstructorClause}\n"
113 + " ${Methods}\n"
114 + " ${Fields}\n"
115 + "}\n";
116
117 public static final String CONSTUCTOR_PROTOTYPE = "public ${ClassName}(ClassLoader parent) { super(parent);}\n";
118
119 private enum GC {
120 FULL_GC {
121 @Override
122 public void provoke() {
123 System.gc();
124 }
125 },
126 CMC {
127 @Override
128 public void provoke() {
129 // We need 2 young gc to promote class loader to old gen
130 // Otherwise it will not be unloaded after CMC
131 WHITE_BOX.youngGC();
132 Helpers.waitTillCMCFinished(WHITE_BOX, 0);
133 WHITE_BOX.youngGC();
134 Helpers.waitTillCMCFinished(WHITE_BOX, 0);
135 WHITE_BOX.g1StartConcMarkCycle();
136 Helpers.waitTillCMCFinished(WHITE_BOX, 0);
137 }
138 },
139 FULL_GC_MEMORY_PRESSURE {
140 @Override
141 public void provoke() {
142 WHITE_BOX.fullGC();
143 }
144 };
145 private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
146
147 public abstract void provoke();
148 }
149
150 public static void main(String[] args) throws ClassNotFoundException, InstantiationException,
151 IllegalAccessException, IOException, NoSuchMethodException, InvocationTargetException {
152
153 if (args.length != 1) {
154 throw new Error("Test Bug: Expected GC type wasn't provided as command line argument");
155 }
156 GC gc = GC.valueOf(args[0]);
157
158 Path wrkDir = Paths.get("");
159 URL[] url = {wrkDir.toUri().toURL()};
160 URLClassLoader urlLoader = new URLClassLoader(url);
161
162 Class<?> simpleClassLoaderClass = urlLoader.loadClass(SIMPLE_CLASSLOADER_NAME);
163
164 ClassLoader simpleClassLoader = (ClassLoader) simpleClassLoaderClass
165 .getConstructor(java.lang.ClassLoader.class)
166 .newInstance(TestHumongousClassLoader.class.getClassLoader());
167
168 // Sanity check
169 Asserts.assertEquals(WB.g1IsHumongous(simpleClassLoader), false,
170 "Test Bug: simpleClassLoader is expected to be non-humongous but it's humongous");
171
172
173 Class<?> humongousClassLoaderClass = simpleClassLoader.loadClass(HUMONGOUS_CLASSLOADER_NAME);
174
175 ClassLoader humongousClassLoader = (ClassLoader) humongousClassLoaderClass
176 .getConstructor(java.lang.ClassLoader.class)
177 .newInstance(simpleClassLoader);
178
179 // Sanity check
180 Asserts.assertEquals(WB.g1IsHumongous(humongousClassLoader), true,
181 "Test Bug: humongousClassLoader is expected to be humongous but it's non-humongous");
182
183 //Asserts.assertEquals(1,0);
184
185 Object[] loadedClasses = new Object[]{
186 G1SampleClass.LARGEST_NON_HUMONGOUS.getCls(humongousClassLoader, wrkDir, SAMPLE_CLASS_NAME_PREFIX)
187 .newInstance(),
188 G1SampleClass.SMALLEST_HUMONGOUS.getCls(humongousClassLoader, wrkDir, SAMPLE_CLASS_NAME_PREFIX)
189 .newInstance(),
190 G1SampleClass.ONE_REGION_HUMONGOUS.getCls(humongousClassLoader, wrkDir, SAMPLE_CLASS_NAME_PREFIX)
191 .newInstance(),
192 G1SampleClass.TWO_REGION_HUMONGOUS.getCls(humongousClassLoader, wrkDir, SAMPLE_CLASS_NAME_PREFIX)
193 .newInstance(),
194 };
195
196 // forgetting references to loaded classes
197 for (int i = 0; i < loadedClasses.length; ++i) {
198 loadedClasses[i] = null;
199 }
200
201 // forgetting referencies to classloaders
202 humongousClassLoader = null;
203 humongousClassLoaderClass = null;
204
205 simpleClassLoader = null;
206 simpleClassLoaderClass = null;
207
208 gc.provoke();
209
210 // Test checks
211 Asserts.assertEquals(WB.isClassAlive(HUMONGOUS_CLASSLOADER_NAME), false,
212 String.format("Classloader class %s is loaded after we forget all references to it",
213 HUMONGOUS_CLASSLOADER_NAME));
214
215 for (G1SampleClass sampleClass : G1SampleClass.values()) {
216 String className = Helpers.enumNameToClassName(sampleClass.name()) + "Class";
217 Asserts.assertEquals(WB.isClassAlive(className), false,
218 String.format("Class %s is loaded after we forget all references to it", className));
219 }
220 }
221
222 }