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 final int numGroups = 7;
107 private static final int numGCsPerGroup = 4;
108
109 private static Map<String, String> longLivedMap = new TreeMap<>();
110
111 private static void populateLongLived() {
112 for (int i = 0; i < 1000000; i++) {
113 String key = "all" + " key = " + i;
114 String value = "the value is " + i;
115 longLivedMap.put(key, value);
116 }
117 }
118
119 private static long getDelayMS(int group) {
120 if (group == 0) {
121 return 0;
122 }
123
124 int res = 16;
125 for (int i = 0; i < group; i++) {
126 res *= 2;
127 }
128 return res;
129 }
130
131 private static void doSystemGCs() {
132 ThreadUtils.sleep(1000);
133
134 for (int i = 0; i < numGroups; i++) {
135 for (int j = 0; j < numGCsPerGroup; j++) {
136 System.gc();
137 ThreadUtils.sleep(getDelayMS(i));
138 }
139 }
140 }
141
142 private static SystemGCTask createSystemGCTask(int group) {
143 long delay0 = getDelayMS(group);
144 long delay1 = getDelayMS(group + 1);
145 long delay = delay0 + (delay1 - delay0) / 2;
146 return new SystemGCTask(delay);
147 }
148
149 private static void startTask(Runnable task) {
150 if (task != null) {
151 new Thread(task).start();
152 }
153 }
154
155 private static void exitTask(Exitable task) {
156 if (task != null) {
157 task.exit();
158 }
159 }
160
161 private static void runAllPhases() {
162 for (int i = 0; i < 4; i++) {
163 SystemGCTask gcTask =
164 (i % 2 == 1) ? createSystemGCTask(numGroups / 3) : null;
165 ShortLivedAllocationTask shortTask =
166 (i == 1 || i == 3) ? new ShortLivedAllocationTask() : null;
167 LongLivedAllocationTask longTask =
168 (i == 2 || i == 3) ? new LongLivedAllocationTask(longLivedMap) : null;
169
170 startTask(gcTask);
171 startTask(shortTask);
172 startTask(longTask);
173
174 doSystemGCs();
175
176 exitTask(gcTask);
177 exitTask(shortTask);
178 exitTask(longTask);
179
180 ThreadUtils.sleep(1000);
181 }
182 }
183
184 public static void main(String[] args) {
185 // First allocate the long lived objects and then run all phases.
186 populateLongLived();
187 runAllPhases();
188 if (args.length > 0 && args[0].equals("long")) {
189 runAllPhases();
190 }
191 }
192 }