--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/humongousObjects/ClassLoaderGenerator.java	Thu Apr 21 17:55:14 2016 +0300
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+package gc.g1.humongousObjects;
+
+import gc.testlibrary.Helpers;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+/**
+ * Generates non-humongous and humongous class loaders.
+ * Since the generation depends on current host architecture it cannot be done as part of pre-compilation step
+ */
+public class ClassLoaderGenerator {
+    public static void main(String[] args) throws IOException {
+
+        if (args.length != 1) {
+            throw new Error("Test Bug: Expected region size wasn't provided as command line argument");
+        }
+
+        long regionSize = Long.parseLong(args[0]) * 1024 * 1024;
+
+        Path wrkDir = Paths.get("");
+        generateClassLoader(regionSize, wrkDir);
+
+    }
+
+    public static void generateClassLoader(long regionSize, Path wrkDir) throws IOException {
+        // Generating simple classloader
+        String finalSimpleClassLoaderPrototype = TestHumongousClassLoader.GENERIC_PROTOTYPE
+                .replace("${Methods}",
+                        TestHumongousClassLoader.LOAD_CLASS_METHOD_PROTOTYPE
+                                .replace("${ClassLoadFilter}",
+                                        "fileName.equals(\"" + TestHumongousClassLoader.HUMONGOUS_CLASSLOADER_NAME
+                                                + "\")"))
+                .replace("${ClassHeader}", TestHumongousClassLoader.CLASS_HEADER)
+                .replace("${ConstructorClause}", TestHumongousClassLoader.CONSTUCTOR_PROTOTYPE);
+
+        Helpers.generateByTemplateAndCompile(TestHumongousClassLoader.SIMPLE_CLASSLOADER_NAME, "ClassLoader",
+                finalSimpleClassLoaderPrototype, TestHumongousClassLoader.CONSTUCTOR_PROTOTYPE, regionSize / 4,
+                wrkDir, TestHumongousClassLoader.SIMPLE_CLASSLOADER_NAME + "Base");
+
+
+        // Preparations for generating humongous classloader
+
+        // Generating condition for loadClass method of generated class loader
+        // We want the generated class loader to load only classes from G1SampleClass enum
+        // All other classes should be loaded by parent classloader
+        // As result we get full loadClass method
+        StringBuilder classesToLoadBuilder = new StringBuilder();
+        for (G1SampleClass g1SampleClass : G1SampleClass.values()) {
+            if (classesToLoadBuilder.length() != 0) {
+                classesToLoadBuilder.append(" || ");
+            }
+            classesToLoadBuilder.append("fileName.startsWith(\"" + Helpers.enumNameToClassName(g1SampleClass.name())
+                    + "\")");
+        }
+
+        // Generating final class loader prototype - with specified methods,header and constructor
+        String finalHumongousClassLoaderPrototype = TestHumongousClassLoader.GENERIC_PROTOTYPE
+                .replace("${Methods}",
+                        TestHumongousClassLoader.LOAD_CLASS_METHOD_PROTOTYPE
+                                .replace("${ClassLoadFilter}", classesToLoadBuilder))
+                .replace("${ClassHeader}", TestHumongousClassLoader.CLASS_HEADER)
+                .replace("${ConstructorClause}", TestHumongousClassLoader.CONSTUCTOR_PROTOTYPE);
+
+
+        // Generating humongous classloader with specified name, base class, final class prototype and
+        // constructor prototype for filler classes
+        // Generated class instance should be humongous since we specify size of (regionSize * 3 / 4)
+        Helpers.generateByTemplateAndCompile(TestHumongousClassLoader.HUMONGOUS_CLASSLOADER_NAME, "ClassLoader",
+                finalHumongousClassLoaderPrototype, TestHumongousClassLoader.CONSTUCTOR_PROTOTYPE,
+                regionSize * 3 / 4,
+                wrkDir, TestHumongousClassLoader.HUMONGOUS_CLASSLOADER_NAME + "Base");
+
+
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/humongousObjects/TestHumongousClassLoader.java	Thu Apr 21 17:55:14 2016 +0300
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+package gc.g1.humongousObjects;
+
+import gc.testlibrary.Helpers;
+import jdk.test.lib.Asserts;
+import sun.hotspot.WhiteBox;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+/**
+ * @test gc.g1.humongousObjects.TestHumongousClassLoader
+ * @summary Checks that unreachable classes and unreachable humongous class loader are unloaded after GC
+ * @requires vm.gc=="G1" | vm.gc=="null"
+ * @requires vm.opt.G1HeapRegionSize == "null" | vm.opt.G1HeapRegionSize == "1M"
+ * @library /testlibrary /test/lib /
+ * @modules java.management
+ * @build sun.hotspot.WhiteBox
+ *        gc.testlibrary.Helpers
+ *        gc.g1.humongousObjects.G1SampleClass
+ *        gc.g1.humongousObjects.ClassLoaderGenerator
+ *        gc.g1.humongousObjects.TestHumongousClassLoader
+ *
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ *                                sun.hotspot.WhiteBox$WhiteBoxPermission
+ *
+ * @run main/othervm/timeout=240  -Xms256M -Xmx256M -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ *                                gc.g1.humongousObjects.ClassLoaderGenerator 1
+ *
+ * @run main/othervm -Xms256M -Xmx256M -XX:+UseG1GC -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ *                   -Xlog:classload,classunload=debug:file=TestHumongousClassLoader_Full_GC.log
+ *                   -XX:G1HeapRegionSize=1M
+ *                   gc.g1.humongousObjects.TestHumongousClassLoader FULL_GC
+ *
+ * @run main/othervm -Xms256M -Xmx256M -XX:+UseG1GC -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ *                   -Xlog:classload,classunload=debug:file=TestHumongousClassLoader_Full_GC_Mem_Pressure.log
+ *                   -XX:G1HeapRegionSize=1M
+ *                   gc.g1.humongousObjects.TestHumongousClassLoader FULL_GC_MEMORY_PRESSURE
+ *
+ *@run main/othervm -Xms256M -Xmx256M -XX:+UseG1GC -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ *                   -Xlog:classload,classunload=debug:file=TestHumongousClassLoader_CMC.log
+ *                   -XX:G1HeapRegionSize=1M -XX:MaxTenuringThreshold=1
+ *                   gc.g1.humongousObjects.TestHumongousClassLoader CMC
+ *
+ */
+
+public class TestHumongousClassLoader {
+
+    private static final WhiteBox WB = WhiteBox.getWhiteBox();
+    private static final String SAMPLE_CLASS_NAME_PREFIX = "SampleClassFiller";
+    public static final String SIMPLE_CLASSLOADER_NAME = "SimpleClassLoader";
+    public static final String HUMONGOUS_CLASSLOADER_NAME = "HumongousClassLoader";
+
+
+    public static final String LOAD_CLASS_METHOD_PROTOTYPE =
+            "    @Override\n"
+                    + "    public Class loadClass(String fileName) throws ClassNotFoundException {\n"
+                    + "        if (${ClassLoadFilter}) {\n"
+                    + "            System.out.println(\"Loading class \" + fileName);\n"
+                    + "            byte[] b = null;\n"
+                    + "            try {\n"
+                    + "                b = Files.readAllBytes(new File(fileName + \".class\").toPath());\n"
+                    + "            } catch (IOException e) {\n"
+                    + "                e.printStackTrace();\n"
+                    + "            }\n"
+                    + "            Class c = defineClass(fileName, b, 0, b.length);\n"
+                    + "            resolveClass(c);\n"
+                    + "            return c;\n"
+                    + "        } else {\n"
+                    + "            return super.loadClass(fileName);\n"
+                    + "        }\n"
+                    + "\n"
+                    + "\n"
+                    + "    }\n";
+
+    public static final String CLASS_HEADER = "import java.io.File;\n"
+            + "import java.io.IOException;\n"
+            + "import java.nio.file.Files;\n"
+            + "import java.nio.file.Paths;\n";
+
+    public static final String GENERIC_PROTOTYPE = "${ClassHeader}\n"
+            + "public class ${ClassName} extends ${BaseClass}{\n"
+            + "    ${ConstructorClause}\n"
+            + "    ${Methods}\n"
+            + "    ${Fields}\n"
+            + "}\n";
+
+    public static final String CONSTUCTOR_PROTOTYPE = "public ${ClassName}(ClassLoader parent) { super(parent);}\n";
+
+    private enum GC {
+        FULL_GC {
+            @Override
+            public void provoke() {
+                System.gc();
+            }
+        },
+        CMC {
+            @Override
+            public void provoke() {
+                // We need 2 young gc to promote class loader to old gen
+                // Otherwise it will not be unloaded after CMC
+                WHITE_BOX.youngGC();
+                Helpers.waitTillCMCFinished(WHITE_BOX, 0);
+                WHITE_BOX.youngGC();
+                Helpers.waitTillCMCFinished(WHITE_BOX, 0);
+                WHITE_BOX.g1StartConcMarkCycle();
+                Helpers.waitTillCMCFinished(WHITE_BOX, 0);
+            }
+        },
+        FULL_GC_MEMORY_PRESSURE {
+            @Override
+            public void provoke() {
+                WHITE_BOX.fullGC();
+            }
+        };
+        private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
+
+        public abstract void provoke();
+    }
+
+    public static void main(String[] args) throws ClassNotFoundException, InstantiationException,
+            IllegalAccessException, IOException, NoSuchMethodException, InvocationTargetException {
+
+        if (args.length != 1) {
+            throw new Error("Test Bug: Expected GC type wasn't provided as command line argument");
+        }
+        GC gc = GC.valueOf(args[0]);
+
+        Path wrkDir = Paths.get("");
+        URL[] url = {wrkDir.toUri().toURL()};
+        URLClassLoader urlLoader = new URLClassLoader(url);
+
+        Class<?> simpleClassLoaderClass = urlLoader.loadClass(SIMPLE_CLASSLOADER_NAME);
+
+        ClassLoader simpleClassLoader = (ClassLoader) simpleClassLoaderClass
+                .getConstructor(java.lang.ClassLoader.class)
+                .newInstance(TestHumongousClassLoader.class.getClassLoader());
+
+        // Sanity check
+        Asserts.assertEquals(WB.g1IsHumongous(simpleClassLoader), false,
+                "Test Bug: simpleClassLoader is expected to be non-humongous but it's humongous");
+
+
+        Class<?> humongousClassLoaderClass = simpleClassLoader.loadClass(HUMONGOUS_CLASSLOADER_NAME);
+
+        ClassLoader humongousClassLoader = (ClassLoader) humongousClassLoaderClass
+                .getConstructor(java.lang.ClassLoader.class)
+                .newInstance(simpleClassLoader);
+
+        // Sanity check
+        Asserts.assertEquals(WB.g1IsHumongous(humongousClassLoader), true,
+                "Test Bug: humongousClassLoader is expected to be humongous but it's non-humongous");
+
+        //Asserts.assertEquals(1,0);
+
+        Object[] loadedClasses = new Object[]{
+                G1SampleClass.LARGEST_NON_HUMONGOUS.getCls(humongousClassLoader, wrkDir, SAMPLE_CLASS_NAME_PREFIX)
+                        .newInstance(),
+                G1SampleClass.SMALLEST_HUMONGOUS.getCls(humongousClassLoader, wrkDir, SAMPLE_CLASS_NAME_PREFIX)
+                        .newInstance(),
+                G1SampleClass.ONE_REGION_HUMONGOUS.getCls(humongousClassLoader, wrkDir, SAMPLE_CLASS_NAME_PREFIX)
+                        .newInstance(),
+                G1SampleClass.TWO_REGION_HUMONGOUS.getCls(humongousClassLoader, wrkDir, SAMPLE_CLASS_NAME_PREFIX)
+                        .newInstance(),
+        };
+
+        // forgetting references to loaded classes
+        for (int i = 0; i < loadedClasses.length; ++i) {
+            loadedClasses[i] = null;
+        }
+
+        // forgetting referencies to classloaders
+        humongousClassLoader = null;
+        humongousClassLoaderClass = null;
+
+        simpleClassLoader = null;
+        simpleClassLoaderClass = null;
+
+        gc.provoke();
+
+        // Test checks
+        Asserts.assertEquals(WB.isClassAlive(HUMONGOUS_CLASSLOADER_NAME), false,
+                String.format("Classloader class %s is loaded after we forget all references to it",
+                        HUMONGOUS_CLASSLOADER_NAME));
+
+        for (G1SampleClass sampleClass : G1SampleClass.values()) {
+            String className = Helpers.enumNameToClassName(sampleClass.name()) + "Class";
+            Asserts.assertEquals(WB.isClassAlive(className), false,
+                    String.format("Class %s is loaded after we forget all references to it", className));
+        }
+    }
+
+}