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