--- /dev/null	2020-08-18 08:55:39.381895418 +0200
+++ new/test/hotspot/jtreg/gc/g1/TestHumongousConcurrentStartUndo.java	2020-08-18 18:23:29.248317437 +0200
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2020, 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;
+
+/*
+ * @test TestHumongousConcurrentStartUndo
+ * @summary Tests an alternating sequence of Concurrent Mark and Concurrent Undo
+ * cycles.
+ * reclaim heap occupancy falls below the IHOP value.
+ * @requires vm.gc.G1
+ * @library /test/lib /testlibrary /
+ * @modules java.base/jdk.internal.misc
+ *          java.management
+ * @build sun.hotspot.WhiteBox
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ *             sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockExperimentalVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ *                   gc.g1.TestHumongousConcurrentStartUndo
+ */
+
+import gc.testlibrary.Helpers;
+
+import sun.hotspot.WhiteBox;
+import jdk.test.lib.process.OutputAnalyzer;
+import jdk.test.lib.process.ProcessTools;
+
+import java.util.Queue;
+import java.util.concurrent.ArrayBlockingQueue;
+
+public class TestHumongousConcurrentStartUndo {
+    // Heap sizes < 224 MB are increased to 224 MB if vm_page_size == 64K to
+    // fulfill alignment constraints.
+    private static final int HeapSize                       = 224; // MB
+    private static final int HeapRegionSize                 = 1;   // MB
+    private static final int InitiatingHeapOccupancyPercent = 50;  // %
+    private static final int YoungSize                      = HeapSize / 8;
+
+    public static void main(String[] args) throws Exception {
+        ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
+            "-Xbootclasspath/a:.",
+            "-XX:+UseG1GC",
+            "-Xms" + HeapSize + "m",
+            "-Xmx" + HeapSize + "m",
+            "-Xmn" + YoungSize + "m",
+            "-XX:G1HeapRegionSize=" + HeapRegionSize + "m",
+            "-XX:InitiatingHeapOccupancyPercent=" + InitiatingHeapOccupancyPercent,
+            "-XX:-G1UseAdaptiveIHOP",
+            "-XX:+UnlockExperimentalVMOptions",
+            "-XX:+WhiteBoxAPI",
+            "-Xlog:gc*",
+            EdenObjectAllocatorWithHumongousAllocation.class.getName());
+
+        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        output.shouldContain("Pause Young (Concurrent Start) (G1 Humongous Allocation)");
+        output.shouldContain("Concurrent Undo Cycle");
+        output.shouldContain("Concurrent Mark Cycle");
+        output.shouldHaveExitValue(0);
+        System.out.println(output.getStdout());
+    }
+
+    static class EdenObjectAllocatorWithHumongousAllocation {
+        private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
+
+        private static void allocateHumongous(int num, int objSize, Queue keeper) {
+            for (int i = 1; i <= num; i++) {
+                if (i % 10 == 0) {
+                    System.out.println("Allocating humongous object " + i + "/" + num +
+                                       " of size " + objSize + " bytes");
+                }
+                byte[] e = new byte[objSize];
+                if (!keeper.offer(e)) {
+                    keeper.remove();
+                    keeper.offer(e);
+                }
+            }
+        }
+
+        public static void main(String [] args) throws Exception {
+            final int M = 1024 * 1024;
+            // Make humongous object size 75% of region size
+            final int humongousObjectSize =
+                (int)(HeapRegionSize * M * 0.75);
+
+            // Number of objects to allocate to go above IHOP
+            final int humongousObjectAllocations =
+                (int)(((HeapSize - YoungSize) * 80 / 100.0) / HeapRegionSize);
+
+            ArrayBlockingQueue a;
+            for (int iterate = 0; iterate < 3; iterate++) {
+                WHITE_BOX.fullGC();
+
+                a = new ArrayBlockingQueue(1);
+                allocateHumongous(humongousObjectAllocations, humongousObjectSize, a);
+                Helpers.waitTillCMCFinished(WHITE_BOX, 1);
+                a = null;
+
+                a = new ArrayBlockingQueue(humongousObjectAllocations);
+                allocateHumongous(humongousObjectAllocations, humongousObjectSize, a);
+                Helpers.waitTillCMCFinished(WHITE_BOX, 1);
+                a = null;
+
+                allocateHumongous(1, humongousObjectSize, new ArrayBlockingQueue(1));
+                Helpers.waitTillCMCFinished(WHITE_BOX, 1);
+            }
+        }
+    }
+}
+