changeset 37232:be6614a0fd2b

8148397: Create new tests for IHOP Reviewed-by: tschatzl, dfazunen
author mchernov
date Fri, 01 Apr 2016 16:15:37 +0300
parents 7fe9301bf255
children e8e674469545 d9a0c407ac98
files hotspot/test/gc/g1/ihop/TestIHOPErgo.java hotspot/test/gc/g1/ihop/TestIHOPStatic.java hotspot/test/gc/g1/ihop/lib/IhopUtils.java hotspot/test/stress/gc/TestStressIHOPMultiThread.java
diffstat 4 files changed, 787 insertions(+), 0 deletions(-) [+]
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/ihop/TestIHOPErgo.java	Fri Apr 01 16:15:37 2016 +0300
@@ -0,0 +1,228 @@
+/*
+ * 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.
+ */
+
+ /*
+ * @test TestIHOPErgo
+ * @bug 8148397
+ * @summary Test checks that behavior of Adaptive and Static IHOP at concurrent cycle initiation
+ * @requires vm.gc=="G1" | vm.gc=="null"
+ * @requires vm.opt.FlightRecorder != true
+ * @requires vm.opt.ExplicitGCInvokesConcurrent != true
+ * @library /testlibrary /test/lib /
+ * @modules java.management
+ * @build gc.g1.ihop.TestIHOPErgo
+ *        gc.g1.ihop.lib.IhopUtils
+ * @run driver/timeout=480 gc.g1.ihop.TestIHOPErgo
+ */
+package gc.g1.ihop;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+import jdk.test.lib.OutputAnalyzer;
+import jdk.test.lib.ProcessTools;
+
+import gc.g1.ihop.lib.IhopUtils;
+
+/**
+ * The test starts the AppIHOP multiple times varying settings of MaxHeapSize.
+ * The test parses GC log from AppIHOP to check:
+ * - occupancy is not less than threshold for Adaptive and Static IHOP at
+ * concurrent cycle initiation
+ * - Adaptive IHOP prediction was started during AppIHOP executing
+ * - log contains ergonomic messages in log
+ */
+public class TestIHOPErgo {
+
+    // Common GC tune and logging options for test.
+    private final static String[] COMMON_OPTIONS = {
+        "-XX:+UnlockExperimentalVMOptions",
+        "-XX:G1MixedGCLiveThresholdPercent=100",
+        "-XX:G1HeapWastePercent=0",
+        "-XX:MaxGCPauseMillis=30000",
+        "-XX:G1MixedGCCountTarget=1",
+        "-XX:+UseG1GC",
+        "-XX:G1HeapRegionSize=1m",
+        "-XX:+G1UseAdaptiveIHOP",
+        "-Xlog:gc+ihop=debug,gc+ihop+ergo=debug,gc+ergo=debug",
+        "-XX:+AlwaysTenure",
+        "-XX:G1AdaptiveIHOPNumInitialSamples=1",
+        "-XX:InitiatingHeapOccupancyPercent=30"
+    };
+
+    public static void main(String[] args) throws Throwable {
+
+        // heap size MB, sleep time for allocator, true/false for adaptive/static
+        runTest(64, 0, false);
+        runTest(64, 100, false);
+        runTest(128, 100, false);
+        runTest(256, 50, false);
+        runTest(512, 30, false);
+        runTest(64, 50, true);
+        runTest(128, 200, true);
+        runTest(256, 100, true);
+        runTest(512, 50, true);
+    }
+
+    /**
+     * Runs AppIHOP in separate VM and checks GC log.
+     *
+     * @param heapSize       heap size
+     * @param sleepTime      sleep time between memory allocations.
+     * @param isIhopAdaptive true forAdaptive IHOP, false for Static
+     *
+     * @throws Throwable
+     */
+    private static void runTest(int heapSize, int sleepTime, boolean isIhopAdaptive) throws Throwable {
+        System.out.println("IHOP test:");
+        System.out.println("  MaxHeapSize : " + heapSize);
+
+        List<String> options = new ArrayList<>();
+        Collections.addAll(options,
+                "-Dheap.size=" + heapSize,
+                "-Dsleep.time=" + sleepTime,
+                "-XX:MaxHeapSize=" + heapSize + "M",
+                "-XX:NewSize=" + heapSize / 8 + "M",
+                "-XX:MaxNewSize=" + heapSize / 8 + "M",
+                "-XX:InitialHeapSize=" + heapSize + "M",
+                "-XX:" + (isIhopAdaptive ? "+" : "-") + "G1UseAdaptiveIHOP"
+        );
+
+        Collections.addAll(options, COMMON_OPTIONS);
+        options.add(AppIHOP.class.getName());
+        OutputAnalyzer out = executeTest(options);
+
+        // Checks that log contains message which indicates that IHOP prediction is active
+        if (isIhopAdaptive) {
+            IhopUtils.checkAdaptiveIHOPWasActivated(out);
+        }
+        // Checks that log contains messages which indicates that VM initiates/checks heap occupancy
+        // and tries to start concurrent cycle.
+        IhopUtils.checkErgoMessagesExist(out);
+
+        // Checks threshold and occupancy values
+        IhopUtils.checkIhopLogValues(out);
+    }
+
+    private static OutputAnalyzer executeTest(List<String> options) throws Throwable, RuntimeException {
+        OutputAnalyzer out;
+        out = ProcessTools.executeTestJvm(options.toArray(new String[options.size()]));
+        if (out.getExitValue() != 0) {
+            System.out.println(out.getOutput());
+            throw new RuntimeException("AppIHOP failed with exit code" + out.getExitValue());
+        }
+        return out;
+    }
+
+    /**
+     * The AppIHOP fills 60% of heap and allocates and frees 30% of existing
+     * heap 'iterations' times to achieve IHOP activation. To be executed in
+     * separate VM. Expected properties:
+     * heap.size - heap size which is used to calculate amount of memory
+     *             to be allocated and freed
+     * sleep.time - short pause between filling each MB
+     */
+    public static class AppIHOP {
+
+        public final static LinkedList<Object> GARBAGE = new LinkedList<>();
+
+        private final int ITERATIONS = 10;
+        private final int OBJECT_SIZE = 100000;
+        // 60% of the heap will be filled before test cycles.
+        // 30% of the heap will be filled and freed during test cycle.
+        private final long HEAP_PREALLOC_PCT = 60;
+        private final long HEAP_ALLOC_PCT = 30;
+        private final long HEAP_SIZE;
+        // Amount of memory to be allocated before iterations start
+        private final long HEAP_PREALLOC_SIZE;
+        // Amount of memory to be allocated and freed during iterations
+        private final long HEAP_ALLOC_SIZE;
+        private final int SLEEP_TIME;
+
+        public static void main(String[] args) throws InterruptedException {
+            new AppIHOP().start();
+        }
+
+        AppIHOP() {
+            HEAP_SIZE = Integer.getInteger("heap.size") * 1024 * 1024;
+            SLEEP_TIME = Integer.getInteger("sleep.time");
+
+            HEAP_PREALLOC_SIZE = HEAP_SIZE * HEAP_PREALLOC_PCT / 100;
+            HEAP_ALLOC_SIZE = HEAP_SIZE * HEAP_ALLOC_PCT / 100;
+        }
+
+        public void start() throws InterruptedException {
+            fill(HEAP_PREALLOC_SIZE);
+            fillAndFree(HEAP_ALLOC_SIZE, ITERATIONS);
+        }
+
+        /**
+         * Fills allocationSize bytes of garbage.
+         *
+         * @param allocationSize amount of garbage
+         */
+        private void fill(long allocationSize) {
+            long allocated = 0;
+            while (allocated < allocationSize) {
+                GARBAGE.addFirst(new byte[OBJECT_SIZE]);
+                allocated += OBJECT_SIZE;
+            }
+        }
+
+        /**
+         * Allocates allocationSize bytes of garbage. Performs a short pauses
+         * during allocation. Frees allocated garbage.
+         *
+         * @param allocationSize amount of garbage per iteration
+         * @param iterations     iteration count
+         *
+         * @throws InterruptedException
+         */
+        private void fillAndFree(long allocationSize, int iterations) throws InterruptedException {
+
+            for (int i = 0; i < iterations; ++i) {
+                System.out.println("Iteration:" + i);
+                long allocated = 0;
+                long counter = 0;
+                while (allocated < allocationSize) {
+                    GARBAGE.addFirst(new byte[OBJECT_SIZE]);
+                    allocated += OBJECT_SIZE;
+                    counter += OBJECT_SIZE;
+                    if (counter > 1024 * 1024) {
+                        counter = 0;
+                        if (SLEEP_TIME != 0) {
+                            Thread.sleep(SLEEP_TIME);
+                        }
+                    }
+                }
+                long removed = 0;
+                while (removed < allocationSize) {
+                    GARBAGE.removeLast();
+                    removed += OBJECT_SIZE;
+                }
+            }
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/ihop/TestIHOPStatic.java	Fri Apr 01 16:15:37 2016 +0300
@@ -0,0 +1,199 @@
+/*
+ * 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.
+ */
+
+ /*
+ * @test TestIHOPStatic
+ * @bug 8148397
+ * @summary Test checks concurrent cycle initiation which depends on IHOP value.
+ * @requires vm.gc=="G1" | vm.gc=="null"
+ * @requires vm.opt.FlightRecorder != true
+ * @requires vm.opt.ExplicitGCInvokesConcurrent != true
+ * @library /testlibrary /
+ * @modules java.management
+ * @build gc.g1.ihop.TestIHOPStatic
+ *        gc.g1.ihop.lib.IhopUtils
+ * @run driver/timeout=240 gc.g1.ihop.TestIHOPStatic
+ */
+package gc.g1.ihop;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import jdk.test.lib.OutputAnalyzer;
+import jdk.test.lib.ProcessTools;
+import jdk.test.lib.Utils;
+
+import gc.g1.ihop.lib.IhopUtils;
+
+/**
+ * The test starts the AppIHOP multiple times varying setting of MaxHeapSize,
+ * IHOP and amount of memory to allocate. Then the test parses the GC log from
+ * the app to check that Concurrent Mark Cycle was initiated only if needed
+ * and at the right moment, defined by IHOP setting.
+ */
+public class TestIHOPStatic {
+
+    final static long YOUNG_SIZE = 8 * 1024 * 1024;
+
+    private final static String[] COMMON_OPTIONS = {
+        "-XX:+UseG1GC",
+        "-XX:G1HeapRegionSize=1m",
+        "-XX:-G1UseAdaptiveIHOP",
+        "-XX:NewSize=" + YOUNG_SIZE,
+        "-XX:MaxNewSize=" + YOUNG_SIZE,
+        "-Xlog:gc+ihop+ergo=debug,gc*=debug"
+    };
+
+    public static void main(String[] args) throws Throwable {
+
+        // Test case:
+        // IHOP value, heap occupancy, heap size, expectation of message
+        // Test cases for occupancy is greater than IHOP
+        runTest(30, 35, 64, true);
+        runTest(50, 55, 256, true);
+        runTest(60, 65, 64, true);
+        runTest(70, 75, 512, true);
+
+        // Test cases for big difference between occupancy and IHOP
+        runTest(30, 50, 256, true);
+        runTest(30, 70, 512, true);
+        runTest(50, 70, 256, true);
+
+        // Test cases for occupancy is less than IHOP
+        runTest(30, 25, 64, false);
+        runTest(50, 45, 256, false);
+        runTest(70, 65, 64, false);
+        runTest(70, 65, 512, false);
+
+        // Test cases for big difference between occupancy and IHOP
+        runTest(50, 30, 300, false);
+        runTest(70, 50, 160, false);
+
+        // Cases for 0 and 100 IHOP.
+        runTest(0, 50, 256, true);
+        runTest(0, 95, 512, true);
+        runTest(100, 20, 64, false);
+        runTest(100, 100, 512, false);
+    }
+
+    /**
+     * Runs the test case.
+     *
+     * @param ihop                    IHOP value
+     * @param pctToFill               heap percentage to be filled
+     * @param heapSize                heap size for test
+     * @param expectInitiationMessage
+     *                                true - concurrent cycle initiation message is expected
+     *                                false - message is not expected
+     *
+     * @throws Throwable
+     */
+    private static void runTest(int ihop, long pctToFill, long heapSize, boolean expectInitiationMessage) throws Throwable {
+        System.out.println("");
+        System.out.println("IHOP test:");
+        System.out.println("  InitiatingHeapOccupancyPercent : " + ihop);
+        System.out.println("  Part of heap to fill (percentage) : " + pctToFill);
+        System.out.println("  MaxHeapSize : " + heapSize);
+        System.out.println("  Expect for concurrent cycle initiation message : " + expectInitiationMessage);
+        List<String> options = new ArrayList<>();
+        Collections.addAll(options, Utils.getTestJavaOpts());
+        Collections.addAll(options,
+                "-XX:InitiatingHeapOccupancyPercent=" + ihop,
+                "-Dmemory.fill=" + (heapSize * 1024 * 1024 * pctToFill / 100),
+                "-XX:MaxHeapSize=" + heapSize + "M",
+                "-XX:InitialHeapSize=" + heapSize + "M"
+        );
+        Collections.addAll(options, COMMON_OPTIONS);
+        options.add(AppIHOP.class.getName());
+
+        OutputAnalyzer out = ProcessTools.executeTestJvm(options.toArray(new String[options.size()]));
+
+        if (out.getExitValue() != 0) {
+            System.out.println(out.getOutput());
+            throw new RuntimeException("IhopTest failed with exit code " + out.getExitValue());
+        }
+
+        checkResult(out, expectInitiationMessage);
+    }
+
+    /**
+     * Checks execution results to ensure that concurrent cycle was initiated or
+     * was not.
+     *
+     * @param out
+     * @param expectInitiationMessage true - test expects for concurrent cycle initiation.
+     *                                false - test does not expect for concurrent cycle initiation
+     */
+    private static void checkResult(OutputAnalyzer out, boolean expectInitiationMessage) {
+        // Find expected messages
+        List<String> logItems = IhopUtils.getErgoInitiationMessages(out);
+
+        // Concurrent cycle was not initiated but was expected.
+        if (logItems.isEmpty() && expectInitiationMessage) {
+            System.out.println(out.getOutput());
+            throw new RuntimeException("Concurrent cycle was not initiated.");
+        }
+        IhopUtils.checkIhopLogValues(out);
+    }
+
+    static class AppIHOP {
+
+        /**
+         * Simple class which fills part of memory and initiates GC.
+         * To be executed in separate VM.
+         * Expect next VM properties to be set:
+         * memory.fill - amount of garbage to be created.
+         */
+        private static final long MEMORY_TO_FILL = Integer.getInteger("memory.fill");
+        private final static int CHUNK_SIZE = 10000;
+
+        public final static ArrayList<Object> STORAGE = new ArrayList<>();
+
+        public static void main(String[] args) throws InterruptedException {
+
+            // Calculate part of heap to be filled to achieve expected occupancy.
+            System.out.println("Mem to fill:" + MEMORY_TO_FILL);
+            if (MEMORY_TO_FILL <= 0) {
+                throw new RuntimeException("Wrong memory size: " + MEMORY_TO_FILL);
+            }
+            try {
+                createGarbage(MEMORY_TO_FILL);
+            } catch (OutOfMemoryError oome) {
+                return;
+            }
+            // Concurrent cycle initiation should start at end of Young GC cycle.
+            // Will fill entire young gen with garbage to guarantee that Young GC was initiated.
+            try {
+                createGarbage(TestIHOPStatic.YOUNG_SIZE);
+            } catch (OutOfMemoryError oome) {
+            }
+        }
+
+        private static void createGarbage(long memToFill) {
+            for (long i = 0; i < memToFill / CHUNK_SIZE; i++) {
+                STORAGE.add(new byte[CHUNK_SIZE]);
+            }
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/ihop/lib/IhopUtils.java	Fri Apr 01 16:15:37 2016 +0300
@@ -0,0 +1,144 @@
+/*
+ * 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.ihop.lib;
+
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import jdk.test.lib.OutputAnalyzer;
+
+
+/**
+ * Utility class to extract IHOP related information from the GC log.
+ * The class provides a number of static method to be used from tests.
+ */
+public class IhopUtils {
+
+    // Examples of GC log for IHOP:
+    // [0.402s][debug][gc,ergo,ihop] GC(9) Do not request concurrent cycle initiation (still doing mixed collections) occupancy: 66060288B allocation request: 0B threshold: 59230757B (88.26) source: end of GC
+    // [0.466s][debug][gc,ergo,ihop] GC(18) Request concurrent cycle initiation (occupancy higher than threshold) occupancy: 52428800B allocation request: 0B threshold: 0B (0.00) source: end of GC
+
+    /**
+     * Patterns are used for extracting occupancy and threshold from GC log.
+     */
+    private final static Pattern OCCUPANCY = Pattern.compile("occupancy: (\\d+)B");
+    private final static Pattern THRESHOLD = Pattern.compile("threshold: (\\d+)B");
+
+    /**
+     * Messages related to concurrent cycle initiation.
+     */
+    private final static String CYCLE_INITIATION_MESSAGE = "Request concurrent cycle initiation (occupancy higher than threshold)";
+    private final static String CYCLE_INITIATION_MESSAGE_FALSE = "Do not request concurrent cycle initiation (still doing mixed collections)";
+    private final static String ADAPTIVE_IHOP_PREDICTION_ACTIVE_MESSAGE = "prediction active: true";
+
+    /**
+     * Finds strings which contains patterns for finding.
+     *
+     * @param outputAnalyzer List of string for IHOP messages extraction
+     * @param stringsToFind Strings which is checked for matching with OutputAnalyzer content
+     * @return List of strings which were matched.
+     */
+    private static List<String> findInLog(OutputAnalyzer outputAnalyzer, String... stringsToFind) {
+        return outputAnalyzer.asLines().stream()
+                .filter(string -> {
+                    return Stream.of(stringsToFind)
+                            .filter(find -> string.contains(find))
+                            .findAny()
+                            .isPresent();
+                })
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Checks that memory occupancy is greater or equal to the threshold.
+     * This methods searches for occupancy and threshold in the GC log corresponding Conc Mark Cycle initiation
+     * and compare their values.If no CMC initiation happens, does nothing.
+     * @param outputAnalyzer OutputAnalyzer which contains GC log to be checked
+     * @throw RuntimeException If check fails
+     */
+    public static void checkIhopLogValues(OutputAnalyzer outputAnalyzer) {
+        // Concurrent cycle was initiated but was not expected.
+        // Checks occupancy should be greater than threshold.
+        List<String> logItems = IhopUtils.getErgoMessages(outputAnalyzer);
+        logItems.stream()
+                .forEach(item -> {
+                    long occupancy = IhopUtils.getLongByPattern(item, IhopUtils.OCCUPANCY);
+                    long threshold = IhopUtils.getLongByPattern(item, IhopUtils.THRESHOLD);
+                    if (occupancy < threshold) {
+                        System.out.println(outputAnalyzer.getOutput());
+                        throw new RuntimeException("Concurrent cycle initiation is unexpected. Occupancy (" + occupancy + ") is less then threshold (" + threshold + ")");
+                    }
+                    System.out.printf("Concurrent cycle was initiated with occupancy = %d and threshold = %d%n", occupancy, threshold);
+                });
+    }
+
+    private static Long getLongByPattern(String line, Pattern pattern) {
+        Matcher number = pattern.matcher(line);
+        if (number.find()) {
+            return Long.parseLong(number.group(1));
+        }
+        System.out.println(line);
+        throw new RuntimeException("Cannot find Long in string.");
+    }
+
+    /**
+     * Finds concurrent cycle initiation messages.
+     * @param outputAnalyzer OutputAnalyzer
+     * @return List with messages which were found.
+     */
+    public static List<String> getErgoInitiationMessages(OutputAnalyzer outputAnalyzer) {
+        return IhopUtils.findInLog(outputAnalyzer, CYCLE_INITIATION_MESSAGE);
+    }
+
+    /**
+     * Gets IHOP ergo messages from GC log.
+     * @param outputAnalyzer
+     * @return List with found messages
+     */
+    private static List<String> getErgoMessages(OutputAnalyzer outputAnalyzer) {
+        return IhopUtils.findInLog(outputAnalyzer, CYCLE_INITIATION_MESSAGE, CYCLE_INITIATION_MESSAGE_FALSE);
+    }
+
+    /**
+     * Checks that GC log contains expected ergonomic messages
+     * @param outputAnalyzer OutputAnalyer with GC log for checking
+     * @throws RuntimeException If no IHOP ergo messages were not found
+     */
+    public static void checkErgoMessagesExist(OutputAnalyzer outputAnalyzer) {
+        String output = outputAnalyzer.getOutput();
+        if (!(output.contains(CYCLE_INITIATION_MESSAGE) | output.contains(CYCLE_INITIATION_MESSAGE_FALSE))) {
+            throw new RuntimeException("Cannot find expected IHOP ergonomics messages");
+        }
+    }
+
+    /**
+     * Checks that adaptive IHOP was activated
+     * @param outputAnalyzer OutputAnalyer with GC log for checking
+     * @throws RuntimeException If IHOP message was not found.
+     */
+    public static void checkAdaptiveIHOPWasActivated(OutputAnalyzer outputAnalyzer) {
+        outputAnalyzer.shouldContain(ADAPTIVE_IHOP_PREDICTION_ACTIVE_MESSAGE);
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/stress/gc/TestStressIHOPMultiThread.java	Fri Apr 01 16:15:37 2016 +0300
@@ -0,0 +1,216 @@
+/*
+ * 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.
+ */
+
+ /*
+ * @test TestStressIHOPMultiThread
+ * @bug 8148397
+ * @key stress
+ * @summary Stress test for IHOP
+ * @requires vm.gc=="G1" | vm.gc=="null"
+ * @run main/othervm/timeout=200 -Xmx128m -XX:G1HeapWastePercent=0 -XX:G1MixedGCCountTarget=1
+ *              -XX:+UseG1GC -XX:G1HeapRegionSize=1m -XX:+G1UseAdaptiveIHOP
+ *              -Xlog:gc+ihop=debug,gc+ihop+ergo=debug,gc+ergo=debug:TestStressIHOPMultiThread1.log
+ *              -Dtimeout=2 -DheapUsageMinBound=30 -DheapUsageMaxBound=80
+ *              -Dthreads=2 TestStressIHOPMultiThread
+ * @run main/othervm/timeout=200 -Xmx256m -XX:G1HeapWastePercent=0 -XX:G1MixedGCCountTarget=1
+ *              -XX:+UseG1GC -XX:G1HeapRegionSize=2m -XX:+G1UseAdaptiveIHOP
+ *              -Xlog:gc+ihop=debug,gc+ihop+ergo=debug,gc+ergo=debug:TestStressIHOPMultiThread2.log
+ *              -Dtimeout=2 -DheapUsageMinBound=60 -DheapUsageMaxBound=90
+ *              -Dthreads=3 TestStressIHOPMultiThread
+ * @run main/othervm/timeout=200 -Xmx256m -XX:G1HeapWastePercent=0 -XX:G1MixedGCCountTarget=1
+ *              -XX:+UseG1GC -XX:G1HeapRegionSize=4m -XX:-G1UseAdaptiveIHOP
+ *              -Xlog:gc+ihop=debug,gc+ihop+ergo=debug,gc+ergo=debug:TestStressIHOPMultiThread3.log
+ *              -Dtimeout=2 -DheapUsageMinBound=40 -DheapUsageMaxBound=90
+ *              -Dthreads=5 TestStressIHOPMultiThread
+ * @run main/othervm/timeout=200 -Xmx128m -XX:G1HeapWastePercent=0 -XX:G1MixedGCCountTarget=1
+ *              -XX:+UseG1GC -XX:G1HeapRegionSize=8m -XX:+G1UseAdaptiveIHOP
+ *              -Xlog:gc+ihop=debug,gc+ihop+ergo=debug,gc+ergo=debug:TestStressIHOPMultiThread4.log
+ *              -Dtimeout=2 -DheapUsageMinBound=20 -DheapUsageMaxBound=90
+ *              -Dthreads=10 TestStressIHOPMultiThread
+ * @run main/othervm/timeout=200 -Xmx512m -XX:G1HeapWastePercent=0 -XX:G1MixedGCCountTarget=1
+ *              -XX:+UseG1GC -XX:G1HeapRegionSize=16m -XX:+G1UseAdaptiveIHOP
+ *              -Xlog:gc+ihop=debug,gc+ihop+ergo=debug,gc+ergo=debug:TestStressIHOPMultiThread5.log
+ *              -Dtimeout=2 -DheapUsageMinBound=20 -DheapUsageMaxBound=90
+ *              -Dthreads=17 TestStressIHOPMultiThread
+ */
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Stress test for Adaptive IHOP. Starts a number of threads that fill and free
+ * specified amount of memory. Tests work with enabled IHOP logging.
+ *
+ */
+public class TestStressIHOPMultiThread {
+
+    public final static List<Object> GARBAGE = new LinkedList<>();
+
+    private final long HEAP_SIZE;
+    // Amount of memory to be allocated before iterations start
+    private final long HEAP_PREALLOC_SIZE;
+    // Amount of memory to be allocated and freed during iterations
+    private final long HEAP_ALLOC_SIZE;
+    private final int CHUNK_SIZE = 100000;
+
+    private final int TIMEOUT;
+    private final int THREADS;
+    private final int HEAP_LOW_BOUND;
+    private final int HEAP_HIGH_BOUND;
+
+    private volatile boolean running = true;
+    private final List<AllocationThread> threads;
+
+    public static void main(String[] args) throws InterruptedException {
+        new TestStressIHOPMultiThread().start();
+
+    }
+
+    TestStressIHOPMultiThread() {
+
+        TIMEOUT = Integer.getInteger("timeout") * 60;
+        THREADS = Integer.getInteger("threads");
+        HEAP_LOW_BOUND = Integer.getInteger("heapUsageMinBound");
+        HEAP_HIGH_BOUND = Integer.getInteger("heapUsageMaxBound");
+        HEAP_SIZE = Runtime.getRuntime().maxMemory();
+
+        HEAP_PREALLOC_SIZE = HEAP_SIZE * HEAP_LOW_BOUND / 100;
+        HEAP_ALLOC_SIZE = HEAP_SIZE * (HEAP_HIGH_BOUND - HEAP_LOW_BOUND) / 100;
+
+        threads = new ArrayList<>(THREADS);
+    }
+
+    public void start() throws InterruptedException {
+        fill();
+        createThreads();
+        waitForStress();
+        stressDone();
+        waitForFinish();
+    }
+
+    /**
+     * Fills HEAP_PREALLOC_SIZE bytes of garbage.
+     */
+    private void fill() {
+        long allocated = 0;
+        while (allocated < HEAP_PREALLOC_SIZE) {
+            GARBAGE.add(new byte[CHUNK_SIZE]);
+            allocated += CHUNK_SIZE;
+        }
+    }
+
+    /**
+     * Creates a number of threads which will fill and free amount of memory.
+     */
+    private void createThreads() {
+        for (int i = 0; i < THREADS; ++i) {
+            System.out.println("Create thread " + i);
+            AllocationThread thread =new TestStressIHOPMultiThread.AllocationThread(i, HEAP_ALLOC_SIZE / THREADS);
+            // Put reference to thread garbage into common garbage for avoiding possible optimization.
+            GARBAGE.add(thread.getList());
+            threads.add(thread);
+        }
+        threads.forEach(t -> t.start());
+    }
+
+    /**
+     * Wait each thread for finishing
+     */
+    private void waitForFinish() {
+        threads.forEach(thread -> {
+            thread.silentJoin();
+        });
+    }
+
+    private boolean isRunning() {
+        return running;
+    }
+
+    private void stressDone() {
+        running = false;
+    }
+
+    private void waitForStress() throws InterruptedException {
+        Thread.sleep(TIMEOUT * 1000);
+    }
+
+    private class AllocationThread extends Thread {
+
+        private final List<Object> garbage;
+
+        private final long amountOfGarbage;
+        private final int threadId;
+
+        public AllocationThread(int id, long amount) {
+            super("Thread " + id);
+            threadId = id;
+            amountOfGarbage = amount;
+            garbage = new LinkedList<>();
+        }
+
+        /**
+         * Returns list of garbage.
+         * @return List with thread garbage.
+         */
+        public List<Object> getList(){
+            return garbage;
+        }
+
+        @Override
+        public void run() {
+            System.out.println("Start the thread " + threadId);
+            while (TestStressIHOPMultiThread.this.isRunning()) {
+                allocate(amountOfGarbage);
+                free();
+            }
+        }
+
+        private void silentJoin() {
+            System.out.println("Join the thread " + threadId);
+            try {
+                join();
+            } catch (InterruptedException ie) {
+                throw new RuntimeException(ie);
+            }
+        }
+
+        /**
+         * Allocates thread local garbage
+         */
+        private void allocate(long amount) {
+            long allocated = 0;
+            while (allocated < amount && TestStressIHOPMultiThread.this.isRunning()) {
+                garbage.add(new byte[CHUNK_SIZE]);
+                allocated += CHUNK_SIZE;
+            }
+        }
+
+        /**
+         * Frees thread local garbage
+         */
+        private void free() {
+            garbage.clear();
+        }
+    }
+}