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 }