diff --git a/.gitignore b/.gitignore index 05b4d5e23ac3c7611f15483aec6906994a936755..6804809b49e243976cc8f3c62cbfff8eef54d6cb 100644 --- a/.gitignore +++ b/.gitignore @@ -49,6 +49,7 @@ replay_*.log ~*.* *.~* +jastadd-gen/ xtend-gen/ neo4j-server/ out/ diff --git a/trainbenchmark/settings.gradle b/trainbenchmark/settings.gradle index 32529737319d3d52690c34fdc9c6ee0c1064401d..a3cac02a11c170f6d4f7f7807285023a50aa76d2 100644 --- a/trainbenchmark/settings.gradle +++ b/trainbenchmark/settings.gradle @@ -1,32 +1,18 @@ -//ViatraBackendrootProject.name = 'trainbenchmark' include ':trainbenchmark-config' include ':trainbenchmark-format-emf' include ':trainbenchmark-format-emf-model' -//include ':trainbenchmark-format-graph-neo4j' -//include ':trainbenchmark-format-rdf' -//include ':trainbenchmark-format-sql' include ':trainbenchmark-generator' include ':trainbenchmark-generator-emf' -//include ':trainbenchmark-generator-graph-cypher' -//include ':trainbenchmark-generator-graph-neo4j' include ':trainbenchmark-generator-graph-tinkerpop' -//include ':trainbenchmark-generator-rdf' -//include ':trainbenchmark-generator-sql' include ':trainbenchmark-generator-json4ag' include ':trainbenchmark-generator-json4ag-special' +include ':trainbenchmark-generator-relast' include ':trainbenchmark-generator-dot' include ':trainbenchmark-reporting' include ':trainbenchmark-scripts' include ':trainbenchmark-server' include ':trainbenchmark-tool' -//include ':trainbenchmark-tool-blazegraph' -//include ':trainbenchmark-tool-drools' -//include ':trainbenchmark-tool-eclipseocl' include ':trainbenchmark-tool-emf' -//include ':trainbenchmark-tool-emfapi' -//include ':trainbenchmark-tool-epsilon' -//include ':trainbenchmark-tool-ingraph' -//include ':trainbenchmark-tool-ingraph-query-plans' include ':trainbenchmark-tool-jastadd-base' include ':trainbenchmark-tool-jastadd-namelookup' include ':trainbenchmark-tool-jastadd-namelookup-base' @@ -35,21 +21,10 @@ include ':trainbenchmark-tool-jastadd-optimized' include ':trainbenchmark-tool-jastadd-optimized-base' include ':trainbenchmark-tool-jastadd-optimized-incremental' include ':trainbenchmark-tool-jastadd-specialized' +include ':trainbenchmark-tool-jastadd-relast' include ':trainbenchmark-tool-jastadd-specialized-base' include ':trainbenchmark-tool-jastadd-specialized-incremental' -//include ':trainbenchmark-tool-kiama' -//include ':trainbenchmark-tool-racr' -//include ':trainbenchmark-tool-racr-python' -//include ':trainbenchmark-tool-racr-scheme' -//include ':trainbenchmark-tool-racr-cpp' -//include ':trainbenchmark-tool-jena' -//include ':trainbenchmark-tool-mysql' -//include ':trainbenchmark-tool-neo4j' -//include ':trainbenchmark-tool-rdf' -//include ':trainbenchmark-tool-rdf4j' -//include ':trainbenchmark-tool-sesame' -//include ':trainbenchmark-tool-sql' -//include ':trainbenchmark-tool-sqlite' +include ':trainbenchmark-tool-jastadd-relast-incremental' include ':trainbenchmark-tool-tinkergraph' include ':trainbenchmark-tool-viatra' include ':trainbenchmark-tool-viatra-patterns' diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/.editorconfig b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/.editorconfig new file mode 100644 index 0000000000000000000000000000000000000000..5b0ed0442155d26acd0e00a7c141a2b352c140ad --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/.editorconfig @@ -0,0 +1,28 @@ +root = true + +[*.java] +charset = utf-8 +end_of_line = lf +indent_size = 2 +indent_style = space +insert_final_newline = true +max_line_length = 140 +trim_trailing_whitespace = true + +[*.jadd] +charset = utf-8 +end_of_line = lf +indent_size = 2 +indent_style = space +insert_final_newline = true +max_line_length = 140 +trim_trailing_whitespace = true + +[*.jrag] +charset = utf-8 +end_of_line = lf +indent_size = 2 +indent_style = space +insert_final_newline = true +max_line_length = 140 +trim_trailing_whitespace = true diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/build.gradle b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/build.gradle new file mode 100644 index 0000000000000000000000000000000000000000..6f12751f4343e084ac2100d1a99ac2f3083d9334 --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/build.gradle @@ -0,0 +1,77 @@ +plugins { id "com.github.johnrengelman.shadow" version "1.2.3" } + +shadowJar { + classifier = 'fat' + manifest { attributes 'Main-Class': 'de.tudresden.inf.st.train.jastadd.JastaddBenchmarkMain' } +} + +task preprocess(type: JavaExec) { + doFirst { + delete fileTree('src/main/jastadd-gen') + } + group = 'Build' + main = "-jar" + args = [ + "../trainbenchmark-tool-jastadd-base/libs/relast-compiler.jar", + "../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/Train.relast", + "--listClass=RefList", + "--serializer=jackson", + "--grammarName=src/main/jastadd-gen/Train", + "--file" + ] +} + +task jastadd(type: JavaExec) { + group = 'Build' + main = "-jar" + args = [ + "../trainbenchmark-tool-jastadd-base/libs/jastadd2.jar", + "--cache=all", + "--flush=full", + "--incremental=param", + "--rewrite=cnta", + "--package=de.tudresden.inf.st.train.jastadd.ast", + "--o=src/main/java-gen", + "--tracing=api", + ] + fileTree("../trainbenchmark-tool-jastadd-base/src/main/jastadd/") + fileTree("src/main/jastadd-gen/") + fileTree("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/").matching {exclude "*.relast"} + doFirst { + delete fileTree('src/main/java-gen') + } + doLast { + ant.replaceregexp(match:'RefList extends List', replace:'RefList<T extends ASTNode> extends List<T>', flags:'g', byline:true) { + fileset(dir: 'src/main/java-gen/de/tudresden/inf/st/train/jastadd/ast', includes: 'RefList.java') + } + } + + inputs.files fileTree("../trainbenchmark-tool-jastadd-base/src/main/jastadd/") + fileTree("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/") + fileTree("src/main/jastadd-gen/") + outputs.files file("src/main/java-gen") +} + +sourceSets { + main { + java { + srcDir 'src/main/java' + srcDir 'src/main/java-gen' + srcDir '../trainbenchmark-tool-jastadd-base/src/main/java' + srcDir '../trainbenchmark-tool-jastadd-specialized-base/src/main/java' + } + } +} + +clean { + delete fileTree('src/main/java-gen') +} + +dependencies { + compile project(':trainbenchmark-tool') + compile project(':trainbenchmark-tool-jastadd-base') + compile project(':trainbenchmark-tool-jastadd-specialized-base') + compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.8.8.1' +} + +test { + outputs.upToDateWhen { false } +} + +jastadd.dependsOn preprocess +compileJava.dependsOn jastadd \ No newline at end of file diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java-gen/.gitignore b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java-gen/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..d6b7ef32c8478a48c3994dcadc86837f4371184d --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java-gen/.gitignore @@ -0,0 +1,2 @@ +* +!.gitignore diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/JastaddBenchmarkMain.java b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/JastaddBenchmarkMain.java new file mode 100644 index 0000000000000000000000000000000000000000..c17cbc9a495056eace5c8fa80a68f9425b641eed --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/JastaddBenchmarkMain.java @@ -0,0 +1,13 @@ +package de.tudresden.inf.st.train.jastadd; + +import de.tudresden.inf.st.train.jastadd.config.JastaddRelASTBenchmarkConfig; +import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfig; + +public class JastaddBenchmarkMain { + public static void main(final String[] args) throws Exception { + final JastaddRelASTBenchmarkConfig bc = BenchmarkConfig.fromFile(args[0], JastaddRelASTBenchmarkConfig.class); + final JastaddRelASTBenchmarkScenario scenario = new JastaddRelASTBenchmarkScenario(bc); + scenario.performBenchmark(); + scenario.printTraces(); + } +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/JastaddRelASTBenchmarkScenario.java b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/JastaddRelASTBenchmarkScenario.java new file mode 100644 index 0000000000000000000000000000000000000000..0fc13c828070faea0d08f6bd76bbf1c4c0aabbe2 --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/JastaddRelASTBenchmarkScenario.java @@ -0,0 +1,12 @@ +package de.tudresden.inf.st.train.jastadd; + +import de.tudresden.inf.st.train.jastadd.config.JastaddRelASTBenchmarkConfig; + +public class JastaddRelASTBenchmarkScenario extends + JastaddAbstractBenchmarkScenario<JastaddRelASTBenchmarkConfig> { + + public JastaddRelASTBenchmarkScenario(final JastaddRelASTBenchmarkConfig bc) throws Exception { + super(bc, true); + } + +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/config/JastaddRelASTBenchmarkConfig.java b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/config/JastaddRelASTBenchmarkConfig.java new file mode 100644 index 0000000000000000000000000000000000000000..f1f89ec2df1c5223634b25513c1d3b226862864b --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/config/JastaddRelASTBenchmarkConfig.java @@ -0,0 +1,21 @@ +package de.tudresden.inf.st.train.jastadd.config; + +import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBase; + +public class JastaddRelASTBenchmarkConfig extends JastaddAbstractBenchmarkConfig { + + protected JastaddRelASTBenchmarkConfig(final BenchmarkConfigBase configBase) { + super(configBase); + } + + @Override + public String getToolName() { + return "Grammar Extension with Serialiser"; + } + + @Override + public String getProjectName() { + return "jastadd-relast"; + } + +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/config/JastaddRelASTBenchmarkConfigBuilder.java b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/config/JastaddRelASTBenchmarkConfigBuilder.java new file mode 100644 index 0000000000000000000000000000000000000000..6880451cee0f9cccf43e205630d47f18061eb384 --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/config/JastaddRelASTBenchmarkConfigBuilder.java @@ -0,0 +1,13 @@ +package de.tudresden.inf.st.train.jastadd.config; + +import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBuilder; + +public class JastaddRelASTBenchmarkConfigBuilder extends BenchmarkConfigBuilder<JastaddRelASTBenchmarkConfig, JastaddRelASTBenchmarkConfigBuilder> { + + @Override + public JastaddRelASTBenchmarkConfig createConfig() { + checkNotNulls(); + return new JastaddRelASTBenchmarkConfig(configBase); + } + +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/driver/JastaddDriver.java b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/driver/JastaddDriver.java new file mode 100644 index 0000000000000000000000000000000000000000..b4e1374576146486cfde5b66f3b873ce99aa8f12 --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/driver/JastaddDriver.java @@ -0,0 +1,73 @@ +package de.tudresden.inf.st.train.jastadd.driver; + +import de.tudresden.inf.st.train.jastadd.ast.ASTState; +import de.tudresden.inf.st.train.jastadd.ast.DeserializationException; +import de.tudresden.inf.st.train.jastadd.ast.RailwayContainer; +import de.tudresden.inf.st.train.jastadd.ast.SerializationException; +import de.tudresden.inf.st.train.jastadd.driver.deserializer.JsonDeserializer; +import hu.bme.mit.trainbenchmark.benchmark.driver.Driver; + +import java.io.File; +import java.io.IOException; + + +public class JastaddDriver extends Driver { + + RailwayContainer root; + + private int idCounter = 0; + + public boolean flushCaches() { + return flushCaches; + } + + private final boolean flushCaches; + private final ASTState.Trace.Receiver receiver; + + public JastaddDriver(boolean flushCaches, ASTState.Trace.Receiver receiver) { + super(); + this.flushCaches = flushCaches; + this.receiver = receiver; + } + + public static JastaddDriver create(boolean flushCaches, ASTState.Trace.Receiver receiver) { + return new JastaddDriver(flushCaches, receiver); + } + + public int nextId() { + idCounter--; + return idCounter; + } + + public RailwayContainer getModel() { + return root; + } + + @Override + public void read(final String modelPath) throws IOException { + + File modelFile = new File(modelPath); + try { + root = RailwayContainer.deserialize(modelFile); + root.resolveAll(); + } catch (DeserializationException e) { + throw new IOException(e); + } + + // enable tracing if there is a receiver + if (receiver != null) { + getModel().trace().setReceiver(receiver); + } + } + + @Override + public String getPostfix() { + return "-relast.json"; + } + + public void flushCache() { + if (flushCaches) { + getModel().flushTreeCache(); + } + } +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/driver/deserializer/ASTNodeDeserializer.java b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/driver/deserializer/ASTNodeDeserializer.java new file mode 100644 index 0000000000000000000000000000000000000000..e41ba04655aad40077eca30b5b73e4faf20b1b6c --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/driver/deserializer/ASTNodeDeserializer.java @@ -0,0 +1,33 @@ +package de.tudresden.inf.st.train.jastadd.driver.deserializer; + +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.DeserializationContext; +import com.fasterxml.jackson.databind.JavaType; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.deser.std.StdDeserializer; +import de.tudresden.inf.st.train.jastadd.ast.*; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + +/** + * Created by jm on 5/15/17. + */ +public class ASTNodeDeserializer extends StdDeserializer<ASTNode> { + + public ASTNodeDeserializer() { + super((JavaType) null); + } + + protected ASTNodeDeserializer(Class<?> vc) { + super(vc); + } + + @Override + public ASTNode deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException { + throw new RuntimeException("this should not be called"); + } +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/test/java/de/tudresden/inf/st/train/jastadd/test/RelASTSerializerIncrementalTest.java b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/test/java/de/tudresden/inf/st/train/jastadd/test/RelASTSerializerIncrementalTest.java new file mode 100644 index 0000000000000000000000000000000000000000..a4a4be6acfa671a1e4b7ceb855bf32849305e31d --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast-incremental/src/test/java/de/tudresden/inf/st/train/jastadd/test/RelASTSerializerIncrementalTest.java @@ -0,0 +1,20 @@ +package de.tudresden.inf.st.train.jastadd.test; + +import de.tudresden.inf.st.train.jastadd.JastaddRelASTBenchmarkScenario; +import de.tudresden.inf.st.train.jastadd.config.JastaddRelASTBenchmarkConfig; +import de.tudresden.inf.st.train.jastadd.config.JastaddRelASTBenchmarkConfigBuilder; +import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBase; +import hu.bme.mit.trainbenchmark.benchmark.runcomponents.BenchmarkResult; +import hu.bme.mit.trainbenchmark.benchmark.test.TrainBenchmarkTest; + +public class RelASTSerializerIncrementalTest extends TrainBenchmarkTest { + + @Override + protected BenchmarkResult runTest(final BenchmarkConfigBase bcb) throws Exception { + final JastaddRelASTBenchmarkConfig bc = new JastaddRelASTBenchmarkConfigBuilder().setConfigBase(bcb).createConfig(); + final JastaddRelASTBenchmarkScenario scenario = new JastaddRelASTBenchmarkScenario(bc); + final BenchmarkResult result = scenario.performBenchmark(); + return result; + } + +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast/.editorconfig b/trainbenchmark/trainbenchmark-tool-jastadd-relast/.editorconfig new file mode 100644 index 0000000000000000000000000000000000000000..5b0ed0442155d26acd0e00a7c141a2b352c140ad --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast/.editorconfig @@ -0,0 +1,28 @@ +root = true + +[*.java] +charset = utf-8 +end_of_line = lf +indent_size = 2 +indent_style = space +insert_final_newline = true +max_line_length = 140 +trim_trailing_whitespace = true + +[*.jadd] +charset = utf-8 +end_of_line = lf +indent_size = 2 +indent_style = space +insert_final_newline = true +max_line_length = 140 +trim_trailing_whitespace = true + +[*.jrag] +charset = utf-8 +end_of_line = lf +indent_size = 2 +indent_style = space +insert_final_newline = true +max_line_length = 140 +trim_trailing_whitespace = true diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast/build.gradle b/trainbenchmark/trainbenchmark-tool-jastadd-relast/build.gradle new file mode 100644 index 0000000000000000000000000000000000000000..3f9a633c4459697f0b2a1d5eee4133e4267d3603 --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast/build.gradle @@ -0,0 +1,75 @@ +plugins { id "com.github.johnrengelman.shadow" version "1.2.3" } + +shadowJar { + classifier = 'fat' + manifest { attributes 'Main-Class': 'de.tudresden.inf.st.train.jastadd.JastaddBenchmarkMain' } +} + +task preprocess(type: JavaExec) { + doFirst { + delete fileTree('src/main/jastadd-gen') + } + group = 'Build' + main = "-jar" + args = [ + "../trainbenchmark-tool-jastadd-base/libs/relast-compiler.jar", + "../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/Train.relast", + "--listClass=RefList", + "--serializer=jackson", + "--grammarName=src/main/jastadd-gen/Train", + "--file" + ] +} + +task jastadd(type: JavaExec) { + group = 'Build' + main = "-jar" + args = [ + "../trainbenchmark-tool-jastadd-base/libs/jastadd2.jar", + "--cache=all", + "--flush=full", + "--package=de.tudresden.inf.st.train.jastadd.ast", + "--o=src/main/java-gen", + "--tracing=api", + ] + fileTree("../trainbenchmark-tool-jastadd-base/src/main/jastadd/") + fileTree("src/main/jastadd-gen/") + fileTree("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/").matching {exclude "*.relast"} + doFirst { + delete fileTree('src/main/java-gen') + } + doLast { + ant.replaceregexp(match:'RefList extends List', replace:'RefList<T extends ASTNode> extends List<T>', flags:'g', byline:true) { + fileset(dir: 'src/main/java-gen/de/tudresden/inf/st/train/jastadd/ast', includes: 'RefList.java') + } + } + + inputs.files fileTree("../trainbenchmark-tool-jastadd-base/src/main/jastadd/") + fileTree("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/") + fileTree("src/main/jastadd-gen/") + outputs.files file("src/main/java-gen") +} + +sourceSets { + main { + java { + srcDir 'src/main/java' + srcDir 'src/main/java-gen' + srcDir '../trainbenchmark-tool-jastadd-base/src/main/java' + srcDir '../trainbenchmark-tool-jastadd-specialized-base/src/main/java' + } + } +} + +clean { + delete fileTree('src/main/java-gen') +} + +dependencies { + compile project(':trainbenchmark-tool') + compile project(':trainbenchmark-tool-jastadd-base') + compile project(':trainbenchmark-tool-jastadd-specialized-base') + compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.8.8.1' +} + +test { + outputs.upToDateWhen { false } +} + +jastadd.dependsOn preprocess +compileJava.dependsOn jastadd \ No newline at end of file diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java-gen/.gitignore b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java-gen/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..d6b7ef32c8478a48c3994dcadc86837f4371184d --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java-gen/.gitignore @@ -0,0 +1,2 @@ +* +!.gitignore diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/JastaddBenchmarkMain.java b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/JastaddBenchmarkMain.java new file mode 100644 index 0000000000000000000000000000000000000000..c17cbc9a495056eace5c8fa80a68f9425b641eed --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/JastaddBenchmarkMain.java @@ -0,0 +1,13 @@ +package de.tudresden.inf.st.train.jastadd; + +import de.tudresden.inf.st.train.jastadd.config.JastaddRelASTBenchmarkConfig; +import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfig; + +public class JastaddBenchmarkMain { + public static void main(final String[] args) throws Exception { + final JastaddRelASTBenchmarkConfig bc = BenchmarkConfig.fromFile(args[0], JastaddRelASTBenchmarkConfig.class); + final JastaddRelASTBenchmarkScenario scenario = new JastaddRelASTBenchmarkScenario(bc); + scenario.performBenchmark(); + scenario.printTraces(); + } +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/JastaddRelASTBenchmarkScenario.java b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/JastaddRelASTBenchmarkScenario.java new file mode 100644 index 0000000000000000000000000000000000000000..0fc13c828070faea0d08f6bd76bbf1c4c0aabbe2 --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/JastaddRelASTBenchmarkScenario.java @@ -0,0 +1,12 @@ +package de.tudresden.inf.st.train.jastadd; + +import de.tudresden.inf.st.train.jastadd.config.JastaddRelASTBenchmarkConfig; + +public class JastaddRelASTBenchmarkScenario extends + JastaddAbstractBenchmarkScenario<JastaddRelASTBenchmarkConfig> { + + public JastaddRelASTBenchmarkScenario(final JastaddRelASTBenchmarkConfig bc) throws Exception { + super(bc, true); + } + +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/config/JastaddRelASTBenchmarkConfig.java b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/config/JastaddRelASTBenchmarkConfig.java new file mode 100644 index 0000000000000000000000000000000000000000..f1f89ec2df1c5223634b25513c1d3b226862864b --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/config/JastaddRelASTBenchmarkConfig.java @@ -0,0 +1,21 @@ +package de.tudresden.inf.st.train.jastadd.config; + +import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBase; + +public class JastaddRelASTBenchmarkConfig extends JastaddAbstractBenchmarkConfig { + + protected JastaddRelASTBenchmarkConfig(final BenchmarkConfigBase configBase) { + super(configBase); + } + + @Override + public String getToolName() { + return "Grammar Extension with Serialiser"; + } + + @Override + public String getProjectName() { + return "jastadd-relast"; + } + +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/config/JastaddRelASTBenchmarkConfigBuilder.java b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/config/JastaddRelASTBenchmarkConfigBuilder.java new file mode 100644 index 0000000000000000000000000000000000000000..6880451cee0f9cccf43e205630d47f18061eb384 --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/config/JastaddRelASTBenchmarkConfigBuilder.java @@ -0,0 +1,13 @@ +package de.tudresden.inf.st.train.jastadd.config; + +import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBuilder; + +public class JastaddRelASTBenchmarkConfigBuilder extends BenchmarkConfigBuilder<JastaddRelASTBenchmarkConfig, JastaddRelASTBenchmarkConfigBuilder> { + + @Override + public JastaddRelASTBenchmarkConfig createConfig() { + checkNotNulls(); + return new JastaddRelASTBenchmarkConfig(configBase); + } + +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/driver/JastaddDriver.java b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/driver/JastaddDriver.java new file mode 100644 index 0000000000000000000000000000000000000000..b4e1374576146486cfde5b66f3b873ce99aa8f12 --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/driver/JastaddDriver.java @@ -0,0 +1,73 @@ +package de.tudresden.inf.st.train.jastadd.driver; + +import de.tudresden.inf.st.train.jastadd.ast.ASTState; +import de.tudresden.inf.st.train.jastadd.ast.DeserializationException; +import de.tudresden.inf.st.train.jastadd.ast.RailwayContainer; +import de.tudresden.inf.st.train.jastadd.ast.SerializationException; +import de.tudresden.inf.st.train.jastadd.driver.deserializer.JsonDeserializer; +import hu.bme.mit.trainbenchmark.benchmark.driver.Driver; + +import java.io.File; +import java.io.IOException; + + +public class JastaddDriver extends Driver { + + RailwayContainer root; + + private int idCounter = 0; + + public boolean flushCaches() { + return flushCaches; + } + + private final boolean flushCaches; + private final ASTState.Trace.Receiver receiver; + + public JastaddDriver(boolean flushCaches, ASTState.Trace.Receiver receiver) { + super(); + this.flushCaches = flushCaches; + this.receiver = receiver; + } + + public static JastaddDriver create(boolean flushCaches, ASTState.Trace.Receiver receiver) { + return new JastaddDriver(flushCaches, receiver); + } + + public int nextId() { + idCounter--; + return idCounter; + } + + public RailwayContainer getModel() { + return root; + } + + @Override + public void read(final String modelPath) throws IOException { + + File modelFile = new File(modelPath); + try { + root = RailwayContainer.deserialize(modelFile); + root.resolveAll(); + } catch (DeserializationException e) { + throw new IOException(e); + } + + // enable tracing if there is a receiver + if (receiver != null) { + getModel().trace().setReceiver(receiver); + } + } + + @Override + public String getPostfix() { + return "-relast.json"; + } + + public void flushCache() { + if (flushCaches) { + getModel().flushTreeCache(); + } + } +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/driver/deserializer/ASTNodeDeserializer.java b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/driver/deserializer/ASTNodeDeserializer.java new file mode 100644 index 0000000000000000000000000000000000000000..e41ba04655aad40077eca30b5b73e4faf20b1b6c --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/main/java/de/tudresden/inf/st/train/jastadd/driver/deserializer/ASTNodeDeserializer.java @@ -0,0 +1,33 @@ +package de.tudresden.inf.st.train.jastadd.driver.deserializer; + +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.DeserializationContext; +import com.fasterxml.jackson.databind.JavaType; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.deser.std.StdDeserializer; +import de.tudresden.inf.st.train.jastadd.ast.*; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + +/** + * Created by jm on 5/15/17. + */ +public class ASTNodeDeserializer extends StdDeserializer<ASTNode> { + + public ASTNodeDeserializer() { + super((JavaType) null); + } + + protected ASTNodeDeserializer(Class<?> vc) { + super(vc); + } + + @Override + public ASTNode deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException { + throw new RuntimeException("this should not be called"); + } +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/test/java/de/tudresden/inf/st/train/jastadd/test/RelASTSerializerTest.java b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/test/java/de/tudresden/inf/st/train/jastadd/test/RelASTSerializerTest.java new file mode 100644 index 0000000000000000000000000000000000000000..057b12f84bfab086ece4e03ef537ac9f788a3323 --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-relast/src/test/java/de/tudresden/inf/st/train/jastadd/test/RelASTSerializerTest.java @@ -0,0 +1,20 @@ +package de.tudresden.inf.st.train.jastadd.test; + +import de.tudresden.inf.st.train.jastadd.JastaddRelASTBenchmarkScenario; +import de.tudresden.inf.st.train.jastadd.config.JastaddRelASTBenchmarkConfig; +import de.tudresden.inf.st.train.jastadd.config.JastaddRelASTBenchmarkConfigBuilder; +import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBase; +import hu.bme.mit.trainbenchmark.benchmark.runcomponents.BenchmarkResult; +import hu.bme.mit.trainbenchmark.benchmark.test.TrainBenchmarkTest; + +public class RelASTSerializerTest extends TrainBenchmarkTest { + + @Override + protected BenchmarkResult runTest(final BenchmarkConfigBase bcb) throws Exception { + final JastaddRelASTBenchmarkConfig bc = new JastaddRelASTBenchmarkConfigBuilder().setConfigBase(bcb).createConfig(); + final JastaddRelASTBenchmarkScenario scenario = new JastaddRelASTBenchmarkScenario(bc); + final BenchmarkResult result = scenario.performBenchmark(); + return result; + } + +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/build.gradle b/trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/build.gradle index 065d38d4bc83203b9ec861e78ecaf4e4f15ca8ff..c17b53627dcc366aa8c12d40195589ef61a2c094 100644 --- a/trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/build.gradle +++ b/trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/build.gradle @@ -6,17 +6,18 @@ shadowJar { } task preprocess(type: JavaExec) { + doFirst { + delete fileTree('src/main/jastadd-gen') + } group = 'Build' main = "-jar" args = [ "../trainbenchmark-tool-jastadd-base/libs/relast-compiler.jar", "../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/Train.relast", "--listClass=RefList", + "--grammarName=src/main/jastadd-gen/Train", "--file" ] - - inputs.files file("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/Train.relast") - outputs.files file("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/TrainGen.ast"), file("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/TrainGen.jadd") } task jastadd(type: JavaExec) { @@ -31,7 +32,7 @@ task jastadd(type: JavaExec) { "--package=de.tudresden.inf.st.train.jastadd.ast", "--o=src/main/java-gen", "--tracing=api", - ] + fileTree("../trainbenchmark-tool-jastadd-base/src/main/jastadd/") + fileTree("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/").matching {exclude "*.relast"} + ] + fileTree("../trainbenchmark-tool-jastadd-base/src/main/jastadd/") + fileTree("src/main/jastadd-gen/") + fileTree("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/").matching {exclude "*.relast"} doFirst { delete fileTree('src/main/java-gen') } @@ -41,7 +42,7 @@ task jastadd(type: JavaExec) { } } - inputs.files fileTree("../trainbenchmark-tool-jastadd-base/src/main/jastadd/") + fileTree("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/") + inputs.files fileTree("../trainbenchmark-tool-jastadd-base/src/main/jastadd/") + fileTree("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/") + fileTree("src/main/jastadd-gen/") outputs.files file("src/main/java-gen") } @@ -67,5 +68,9 @@ dependencies { compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.8.8.1' } +test { + outputs.upToDateWhen { false } +} + jastadd.dependsOn preprocess -compileJava.dependsOn jastadd +compileJava.dependsOn jastadd \ No newline at end of file diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-specialized-base/src/main/java/de/tudresden/inf/st/train/jastadd/driver/JastaddDriver.java b/trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/driver/JastaddDriver.java similarity index 99% rename from trainbenchmark/trainbenchmark-tool-jastadd-specialized-base/src/main/java/de/tudresden/inf/st/train/jastadd/driver/JastaddDriver.java rename to trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/driver/JastaddDriver.java index 302a2f58d33c677f5d183b24b921568d7507db24..902fc1ab214a03a0fcc8fbd7f815ddeaaa064abb 100644 --- a/trainbenchmark/trainbenchmark-tool-jastadd-specialized-base/src/main/java/de/tudresden/inf/st/train/jastadd/driver/JastaddDriver.java +++ b/trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/driver/JastaddDriver.java @@ -11,17 +11,10 @@ import java.io.IOException; public class JastaddDriver extends Driver { - RailwayContainer root; - - private int idCounter = 0; - - public boolean flushCaches() { - return flushCaches; - } - private final boolean flushCaches; private final ASTState.Trace.Receiver receiver; - + RailwayContainer root; + private int idCounter = 0; public JastaddDriver(boolean flushCaches, ASTState.Trace.Receiver receiver) { super(); this.flushCaches = flushCaches; @@ -32,6 +25,10 @@ public class JastaddDriver extends Driver { return new JastaddDriver(flushCaches, receiver); } + public boolean flushCaches() { + return flushCaches; + } + public int nextId() { idCounter--; return idCounter; diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-specialized-base/src/main/java/de/tudresden/inf/st/train/jastadd/driver/deserializer/ASTNodeDeserializer.java b/trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/driver/deserializer/ASTNodeDeserializer.java similarity index 99% rename from trainbenchmark/trainbenchmark-tool-jastadd-specialized-base/src/main/java/de/tudresden/inf/st/train/jastadd/driver/deserializer/ASTNodeDeserializer.java rename to trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/driver/deserializer/ASTNodeDeserializer.java index f449de658010beb39989f541fc440f72fcaaa612..2b2e0e43e7c3b98aca6fcd390fe1e8abc4631868 100644 --- a/trainbenchmark/trainbenchmark-tool-jastadd-specialized-base/src/main/java/de/tudresden/inf/st/train/jastadd/driver/deserializer/ASTNodeDeserializer.java +++ b/trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/src/main/java/de/tudresden/inf/st/train/jastadd/driver/deserializer/ASTNodeDeserializer.java @@ -4,14 +4,13 @@ import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.databind.DeserializationContext; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.deser.std.StdDeserializer; +import de.tudresden.inf.st.train.jastadd.ast.*; import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; import java.util.Map; -import de.tudresden.inf.st.train.jastadd.ast.*; - /** * Created by jm on 5/15/17. */ diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/src/test/java/de/tudresden/inf/st/train/jastadd/test/JastaddRefTest.java b/trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/src/test/java/de/tudresden/inf/st/train/jastadd/test/RelASTIncrementalTest.java similarity index 94% rename from trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/src/test/java/de/tudresden/inf/st/train/jastadd/test/JastaddRefTest.java rename to trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/src/test/java/de/tudresden/inf/st/train/jastadd/test/RelASTIncrementalTest.java index eddd876408266fe8fce6048604410a981a1062fc..0de660941c750fff02d6fc4739ff3745de65ce65 100644 --- a/trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/src/test/java/de/tudresden/inf/st/train/jastadd/test/JastaddRefTest.java +++ b/trainbenchmark/trainbenchmark-tool-jastadd-specialized-incremental/src/test/java/de/tudresden/inf/st/train/jastadd/test/RelASTIncrementalTest.java @@ -7,7 +7,7 @@ import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBase; import hu.bme.mit.trainbenchmark.benchmark.runcomponents.BenchmarkResult; import hu.bme.mit.trainbenchmark.benchmark.test.TrainBenchmarkTest; -public class JastaddRefTest extends TrainBenchmarkTest { +public class RelASTIncrementalTest extends TrainBenchmarkTest { @Override protected BenchmarkResult runTest(final BenchmarkConfigBase bcb) throws Exception { diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-specialized/build.gradle b/trainbenchmark/trainbenchmark-tool-jastadd-specialized/build.gradle index 20e0a9f6fd65094bda7e9954e4279baa244ebccb..bb3319ff0433bce141420025f08edca823734643 100644 --- a/trainbenchmark/trainbenchmark-tool-jastadd-specialized/build.gradle +++ b/trainbenchmark/trainbenchmark-tool-jastadd-specialized/build.gradle @@ -6,17 +6,18 @@ shadowJar { } task preprocess(type: JavaExec) { + doFirst { + delete fileTree('src/main/jastadd-gen') + } group = 'Build' main = "-jar" args = [ "../trainbenchmark-tool-jastadd-base/libs/relast-compiler.jar", "../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/Train.relast", "--listClass=RefList", + "--grammarName=src/main/jastadd-gen/Train", "--file" ] - - inputs.files file("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/Train.relast") - outputs.files file("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/TrainGen.ast"), file("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/TrainGen.jadd") } task jastadd(type: JavaExec) { @@ -29,7 +30,7 @@ task jastadd(type: JavaExec) { "--package=de.tudresden.inf.st.train.jastadd.ast", "--o=src/main/java-gen", "--tracing=api", - ] + fileTree("../trainbenchmark-tool-jastadd-base/src/main/jastadd/") + fileTree("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/").matching {exclude "*.relast"} + ] + fileTree("../trainbenchmark-tool-jastadd-base/src/main/jastadd/") + fileTree("src/main/jastadd-gen/") + fileTree("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/").matching {exclude "*.relast"} doFirst { delete fileTree('src/main/java-gen') } @@ -39,7 +40,7 @@ task jastadd(type: JavaExec) { } } - inputs.files fileTree("../trainbenchmark-tool-jastadd-base/src/main/jastadd/") + fileTree("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/") + inputs.files fileTree("../trainbenchmark-tool-jastadd-base/src/main/jastadd/") + fileTree("../trainbenchmark-tool-jastadd-specialized-base/src/main/jastadd/") + fileTree("src/main/jastadd-gen/") outputs.files file("src/main/java-gen") } @@ -65,5 +66,9 @@ dependencies { compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.8.8.1' } +test { + outputs.upToDateWhen { false } +} + jastadd.dependsOn preprocess -compileJava.dependsOn jastadd +compileJava.dependsOn jastadd \ No newline at end of file diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-specialized/src/main/java/de/tudresden/inf/st/train/jastadd/driver/JastaddDriver.java b/trainbenchmark/trainbenchmark-tool-jastadd-specialized/src/main/java/de/tudresden/inf/st/train/jastadd/driver/JastaddDriver.java new file mode 100644 index 0000000000000000000000000000000000000000..902fc1ab214a03a0fcc8fbd7f815ddeaaa064abb --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-specialized/src/main/java/de/tudresden/inf/st/train/jastadd/driver/JastaddDriver.java @@ -0,0 +1,63 @@ +package de.tudresden.inf.st.train.jastadd.driver; + +import de.tudresden.inf.st.train.jastadd.ast.ASTState; +import de.tudresden.inf.st.train.jastadd.ast.RailwayContainer; +import de.tudresden.inf.st.train.jastadd.driver.deserializer.JsonDeserializer; +import hu.bme.mit.trainbenchmark.benchmark.driver.Driver; + +import java.io.File; +import java.io.IOException; + + +public class JastaddDriver extends Driver { + + private final boolean flushCaches; + private final ASTState.Trace.Receiver receiver; + RailwayContainer root; + private int idCounter = 0; + public JastaddDriver(boolean flushCaches, ASTState.Trace.Receiver receiver) { + super(); + this.flushCaches = flushCaches; + this.receiver = receiver; + } + + public static JastaddDriver create(boolean flushCaches, ASTState.Trace.Receiver receiver) { + return new JastaddDriver(flushCaches, receiver); + } + + public boolean flushCaches() { + return flushCaches; + } + + public int nextId() { + idCounter--; + return idCounter; + } + + public RailwayContainer getModel() { + return root; + } + + @Override + public void read(final String modelPath) throws IOException { + + File modelFile = new File(modelPath); + root = JsonDeserializer.read(modelFile); + + // enable tracing if there is a receiver + if (receiver != null) { + getModel().trace().setReceiver(receiver); + } + } + + @Override + public String getPostfix() { + return "-ag-special.json"; + } + + public void flushCache() { + if (flushCaches) { + getModel().flushTreeCache(); + } + } +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-specialized/src/main/java/de/tudresden/inf/st/train/jastadd/driver/deserializer/ASTNodeDeserializer.java b/trainbenchmark/trainbenchmark-tool-jastadd-specialized/src/main/java/de/tudresden/inf/st/train/jastadd/driver/deserializer/ASTNodeDeserializer.java new file mode 100644 index 0000000000000000000000000000000000000000..2b2e0e43e7c3b98aca6fcd390fe1e8abc4631868 --- /dev/null +++ b/trainbenchmark/trainbenchmark-tool-jastadd-specialized/src/main/java/de/tudresden/inf/st/train/jastadd/driver/deserializer/ASTNodeDeserializer.java @@ -0,0 +1,376 @@ +package de.tudresden.inf.st.train.jastadd.driver.deserializer; + +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.databind.DeserializationContext; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.deser.std.StdDeserializer; +import de.tudresden.inf.st.train.jastadd.ast.*; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + +/** + * Created by jm on 5/15/17. + */ +public class ASTNodeDeserializer extends StdDeserializer<ASTNode> { + + public static class IM<Node extends ASTNode> { + + private final Node node; + private final int ref; + + public IM(Node node, int ref) { + this.node = node; + this.ref = ref; + } + + public Node getNode() { + return node; + } + public int getRef() { + return ref; + } + + @Override + public int hashCode() { + return node.hashCode() ^ Integer.hashCode(ref); + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof IM)) return false; + IM pairo = (IM) o; + return this.node.equals(pairo.getNode()) && + this.ref == pairo.getRef(); + } + + } + + final String packageName = "de.tudresden.inf.st.train.jastadd.ast"; + + public ASTNodeDeserializer() { + this(null); + } + + public ASTNodeDeserializer(Class<?> vc) { + super(vc); + } + + private java.util.List<IM<Route>> listRoute_impl_requires = new ArrayList<>(); + private java.util.List<IM<Route>> listRoute_impl_entry = new ArrayList<>(); + private java.util.List<IM<Route>> listRoute_impl_exit = new ArrayList<>(); + private java.util.List<IM<SwitchPosition>> listSwitchPosition_impl_target = new ArrayList<>(); + private java.util.List<IM<Sensor>> listSensor_impl_monitors = new ArrayList<>(); + private java.util.List<IM<Sensor>> listSensor_impl_requiredBy = new ArrayList<>(); + private java.util.List<IM<TrackElement>> listTrackElement_impl_monitoredBy = new ArrayList<>(); + private java.util.List<IM<TrackElement>> listTrackElement_impl_connectsTo = new ArrayList<>(); + private java.util.List<IM<Switch>> listSwitch_impl_positions = new ArrayList<>(); + + private Map<Integer, ASTNode> idMap = new HashMap<>(); + + @Override + public RailwayContainer deserialize(JsonParser jp, DeserializationContext ctxt) + throws IOException { + + JsonNode node = jp.getCodec().readTree(jp); + RailwayContainer result = deserializeRailwayContainer(node); + + for (IM<Route> e : listRoute_impl_requires) { + if (idMap.get(e.getRef()) == null) { + throw new DeserializationException(); + } + if (e.getNode().get_impl_requires() == null) { + e.getNode().set_impl_requires(new RefList<>()); + } + e.getNode().get_impl_requires().add((Sensor)idMap.get(e.getRef())); + } + for (IM<Route> e : listRoute_impl_entry) { + if (idMap.get(e.getRef()) == null) { + throw new DeserializationException(); + } + e.getNode().set_impl_entry((Semaphore)idMap.get(e.getRef())); + } + for (IM<Route> e : listRoute_impl_exit) { + e.getNode().set_impl_exit((Semaphore)idMap.get(e.getRef())); + } + for (IM<SwitchPosition> e : listSwitchPosition_impl_target) { + if (idMap.get(e.getRef()) == null) { + throw new DeserializationException(); + } + e.getNode().set_impl_target((Switch)idMap.get(e.getRef())); + } + for (IM<Sensor> e : listSensor_impl_monitors) { + if (idMap.get(e.getRef()) == null) { + throw new DeserializationException(); + } + if (e.getNode().get_impl_monitors() == null) { + e.getNode().set_impl_monitors(new RefList<>()); + } + e.getNode().get_impl_monitors().add((TrackElement)idMap.get(e.getRef())); + } + for (IM<Sensor> e : listSensor_impl_requiredBy) { + if (idMap.get(e.getRef()) == null) { + throw new DeserializationException(); + } + if (e.getNode().get_impl_requiredBy() == null) { + e.getNode().set_impl_requiredBy(new RefList<>()); + } + e.getNode().get_impl_requiredBy().add((Route)idMap.get(e.getRef())); + } + for (IM<TrackElement> e : listTrackElement_impl_monitoredBy) { + if (idMap.get(e.getRef()) == null) { + throw new DeserializationException(); + } + if (e.getNode().get_impl_monitoredBy() == null) { + e.getNode().set_impl_monitoredBy(new RefList<>()); + } + e.getNode().get_impl_monitoredBy().add((Sensor)idMap.get(e.getRef())); + } + for (IM<TrackElement> e : listTrackElement_impl_connectsTo) { + if (idMap.get(e.getRef()) == null) { + throw new DeserializationException(); + } + if (e.getNode().get_impl_connectsTo() == null) { + e.getNode().set_impl_connectsTo(new RefList<>()); + } + e.getNode().get_impl_connectsTo().add((TrackElement)idMap.get(e.getRef())); + } + for (IM<Switch> e : listSwitch_impl_positions) { + if (idMap.get(e.getRef()) == null) { + throw new DeserializationException(); + } + if (e.getNode().get_impl_positions() == null) { + e.getNode().set_impl_positions(new RefList<>()); + } + e.getNode().get_impl_positions().add((SwitchPosition)idMap.get(e.getRef())); + } + + return result; + } + + private RailwayContainer deserializeRailwayContainer(JsonNode node) { + RailwayContainer instance = new RailwayContainer(); + + // Route* + for (JsonNode child : node.get("c").get("Route").get("c")) { + instance.addRoute(deserializeRoute(child)); + } + + // Region* + for (JsonNode child : node.get("c").get("Region").get("c")) { + instance.addRegion(deserializeRegion(child)); + } + + return instance; + } + + private Region deserializeRegion(JsonNode node) { + Region instance = new Region(); + + // Id + Integer id = node.get("c").get("Id").get("v").asInt(); + instance.setId(id); + idMap.put(id, instance); + + // TrackElement* + for (JsonNode child : node.get("c").get("TrackElement").get("c")) { + instance.addTrackElement(deserializeTrackElement(child)); + } + + // Sensor* + for (JsonNode child : node.get("c").get("Sensor").get("c")) { + instance.addSensor(deserializeSensor(child)); + } + + return instance; + } + + private Semaphore deserializeSemaphore(JsonNode node) { + Semaphore instance = new Semaphore(); + + // Id + Integer id = node.get("c").get("Id").get("v").asInt(); + instance.setId(id); + idMap.put(id, instance); + + // Signal + switch (node.get("c").get("Signal").get("v").asText()) { + case "GO": + instance.setSignal(Signal.GO); + break; + case "STOP": + instance.setSignal(Signal.STOP); + break; + case "FAILURE": + instance.setSignal(Signal.FAILURE); + break; + default: + throw new DeserializationException(); + } + + return instance; + } + + private Route deserializeRoute(JsonNode node) { + Route instance = new Route(); + + // Id + Integer id = node.get("c").get("Id").get("v").asInt(); + instance.setId(id); + idMap.put(id, instance); + + // Active + instance.setActive(node.get("c").get("Active").get("v").asBoolean()); + + // SwitchPosition + for (JsonNode child : node.get("c").get("SwitchPosition").get("c")) { + instance.addSwitchPosition(deserializeSwitchPosition(child)); + } + + // _impl_requires + for (JsonNode child : node.get("c").get("_impl_requires").get("c")) { + int ref = child.get("v").asInt(); + this.listRoute_impl_requires.add(new IM<Route>(instance, ref)); + } + + // _impl_Entry + if (!node.get("c").get("_impl_entry").get("v").isNull()) { + this.listRoute_impl_entry.add(new IM<Route>(instance, node.get("c").get("_impl_entry").get("v").asInt())); + } + + /// _impl_Exit + if (!node.get("c").get("_impl_exit").get("v").isNull()) { + this.listRoute_impl_exit.add(new IM<Route>(instance, node.get("c").get("_impl_exit").get("v").asInt())); + } + return instance; + } + + private SwitchPosition deserializeSwitchPosition(JsonNode node) { + SwitchPosition instance = new SwitchPosition(); + + // Id + Integer id = node.get("c").get("Id").get("v").asInt(); + instance.setId(id); + idMap.put(id, instance); + + // Position + switch (node.get("c").get("Position").get("v").asText()) { + case "FAILURE": + instance.setPosition(Position.FAILURE); + break; + case "STRAIGHT": + instance.setPosition(Position.STRAIGHT); + break; + case "DIVERGING": + instance.setPosition(Position.DIVERGING); + break; + default: + throw new DeserializationException(); + } + + // _impl_Target + this.listSwitchPosition_impl_target.add(new IM<SwitchPosition>(instance, node.get("c").get("_impl_target").get("v").asInt())); + + + return instance; + } + + private Sensor deserializeSensor(JsonNode node) { + Sensor instance = new Sensor(); + + // Id + Integer id = node.get("c").get("Id").get("v").asInt(); + instance.setId(id); + idMap.put(id, instance); + + // _impl_Monitors + for (JsonNode child : node.get("c").get("_impl_monitors").get("c")) { + int ref = child.get("v").asInt(); + this.listSensor_impl_monitors.add(new IM<Sensor>(instance, ref)); + } + + // _impl_RequiringRoutes + for (JsonNode child : node.get("c").get("_impl_requiredBy").get("c")) { + int ref = child.get("v").asInt(); + this.listSensor_impl_requiredBy.add(new IM<Sensor>(instance, ref)); + } + + return instance; + } + + private TrackElement deserializeTrackElement(JsonNode node) { + + TrackElement instance; + + if (node.get("t").asText().equals("Segment")) { + instance = deserializeSegment(node); + } else if (node.get("t").asText().equals("Switch")) { + instance = deserializeSwitch(node); + } else { + throw new DeserializationException(); + } + + // Id + Integer id = node.get("c").get("Id").get("v").asInt(); + instance.setId(id); + idMap.put(id, instance); + + // _impl_MonitoredBy + for (JsonNode child : node.get("c").get("_impl_monitoredBy").get("c")) { + int ref = child.get("v").asInt(); + this.listTrackElement_impl_monitoredBy.add(new IM<TrackElement>(instance, ref)); + } + + // _impl_ConnectsTo + for (JsonNode child : node.get("c").get("_impl_connectsTo").get("c")) { + int ref = child.get("v").asInt(); + this.listTrackElement_impl_connectsTo.add(new IM<TrackElement>(instance, ref)); + } + + return instance; + } + + private Segment deserializeSegment(JsonNode node) { + Segment instance = new Segment(); + + // Length + instance.setLength(node.get("c").get("Length").get("v").asInt()); + + // Semaphore* + for (JsonNode child : node.get("c").get("Semaphore").get("c")) { + instance.addSemaphore(deserializeSemaphore(child)); + } + + return instance; + } + + private Switch deserializeSwitch(JsonNode node) { + Switch instance = new Switch(); + + // CurrentPosition + switch (node.get("c").get("CurrentPosition").get("v").asText()) { + case "FAILURE": + instance.setCurrentPosition(Position.FAILURE); + break; + case "STRAIGHT": + instance.setCurrentPosition(Position.STRAIGHT); + break; + case "DIVERGING": + instance.setCurrentPosition(Position.DIVERGING); + break; + default: + throw new DeserializationException(); + } + + // _impl_Positions + for (JsonNode child : node.get("c").get("_impl_positions").get("c")) { + int ref = child.get("v").asInt(); + this.listSwitch_impl_positions.add(new IM<Switch>(instance, ref)); + } + + return instance; + } + +} diff --git a/trainbenchmark/trainbenchmark-tool-jastadd-specialized/src/test/java/de/tudresden/inf/st/train/jastadd/test/JastaddRefTest.java b/trainbenchmark/trainbenchmark-tool-jastadd-specialized/src/test/java/de/tudresden/inf/st/train/jastadd/test/RelASTTest.java similarity index 94% rename from trainbenchmark/trainbenchmark-tool-jastadd-specialized/src/test/java/de/tudresden/inf/st/train/jastadd/test/JastaddRefTest.java rename to trainbenchmark/trainbenchmark-tool-jastadd-specialized/src/test/java/de/tudresden/inf/st/train/jastadd/test/RelASTTest.java index 7d01c4dae9550e18d13a7d3ada62d9758d86487d..da68376043d05b1d96a4d1cc54c5231a8a72a8f7 100644 --- a/trainbenchmark/trainbenchmark-tool-jastadd-specialized/src/test/java/de/tudresden/inf/st/train/jastadd/test/JastaddRefTest.java +++ b/trainbenchmark/trainbenchmark-tool-jastadd-specialized/src/test/java/de/tudresden/inf/st/train/jastadd/test/RelASTTest.java @@ -7,7 +7,7 @@ import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBase; import hu.bme.mit.trainbenchmark.benchmark.runcomponents.BenchmarkResult; import hu.bme.mit.trainbenchmark.benchmark.test.TrainBenchmarkTest; -public class JastaddRefTest extends TrainBenchmarkTest { +public class RelASTTest extends TrainBenchmarkTest { @Override protected BenchmarkResult runTest(final BenchmarkConfigBase bcb) throws Exception {