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
25 // Stress the GC locker by calling GetPrimitiveArrayCritical while
26 // concurrently filling up old gen.
27
28 import java.lang.management.MemoryPoolMXBean;
29 import java.lang.management.ManagementFactory;
30 import java.lang.management.MemoryUsage;
31 import java.nio.ByteBuffer;
32 import java.util.ArrayDeque;
33 import java.util.HashMap;
34 import java.util.List;
35 import java.util.Map;
36 import java.util.Queue;
37
38 final class ThreadUtils {
39 public static void sleep(long durationMS) {
40 try {
41 Thread.sleep(durationMS);
42 } catch (Exception e) {
43 }
44 }
45 }
46
47 class Filler {
48 private static final int SIZE = 250000;
49
50 private int[] i1 = new int[SIZE];
51 private int[] i2 = new int[SIZE];
52 private short[] s1 = new short[SIZE];
53 private short[] s2 = new short[SIZE];
54
55 private Map<Object, Object> map = new HashMap<>();
56
57 public Filler() {
58 for (int i = 0; i < 10000; i++) {
59 map.put(new Object(), new Object());
60 }
61 }
62 }
63
64 class Exitable {
65 private volatile boolean shouldExit = false;
66
67 protected boolean shouldExit() {
68 return shouldExit;
69 }
70
71 public void exit() {
72 shouldExit = true;
73 }
74 }
75
76 class MemoryWatcher {
77 private MemoryPoolMXBean bean;
78 private final int thresholdPromille = 750;
79 private final int criticalThresholdPromille = 800;
80 private final int minGCWaitMS = 1000;
81 private final int minFreeWaitElapsedMS = 30000;
82 private final int minFreeCriticalWaitMS = 500;
83
84 private int lastUsage = 0;
85 private long lastGCDetected = System.currentTimeMillis();
86 private long lastFree = System.currentTimeMillis();
87
88 public MemoryWatcher(String mxBeanName) {
89 List<MemoryPoolMXBean> memoryBeans = ManagementFactory.getMemoryPoolMXBeans();
90 for (MemoryPoolMXBean bean : memoryBeans) {
91 if (bean.getName().equals(mxBeanName)) {
92 this.bean = bean;
93 break;
94 }
95 }
96 }
97
98 private int getMemoryUsage() {
99 if (bean == null) {
100 Runtime r = Runtime.getRuntime();
101 float free = (float) r.freeMemory() / r.maxMemory();
102 return Math.round((1 - free) * 1000);
103 } else {
104 MemoryUsage usage = bean.getUsage();
105 float used = (float) usage.getUsed() / usage.getCommitted();
106 return Math.round(used * 1000);
107 }
108 }
109
110 public synchronized boolean shouldFreeUpSpace() {
111 int usage = getMemoryUsage();
112 long now = System.currentTimeMillis();
113
114 boolean detectedGC = false;
115 if (usage < lastUsage) {
116 lastGCDetected = now;
117 detectedGC = true;
118 }
119
120 lastUsage = usage;
121
122 long elapsed = now - lastFree;
123 long timeSinceLastGC = now - lastGCDetected;
124
125 if (usage > criticalThresholdPromille && elapsed > minFreeCriticalWaitMS) {
126 lastFree = now;
127 return true;
128 } else if (usage > thresholdPromille && !detectedGC) {
129 if (elapsed > minFreeWaitElapsedMS || timeSinceLastGC > minGCWaitMS) {
130 lastFree = now;
131 return true;
132 }
133 }
134
135 return false;
136 }
137 }
138
139 class MemoryUser extends Exitable implements Runnable {
140 private final Queue<Filler> cache = new ArrayDeque<Filler>();
141 private final MemoryWatcher watcher;
142
143 private void load() {
144 if (watcher.shouldFreeUpSpace()) {
145 int toRemove = cache.size() / 5;
146 for (int i = 0; i < toRemove; i++) {
147 cache.remove();
148 }
149 }
150 cache.add(new Filler());
151 }
152
153 public MemoryUser(String mxBeanName) {
154 watcher = new MemoryWatcher(mxBeanName);
155 }
156
157 @Override
158 public void run() {
159 for (int i = 0; i < 200; i++) {
160 load();
161 }
162
163 while (!shouldExit()) {
164 load();
165 }
166 }
167 }
168
169 class GCLockerStresser extends Exitable implements Runnable {
170 static native void fillWithRandomValues(byte[] array);
171
172 @Override
173 public void run() {
174 byte[] array = new byte[1024 * 1024];
175 while (!shouldExit()) {
176 fillWithRandomValues(array);
177 }
178 }
179 }
180
181 public class TestGCLocker {
182 private static Exitable startGCLockerStresser(String name) {
183 GCLockerStresser task = new GCLockerStresser();
184
185 Thread thread = new Thread(task);
186 thread.setName(name);
187 thread.setPriority(Thread.MIN_PRIORITY);
188 thread.start();
189
190 return task;
191 }
192
193 private static Exitable startMemoryUser(String mxBeanName) {
194 MemoryUser task = new MemoryUser(mxBeanName);
195
196 Thread thread = new Thread(task);
197 thread.setName("Memory User");
198 thread.start();
199
200 return task;
201 }
202
203 public static void main(String[] args) {
204 System.loadLibrary("TestGCLocker");
205
206 long durationMinutes = args.length > 0 ? Long.parseLong(args[0]) : 5;
207 String mxBeanName = args.length > 1 ? args[1] : null;
208
209 long startMS = System.currentTimeMillis();
210
211 Exitable stresser1 = startGCLockerStresser("GCLockerStresser1");
212 Exitable stresser2 = startGCLockerStresser("GCLockerStresser2");
213 Exitable memoryUser = startMemoryUser(mxBeanName);
214
215 long durationMS = durationMinutes * 60 * 1000;
216 while ((System.currentTimeMillis() - startMS) < durationMS) {
217 ThreadUtils.sleep(10 * 1010);
218 }
219
220 stresser1.exit();
221 stresser2.exit();
222 memoryUser.exit();
223 }
224 }