< prev index next >
test/testlibrary/jittester/src/jdk/test/lib/jittester/Automatic.java
Print this page
@@ -21,129 +21,169 @@
* questions.
*/
package jdk.test.lib.jittester;
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import jdk.test.lib.jittester.IRNode;
-import jdk.test.lib.jittester.ProductionParams;
-import jdk.test.lib.jittester.SymbolTable;
-import jdk.test.lib.jittester.TypeList;
+import jdk.test.lib.Pair;
import jdk.test.lib.jittester.factories.IRNodeBuilder;
-import jdk.test.lib.jittester.TypesParser;
+import jdk.test.lib.jittester.jtreg.Printer;
import jdk.test.lib.jittester.types.TypeKlass;
-import jdk.test.lib.jittester.visitors.JavaCodeVisitor;
+import jdk.test.lib.jittester.utils.FixedTrees;
import jdk.test.lib.jittester.utils.OptionResolver;
import jdk.test.lib.jittester.utils.OptionResolver.Option;
import jdk.test.lib.jittester.utils.PseudoRandom;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalTime;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
public class Automatic {
- public static final int minutesToWait = 3;
+ private static final int MINUTES_TO_WAIT = Integer.getInteger("jdk.test.lib.jittester", 3);
+
+ static String getJtregHeader(String mainClass, boolean addCompile) {
+ String synopsis = "seed = '" + ProductionParams.seed.value() + "'"
+ + ", specificSeed = '" + PseudoRandom.getCurrentSeed() + "'";
+ StringBuilder header = new StringBuilder();
+ header.append("/*\n * @test\n * @summary ")
+ .append(synopsis)
+ .append(" \n* @library / ../\n");
+ if (addCompile) {
+ header.append("\n * @compile ")
+ .append(mainClass)
+ .append(".java\n");
+ }
+ header.append(" * @run build jdk.test.lib.jittester.jtreg.JitTesterDriver "
+ + "jdk.test.lib.jittester.jtreg.Printer\n")
+ .append(" * @run driver jdk.test.lib.jittester.jtreg.JitTesterDriver ")
+ .append(mainClass)
+ .append("\n */\n\n");
+ if (ProductionParams.printHierarchy.value()) {
+ header.append("/*\n")
+ .append(Automatic.printHierarchy())
+ .append("*/\n");
+ }
+ return header.toString();
+ }
- private static String makeTestCase(String name) {
+ private static Pair<IRNode, IRNode> generateIRTree(String name) {
SymbolTable.removeAll();
TypeList.removeAll();
- StringBuilder resultVis = new StringBuilder();
- StringBuilder headerBuilder = new StringBuilder();
- try {
+
IRNodeBuilder builder = new IRNodeBuilder()
.setPrefix(name)
.setName(name)
.setLevel(0);
- JavaCodeVisitor vis = new JavaCodeVisitor();
- String synopsis = "seed = '" + ProductionParams.seed.value() + "'";
- String pathPrefix = ProductionParams.testbaseDir.value()
- .replaceAll("([^/]+)", "..");
- headerBuilder
- .append("/*\n")
- .append(" * @test\n")
- .append(" * @summary ")
- .append(synopsis)
- .append("\n")
- .append(" * @compile ")
- .append(name)
- .append(".java\n")
- .append(" * @run build jdk.test.lib.jittester.jtreg.JitTesterDriver\n")
- .append(" * @run driver jdk.test.lib.jittester.jtreg.JitTesterDriver ")
- .append(name)
- .append("\n")
- .append(" */\n\n");
-
-
+ Long complexityLimit = ProductionParams.complexityLimit.value();
+ IRNode privateClasses = null;
if (!ProductionParams.disableClasses.value()) {
- long comlexityLimit = (long) (ProductionParams.complexityLimit.value()
- * PseudoRandom.random());
- IRNode privateClasses = builder.setComplexityLimit(comlexityLimit)
+ long privateClassComlexity = (long) (complexityLimit * PseudoRandom.random());
+ try {
+ privateClasses = builder.setComplexityLimit(privateClassComlexity)
.getClassDefinitionBlockFactory()
.produce();
- if (privateClasses != null) {
- resultVis.append(privateClasses.accept(vis));
+ } catch (ProductionFailedException ex) {
+ ex.printStackTrace(System.out);
}
}
- long mainComplexityLimit = (long) (ProductionParams.complexityLimit.value()
- * PseudoRandom.random());
- IRNode mainClass = builder.setComplexityLimit(mainComplexityLimit)
+ long mainClassComplexity = (long) (complexityLimit * PseudoRandom.random());
+ IRNode mainClass = null;
+ try {
+ mainClass = builder.setComplexityLimit(mainClassComplexity)
.getMainKlassFactory()
.produce();
- resultVis.append(mainClass.accept(vis));
-
- if (ProductionParams.printHierarchy.value()) {
- headerBuilder
- .append("/*\n")
- .append(Automatic.printHierarchy())
- .append("*/\n");
+ TypeKlass aClass = new TypeKlass(name);
+ mainClass.getChild(1).addChild(FixedTrees.generateMainOrExecuteMethod(aClass, true));
+ mainClass.getChild(1).addChild(FixedTrees.generateMainOrExecuteMethod(aClass, false));
+ } catch (ProductionFailedException ex) {
+ ex.printStackTrace(System.out);
}
- } catch (Exception e) {
- e.printStackTrace(System.out);
- }
- return headerBuilder.append(resultVis).toString();
+ return new Pair<>(mainClass, privateClasses);
}
private static void initializeTestGenerator(String[] params) {
OptionResolver parser = new OptionResolver();
- Option<String> propertyFileOpt = parser.addStringOption('p', "property-file", "",
- "File to read properties from");
+ Option<String> propertyFileOpt = parser.addStringOption('p', "property-file",
+ "conf/default.properties", "File to read properties from");
ProductionParams.register(parser);
parser.parse(params, propertyFileOpt);
- jdk.test.lib.jittester.utils.PseudoRandom.reset(ProductionParams.seed.value());
- TypesParser.parseTypesAndMethods(ProductionParams.classesFile.value(), ProductionParams.excludeMethodsFile.value());
+ PseudoRandom.reset(ProductionParams.seed.value());
+ TypesParser.parseTypesAndMethods(ProductionParams.classesFile.value(),
+ ProductionParams.excludeMethodsFile.value());
+ if (ProductionParams.specificSeed.isSet()) {
+ PseudoRandom.setCurrentSeed(ProductionParams.specificSeed.value());
+ }
}
public static void main(String[] args) {
initializeTestGenerator(args);
int counter = 0;
try {
- String testbaseDir = ProductionParams.testbaseDir.value();
+ Path testbaseDir = Paths.get(ProductionParams.testbaseDir.value());
+ System.out.printf(" %13s | %8s | %8s | %8s |%n", "start time", "count", "generat",
+ "running");
+ System.out.printf(" %13s | %8s | %8s | %8s |%n", "---", "---", "---","---");
+ String path = getJavaPath();
+ String javacPath = Paths.get(path, "javac").toString();
+ String javaPath = Paths.get(path, "java").toString();
+
+ // compile Printer class first. A common one for all tests
+ ensureExisting(testbaseDir);
+ ProcessBuilder pbPrinter = new ProcessBuilder(javacPath,
+ Paths.get(testbaseDir.toString(), "jdk", "test", "lib", "jittester",
+ "jtreg", "Printer.java").toString());
+ runProcess(pbPrinter, testbaseDir.resolve("Printer").toString());
do {
double start = System.currentTimeMillis();
+ System.out.print("[" + LocalTime.now() + "] |");
String name = "Test_" + counter;
- generateTestFile(name);
+ Pair<IRNode, IRNode> irTree = generateIRTree(name);
+ System.out.printf(" %8d |", counter);
double generationTime = System.currentTimeMillis() - start;
- String path = getJavaPath();
- ProcessBuilder pb = new ProcessBuilder(path + "javac", testbaseDir + "/" + name + ".java");
- runProcess(pb, testbaseDir + "/" + name);
+ System.out.printf(" %8.0f |", generationTime);
+ if (!ProductionParams.disableJavacodeGeneration.value()) {
+ JavaCodeGenerator generator = new JavaCodeGenerator();
+ String javaFile = generator.apply(irTree.first, irTree.second);
+ ProcessBuilder pb = new ProcessBuilder(javacPath, "-cp", testbaseDir.toString()
+ + ":" + generator.getTestbase().toString(), javaFile);
+ runProcess(pb, generator.getTestbase().resolve(name).toString());
+ start = System.currentTimeMillis();
+ // Run compiled class files
+ pb = new ProcessBuilder(javaPath, "-Xint", "-cp", testbaseDir.toString()
+ + ":" + generator.getTestbase().toString(), name);
+ String goldFile = name + ".gold";
+ runProcess(pb, generator.getTestbase().resolve(goldFile).toString());
+ }
+
+ if (!ProductionParams.disableBytecodeGeneration.value()) {
+ ByteCodeGenerator generator = new ByteCodeGenerator();
+ generator.apply(irTree.first, irTree.second);
+ generator.writeJtregBytecodeRunner(name);
+ // Run generated bytecode
+ ProcessBuilder pb = new ProcessBuilder(javaPath, "-Xint", "-Xverify", "-cp",
+ testbaseDir.toString() + ":" + generator.getTestbase().toString(),
+ name);
+ String goldFile = name + ".gold";
start = System.currentTimeMillis();
- pb = new ProcessBuilder(path + "java", "-Xint", "-cp", testbaseDir, name);
- name = name + ".gold";
- runProcess(pb, testbaseDir + "/" + name);
+ runProcess(pb, generator.getTestbase().resolve(goldFile).toString());
+ }
+
double runningTime = System.currentTimeMillis() - start;
- System.out.printf("%4d : generation time (ms) : %8.0f running time (ms) : %8.0f\n",
- counter, generationTime, runningTime);
- if (runningTime < TimeUnit.MINUTES.toMillis(minutesToWait))
+ System.out.printf(" %8.0f |%n", runningTime);
+ if (runningTime < TimeUnit.MINUTES.toMillis(MINUTES_TO_WAIT)) {
++counter;
+ }
} while (counter < ProductionParams.numberOfTests.value());
} catch (IOException | InterruptedException ex) {
- Logger.getLogger(Automatic.class.getName()).log(Level.SEVERE, null, ex);
+ ex.printStackTrace();
}
}
private static String getJavaPath() {
String[] env = { "JDK_HOME", "JAVA_HOME", "BOOTDIR" };
@@ -154,67 +194,49 @@
}
}
return "";
}
- private static void runProcess(ProcessBuilder pb, String name)
+ private static int runProcess(ProcessBuilder pb, String name)
throws IOException, InterruptedException {
pb.redirectError(new File(name + ".err"));
pb.redirectOutput(new File(name + ".out"));
Process process = pb.start();
- if (process.waitFor(minutesToWait, TimeUnit.MINUTES)) {
+ if (process.waitFor(MINUTES_TO_WAIT, TimeUnit.MINUTES)) {
try (FileWriter file = new FileWriter(name + ".exit")) {
file.write(Integer.toString(process.exitValue()));
}
+ return process.exitValue();
} else {
process.destroyForcibly();
- }
- TimeUnit.MILLISECONDS.sleep(300);
- }
-
- private static void generateTestFile(String testName) {
- String code = makeTestCase(testName);
- String testbaseDir = ProductionParams.testbaseDir.value();
- String fileName = testbaseDir + "/" + testName + ".java";
- try (FileWriter file = new FileWriter(fileName)) {
- file.write(code);
- //file.close();
- } catch (IOException ex) {
- Logger.getLogger(Automatic.class.getName())
- .log(Level.SEVERE, " Cannot write to file " + fileName, ex);
+ return -1;
}
}
private static String printHierarchy() {
- String r = "CLASS HIERARCHY:\n";
- for (Type t : TypeList.getAll()) {
- if (t instanceof TypeKlass) {
- TypeKlass k = (TypeKlass) t;
- if (k.isAbstract()) {
- r += "abstract ";
- }
- if (k.isFinal()) {
- r += "final ";
- }
- if (k.isInterface()) {
- r += "interface ";
- } else {
- r += "class ";
+ return TypeList.getAll().stream()
+ .filter(t -> t instanceof TypeKlass)
+ .map(t -> typeDescription((TypeKlass) t))
+ .collect(Collectors.joining("\n","CLASS HIERARCHY:\n", "\n"));
+ }
+
+ private static String typeDescription(TypeKlass type) {
+ StringBuilder result = new StringBuilder();
+ String parents = type.getParentsNames().stream().collect(Collectors.joining(","));
+ result.append(type.isAbstract() ? "abstract " : "")
+ .append(type.isFinal() ? "final " : "")
+ .append(type.isInterface() ? "interface " : "class ")
+ .append(type.getName())
+ .append(parents.isEmpty() ? "" : ": " + parents);
+ return result.toString();
}
- r += k.getName() + ": ";
- HashSet<String> parents = k.getParentsNames();
- if (parents != null) {
- Iterator<String> n = parents.iterator();
- int size = parents.size();
- for (int i = 0; n.hasNext() && i < size - 1; i++) {
- r += n.next() + ", ";
- }
- if (n.hasNext()) {
- r += n.next();
- }
- }
- r += "\n";
+
+ static void ensureExisting(Path path) {
+ if (Files.notExists(path)) {
+ try {
+ Files.createDirectories(path);
+ } catch (IOException ex) {
+ ex.printStackTrace();
}
}
- return r;
}
}
< prev index next >