--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/humongousObjects/TestHeapCounters.java	Tue Feb 02 18:06:14 2016 +0300
@@ -0,0 +1,193 @@
+/*
+ * 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.lang.management.GarbageCollectorMXBean;
+import java.lang.management.ManagementFactory;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @test TestHeapCounters
+ * @summary Checks that heap counters work as expected after humongous allocations/deallocations
+ * @requires vm.gc=="G1" | vm.gc=="null"
+ * @library /testlibrary /test/lib /
+ * @modules java.management
+ * @build sun.hotspot.WhiteBox
+ *        gc.testlibrary.Helpers
+ *        gc.g1.humongousObjects.TestHeapCounters
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ *             sun.hotspot.WhiteBox$WhiteBoxPermission
+ *
+ * @run main/othervm -XX:+UseG1GC -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ *                   -Xmx128m -Xms128m
+ *                   -XX:G1HeapRegionSize=1M -XX:InitiatingHeapOccupancyPercent=100 -XX:-G1UseAdaptiveIHOP
+ *                   -Xlog:gc -Xlog:gc:file=TestHeapCountersRuntime.gc.log
+ *                    gc.g1.humongousObjects.TestHeapCounters RUNTIME_COUNTER
+ *
+ * @run main/othervm -XX:+UseG1GC -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ *                   -Xmx128m -Xms128m
+ *                   -XX:G1HeapRegionSize=1M -XX:InitiatingHeapOccupancyPercent=100 -XX:-G1UseAdaptiveIHOP
+ *                   -Xlog:gc -Xlog:gc:file=TestHeapCountersMXBean.gc.log
+ *                    gc.g1.humongousObjects.TestHeapCounters MX_BEAN_COUNTER
+ */
+public class TestHeapCounters {
+    private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
+    private static final int G1_REGION_SIZE = WHITE_BOX.g1RegionSize();
+    private static final int HALF_G1_REGION_SIZE = G1_REGION_SIZE / 2;
+
+    // Since during deallocation GC could free (very unlikely) some non-humongous data this value relaxes amount of
+    // memory we expect to be freed.
+    private static final double ALLOCATION_SIZE_TOLERANCE_FACTOR = 0.85D;
+
+    private enum MemoryCounter {
+        MX_BEAN_COUNTER {
+            @Override
+            public long getUsedMemory() {
+                return ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+            }
+        },
+        RUNTIME_COUNTER {
+            @Override
+            public long getUsedMemory() {
+                return Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
+            }
+        };
+
+        public abstract long getUsedMemory();
+    }
+
+    private static class Allocation {
+        private byte[] allocation;
+        public final long expectedSize;
+
+        public Allocation(int allocationSize, long allocationExpectedSize) {
+            allocation = new byte[allocationSize];
+            expectedSize = allocationExpectedSize;
+
+            System.out.println(String.format("Object size is %d; Object is %shumongous",
+                    WHITE_BOX.getObjectSize(allocation),
+                    (WHITE_BOX.g1IsHumongous(allocation) ? "" : "non-")));
+
+            selfTest();
+        }
+
+        private void selfTest() {
+            boolean isHumongous = WHITE_BOX.getObjectSize(allocation) > HALF_G1_REGION_SIZE;
+            boolean shouldBeHumongous = WHITE_BOX.g1IsHumongous(allocation);
+
+            // Sanity check
+            Asserts.assertEquals(isHumongous, shouldBeHumongous,
+                    String.format("Test Bug: Object of size %d is expected to be %shumongous but it is not",
+                            WHITE_BOX.getObjectSize(allocation), (shouldBeHumongous ? "" : "non-")));
+        }
+
+        public void forgetAllocation() {
+            allocation = null;
+        }
+    }
+
+    public static void main(String[] args) {
+
+        if (args.length != 1) {
+            throw new Error("Expected memory counter name wasn't provided as command line argument");
+        }
+        MemoryCounter memoryCounter = MemoryCounter.valueOf(args[0].toUpperCase());
+
+        int byteArrayMemoryOverhead = Helpers.detectByteArrayAllocationOverhead();
+
+        // Largest non-humongous byte[]
+        int maxByteArrayNonHumongousSize = HALF_G1_REGION_SIZE - byteArrayMemoryOverhead;
+
+        // Maximum byte[] that takes one region
+        int maxByteArrayOneRegionSize = G1_REGION_SIZE - byteArrayMemoryOverhead;
+
+        List<Integer> allocationSizes = Arrays.asList(
+                (int) maxByteArrayNonHumongousSize + 1,
+                (int) (0.8f * maxByteArrayOneRegionSize),
+                (int) (maxByteArrayOneRegionSize),
+                (int) (1.2f * maxByteArrayOneRegionSize),
+                (int) (1.5f * maxByteArrayOneRegionSize),
+                (int) (1.7f * maxByteArrayOneRegionSize),
+                (int) (2.0f * maxByteArrayOneRegionSize),
+                (int) (2.5f * maxByteArrayOneRegionSize)
+        );
+
+        List<Allocation> allocations = new ArrayList<>();
+        List<GarbageCollectorMXBean> gcBeans =
+                ManagementFactory.getGarbageCollectorMXBeans();
+
+        long gcCountBefore = gcBeans.stream().mapToLong(GarbageCollectorMXBean::getCollectionCount).sum();
+
+
+        System.out.println("Starting allocations - no GC should happen until we finish them");
+
+        for (int allocationSize : allocationSizes) {
+
+            long usedMemoryBefore = memoryCounter.getUsedMemory();
+            long expectedAllocationSize = (long) Math.ceil((double) allocationSize / G1_REGION_SIZE) * G1_REGION_SIZE;
+            allocations.add(new Allocation(allocationSize, expectedAllocationSize));
+            long usedMemoryAfter = memoryCounter.getUsedMemory();
+
+            System.out.format("Expected allocation size: %d\nUsed memory before allocation: %d\n"
+                            + "Used memory after allocation: %d\n",
+                    expectedAllocationSize, usedMemoryBefore, usedMemoryAfter);
+
+            long gcCountNow = gcBeans.stream().mapToLong(GarbageCollectorMXBean::getCollectionCount).sum();
+
+            if (gcCountNow == gcCountBefore) {
+                // We should allocate at least allocation.expectedSize
+                Asserts.assertGreaterThanOrEqual(usedMemoryAfter - usedMemoryBefore, expectedAllocationSize,
+                        "Counter of type " + memoryCounter.getClass().getSimpleName() +
+                                " returned wrong allocation size");
+            } else {
+                System.out.println("GC happened during allocation so the check is skipped");
+                gcCountBefore = gcCountNow;
+            }
+        }
+
+        System.out.println("Finished allocations - no GC should have happened before this line");
+
+
+        allocations.stream().forEach(allocation -> {
+            long usedMemoryBefore = memoryCounter.getUsedMemory();
+            allocation.forgetAllocation();
+
+            WHITE_BOX.fullGC();
+
+            long usedMemoryAfter = memoryCounter.getUsedMemory();
+
+            // We should free at least allocation.expectedSize * ALLOCATION_SIZE_TOLERANCE_FACTOR
+            Asserts.assertGreaterThanOrEqual(usedMemoryBefore - usedMemoryAfter,
+                    (long) (allocation.expectedSize * ALLOCATION_SIZE_TOLERANCE_FACTOR),
+                    "Counter of type " + memoryCounter.getClass().getSimpleName() + " returned wrong allocation size");
+        });
+    }
+}