1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
/*
* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
/**
* An abstract superclass for threaded tests.
*
* This class will try to read a property named test.concurrency.
* The property can be provided by passing this option to jtreg:
* -javaoption:-Dtest.concurrency=#
*
* If the property is not set the class will use a heuristic to determine the
* maximum number of threads that can be fired to execute a given test.
*
* This code will have to be revisited if jprt starts using concurrency for
* for running jtreg tests.
*/
public abstract class JavacTestingAbstractThreadedTest {
protected static AtomicInteger numberOfThreads = new AtomicInteger();
protected static int getThreadPoolSize() {
Integer testConc = Integer.getInteger("test.concurrency");
if (testConc != null) return testConc;
int cores = Runtime.getRuntime().availableProcessors();
numberOfThreads.set(Math.max(2, Math.min(8, cores / 2)));
return numberOfThreads.get();
}
protected static void checkAfterExec() throws InterruptedException {
checkAfterExec(true);
};
protected static boolean throwAssertionOnError = true;
protected static boolean printAll = false;
protected static StringWriter errSWriter = new StringWriter();
protected static PrintWriter errWriter = new PrintWriter(errSWriter);
protected static StringWriter outSWriter = new StringWriter();
protected static PrintWriter outWriter = new PrintWriter(outSWriter);
protected static void checkAfterExec(boolean printCheckCount)
throws InterruptedException {
pool.shutdown();
pool.awaitTermination(15, TimeUnit.MINUTES);
if (errCount.get() > 0) {
if (throwAssertionOnError) {
closePrinters();
System.err.println(errSWriter.toString());
throw new AssertionError(
String.format("%d errors found", errCount.get()));
} else {
System.err.println(
String.format("%d errors found", errCount.get()));
}
} else if (printCheckCount) {
outWriter.println("Total check executed: " + checkCount.get());
}
/*
* This output is for supporting debugging. It does not mean that a given
* test had executed that number of threads concurrently. The value printed
* here is the maximum possible amount.
*/
closePrinters();
if (printAll) {
System.out.println(errSWriter.toString());
System.out.println(outSWriter.toString());
}
System.out.println("Total number of threads in thread pool: " +
numberOfThreads.get());
}
protected static void closePrinters() {
errWriter.close();
outWriter.close();
}
protected static void processException(Throwable t) {
errCount.incrementAndGet();
t.printStackTrace(errWriter);
pool.shutdown();
}
//number of checks executed
protected static AtomicInteger checkCount = new AtomicInteger();
//number of errors found while running combo tests
protected static AtomicInteger errCount = new AtomicInteger();
//create default shared JavaCompiler - reused across multiple compilations
protected static JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
protected static ExecutorService pool = Executors.newFixedThreadPool(
getThreadPoolSize(), new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
@Override
public void uncaughtException(Thread t, Throwable e) {
pool.shutdown();
errCount.incrementAndGet();
e.printStackTrace(System.err);
}
});
return t;
}
});
/*
* File manager is not thread-safe so it cannot be re-used across multiple
* threads. However we cache per-thread FileManager to avoid excessive
* object creation
*/
protected static final ThreadLocal<StandardJavaFileManager> fm =
new ThreadLocal<StandardJavaFileManager>() {
@Override protected StandardJavaFileManager initialValue() {
return comp.getStandardFileManager(null, null, null);
}
};
}
|
