1 /*
2 * Copyright (c) 2017, 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 // A test that stresses a full GC by allocating objects of different lifetimes
25 // and concurrently calling System.gc().
26
27 import java.util.ArrayList;
28 import java.util.HashMap;
29 import java.util.Map;
30 import java.util.TreeMap;
31
32 final class ThreadUtils {
33 public static void sleep(long durationMS) {
34 try {
35 Thread.sleep(durationMS);
36 } catch (Exception e) {
37 }
38 }
39 }
40
41 class Exitable {
42 private volatile boolean shouldExit = false;
43
44 protected boolean shouldExit() {
45 return shouldExit;
46 }
47
48 public void exit() {
49 shouldExit = true;
50 }
51 }
52
53 class ShortLivedAllocationTask extends Exitable implements Runnable {
54 private Map<String, String> map = new HashMap<>();
55
56 @Override
57 public void run() {
58 map = new HashMap<>();
59 while (!shouldExit()) {
60 for (int i = 0; i < 200; i++) {
61 String key = "short" + " key = " + i;
62 String value = "the value is " + i;
63 map.put(key, value);
64 }
65 }
66 }
67 }
68
69 class LongLivedAllocationTask extends Exitable implements Runnable {
70 private Map<String, String> map;
71
72 LongLivedAllocationTask(Map<String, String> map) {
73 this.map = map;
74 }
75
76 @Override
77 public void run() {
78 while (!shouldExit()) {
79 String prefix = "long" + System.currentTimeMillis();
80 for (int i = 0; i < 10; i++) {
81 String key = prefix + " key = " + i;
82 String value = "the value is " + i;
83 map.put(key, value);
84 }
85 }
86 }
87 }
88
89 class SystemGCTask extends Exitable implements Runnable {
90 private long delayMS;
91
92 SystemGCTask(long delayMS) {
93 this.delayMS = delayMS;
94 }
95
96 @Override
97 public void run() {
98 while (!shouldExit()) {
99 System.gc();
100 ThreadUtils.sleep(delayMS);
101 }
102 }
103 }
104
105 public class TestSystemGC {
106 private static long endTime;
107
108 private static final int numGroups = 7;
109 private static final int numGCsPerGroup = 4;
110
111 private static Map<String, String> longLivedMap = new TreeMap<>();
112
113 private static void populateLongLived() {
114 for (int i = 0; i < 1000000; i++) {
115 String key = "all" + " key = " + i;
116 String value = "the value is " + i;
117 longLivedMap.put(key, value);
118 }
119 }
120
121 private static long getDelayMS(int group) {
122 if (group == 0) {
123 return 0;
124 }
125
126 int res = 16;
127 for (int i = 0; i < group; i++) {
128 res *= 2;
129 }
130 return res;
131 }
132
133 private static void doSystemGCs() {
134 ThreadUtils.sleep(1000);
135
136 for (int i = 0; i < numGroups; i++) {
137 for (int j = 0; j < numGCsPerGroup; j++) {
138 System.gc();
139 if (System.currentTimeMillis() >= endTime) {
140 return;
141 }
142 ThreadUtils.sleep(getDelayMS(i));
143 }
144 }
145 }
146
147 private static SystemGCTask createSystemGCTask(int group) {
148 long delay0 = getDelayMS(group);
149 long delay1 = getDelayMS(group + 1);
150 long delay = delay0 + (delay1 - delay0) / 2;
151 return new SystemGCTask(delay);
152 }
153
154 private static void startTask(Runnable task) {
155 if (task != null) {
156 new Thread(task).start();
157 }
158 }
159
160 private static void exitTask(Exitable task) {
161 if (task != null) {
162 task.exit();
163 }
164 }
165
166 private static void runAllPhases() {
167 for (int i = 0; i < 4 && System.currentTimeMillis() < endTime; i++) {
168 SystemGCTask gcTask =
169 (i % 2 == 1) ? createSystemGCTask(numGroups / 3) : null;
170 ShortLivedAllocationTask shortTask =
171 (i == 1 || i == 3) ? new ShortLivedAllocationTask() : null;
172 LongLivedAllocationTask longTask =
173 (i == 2 || i == 3) ? new LongLivedAllocationTask(longLivedMap) : null;
174
175 startTask(gcTask);
176 startTask(shortTask);
177 startTask(longTask);
178
179 doSystemGCs();
180
181 exitTask(gcTask);
182 exitTask(shortTask);
183 exitTask(longTask);
184
185 ThreadUtils.sleep(1000);
186 }
187 }
188
189 public static void main(String[] args) throws Exception {
190 if (args.length == 0) {
191 throw new IllegalArgumentException("Must specify timeout in seconds as first argument");
192 }
193 int timeout = Integer.parseInt(args[0]) * 1000;
194 System.out.println("Running with timeout of " + timeout + "ms");
195 endTime = System.currentTimeMillis() + timeout;
196 // First allocate the long lived objects and then run all phases.
197 populateLongLived();
198 runAllPhases();
199 }
200 }