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 /*
25 * @test TestIHOPStatic
26 * @bug 8148397
27 * @summary Test checks concurrent cycle initiation which depends on IHOP value.
28 * @requires vm.gc.G1
29 * @requires !vm.flightRecorder
30 * @requires vm.opt.ExplicitGCInvokesConcurrent != true
31 * @library /test/lib /
32 * @modules java.base/jdk.internal.misc
33 * @modules java.management
34 * @run driver/timeout=240 gc.g1.ihop.TestIHOPStatic
35 */
36package gc.g1.ihop;
37
38import java.util.ArrayList;
39import java.util.Collections;
40import java.util.List;
41
42import jdk.test.lib.process.ProcessTools;
43import jdk.test.lib.process.OutputAnalyzer;
44import jdk.test.lib.Utils;
45
46import gc.g1.ihop.lib.IhopUtils;
47
48/**
49 * The test starts the AppIHOP multiple times varying setting of MaxHeapSize,
50 * IHOP and amount of memory to allocate. Then the test parses the GC log from
51 * the app to check that Concurrent Mark Cycle was initiated only if needed
52 * and at the right moment, defined by IHOP setting.
53 */
54public class TestIHOPStatic {
55
56    final static long YOUNG_SIZE = 8 * 1024 * 1024;
57
58    private final static String[] COMMON_OPTIONS = {
59        "-XX:+UseG1GC",
60        "-XX:G1HeapRegionSize=1m",
61        "-XX:-G1UseAdaptiveIHOP",
62        "-XX:NewSize=" + YOUNG_SIZE,
63        "-XX:MaxNewSize=" + YOUNG_SIZE,
64        "-Xlog:gc+ihop+ergo=debug,gc*=debug"
65    };
66
67    public static void main(String[] args) throws Throwable {
68
69        // Test case:
70        // IHOP value, heap occupancy, heap size, expectation of message
71        // Test cases for occupancy is greater than IHOP
72        runTest(30, 35, 64, true);
73        runTest(50, 55, 256, true);
74        runTest(60, 65, 64, true);
75        runTest(70, 75, 512, true);
76
77        // Test cases for big difference between occupancy and IHOP
78        runTest(30, 50, 256, true);
79        runTest(30, 70, 512, true);
80        runTest(50, 70, 256, true);
81
82        // Test cases for occupancy is less than IHOP
83        runTest(30, 25, 64, false);
84        runTest(50, 45, 256, false);
85        runTest(70, 65, 64, false);
86        runTest(70, 65, 512, false);
87
88        // Test cases for big difference between occupancy and IHOP
89        runTest(50, 30, 300, false);
90        runTest(70, 50, 160, false);
91
92        // Cases for 0 and 100 IHOP.
93        runTest(0, 50, 256, true);
94        runTest(0, 95, 512, true);
95        runTest(100, 20, 64, false);
96        runTest(100, 100, 512, false);
97    }
98
99    /**
100     * Runs the test case.
101     *
102     * @param ihop                    IHOP value
103     * @param pctToFill               heap percentage to be filled
104     * @param heapSize                heap size for test
105     * @param expectInitiationMessage
106     *                                true - concurrent cycle initiation message is expected
107     *                                false - message is not expected
108     *
109     * @throws Throwable
110     */
111    private static void runTest(int ihop, long pctToFill, long heapSize, boolean expectInitiationMessage) throws Throwable {
112        System.out.println("");
113        System.out.println("IHOP test:");
114        System.out.println("  InitiatingHeapOccupancyPercent : " + ihop);
115        System.out.println("  Part of heap to fill (percentage) : " + pctToFill);
116        System.out.println("  MaxHeapSize : " + heapSize);
117        System.out.println("  Expect for concurrent cycle initiation message : " + expectInitiationMessage);
118        List<String> options = new ArrayList<>();
119        Collections.addAll(options, Utils.getTestJavaOpts());
120        Collections.addAll(options,
121                "-XX:InitiatingHeapOccupancyPercent=" + ihop,
122                "-Dmemory.fill=" + (heapSize * 1024 * 1024 * pctToFill / 100),
123                "-XX:MaxHeapSize=" + heapSize + "M",
124                "-XX:InitialHeapSize=" + heapSize + "M"
125        );
126        Collections.addAll(options, COMMON_OPTIONS);
127        options.add(AppIHOP.class.getName());
128
129        OutputAnalyzer out = ProcessTools.executeTestJvm(options.toArray(new String[options.size()]));
130
131        if (out.getExitValue() != 0) {
132            System.out.println(out.getOutput());
133            throw new RuntimeException("IhopTest failed with exit code " + out.getExitValue());
134        }
135
136        checkResult(out, expectInitiationMessage);
137    }
138
139    /**
140     * Checks execution results to ensure that concurrent cycle was initiated or
141     * was not.
142     *
143     * @param out
144     * @param expectInitiationMessage true - test expects for concurrent cycle initiation.
145     *                                false - test does not expect for concurrent cycle initiation
146     */
147    private static void checkResult(OutputAnalyzer out, boolean expectInitiationMessage) {
148        // Find expected messages
149        List<String> logItems = IhopUtils.getErgoInitiationMessages(out);
150
151        // Concurrent cycle was not initiated but was expected.
152        if (logItems.isEmpty() && expectInitiationMessage) {
153            System.out.println(out.getOutput());
154            throw new RuntimeException("Concurrent cycle was not initiated.");
155        }
156        IhopUtils.checkIhopLogValues(out);
157    }
158
159    static class AppIHOP {
160
161        /**
162         * Simple class which fills part of memory and initiates GC.
163         * To be executed in separate VM.
164         * Expect next VM properties to be set:
165         * memory.fill - amount of garbage to be created.
166         */
167        private static final long MEMORY_TO_FILL = Integer.getInteger("memory.fill");
168        private final static int CHUNK_SIZE = 10000;
169
170        public final static ArrayList<Object> STORAGE = new ArrayList<>();
171
172        public static void main(String[] args) throws InterruptedException {
173
174            // Calculate part of heap to be filled to achieve expected occupancy.
175            System.out.println("Mem to fill:" + MEMORY_TO_FILL);
176            if (MEMORY_TO_FILL <= 0) {
177                throw new RuntimeException("Wrong memory size: " + MEMORY_TO_FILL);
178            }
179            try {
180                createGarbage(MEMORY_TO_FILL);
181            } catch (OutOfMemoryError oome) {
182                return;
183            }
184            // Concurrent cycle initiation should start at end of Young GC cycle.
185            // Will fill entire young gen with garbage to guarantee that Young GC was initiated.
186            try {
187                createGarbage(TestIHOPStatic.YOUNG_SIZE);
188            } catch (OutOfMemoryError oome) {
189            }
190        }
191
192        private static void createGarbage(long memToFill) {
193            for (long i = 0; i < memToFill / CHUNK_SIZE; i++) {
194                STORAGE.add(new byte[CHUNK_SIZE]);
195            }
196        }
197    }
198}
199