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