1 /*
2 * Copyright (c) 2013, 2018, 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 package vm.runtime.defmeth;
25
26 import java.util.ArrayList;
27 import java.util.Arrays;
28 import java.util.List;
29 import java.util.Random;
30 import nsk.share.TestFailure;
31 import nsk.share.test.StressOptions;
32 import nsk.share.test.Stresser;
33 import vm.runtime.defmeth.shared.Constants;
34 import vm.runtime.defmeth.shared.DefMethTest;
35 import vm.runtime.defmeth.shared.ExecutionMode;
36 import vm.runtime.defmeth.shared.builder.TestBuilder;
37 import vm.share.options.Option;
38 import vm.share.options.OptionSupport;
39 import vm.share.options.Options;
40 import static jdk.internal.org.objectweb.asm.Opcodes.*;
41
42 /*
43 * Stress test for default methods implementation.
44 *
45 * Stress scenario is the following:
46 * - in multiple threads ...
47 * - ... continuously run random tests ...
48 * - ... in random configuration ...
49 * - ... until predefined period of time is over...
50 * - ... or any failures occured.
51 */
52 public class StressTest implements Runnable {
53 @Options
54 private StressOptions opts = new StressOptions();
55
56 @Option(name="seed", default_value="0", description="force deterministic behavior")
57 private int seed;
58
59 @Option(name="redefine", default_value="false", description="use scenarios w/ class redefinition")
60 private boolean doRedefine;
61
62 @Option(name="ver", default_value="49", description="minimum class file version to be used in the tests")
63 private int minMajorVer;
64
65 @Option(name="ignoreTestFailures", default_value="false", description="ignore failures of the executed tests")
66 private boolean ignoreTestFailures;
67
68 class Worker extends Thread {
69 private final Random rand;
70
71 private volatile DefMethTest failedTest;
72 private Throwable reason;
73 private volatile long executedTests = 0;
74
75 public Worker(String id, int seed) {
76 setName(id);
77 this.rand = new Random(seed);
78 }
79
80 @Override
81 public void run() {
82 while (!Thread.interrupted()) {
83 int idx = rand.nextInt(testlist.size());
84 DefMethTest test = testlist.get(idx);
85 try {
86 test.run();
87 executedTests++;
88 if (test.isFailed()) {
89 throw new TestFailure(test.toString());
90 }
91 } catch (Throwable e) {
92 if (!ignoreTestFailures) {
93 failedTest = test;
94 reason = e;
95 break;
96 }
97 }
98 }
99 }
100
101 public boolean isFailed() { return failedTest != null; }
102 public Throwable getReason() { return reason; }
103 public DefMethTest getFailedTest() { return failedTest; }
104 public long getExecutedTests() { return executedTests; }
105 }
106
107 private List<DefMethTest> testlist;
108
109 private Worker[] workers;
110
111 Stresser stresser;
112
113 public static void main(String[] args) {
114 StressTest test = new StressTest();
115 OptionSupport.setupAndRun(test, args);
116 }
117
118 @Override
119 public void run() {
120 configureTests();
121 startWorkers();
122
123 stresser = new Stresser(opts);
124 try {
125 stresser.start(0);
126 while (workersAlive() && stresser.continueExecution()) {
127 printStats();
128
129 try {
130 Thread.sleep(1000);
131 } catch (InterruptedException ex) {}
132 }
133 } finally {
134 interruptWorkers();
135 joinWorkers();
136
137 stresser.finish();
138 }
139 }
140
141 private void configureTests() {
142 int[] majorVerValues = new int[52 - minMajorVer + 1];
143 for (int i = 0; i< majorVerValues.length; i++) {
144 majorVerValues[i] = minMajorVer + i;
145 }
146
147 int[] flagsValues = new int[] {
148 0,
149 ACC_STRICT,
150 ACC_SYNCHRONIZED,
151 ACC_STRICT | ACC_SYNCHRONIZED
152 };
153
154 boolean[] doRedefineValues;
155 if (doRedefine) {
156 doRedefineValues = new boolean[] { true, false};
157 } else {
158 doRedefineValues = new boolean[] { false };
159 }
160
161 // Upper limit for test count
162 int testCount = DefMethTest.getTests().size() * majorVerValues.length
163 * flagsValues.length * doRedefineValues.length;
164
165 testlist = new ArrayList<>(testCount);
166
167 // Enumerate all tests in all possible modes
168 for (Class<? extends DefMethTest> testClass : DefMethTest.getTests()) {
169 for (ExecutionMode mode : ExecutionMode.values()) {
170 // Skip REDEFINITION execmode, the top README file indicates that it isn't a
171 // valid execution mode and there's also no code supporting this in the test generator.
172 if ("REDEFINITION".equals(mode.toString())) {
173 continue;
174 }
175
176 for (int majorVer : majorVerValues) {
177 for (int flags : flagsValues ) {
178 for (boolean redefine : doRedefineValues) {
179 // RedefineTest isn't applicable to reflection-based execution scenario (REDEFINE & INVOKE_WITH_ARGS)
180 if (testClass == RedefineTest.class && mode.isReflectionBased()) {
181 continue;
182 }
183
184 // Only run the RedefineTest tests when redefining
185 if (!redefine && testClass == RedefineTest.class) {
186 continue;
187 }
188
189 try {
190 DefMethTest test = testClass.newInstance();
191
192 OptionSupport.setup(test, new String[] {
193 "-execMode", mode.toString(),
194 "-ver", Integer.toString(majorVer),
195 "-flags", Integer.toString(flags),
196 "-redefine", Boolean.toString(redefine),
197 "-ignoreCrashes",
198 "-ignoreKnownFailures",
199 "-silent",
200 "-failfast"});
201
202 testlist.add(test);
203 } catch (InstantiationException | IllegalAccessException ex) {
204 throw new TestFailure(ex);
205 }
206 }
207 }
208 }
209 }
210 }
211
212 System.out.printf("Testlist size: %d\n", testlist.size());
213 }
214
215 private void startWorkers() {
216 Random rand;
217 if (seed == 0) {
218 seed = (new Random()).nextInt();
219 }
220
221 System.out.printf("Seed: %d\n", seed);
222 rand = new Random(seed);
223
224 //Workaround for the deadlock caused by
225 // JDK-7122142: "(ann) Race condition between isAnnotationPresent and getAnnotations"
226 try {
227 // Do a warm-up cycle
228 for (Class<? extends DefMethTest> testClass : DefMethTest.getTests()) {
229 DefMethTest test = testClass.newInstance();
230
231 OptionSupport.setupAndRun(test,
232 new String[] { "-silent", "-ignoreKnownFailures"});
233 }
234 } catch(InstantiationException | IllegalAccessException e) {
235 throw new RuntimeException(e);
236 }
237
238 int threadsCount = opts.getThreadsFactor();
239 if (threadsCount == 1) {
240 threadsCount = 5;
241 }
242
243 workers = new Worker[threadsCount];
244
245 System.out.printf("Spawning %d workers...\n", workers.length);
246
247 for (int i = 0; i < workers.length; i++) {
248 workers[i] = new Worker(
249 String.format("Worker #%d/%d", i+1, workers.length),
250 rand.nextInt());
251 }
252
253 for (Worker worker : workers) {
254 worker.start();
255 }
256 }
257
258 private void interruptWorkers() {
259 for (Worker worker : workers) {
260 worker.interrupt();
261 }
262 }
263
264 private void joinWorkers() {
265 boolean isFailed = false;
266
267 for (Worker worker : workers) {
268 while (worker.isAlive()) {
269 try {
270 worker.join();
271 } catch (InterruptedException e) {}
272 }
273
274 System.out.printf("%s: %s (executed: %d)\n",
275 worker.getName(),
276 worker.isFailed() ? "FAILED: " + worker.getFailedTest() : "PASSED",
277 worker.getExecutedTests());
278
279 if (worker.isFailed()) {
280 if (Constants.PRINT_STACK_TRACE) {
281 worker.getReason().printStackTrace();
282 }
283
284 isFailed = true;
285 }
286 }
287
288 if (isFailed) {
289 throw new TestFailure("Some of the worker threads failed.");
290 }
291 }
292
293 private boolean workersAlive() {
294 for (Worker worker : workers) {
295 if (!worker.isAlive()) {
296 return false;
297 }
298 }
299
300 return true;
301 }
302
303 private void printStats() {
304 long[] counts = new long[workers.length];
305 for (int i = 0; i < counts.length; i++) {
306 counts[i] = workers[i].executedTests;
307 }
308
309 StringBuilder msg = new StringBuilder();
310 msg.append(stresser.getTimeLeft() / 1000).append("s left: ");
311 msg.append(Arrays.toString(counts));
312
313 System.out.println(msg);
314 }
315 }