├── .editorconfig ├── .github └── workflows │ └── compile.yml ├── .gitignore ├── LICENSE ├── README.md ├── build.gradle ├── diagrams └── .gitignore ├── docs ├── README.md ├── developer-guide.md ├── experimenting.md ├── getting-started.md ├── how-to-run-the-benchmark.md ├── instance-models.md ├── railway-containments.png ├── railway-containments.svg ├── railway-inheritance.png ├── railway-inheritance.svg └── schema.md ├── gradle ├── source-layout-xcore.gradle ├── source-layout-xtext.gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── logs ├── .gitignore └── README.md ├── models └── .gitignore ├── postgres ├── load.sh ├── schema.sql └── tb-load.sql ├── results └── .gitignore ├── scripts ├── .gitignore ├── build.sh ├── calculate-model-sizes.sh ├── cloc.sh ├── compress-results.sh ├── deploy.sh ├── get-neo4j.sh ├── install-R-14.04.sh ├── install-R-16.04.sh ├── install-R-packages.sh ├── install-jdk.sh ├── install-mysql-silent.sh ├── install-mysql.sh ├── install-sqlite.sh ├── run.sh └── shadowjar.sh ├── settings.gradle ├── site ├── .gitignore ├── _config.yml ├── _includes │ ├── footer.html │ ├── head.html │ ├── header.html │ ├── icon-github.html │ ├── icon-github.svg │ ├── icon-twitter.html │ └── icon-twitter.svg ├── _layouts │ └── default.html ├── _sass │ ├── _base.scss │ ├── _layout.scss │ └── _syntax-highlighting.scss ├── css │ └── main.scss ├── generated-models.md ├── index.md └── sosym-supplementary.md ├── trainbenchmark-config ├── .gitignore ├── build.gradle └── src │ └── main │ ├── java │ └── hu │ │ └── bme │ │ └── mit │ │ └── trainbenchmark │ │ ├── config │ │ ├── AbstractConfig.java │ │ ├── AbstractConfigBase.java │ │ ├── AbstractConfigBuilder.java │ │ └── ExecutionConfig.java │ │ └── constants │ │ ├── ExecutionPhase.java │ │ ├── ModelConstants.java │ │ ├── Position.java │ │ ├── QueryConstants.java │ │ ├── RailwayOperation.java │ │ ├── RailwayQuery.java │ │ ├── Signal.java │ │ ├── TrainBenchmarkConstants.java │ │ └── TransformationStrategy.java │ └── resources │ └── .gitignore ├── trainbenchmark-format-emf-model ├── .classpath ├── .gitignore ├── .project ├── META-INF │ └── MANIFEST.MF ├── build.gradle ├── build.properties ├── plugin.properties ├── plugin.xml └── src │ └── railway.xcore ├── trainbenchmark-format-emf ├── .gitignore ├── build.gradle └── src │ └── main │ ├── java │ └── hu │ │ └── bme │ │ └── mit │ │ └── trainbenchmark │ │ └── emf │ │ ├── EmfConstants.java │ │ └── EmfUtil.java │ └── resources │ └── .gitignore ├── trainbenchmark-format-graph-neo4j ├── build.gradle └── src │ └── main │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── neo4j │ ├── Neo4jConstants.java │ ├── Neo4jHelper.java │ ├── apoc │ └── ApocHelper.java │ └── config │ ├── Neo4jDeployment.java │ └── Neo4jGraphFormat.java ├── trainbenchmark-format-rdf ├── README.md ├── build.gradle └── src │ └── main │ ├── java │ └── hu │ │ └── bme │ │ └── mit │ │ └── trainbenchmark │ │ └── rdf │ │ ├── RdfConstants.java │ │ ├── RdfFormat.java │ │ └── RdfHelper.java │ └── resources │ └── metamodel │ ├── railway-inferred.nt │ ├── railway-inferred.ttl │ ├── railway-metamodel.nt │ └── railway-metamodel.ttl ├── trainbenchmark-format-sql ├── build.gradle ├── scripts │ ├── README.md │ ├── clean-mysql.sh │ ├── mysql2sqlite.sh │ ├── start-mysql.sh │ └── stop-mysql.sh └── src │ └── main │ ├── java │ └── hu │ │ └── bme │ │ └── mit │ │ └── trainbenchmark │ │ └── sql │ │ ├── constants │ │ └── SqlConstants.java │ │ └── process │ │ └── MySqlProcess.java │ └── resources │ └── metamodel │ ├── railway-footer.sql │ └── railway-header.sql ├── trainbenchmark-generator-emf ├── build.gradle └── src │ ├── main │ ├── java │ │ └── hu │ │ │ └── bme │ │ │ └── mit │ │ │ └── trainbenchmark │ │ │ └── generator │ │ │ └── emf │ │ │ ├── EmfGeneratorMain.java │ │ │ ├── EmfSerializer.java │ │ │ └── config │ │ │ ├── EmfGeneratorConfig.java │ │ │ └── EmfGeneratorConfigBuilder.java │ └── resources │ │ └── .gitignore │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── generator │ └── emf │ └── test │ └── EmfGeneratorTest.java ├── trainbenchmark-generator-graph-cypher ├── build.gradle └── src │ ├── main │ ├── java │ │ └── hu │ │ │ └── bme │ │ │ └── mit │ │ │ └── trainbenchmark │ │ │ └── generator │ │ │ └── cypher │ │ │ ├── CypherGeneratorMain.java │ │ │ ├── CypherSerializer.java │ │ │ └── config │ │ │ ├── CypherFormat.java │ │ │ ├── CypherGeneratorConfig.java │ │ │ └── CypherGeneratorConfigBuilder.java │ └── resources │ │ └── .gitignore │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── generator │ └── cypher │ └── CypherGeneratorTest.java ├── trainbenchmark-generator-graph-neo4j ├── .gitignore ├── build.gradle └── src │ ├── main │ └── java │ │ └── hu │ │ └── bme │ │ └── mit │ │ └── trainbenchmark │ │ └── generator │ │ └── graph │ │ └── neo4j │ │ ├── Neo4jGraphGeneratorMain.java │ │ ├── Neo4jGraphSerializer.java │ │ └── config │ │ ├── Neo4jGraphGeneratorConfig.java │ │ └── Neo4jGraphGeneratorConfigBuilder.java │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── generator │ └── graph │ └── neo4j │ └── test │ └── Neo4jGraphGeneratorTest.java ├── trainbenchmark-generator-graph-tinkerpop ├── .gitignore ├── build.gradle └── src │ ├── main │ └── java │ │ └── hu │ │ └── bme │ │ └── mit │ │ └── trainbenchmark │ │ └── generator │ │ └── graph │ │ └── tinkerpop │ │ ├── TinkerGraphGeneratorMain.java │ │ ├── TinkerGraphSerializer.java │ │ └── config │ │ ├── TinkerGraphFormat.java │ │ ├── TinkerGraphGeneratorConfig.java │ │ └── TinkerGraphGeneratorConfigBuilder.java │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── generator │ └── graph │ └── tinkerpop │ └── test │ └── TinkerGraphGeneratorTest.java ├── trainbenchmark-generator-rdf ├── .gitignore ├── build.gradle └── src │ ├── main │ ├── java │ │ └── hu │ │ │ └── bme │ │ │ └── mit │ │ │ └── trainbenchmark │ │ │ └── generator │ │ │ └── rdf │ │ │ ├── RdfGeneratorMain.java │ │ │ ├── RdfSerializer.java │ │ │ └── config │ │ │ ├── RdfGeneratorConfig.java │ │ │ └── RdfGeneratorConfigBuilder.java │ └── resources │ │ └── .gitignore │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── generator │ └── rdf │ └── test │ └── RdfGeneratorTest.java ├── trainbenchmark-generator-sql ├── build.gradle └── src │ ├── main │ ├── java │ │ └── hu │ │ │ └── bme │ │ │ └── mit │ │ │ └── trainbenchmark │ │ │ └── generator │ │ │ └── sql │ │ │ ├── SqlGeneratorMain.java │ │ │ ├── SqlSerializer.java │ │ │ └── config │ │ │ ├── SqlGeneratorConfig.java │ │ │ └── SqlGeneratorConfigBuilder.java │ └── resources │ │ └── .gitignore │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── generator │ └── sql │ └── SqlGeneratorTest.java ├── trainbenchmark-generator ├── build.gradle └── src │ └── main │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── generator │ ├── ModelGenerator.java │ ├── ModelSerializer.java │ ├── ScalableGeneratorFactory.java │ ├── config │ ├── GeneratorConfig.java │ ├── GeneratorConfigBase.java │ ├── GeneratorConfigBaseBuilder.java │ ├── GeneratorConfigBuilder.java │ └── Scenario.java │ ├── minimal │ ├── MinimalConnectedSegmentsGenerator.java │ ├── MinimalModelGenerator.java │ ├── MinimalPosLengthGenerator.java │ ├── MinimalRouteSensorGenerator.java │ ├── MinimalSemaphoreNeighborGenerator.java │ ├── MinimalSwitchMonitoredGenerator.java │ └── MinimalSwitchSetGenerator.java │ ├── runner │ └── GeneratorRunner.java │ ├── scalable │ └── ScalableModelGenerator.java │ ├── tests │ └── GeneratorTest.java │ └── utils │ ├── ZipIterator.java │ └── ZipUtils.java ├── trainbenchmark-reporting ├── .gitignore ├── build.gradle ├── individual.R ├── install.R ├── memory.R ├── query-plans.R ├── report.R ├── reporting.Rproj ├── tool-list.csv ├── tools.csv ├── util.R └── util2.R ├── trainbenchmark-scripts ├── build.gradle ├── diff.sh ├── src-template │ ├── BenchmarkScript.groovy │ ├── GeneratorScript.groovy │ └── IndividualBenchmarkScript.groovy └── src │ └── .gitignore ├── trainbenchmark-server ├── build.gradle └── src │ └── main │ └── webapp │ ├── diagrams │ └── .gitignore │ └── index.html ├── trainbenchmark-tool-emf ├── build.gradle └── src │ └── main │ ├── java │ └── hu │ │ └── bme │ │ └── mit │ │ └── trainbenchmark │ │ └── benchmark │ │ └── emf │ │ ├── comparators │ │ ├── EmfMatchComparator.java │ │ └── RailwayElementComparator.java │ │ ├── driver │ │ ├── EmfDriver.java │ │ └── EmfDriverFactory.java │ │ ├── matches │ │ ├── EmfConnectedSegmentsInjectMatch.java │ │ ├── EmfConnectedSegmentsMatch.java │ │ ├── EmfMatch.java │ │ ├── EmfPosLengthInjectMatch.java │ │ ├── EmfPosLengthMatch.java │ │ ├── EmfRouteSensorInjectMatch.java │ │ ├── EmfRouteSensorMatch.java │ │ ├── EmfSemaphoreNeighborInjectMatch.java │ │ ├── EmfSemaphoreNeighborMatch.java │ │ ├── EmfSwitchMonitoredInjectMatch.java │ │ ├── EmfSwitchMonitoredMatch.java │ │ ├── EmfSwitchSetInjectMatch.java │ │ └── EmfSwitchSetMatch.java │ │ └── transformation │ │ ├── EmfTransformation.java │ │ ├── inject │ │ ├── EmfTransformationInjectConnectedSegments.java │ │ ├── EmfTransformationInjectPosLength.java │ │ ├── EmfTransformationInjectRouteSensor.java │ │ ├── EmfTransformationInjectSemaphoreNeighbor.java │ │ ├── EmfTransformationInjectSwitchMonitored.java │ │ └── EmfTransformationInjectSwitchSet.java │ │ ├── query │ │ ├── EmfApiQuery.java │ │ ├── EmfApiQueryConnectedSegmentsInject.java │ │ ├── EmfApiQueryPosLengthInject.java │ │ ├── EmfApiQueryRouteSensorInject.java │ │ ├── EmfApiQuerySemaphoreNeighborInject.java │ │ ├── EmfApiQuerySwitchMonitoredInject.java │ │ └── EmfApiQuerySwitchSetInject.java │ │ └── repair │ │ ├── EmfTransformationRepairConnectedSegments.java │ │ ├── EmfTransformationRepairPosLength.java │ │ ├── EmfTransformationRepairRouteSensor.java │ │ ├── EmfTransformationRepairSemaphoreNeighbor.java │ │ ├── EmfTransformationRepairSwitchMonitored.java │ │ └── EmfTransformationRepairSwitchSet.java │ └── resources │ └── .gitignore ├── trainbenchmark-tool-emfapi ├── build.gradle └── src │ ├── main │ ├── java │ │ └── hu │ │ │ └── bme │ │ │ └── mit │ │ │ └── trainbenchmark │ │ │ └── benchmark │ │ │ └── emfapi │ │ │ ├── EmfApiBenchmarkMain.java │ │ │ ├── EmfApiBenchmarkScenario.java │ │ │ ├── config │ │ │ ├── EmfApiBenchmarkConfig.java │ │ │ └── EmfApiBenchmarkConfigBuilder.java │ │ │ ├── operations │ │ │ └── EmfApiModelOperationFactory.java │ │ │ └── queries │ │ │ ├── EmfApiQueryConnectedSegments.java │ │ │ ├── EmfApiQueryPosLength.java │ │ │ ├── EmfApiQueryRouteSensor.java │ │ │ ├── EmfApiQuerySemaphoreNeighbor.java │ │ │ ├── EmfApiQuerySwitchMonitored.java │ │ │ └── EmfApiQuerySwitchSet.java │ └── resources │ │ └── .gitignore │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── benchmark │ └── emfapi │ └── test │ └── EmfApiTest.java ├── trainbenchmark-tool-ingraph ├── .gitignore ├── build.gradle └── src │ ├── main │ ├── java │ │ └── hu │ │ │ └── bme │ │ │ └── mit │ │ │ └── trainbenchmark │ │ │ └── benchmark │ │ │ └── ingraph │ │ │ ├── IngraphBenchmarkMain.java │ │ │ ├── IngraphBenchmarkScenario.java │ │ │ ├── IngraphUtils.java │ │ │ ├── config │ │ │ ├── IngraphBenchmarkConfig.java │ │ │ └── IngraphBenchmarkConfigBuilder.java │ │ │ ├── driver │ │ │ ├── IngraphDriver.java │ │ │ └── IngraphDriverFactory.java │ │ │ ├── match │ │ │ ├── IngraphConnectedSegmentsInjectMatch.java │ │ │ ├── IngraphConnectedSegmentsMatch.java │ │ │ ├── IngraphMatch.java │ │ │ ├── IngraphMatchComparator.java │ │ │ ├── IngraphPosLengthInjectMatch.java │ │ │ ├── IngraphPosLengthMatch.java │ │ │ ├── IngraphRouteSensorInjectMatch.java │ │ │ ├── IngraphRouteSensorMatch.java │ │ │ ├── IngraphSemaphoreNeighborInjectMatch.java │ │ │ ├── IngraphSemaphoreNeighborMatch.java │ │ │ ├── IngraphSwitchMonitoredInjectMatch.java │ │ │ ├── IngraphSwitchMonitoredMatch.java │ │ │ ├── IngraphSwitchSetInjectMatch.java │ │ │ └── IngraphSwitchSetMatch.java │ │ │ ├── operations │ │ │ └── IngraphModelOperationFactory.java │ │ │ ├── queries │ │ │ ├── IngraphChangeListener.java │ │ │ └── IngraphQuery.java │ │ │ └── transformations │ │ │ ├── IngraphTransformation.java │ │ │ ├── inject │ │ │ ├── IngraphTransformationInjectConnectedSegments.java │ │ │ ├── IngraphTransformationInjectPosLength.java │ │ │ ├── IngraphTransformationInjectRouteSensor.java │ │ │ ├── IngraphTransformationInjectSemaphoreNeighbor.java │ │ │ ├── IngraphTransformationInjectSwitchMonitored.java │ │ │ └── IngraphTransformationInjectSwitchSet.java │ │ │ └── repair │ │ │ ├── IngraphTransformationRepairConnectedSegments.java │ │ │ ├── IngraphTransformationRepairPosLength.java │ │ │ ├── IngraphTransformationRepairRouteSensor.java │ │ │ ├── IngraphTransformationRepairSemaphoreNeighbor.java │ │ │ ├── IngraphTransformationRepairSwitchMonitored.java │ │ │ └── IngraphTransformationRepairSwitchSet.java │ └── resources │ │ └── log4j.properties │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── benchmark │ └── ingraph │ └── test │ ├── IngraphTest.java │ └── queryspecific │ ├── IngraphRouteSensorTest.java │ └── IngraphSemaphoreNeighborTest.java ├── trainbenchmark-tool-janusgraph ├── build.gradle ├── conf │ ├── jgex-berkeleyje.properties │ ├── jgex-cassandra.properties │ └── jgex-inmemory.properties └── src │ ├── main │ ├── java │ │ └── hu │ │ │ └── bme │ │ │ └── mit │ │ │ └── trainbenchmark │ │ │ └── benchmark │ │ │ └── janusgraph │ │ │ ├── JanusGraphBenchmarkMain.java │ │ │ ├── JanusGraphBenchmarkScenario.java │ │ │ ├── config │ │ │ ├── JanusGraphBenchmarkConfig.java │ │ │ └── JanusGraphBenchmarkConfigBuilder.java │ │ │ └── driver │ │ │ ├── JanusGraphDriver.java │ │ │ └── JanusGraphDriverFactory.java │ └── resources │ │ └── .gitignore │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── benchmark │ └── janusgraph │ └── test │ └── JanusGraphTest.java ├── trainbenchmark-tool-jena ├── .gitignore ├── build.gradle └── src │ ├── main │ ├── java │ │ └── hu │ │ │ └── bme │ │ │ └── mit │ │ │ └── trainbenchmark │ │ │ └── benchmark │ │ │ └── jena │ │ │ ├── JenaBenchmarkMain.java │ │ │ ├── JenaBenchmarkScenario.java │ │ │ ├── comparators │ │ │ ├── JenaMatchComparator.java │ │ │ └── ResourceComparator.java │ │ │ ├── config │ │ │ ├── JenaBenchmarkConfig.java │ │ │ └── JenaBenchmarkConfigBuilder.java │ │ │ ├── driver │ │ │ ├── JenaDriver.java │ │ │ ├── JenaDriverFactory.java │ │ │ └── StatementComparator.java │ │ │ ├── matches │ │ │ ├── JenaConnectedSegmentsInjectMatch.java │ │ │ ├── JenaConnectedSegmentsMatch.java │ │ │ ├── JenaMatch.java │ │ │ ├── JenaPosLengthInjectMatch.java │ │ │ ├── JenaPosLengthMatch.java │ │ │ ├── JenaRouteSensorInjectMatch.java │ │ │ ├── JenaRouteSensorMatch.java │ │ │ ├── JenaSemaphoreNeighborInjectMatch.java │ │ │ ├── JenaSemaphoreNeighborMatch.java │ │ │ ├── JenaSwitchMonitoredInjectMatch.java │ │ │ ├── JenaSwitchMonitoredMatch.java │ │ │ ├── JenaSwitchSetInjectMatch.java │ │ │ └── JenaSwitchSetMatch.java │ │ │ ├── operations │ │ │ └── JenaModelOperationFactory.java │ │ │ ├── queries │ │ │ └── JenaQuery.java │ │ │ └── transformations │ │ │ ├── JenaTransformation.java │ │ │ ├── inject │ │ │ ├── JenaTransformationInjectConnectedSegments.java │ │ │ ├── JenaTransformationInjectPosLength.java │ │ │ ├── JenaTransformationInjectRouteSensor.java │ │ │ ├── JenaTransformationInjectSemaphoreNeighbor.java │ │ │ ├── JenaTransformationInjectSwitchMonitored.java │ │ │ └── JenaTransformationInjectSwitchSet.java │ │ │ └── repair │ │ │ ├── JenaTransformationRepairConnectedSegments.java │ │ │ ├── JenaTransformationRepairPosLength.java │ │ │ ├── JenaTransformationRepairRouteSensor.java │ │ │ ├── JenaTransformationRepairSemaphoreNeighbor.java │ │ │ ├── JenaTransformationRepairSwitchMonitored.java │ │ │ └── JenaTransformationRepairSwitchSet.java │ └── resources │ │ └── log4j.properties │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── benchmark │ └── jena │ └── test │ └── JenaTest.java ├── trainbenchmark-tool-mysql ├── .gitignore ├── README.md ├── build.gradle └── src │ ├── main │ ├── java │ │ └── hu │ │ │ └── bme │ │ │ └── mit │ │ │ └── trainbenchmark │ │ │ └── benchmark │ │ │ └── mysql │ │ │ ├── MySqlBenchmarkMain.java │ │ │ ├── MySqlBenchmarkScenario.java │ │ │ ├── config │ │ │ ├── MySqlBenchmarkConfig.java │ │ │ └── MySqlBenchmarkConfigBuilder.java │ │ │ ├── driver │ │ │ ├── MySqlDriver.java │ │ │ └── MySqlDriverFactory.java │ │ │ └── operations │ │ │ └── MySqlModelOperationFactory.java │ └── resources │ │ └── .gitignore │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── benchmark │ └── mysql │ └── test │ └── MySqlTest.java ├── trainbenchmark-tool-neo4j ├── README.md ├── build.gradle └── src │ ├── main │ ├── java │ │ └── hu │ │ │ └── bme │ │ │ └── mit │ │ │ └── trainbenchmark │ │ │ └── benchmark │ │ │ └── neo4j │ │ │ ├── Neo4jBenchmarkMain.java │ │ │ ├── Neo4jBenchmarkScenario.java │ │ │ ├── comparators │ │ │ ├── Neo4jMatchComparator.java │ │ │ └── NodeComparator.java │ │ │ ├── config │ │ │ ├── Neo4jBenchmarkConfig.java │ │ │ ├── Neo4jBenchmarkConfigBuilder.java │ │ │ └── Neo4jEngine.java │ │ │ ├── driver │ │ │ ├── Neo4jDriver.java │ │ │ └── Neo4jDriverFactory.java │ │ │ ├── matches │ │ │ ├── Neo4jActiveRouteMatch.java │ │ │ ├── Neo4jConnectedSegmentsInjectMatch.java │ │ │ ├── Neo4jConnectedSegmentsMatch.java │ │ │ ├── Neo4jMatch.java │ │ │ ├── Neo4jPosLengthInjectMatch.java │ │ │ ├── Neo4jPosLengthMatch.java │ │ │ ├── Neo4jRouteLengthMatch.java │ │ │ ├── Neo4jRouteReachabilityMatch.java │ │ │ ├── Neo4jRouteSensorInjectMatch.java │ │ │ ├── Neo4jRouteSensorMatch.java │ │ │ ├── Neo4jSemaphoreNeighborInjectMatch.java │ │ │ ├── Neo4jSemaphoreNeighborMatch.java │ │ │ ├── Neo4jSwitchMonitoredInjectMatch.java │ │ │ ├── Neo4jSwitchMonitoredMatch.java │ │ │ ├── Neo4jSwitchSetInjectMatch.java │ │ │ └── Neo4jSwitchSetMatch.java │ │ │ ├── operations │ │ │ └── Neo4jModelOperationFactory.java │ │ │ ├── queries │ │ │ ├── Neo4jQuery.java │ │ │ ├── api │ │ │ │ ├── Neo4JApiQueryConnectedSegments.java │ │ │ │ ├── Neo4JApiQueryConnectedSegmentsInject.java │ │ │ │ ├── Neo4JApiQueryPosLength.java │ │ │ │ ├── Neo4JApiQueryPosLengthInject.java │ │ │ │ ├── Neo4JApiQueryRouteSensor.java │ │ │ │ ├── Neo4JApiQueryRouteSensorInject.java │ │ │ │ ├── Neo4JApiQuerySemaphoreNeighbor.java │ │ │ │ ├── Neo4JApiQuerySemaphoreNeighborInject.java │ │ │ │ ├── Neo4JApiQuerySwitchMonitored.java │ │ │ │ ├── Neo4JApiQuerySwitchMonitoredInject.java │ │ │ │ ├── Neo4JApiQuerySwitchSet.java │ │ │ │ ├── Neo4JApiQuerySwitchSetInject.java │ │ │ │ └── Neo4jApiQuery.java │ │ │ └── cypher │ │ │ │ └── Neo4jCypherQuery.java │ │ │ ├── transformations │ │ │ ├── Neo4jApiTransformation.java │ │ │ ├── Neo4jCypherTransformation.java │ │ │ ├── Neo4jTransformation.java │ │ │ ├── api │ │ │ │ ├── inject │ │ │ │ │ ├── Neo4jApiTransformationInjectConnectedSegments.java │ │ │ │ │ ├── Neo4jApiTransformationInjectPosLength.java │ │ │ │ │ ├── Neo4jApiTransformationInjectRouteSensor.java │ │ │ │ │ ├── Neo4jApiTransformationInjectSemaphoreNeighbor.java │ │ │ │ │ ├── Neo4jApiTransformationInjectSwitchMonitored.java │ │ │ │ │ └── Neo4jApiTransformationInjectSwitchSet.java │ │ │ │ └── repair │ │ │ │ │ ├── Neo4jApiTransformationRepairConnectedSegments.java │ │ │ │ │ ├── Neo4jApiTransformationRepairPosLength.java │ │ │ │ │ ├── Neo4jApiTransformationRepairRouteSensor.java │ │ │ │ │ ├── Neo4jApiTransformationRepairSemaphoreNeighbor.java │ │ │ │ │ ├── Neo4jApiTransformationRepairSwitchMonitored.java │ │ │ │ │ └── Neo4jApiTransformationRepairSwitchSet.java │ │ │ └── cypher │ │ │ │ ├── inject │ │ │ │ ├── Neo4jCypherTransformationInjectConnectedSegments.java │ │ │ │ ├── Neo4jCypherTransformationInjectPosLength.java │ │ │ │ ├── Neo4jCypherTransformationInjectRouteSensor.java │ │ │ │ ├── Neo4jCypherTransformationInjectSemaphoreNeighbor.java │ │ │ │ ├── Neo4jCypherTransformationInjectSwitchMonitored.java │ │ │ │ └── Neo4jCypherTransformationInjectSwitchSet.java │ │ │ │ └── repair │ │ │ │ ├── Neo4jCypherTransformationRepairConnectedSegments.java │ │ │ │ ├── Neo4jCypherTransformationRepairPosLength.java │ │ │ │ ├── Neo4jCypherTransformationRepairRouteSensor.java │ │ │ │ ├── Neo4jCypherTransformationRepairSemaphoreNeighbor.java │ │ │ │ ├── Neo4jCypherTransformationRepairSwitchMonitored.java │ │ │ │ └── Neo4jCypherTransformationRepairSwitchSet.java │ │ │ └── util │ │ │ └── Neo4jUtil.java │ └── resources │ │ ├── queries │ │ ├── ActiveRoute.cypher │ │ ├── ConnectedSegments.cypher │ │ ├── ConnectedSegmentsInject.cypher │ │ ├── PosLength.cypher │ │ ├── PosLengthInject.cypher │ │ ├── RouteLength.cypher │ │ ├── RouteReachability.cypher │ │ ├── RouteSensor.cypher │ │ ├── RouteSensorInject.cypher │ │ ├── SemaphoreNeighbor.cypher │ │ ├── SemaphoreNeighborInject.cypher │ │ ├── SwitchMonitored.cypher │ │ ├── SwitchMonitoredInject.cypher │ │ ├── SwitchSet.cypher │ │ └── SwitchSetInject.cypher │ │ └── transformations │ │ ├── ConnectedSegmentsInjectRhs.cypher │ │ ├── ConnectedSegmentsRepairRhs.cypher │ │ ├── PosLengthInjectRhs.cypher │ │ ├── PosLengthRepairRhs.cypher │ │ ├── RouteSensorInjectRhs.cypher │ │ ├── RouteSensorRepairRhs.cypher │ │ ├── SemaphoreNeighborInjectRhs.cypher │ │ ├── SemaphoreNeighborRepairRhs.cypher │ │ ├── SwitchMonitoredInjectRhs.cypher │ │ ├── SwitchMonitoredRepairRhs.cypher │ │ ├── SwitchSetInjectRhs.cypher │ │ └── SwitchSetRepairRhs.cypher │ └── test │ ├── java │ └── hu │ │ └── bme │ │ └── mit │ │ └── trainbenchmark │ │ └── benchmark │ │ └── neo4j │ │ └── test │ │ ├── Neo4jTest.java │ │ └── NewQueriesTest.java │ └── resources │ └── .gitignore ├── trainbenchmark-tool-orientdb ├── build.gradle ├── conf │ ├── jgex-berkeleyje.properties │ ├── jgex-cassandra.properties │ └── jgex-inmemory.properties └── src │ ├── main │ ├── java │ │ └── hu │ │ │ └── bme │ │ │ └── mit │ │ │ └── trainbenchmark │ │ │ └── benchmark │ │ │ └── orientdb │ │ │ ├── OrientDbBenchmarkMain.java │ │ │ ├── OrientDbBenchmarkScenario.java │ │ │ ├── config │ │ │ ├── OrientDbBenchmarkConfig.java │ │ │ └── OrientDbBenchmarkConfigBuilder.java │ │ │ ├── driver │ │ │ ├── OrientDbDriver.java │ │ │ └── OrientDbDriverFactory.java │ │ │ └── operations │ │ │ └── OrientDbModelOperationFactory.java │ └── resources │ │ └── .gitignore │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── benchmark │ └── orientdb │ └── test │ └── OrientDbTest.java ├── trainbenchmark-tool-rdf ├── build.gradle └── src │ └── main │ ├── java │ └── hu │ │ └── bme │ │ └── mit │ │ └── trainbenchmark │ │ └── benchmark │ │ └── rdf │ │ ├── config │ │ ├── RdfBenchmarkConfig.java │ │ └── RdfBenchmarkConfigBuilder.java │ │ ├── driver │ │ ├── RdfDriver.java │ │ └── RdfDriverFactory.java │ │ ├── queries │ │ └── RdfModelQuery.java │ │ └── tests │ │ └── RdfTest.java │ └── resources │ └── queries │ ├── ConnectedSegments.sparql │ ├── ConnectedSegmentsInject.sparql │ ├── PosLength.sparql │ ├── PosLengthInject.sparql │ ├── RouteSensor.sparql │ ├── RouteSensorInject.sparql │ ├── SemaphoreNeighbor.sparql │ ├── SemaphoreNeighborInject.sparql │ ├── SwitchMonitored.sparql │ ├── SwitchMonitoredInject.sparql │ ├── SwitchSet.sparql │ └── SwitchSetInject.sparql ├── trainbenchmark-tool-sesame ├── .gitignore ├── build.gradle └── src │ ├── main │ ├── java │ │ └── hu │ │ │ └── bme │ │ │ └── mit │ │ │ └── trainbenchmark │ │ │ └── benchmark │ │ │ └── sesame │ │ │ ├── SesameBenchmarkMain.java │ │ │ ├── SesameBenchmarkScenario.java │ │ │ ├── comparators │ │ │ ├── SesameMatchComparator.java │ │ │ └── UriComparator.java │ │ │ ├── config │ │ │ ├── SesameBenchmarkConfig.java │ │ │ └── SesameBenchmarkConfigBuilder.java │ │ │ ├── driver │ │ │ ├── SesameDriver.java │ │ │ └── SesameDriverFactory.java │ │ │ ├── matches │ │ │ ├── SesameConnectedSegmentsInjectMatch.java │ │ │ ├── SesameConnectedSegmentsMatch.java │ │ │ ├── SesameMatch.java │ │ │ ├── SesamePosLengthInjectMatch.java │ │ │ ├── SesamePosLengthMatch.java │ │ │ ├── SesameRouteSensorInjectMatch.java │ │ │ ├── SesameRouteSensorMatch.java │ │ │ ├── SesameSemaphoreNeighborInjectMatch.java │ │ │ ├── SesameSemaphoreNeighborMatch.java │ │ │ ├── SesameSwitchMonitoredInjectMatch.java │ │ │ ├── SesameSwitchMonitoredMatch.java │ │ │ ├── SesameSwitchSetInjectMatch.java │ │ │ └── SesameSwitchSetMatch.java │ │ │ ├── operations │ │ │ └── SesameModelOperationFactory.java │ │ │ ├── queries │ │ │ └── SesameQuery.java │ │ │ └── transformations │ │ │ ├── SesameTransformation.java │ │ │ ├── inject │ │ │ ├── SesameTransformationInjectConnectedSegments.java │ │ │ ├── SesameTransformationInjectPosLength.java │ │ │ ├── SesameTransformationInjectRouteSensor.java │ │ │ ├── SesameTransformationInjectSemaphoreNeighbor.java │ │ │ ├── SesameTransformationInjectSwitchMonitored.java │ │ │ └── SesameTransformationInjectSwitchSet.java │ │ │ └── repair │ │ │ ├── SesameTransformationRepairConnectedSegments.java │ │ │ ├── SesameTransformationRepairPosLength.java │ │ │ ├── SesameTransformationRepairRouteSensor.java │ │ │ ├── SesameTransformationRepairSemaphoreNeighbor.java │ │ │ ├── SesameTransformationRepairSwitchMonitored.java │ │ │ └── SesameTransformationRepairSwitchSet.java │ └── resources │ │ └── .gitignore │ └── test │ ├── java │ └── hu │ │ └── bme │ │ └── mit │ │ └── trainbenchmark │ │ └── benchmark │ │ └── sesame │ │ └── test │ │ └── SesameTest.java │ └── resources │ └── .gitignore ├── trainbenchmark-tool-sql ├── build.gradle └── src │ └── main │ ├── java │ └── hu │ │ └── bme │ │ └── mit │ │ └── trainbenchmark │ │ └── benchmark │ │ └── sql │ │ ├── driver │ │ └── SqlDriver.java │ │ ├── matches │ │ ├── SqlConnectedSegmentsInjectMatch.java │ │ ├── SqlConnectedSegmentsMatch.java │ │ ├── SqlMatch.java │ │ ├── SqlPosLengthInjectMatch.java │ │ ├── SqlPosLengthMatch.java │ │ ├── SqlRouteSensorInjectMatch.java │ │ ├── SqlRouteSensorMatch.java │ │ ├── SqlSemaphoreNeighborInjectMatch.java │ │ ├── SqlSemaphoreNeighborMatch.java │ │ ├── SqlSwitchMonitoredInjectMatch.java │ │ ├── SqlSwitchMonitoredMatch.java │ │ ├── SqlSwitchSetInjectMatch.java │ │ └── SqlSwitchSetMatch.java │ │ ├── queries │ │ └── SqlQuery.java │ │ └── transformations │ │ ├── SqlTransformation.java │ │ ├── inject │ │ ├── SqlTransformationInjectConnectedSegments.java │ │ ├── SqlTransformationInjectPosLength.java │ │ ├── SqlTransformationInjectRouteSensor.java │ │ ├── SqlTransformationInjectSemaphoreNeighbor.java │ │ ├── SqlTransformationInjectSwitchMonitored.java │ │ └── SqlTransformationInjectSwitchSet.java │ │ └── repair │ │ ├── SqlTransformationRepairConnectedSegments.java │ │ ├── SqlTransformationRepairPosLength.java │ │ ├── SqlTransformationRepairRouteSensor.java │ │ ├── SqlTransformationRepairSemaphoreNeighbor.java │ │ ├── SqlTransformationRepairSwitchMonitored.java │ │ └── SqlTransformationRepairSwitchSet.java │ └── resources │ ├── queries │ ├── ConnectedSegments.sql │ ├── ConnectedSegmentsInject.sql │ ├── PosLength.sql │ ├── PosLengthInject.sql │ ├── RouteSensor.sql │ ├── RouteSensorInject.sql │ ├── SemaphoreNeighbor.sql │ ├── SemaphoreNeighborInject.sql │ ├── SwitchMonitored.sql │ ├── SwitchMonitoredInject.sql │ ├── SwitchSet.sql │ └── SwitchSetInject.sql │ └── transformations │ ├── ConnectedSegmentsInjectRhs.sql │ ├── ConnectedSegmentsRepairRhs.sql │ ├── PosLengthInjectRhs.sql │ ├── PosLengthRepairRhs.sql │ ├── RouteSensorInjectRhs.sql │ ├── RouteSensorRepairRhs.sql │ ├── SemaphoreNeighborInjectRhs.sql │ ├── SemaphoreNeighborRepairRhs.sql │ ├── SwitchMonitoredInjectRhs.sql │ ├── SwitchMonitoredRepairRhs.sql │ ├── SwitchSetInjectRhs.sql │ └── SwitchSetRepairRhs.sql ├── trainbenchmark-tool-sqlite ├── .gitignore ├── README.md ├── build.gradle └── src │ ├── main │ ├── java │ │ └── hu │ │ │ └── bme │ │ │ └── mit │ │ │ └── trainbenchmark │ │ │ └── benchmark │ │ │ └── sqlite │ │ │ ├── SQLiteBenchmarkMain.java │ │ │ ├── SQLiteBenchmarkScenario.java │ │ │ ├── config │ │ │ ├── SQLiteBenchmarkConfig.java │ │ │ └── SQLiteBenchmarkConfigBuilder.java │ │ │ ├── driver │ │ │ ├── SQLiteDriver.java │ │ │ └── SQLiteDriverFactory.java │ │ │ ├── operations │ │ │ └── SQLiteModelOperationFactory.java │ │ │ ├── transformation │ │ │ └── SQLiteTransformation.java │ │ │ └── transformations │ │ │ ├── inject │ │ │ ├── SQLiteTransformationInjectConnectedSegments.java │ │ │ └── SQLiteTransformationInjectRouteSensor.java │ │ │ └── repair │ │ │ ├── SQLiteTransformationRepairConnectedSegments.java │ │ │ └── SQLiteTransformationRepairSwitchMonitored.java │ └── resources │ │ └── transformations │ │ ├── ConnectedSegmentsInjectRhs.sql │ │ ├── ConnectedSegmentsRepairRhs.sql │ │ ├── RouteSensorInjectRhs.sql │ │ └── SwitchMonitoredRepairRhs.sql │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── benchmark │ └── sqlite │ └── test │ └── SQLiteTest.java ├── trainbenchmark-tool-tinkergraph ├── build.gradle └── src │ ├── main │ ├── java │ │ └── hu │ │ │ └── bme │ │ │ └── mit │ │ │ └── trainbenchmark │ │ │ └── benchmark │ │ │ └── tinkergraph │ │ │ ├── TinkerGraphBenchmarkMain.java │ │ │ ├── TinkerGraphBenchmarkScenario.java │ │ │ ├── comparators │ │ │ ├── TinkerGraphMatchComparator.java │ │ │ └── VertexComparator.java │ │ │ ├── config │ │ │ ├── TinkerGraphBenchmarkConfig.java │ │ │ ├── TinkerGraphBenchmarkConfigBuilder.java │ │ │ └── TinkerGraphEngine.java │ │ │ ├── driver │ │ │ ├── GraphDriver.java │ │ │ ├── TinkerGraphDriver.java │ │ │ └── TinkerGraphDriverFactory.java │ │ │ ├── matches │ │ │ ├── TinkerGraphConnectedSegmentsInjectMatch.java │ │ │ ├── TinkerGraphConnectedSegmentsMatch.java │ │ │ ├── TinkerGraphMatch.java │ │ │ ├── TinkerGraphPosLengthInjectMatch.java │ │ │ ├── TinkerGraphPosLengthMatch.java │ │ │ ├── TinkerGraphRouteSensorInjectMatch.java │ │ │ ├── TinkerGraphRouteSensorMatch.java │ │ │ ├── TinkerGraphSemaphoreNeighborInjectMatch.java │ │ │ ├── TinkerGraphSemaphoreNeighborMatch.java │ │ │ ├── TinkerGraphSwitchMonitoredInjectMatch.java │ │ │ ├── TinkerGraphSwitchMonitoredMatch.java │ │ │ ├── TinkerGraphSwitchSetInjectMatch.java │ │ │ └── TinkerGraphSwitchSetMatch.java │ │ │ ├── operations │ │ │ └── TinkerGraphModelOperationFactory.java │ │ │ ├── queries │ │ │ ├── TinkerGraphQuery.java │ │ │ ├── api │ │ │ │ ├── TinkerGraphQueryConnectedSegments.java │ │ │ │ ├── TinkerGraphQueryConnectedSegmentsInject.java │ │ │ │ ├── TinkerGraphQueryPosLength.java │ │ │ │ ├── TinkerGraphQueryPosLengthInject.java │ │ │ │ ├── TinkerGraphQueryRouteSensor.java │ │ │ │ ├── TinkerGraphQueryRouteSensorInject.java │ │ │ │ ├── TinkerGraphQuerySemaphoreNeighbor.java │ │ │ │ ├── TinkerGraphQuerySemaphoreNeighborInject.java │ │ │ │ ├── TinkerGraphQuerySwitchMonitored.java │ │ │ │ ├── TinkerGraphQuerySwitchMonitoredInject.java │ │ │ │ ├── TinkerGraphQuerySwitchSet.java │ │ │ │ └── TinkerGraphQuerySwitchSetInject.java │ │ │ └── gremlin │ │ │ │ └── TinkerGraphGremlinQuery.java │ │ │ └── transformations │ │ │ ├── TinkerGraphTransformation.java │ │ │ ├── inject │ │ │ ├── TinkerGraphTransformationInjectConnectedSegments.java │ │ │ ├── TinkerGraphTransformationInjectPosLength.java │ │ │ ├── TinkerGraphTransformationInjectRouteSensor.java │ │ │ ├── TinkerGraphTransformationInjectSemaphoreNeighbor.java │ │ │ ├── TinkerGraphTransformationInjectSwitchMonitored.java │ │ │ └── TinkerGraphTransformationInjectSwitchSet.java │ │ │ ├── repair │ │ │ ├── TinkerGraphTransformationRepairConnectedSegments.java │ │ │ ├── TinkerGraphTransformationRepairPosLength.java │ │ │ ├── TinkerGraphTransformationRepairRouteSensor.java │ │ │ ├── TinkerGraphTransformationRepairSemaphoreNeighbor.java │ │ │ ├── TinkerGraphTransformationRepairSwitchMonitored.java │ │ │ └── TinkerGraphTransformationRepairSwitchSet.java │ │ │ └── util │ │ │ └── TinkerGraphUtil.java │ └── resources │ │ ├── .gitignore │ │ └── queries │ │ ├── ConnectedSegments.gremlin │ │ ├── ConnectedSegmentsInject.gremlin │ │ ├── PosLength.gremlin │ │ ├── PosLengthInject.gremlin │ │ ├── RouteSensor.gremlin │ │ ├── RouteSensorInject.gremlin │ │ ├── SemaphoreNeighbor.gremlin │ │ ├── SemaphoreNeighborInject.gremlin │ │ ├── SwitchMonitored.gremlin │ │ ├── SwitchMonitoredInject.gremlin │ │ ├── SwitchSet.gremlin │ │ └── SwitchSetInject.gremlin │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── benchmark │ └── tinkergraph │ └── test │ └── TinkerGraphTest.java ├── trainbenchmark-tool-viatra-patterns ├── .classpath ├── .gitignore ├── .project ├── META-INF │ └── MANIFEST.MF ├── build.gradle ├── build.properties ├── plugin.xml ├── src-gen │ └── hu │ │ └── bme │ │ └── mit │ │ └── trainbenchmark │ │ └── benchmark │ │ └── viatra │ │ ├── ConnectedSegments.java │ │ ├── ConnectedSegmentsInject.java │ │ ├── ConnectedSegmentsInjectMatch.java │ │ ├── ConnectedSegmentsInjectMatcher.java │ │ ├── ConnectedSegmentsMatch.java │ │ ├── ConnectedSegmentsMatcher.java │ │ ├── EntrySemaphoreMatch.java │ │ ├── EntrySemaphoreMatcher.java │ │ ├── HasSensorMatch.java │ │ ├── HasSensorMatcher.java │ │ ├── PosLength.java │ │ ├── PosLengthInject.java │ │ ├── PosLengthInjectMatch.java │ │ ├── PosLengthInjectMatcher.java │ │ ├── PosLengthMatch.java │ │ ├── PosLengthMatcher.java │ │ ├── RequiredMatch.java │ │ ├── RequiredMatcher.java │ │ ├── RouteSensor.java │ │ ├── RouteSensorInject.java │ │ ├── RouteSensorInjectMatch.java │ │ ├── RouteSensorInjectMatcher.java │ │ ├── RouteSensorMatch.java │ │ ├── RouteSensorMatcher.java │ │ ├── SemaphoreNeighbor.java │ │ ├── SemaphoreNeighborInject.java │ │ ├── SemaphoreNeighborInjectMatch.java │ │ ├── SemaphoreNeighborInjectMatcher.java │ │ ├── SemaphoreNeighborMatch.java │ │ ├── SemaphoreNeighborMatcher.java │ │ ├── SwitchMonitored.java │ │ ├── SwitchMonitoredInject.java │ │ ├── SwitchMonitoredInjectMatch.java │ │ ├── SwitchMonitoredInjectMatcher.java │ │ ├── SwitchMonitoredMatch.java │ │ ├── SwitchMonitoredMatcher.java │ │ ├── SwitchSet.java │ │ ├── SwitchSetInject.java │ │ ├── SwitchSetInjectMatch.java │ │ ├── SwitchSetInjectMatcher.java │ │ ├── SwitchSetMatch.java │ │ ├── SwitchSetMatcher.java │ │ └── util │ │ ├── ConnectedSegmentsInjectProcessor.java │ │ ├── ConnectedSegmentsInjectQuerySpecification.java │ │ ├── ConnectedSegmentsProcessor.java │ │ ├── ConnectedSegmentsQuerySpecification.java │ │ ├── EntrySemaphoreProcessor.java │ │ ├── EntrySemaphoreQuerySpecification.java │ │ ├── HasSensorProcessor.java │ │ ├── HasSensorQuerySpecification.java │ │ ├── PosLengthInjectProcessor.java │ │ ├── PosLengthInjectQuerySpecification.java │ │ ├── PosLengthProcessor.java │ │ ├── PosLengthQuerySpecification.java │ │ ├── RequiredProcessor.java │ │ ├── RequiredQuerySpecification.java │ │ ├── RouteSensorInjectProcessor.java │ │ ├── RouteSensorInjectQuerySpecification.java │ │ ├── RouteSensorProcessor.java │ │ ├── RouteSensorQuerySpecification.java │ │ ├── SemaphoreNeighborInjectProcessor.java │ │ ├── SemaphoreNeighborInjectQuerySpecification.java │ │ ├── SemaphoreNeighborProcessor.java │ │ ├── SemaphoreNeighborQuerySpecification.java │ │ ├── SwitchMonitoredInjectProcessor.java │ │ ├── SwitchMonitoredInjectQuerySpecification.java │ │ ├── SwitchMonitoredProcessor.java │ │ ├── SwitchMonitoredQuerySpecification.java │ │ ├── SwitchSetInjectProcessor.java │ │ ├── SwitchSetInjectQuerySpecification.java │ │ ├── SwitchSetProcessor.java │ │ └── SwitchSetQuerySpecification.java └── src │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── benchmark │ └── viatra │ ├── ConnectedSegments.vql │ ├── ConnectedSegmentsInject.vql │ ├── PosLength.vql │ ├── PosLengthInject.vql │ ├── RouteSensor.vql │ ├── RouteSensorInject.vql │ ├── SemaphoreNeighbor.vql │ ├── SemaphoreNeighborInject.vql │ ├── SwitchMonitored.vql │ ├── SwitchMonitoredInject.vql │ ├── SwitchSet.vql │ └── SwitchSetInject.vql ├── trainbenchmark-tool-viatra ├── build.gradle └── src │ ├── main │ └── java │ │ └── hu │ │ └── bme │ │ └── mit │ │ └── trainbenchmark │ │ └── benchmark │ │ └── viatra │ │ ├── ViatraBenchmarkMain.java │ │ ├── ViatraBenchmarkScenario.java │ │ ├── comparators │ │ └── ViatraMatchComparator.java │ │ ├── config │ │ ├── ViatraBackend.java │ │ ├── ViatraBenchmarkConfig.java │ │ └── ViatraBenchmarkConfigBuilder.java │ │ ├── driver │ │ ├── ViatraDriver.java │ │ └── ViatraDriverFactory.java │ │ ├── operations │ │ └── ViatraModelOperationFactory.java │ │ ├── queries │ │ ├── ViatraQuery.java │ │ ├── ViatraQueryConnectedSegments.java │ │ ├── ViatraQueryConnectedSegmentsInject.java │ │ ├── ViatraQueryPosLength.java │ │ ├── ViatraQueryPosLengthInject.java │ │ ├── ViatraQueryRouteSensor.java │ │ ├── ViatraQueryRouteSensorInject.java │ │ ├── ViatraQuerySemaphoreNeighbor.java │ │ ├── ViatraQuerySemaphoreNeighborInject.java │ │ ├── ViatraQuerySwitchMonitored.java │ │ ├── ViatraQuerySwitchMonitoredInject.java │ │ ├── ViatraQuerySwitchSet.java │ │ └── ViatraQuerySwitchSetInject.java │ │ └── transformations │ │ ├── ViatraTransformation.java │ │ ├── inject │ │ ├── ViatraTransformationInjectConnectedSegments.java │ │ ├── ViatraTransformationInjectPosLength.java │ │ ├── ViatraTransformationInjectRouteSensor.java │ │ ├── ViatraTransformationInjectSemaphoreNeighbor.java │ │ ├── ViatraTransformationInjectSwitchMonitored.java │ │ └── ViatraTransformationInjectSwitchSet.java │ │ └── repair │ │ ├── ViatraTransformationRepairConnectedSegments.java │ │ ├── ViatraTransformationRepairPosLength.java │ │ ├── ViatraTransformationRepairRouteSensor.java │ │ ├── ViatraTransformationRepairSemaphoreNeighbor.java │ │ ├── ViatraTransformationRepairSwitchMonitored.java │ │ └── ViatraTransformationRepairSwitchSet.java │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── benchmark │ └── viatra │ └── test │ └── ViatraTest.java ├── trainbenchmark-tool ├── build.gradle ├── build.properties └── src │ ├── main │ ├── java │ │ └── hu │ │ │ └── bme │ │ │ └── mit │ │ │ └── trainbenchmark │ │ │ └── benchmark │ │ │ ├── comparators │ │ │ ├── LongComparator.java │ │ │ └── LongMatchComparator.java │ │ │ ├── config │ │ │ ├── BenchmarkConfig.java │ │ │ ├── BenchmarkConfigBase.java │ │ │ ├── BenchmarkConfigBaseBuilder.java │ │ │ ├── BenchmarkConfigBuilder.java │ │ │ ├── ModelSetConfig.java │ │ │ └── TransformationChangeSetStrategy.java │ │ │ ├── driver │ │ │ ├── Driver.java │ │ │ └── DriverFactory.java │ │ │ ├── matches │ │ │ ├── ActiveRouteMatch.java │ │ │ ├── BaseMatch.java │ │ │ ├── ConnectedSegmentsInjectMatch.java │ │ │ ├── ConnectedSegmentsMatch.java │ │ │ ├── LongMatch.java │ │ │ ├── Match.java │ │ │ ├── PosLengthInjectMatch.java │ │ │ ├── PosLengthMatch.java │ │ │ ├── RouteLengthMatch.java │ │ │ ├── RouteReachabilityMatch.java │ │ │ ├── RouteSensorInjectMatch.java │ │ │ ├── RouteSensorMatch.java │ │ │ ├── SemaphoreNeighborInjectMatch.java │ │ │ ├── SemaphoreNeighborMatch.java │ │ │ ├── SwitchMonitoredInjectMatch.java │ │ │ ├── SwitchMonitoredMatch.java │ │ │ ├── SwitchSetInjectMatch.java │ │ │ ├── SwitchSetMatch.java │ │ │ └── comparators │ │ │ │ ├── BaseMatchComparator.java │ │ │ │ └── MatchComparator.java │ │ │ ├── operations │ │ │ ├── ModelOperation.java │ │ │ ├── ModelOperationFactory.java │ │ │ ├── ModelOperationRegistry.java │ │ │ ├── ModelQuery.java │ │ │ └── ModelTransformation.java │ │ │ ├── phases │ │ │ ├── BenchmarkScenario.java │ │ │ ├── CleanupPhase.java │ │ │ ├── InitializeOperationsPhase.java │ │ │ ├── Phase.java │ │ │ ├── PhaseExecutor.java │ │ │ ├── QueryPhase.java │ │ │ ├── ReadPhase.java │ │ │ └── TransformationPhase.java │ │ │ ├── result │ │ │ ├── AbstractResult.java │ │ │ └── ResultHelper.java │ │ │ ├── runcomponents │ │ │ ├── BenchmarkBundle.java │ │ │ ├── BenchmarkReporter.java │ │ │ ├── BenchmarkResult.java │ │ │ ├── BenchmarkRunner.java │ │ │ ├── QueryShuffleTransformation.java │ │ │ └── RunResult.java │ │ │ └── test │ │ │ ├── TrainBenchmarkTest.java │ │ │ └── queryspecific │ │ │ ├── QueryTest.java │ │ │ ├── RouteSensorTest.java │ │ │ └── SemaphoreNeighborTest.java │ └── resources │ │ └── .gitignore │ └── test │ └── java │ └── hu │ └── bme │ └── mit │ └── trainbenchmark │ └── benchmark │ └── runcomponents │ └── test │ └── BenchmarkReporterTest.java └── visualization ├── .gitignore └── query-plans ├── RouteSensorA-Relalg.tex ├── RouteSensorA-Rete-cost.tex ├── RouteSensorA-Rete.tex ├── RouteSensorA-ReteExpression.tex ├── RouteSensorB-Relalg.tex ├── RouteSensorB-Rete.tex ├── RouteSensorB-ReteExpression.tex ├── RouteSensorC-Relalg.tex ├── RouteSensorC-Rete.tex ├── RouteSensorC-ReteExpression.tex ├── SemaphoreNeighborA-Relalg.tex ├── SemaphoreNeighborA-Rete-cost.tex ├── SemaphoreNeighborA-Rete.tex ├── SemaphoreNeighborA-ReteExpression.tex ├── SemaphoreNeighborB-Relalg.tex ├── SemaphoreNeighborB-Rete.tex ├── SemaphoreNeighborB-ReteExpression.tex ├── SemaphoreNeighborC-Relalg.tex ├── SemaphoreNeighborC-Rete.tex ├── SemaphoreNeighborC-ReteExpression.tex ├── SemaphoreNeighborD-Relalg.tex ├── SemaphoreNeighborD-Rete.tex ├── SemaphoreNeighborD-ReteExpression.tex ├── SemaphoreNeighborE-Relalg.tex ├── SemaphoreNeighborE-Rete.tex ├── SemaphoreNeighborE-ReteExpression.tex ├── SemaphoreNeighborF-Relalg.tex ├── SemaphoreNeighborF-Rete.tex ├── SemaphoreNeighborF-ReteExpression.tex ├── bootstrap.min.css ├── convert.sh ├── template-footer.html └── template-header.html /.editorconfig: -------------------------------------------------------------------------------- 1 | root = true 2 | 3 | [*.java] 4 | charset = utf-8 5 | end_of_line = lf 6 | indent_size = 4 7 | indent_style = tab 8 | insert_final_newline = true 9 | max_line_length = 140 10 | trim_trailing_whitespace = true 11 | -------------------------------------------------------------------------------- /.github/workflows/compile.yml: -------------------------------------------------------------------------------- 1 | on: [push] 2 | jobs: 3 | build_and_test: 4 | runs-on: ubuntu-latest 5 | steps: 6 | - name: Set up Git repository 7 | uses: actions/checkout@v1 8 | - uses: actions/setup-java@v2 9 | with: 10 | distribution: 'adopt' 11 | java-version: '11' 12 | - name: Build and test 13 | run: | 14 | scripts/get-neo4j.sh 15 | ./gradlew inits build -x :trainbenchmark-generator-sql:test -x :trainbenchmark-tool-mysql:test -x :trainbenchmark-tool-sqlite:test --stacktrace --continue 16 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | plugin.xml_gen 2 | bin/ 3 | target/ 4 | tmp/ 5 | .settings/ 6 | MANIFEST.MF_gen 7 | .DS_Store* 8 | .metadata 9 | runtimeInfo 10 | workspace 11 | *._trace 12 | Thumbs.db 13 | .Rhistory 14 | .pydevproject 15 | deps/ 16 | diagrams/* 17 | .idea 18 | log/ 19 | catalog-v*.xml 20 | .RData 21 | .Rproj.user 22 | *.tar.gz 23 | *.zip 24 | *.gml 25 | 26 | # IntelliJ IDEA 27 | *.iml 28 | 29 | # Eclipse 30 | .project 31 | .classpath 32 | 33 | ### Gradle ### 34 | .gradle 35 | build/ 36 | 37 | # Ignore Gradle GUI config 38 | gradle-app.setting 39 | 40 | # Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored) 41 | !gradle-wrapper.jar 42 | 43 | # Cache of project 44 | .gradletasknamecache 45 | 46 | hs_err_*.log 47 | replay_*.log 48 | 49 | ~*.* 50 | *.~* 51 | 52 | xtend-gen/ 53 | neo4j-server/ 54 | out/ 55 | *.swp 56 | *.report 57 | classes/ 58 | 59 | deployed-content/ 60 | -------------------------------------------------------------------------------- /diagrams/.gitignore: -------------------------------------------------------------------------------- 1 | * 2 | !.gitignore 3 | -------------------------------------------------------------------------------- /docs/README.md: -------------------------------------------------------------------------------- 1 | # Train Benchmark documentation 2 | 3 | * [Getting started](getting-started.md) 4 | * [How to run the benchmark](how-to-run-the-benchmark.md) 5 | * [Developer Guide](developer-guide.md) 6 | * [Experimenting](experimenting.md) 7 | * [Schema](schema.md) 8 | -------------------------------------------------------------------------------- /docs/instance-models.md: -------------------------------------------------------------------------------- 1 | # Instance models 2 | 3 | For each build, the latest instance models are pushed to the gh-pages branch: 4 | 5 | * https://github.com/FTSRG/trainbenchmark/tree/gh-pages/models 6 | * http://docs.inf.mit.bme.hu/trainbenchmark/generated-models.html 7 | -------------------------------------------------------------------------------- /docs/railway-containments.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/docs/railway-containments.png -------------------------------------------------------------------------------- /docs/railway-inheritance.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/docs/railway-inheritance.png -------------------------------------------------------------------------------- /docs/schema.md: -------------------------------------------------------------------------------- 1 | # Schema 2 | 3 | Object-oriented schema for the benchmark's metamodel. 4 | 5 | ## Railway containments 6 | 7 | ![Containment hierarchy](railway-containments.png) 8 | 9 | ## Railway inheritance 10 | 11 | ![Inheritance hierarchy](railway-inheritance.png) 12 | -------------------------------------------------------------------------------- /gradle/source-layout-xcore.gradle: -------------------------------------------------------------------------------- 1 | sourceSets { 2 | main { 3 | java.srcDirs = ['src', 'src-gen'] 4 | resources.srcDirs = ['src', 'src-gen'] 5 | xtendOutputDir = 'xtend-gen' 6 | } 7 | test { 8 | java.srcDirs = [] 9 | resources.srcDirs = [] 10 | } 11 | } 12 | 13 | sourceSets.all { 14 | resources.exclude '**/*.g', '**/*.xtext', '**/*.mwe2', '**/*.xtend', '**/*._trace' 15 | } 16 | 17 | jar { 18 | from('model') { 19 | into('model') 20 | } 21 | manifest { 22 | attributes 'Bundle-SymbolicName': project.name 23 | } 24 | } 25 | 26 | plugins.withId('war') { 27 | webAppDirName = "WebRoot" 28 | } 29 | 30 | plugins.withId('org.xtext.idea-plugin') { 31 | assembleSandbox.metaInf.from('META-INF') 32 | } 33 | -------------------------------------------------------------------------------- /gradle/source-layout-xtext.gradle: -------------------------------------------------------------------------------- 1 | sourceSets { 2 | main { 3 | java.srcDirs = ['src/main/java', 'src/main/xtext-gen'] 4 | resources.srcDirs = ['src/main/resources', 'src/main/xtext-gen'] 5 | xtendOutputDir = 'src/main/xtend-gen' 6 | } 7 | test { 8 | java.srcDirs = ['src/test/java', 'src/test/xtext-gen'] 9 | resources.srcDirs = ['src/test/resources', 'src/test/xtext-gen'] 10 | xtendOutputDir = 'src/test/xtend-gen' 11 | } 12 | } 13 | 14 | jar { 15 | from('model') { 16 | into('model') 17 | } 18 | manifest { 19 | attributes 'Bundle-SymbolicName': project.name 20 | } 21 | } 22 | 23 | plugins.withId('org.xtext.idea-plugin') { 24 | assembleSandbox.metaInf.from('src/main/resources/META-INF') 25 | } 26 | -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | distributionBase=GRADLE_USER_HOME 2 | distributionPath=wrapper/dists 3 | distributionUrl=https\://services.gradle.org/distributions/gradle-4.7-bin.zip 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | -------------------------------------------------------------------------------- /logs/.gitignore: -------------------------------------------------------------------------------- 1 | * 2 | !README.md 3 | !.gitignore 4 | 5 | -------------------------------------------------------------------------------- /logs/README.md: -------------------------------------------------------------------------------- 1 | Save the logs like this: 2 | 3 | ``` 4 | $ scripts/run.py |& tee logs/generator.log 5 | ``` 6 | -------------------------------------------------------------------------------- /models/.gitignore: -------------------------------------------------------------------------------- 1 | * 2 | !.gitignore 3 | -------------------------------------------------------------------------------- /postgres/load.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | PG_CSV_DIR=${1:-$(pwd)/../models/railway-inject-1-csv} 4 | DB_NAME=${2:-trainbenchmark} 5 | PG_USER=${3:-$USER} 6 | 7 | /usr/bin/dropdb $DB_NAME -U $PG_USER 8 | /usr/bin/createdb $DB_NAME -U $PG_USER --template template0 -l "C" 9 | /usr/bin/psql -d $DB_NAME -U $PG_USER -a -f schema.sql 10 | (cat tb-load.sql | sed "s|PATHVAR|$PG_CSV_DIR|g"; echo "\q\n") | /usr/bin/psql -d $DB_NAME -U $PG_USER 11 | -------------------------------------------------------------------------------- /postgres/tb-load.sql: -------------------------------------------------------------------------------- 1 | -- nodes 2 | COPY Route FROM 'PATHVAR/Route.txt' WITH DELIMITER ','; 3 | COPY Region FROM 'PATHVAR/Region.txt' WITH DELIMITER ','; 4 | COPY Segment FROM 'PATHVAR/Segment.txt' WITH DELIMITER ','; 5 | COPY Sensor FROM 'PATHVAR/Sensor.txt' WITH DELIMITER ','; 6 | COPY Semaphore FROM 'PATHVAR/Semaphore.txt' WITH DELIMITER ','; 7 | COPY Switch FROM 'PATHVAR/Switch.txt' WITH DELIMITER ','; 8 | COPY SwitchPosition FROM 'PATHVAR/SwitchPosition.txt' WITH DELIMITER ','; 9 | COPY TrackElement FROM 'PATHVAR/TrackElement.txt' WITH DELIMITER ','; 10 | -- edges 11 | COPY connectsTo FROM 'PATHVAR/connectsTo.txt' WITH DELIMITER ','; 12 | COPY monitoredBy FROM 'PATHVAR/monitoredBy.txt' WITH DELIMITER ','; 13 | COPY requires FROM 'PATHVAR/requires.txt' WITH DELIMITER ','; 14 | -------------------------------------------------------------------------------- /results/.gitignore: -------------------------------------------------------------------------------- 1 | * 2 | !.gitignore 3 | -------------------------------------------------------------------------------- /scripts/.gitignore: -------------------------------------------------------------------------------- 1 | .project 2 | .pydevproject 3 | __pycache__/* 4 | .Rhistory 5 | tb-env/ 6 | init/*.zip 7 | log/ 8 | get-pip.py* 9 | -------------------------------------------------------------------------------- /scripts/build.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | cd "$( cd "$( dirname "$0" )" && pwd )/../" 4 | 5 | ./gradlew build -x test --continue 6 | -------------------------------------------------------------------------------- /scripts/calculate-model-sizes.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | cd "$( cd "$( dirname "$0" )" && pwd )/../models" 4 | 5 | #for variant in inferred metamodel; do 6 | for variant in inferred; do 7 | echo $variant 8 | for scenario in batch inject repair; do 9 | echo $scenario 10 | #ag --count "^[^@#].*[;.]$" *-$scenario-*$variant.ttl | sed "s/\(.*\):\(.*\)/\2\t\1/" | sort --numeric-sort 11 | grep --count "^[^@#].*[;.]$" *-$scenario-*$variant.ttl | sed "s/\(.*\):\(.*\)/\2\t\1/" | sort --numeric-sort 12 | echo 13 | done 14 | echo 15 | done 16 | -------------------------------------------------------------------------------- /scripts/cloc.sh: -------------------------------------------------------------------------------- 1 | cloc . --exclude-dir=trainbenchmark-tool-viatra-patterns,xtend-gen 2 | -------------------------------------------------------------------------------- /scripts/compress-results.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | tar czf results.tar.gz results 4 | -------------------------------------------------------------------------------- /scripts/deploy.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -e # exit with nonzero exit code if anything fails 4 | 5 | # clear and re-create the deployed-content directory 6 | rm -rf deployed-content || exit 0 7 | mkdir -p deployed-content/models 8 | 9 | # copy model files (*.*), but not directories 10 | cp -r site/* deployed-content 11 | cp -r models/* deployed-content/models 12 | 13 | # go to the out directory and create a *new* Git repo 14 | cd deployed-content 15 | git init 16 | 17 | # inside this git repo we'll pretend to be a new user 18 | git config user.name "FTSRG BME" 19 | git config user.email "ftsrg.bme@gmail.com" 20 | 21 | # The first and only commit to this new Git repo contains all the 22 | # files present with the commit message "Deploy to GitHub Pages". 23 | git add . 24 | git commit -m "Deploy to GitHub Pages" 25 | 26 | # Force push from the current repo's master branch to the remote 27 | # repo's gh-pages branch. (All previous history on the gh-pages branch 28 | # will be lost, since we are overwriting it.) We redirect any output to 29 | # /dev/null to hide any sensitive credential data that might otherwise be exposed. 30 | git push --force --quiet "https://${GH_TOKEN}@${GH_REF}" master:gh-pages > /dev/null 2>&1 31 | -------------------------------------------------------------------------------- /scripts/get-neo4j.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | NEO4J_VERSION=3.3.0 4 | 5 | cd "$( cd "$( dirname "$0" )" && pwd )/../" 6 | rm -rf neo4j-server 7 | wget -q https://neo4j.com/artifact.php?name=neo4j-community-$NEO4J_VERSION-unix.tar.gz -O neo4j.tar.gz 8 | tar xf neo4j.tar.gz 9 | mv neo4j-community-$NEO4J_VERSION neo4j-server 10 | -------------------------------------------------------------------------------- /scripts/install-R-14.04.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # based on https://www.digitalocean.com/community/tutorials/how-to-set-up-r-on-ubuntu-14-04 4 | 5 | # change trusty (14.04) to xenial for 16.04 6 | sudo sh -c 'echo "deb http://cran.rstudio.com/bin/linux/ubuntu trusty/" >> /etc/apt/sources.list' 7 | gpg --keyserver keyserver.ubuntu.com --recv-key E084DAB9 8 | gpg -a --export E084DAB9 | sudo apt-key add - 9 | 10 | sudo apt-get update 11 | sudo apt-get install -y r-base r-base-dev 12 | -------------------------------------------------------------------------------- /scripts/install-R-16.04.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | sudo apt-get update 4 | sudo apt-get install -y r-base r-base-dev 5 | -------------------------------------------------------------------------------- /scripts/install-R-packages.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | cd "$( cd "$( dirname "$0" )" && pwd )" 4 | 5 | Rscript ../trainbenchmark-reporting/install.R 6 | -------------------------------------------------------------------------------- /scripts/install-jdk.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | sudo apt install -y openjdk-8-jdk 4 | -------------------------------------------------------------------------------- /scripts/install-mysql-silent.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | sudo debconf-set-selections <<< 'mysql-server mysql-server/root_password password ' 4 | sudo debconf-set-selections <<< 'mysql-server mysql-server/root_password_again password ' 5 | sudo apt-get -y install mysql-server 6 | -------------------------------------------------------------------------------- /scripts/install-mysql.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | sudo apt-get install mysql-server 4 | -------------------------------------------------------------------------------- /scripts/install-sqlite.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | sudo apt-get install -y sqlite3 4 | -------------------------------------------------------------------------------- /scripts/run.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | cd "$( cd "$( dirname "$0" )" && pwd )/../" 4 | 5 | ./gradlew shadowJar generate benchmark plot page 6 | -------------------------------------------------------------------------------- /scripts/shadowjar.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | cd "$( cd "$( dirname "$0" )" && pwd )/../" 4 | 5 | ./gradlew build shadowJar -x test 6 | -------------------------------------------------------------------------------- /site/.gitignore: -------------------------------------------------------------------------------- 1 | _site 2 | .sass-cache 3 | .jekyll-metadata 4 | 5 | -------------------------------------------------------------------------------- /site/_config.yml: -------------------------------------------------------------------------------- 1 | title: Train Benchmark 2 | baseurl: /trainbenchmark 3 | github_username: FTSRG 4 | markdown: kramdown 5 | -------------------------------------------------------------------------------- /site/_includes/footer.html: -------------------------------------------------------------------------------- 1 | 39 | -------------------------------------------------------------------------------- /site/_includes/head.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | {% if page.title %}{{ page.title }}{% else %}{{ site.title }}{% endif %} 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /site/_includes/header.html: -------------------------------------------------------------------------------- 1 |
2 | 3 |
4 | 5 | {{ site.title }} 6 | 7 | 24 | 25 |
26 | 27 |
28 | -------------------------------------------------------------------------------- /site/_includes/icon-github.html: -------------------------------------------------------------------------------- 1 | {% include icon-github.svg %}{{ include.username }} 2 | -------------------------------------------------------------------------------- /site/_includes/icon-github.svg: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /site/_includes/icon-twitter.html: -------------------------------------------------------------------------------- 1 | {% include icon-twitter.svg %}{{ include.username }} 2 | -------------------------------------------------------------------------------- /site/_includes/icon-twitter.svg: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /site/_layouts/default.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | {% include head.html %} 5 | 6 | 7 | 8 | {% include header.html %} 9 | 10 |
11 |
12 | {{ content }} 13 |
14 |
15 | 16 | 17 | 18 | 19 | -------------------------------------------------------------------------------- /site/index.md: -------------------------------------------------------------------------------- 1 | --- 2 | layout: default 3 | --- 4 | 5 | * [Publications](https://github.com/FTSRG/publication-pages/wiki#train-benchmark) 6 | * [GitHub repository](https://github.com/FTSRG/trainbenchmark) 7 | * [SOSYM paper](http://link.springer.com/article/10.1007/s10270-016-0571-8): The Train Benchmark: cross-technology performance evaluation of continuous model queries. [[Supplementary material](sosym-supplementary.html)] 8 | * [Generated models](generated-models.html) 9 | -------------------------------------------------------------------------------- /site/sosym-supplementary.md: -------------------------------------------------------------------------------- 1 | --- 2 | layout: default 3 | --- 4 | 5 | ## Supplementary material for the SOSYM paper 6 | 7 | * The Train Benchmark framework's [1.0 release](https://github.com/FTSRG/trainbenchmark/releases/tag/v1.0). 8 | * Detailed results in CSV format are available in the [`trainbenchmark-sosym`](https://github.com/FTSRG/trainbenchmark-sosym) repository. 9 | -------------------------------------------------------------------------------- /trainbenchmark-config/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | /target/ 3 | -------------------------------------------------------------------------------- /trainbenchmark-config/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compile group: 'commons-lang', name: 'commons-lang', version: commonsLangVersion 3 | compile group: 'com.google.guava', name: 'guava', version: guavaVersion 4 | compile group: 'com.esotericsoftware', name: 'kryo-shaded', version: kryoVersion 5 | } 6 | -------------------------------------------------------------------------------- /trainbenchmark-config/src/main/java/hu/bme/mit/trainbenchmark/config/AbstractConfigBase.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | 13 | package hu.bme.mit.trainbenchmark.config; 14 | 15 | public abstract class AbstractConfigBase { 16 | 17 | public AbstractConfigBase() { 18 | } 19 | 20 | public String getWorkspaceDir() { 21 | return "../"; 22 | } 23 | 24 | public String getModelDir() { 25 | return getWorkspaceDir() + "models/"; 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /trainbenchmark-config/src/main/java/hu/bme/mit/trainbenchmark/config/AbstractConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.config; 2 | 3 | import com.google.common.base.Preconditions; 4 | 5 | /** 6 | * This class uses the Curiously-Recurring Generic Pattern, see 7 | * http://www.artima.com/weblogs/viewpost.jsp?thread=133275 for details. 8 | */ 9 | public abstract class AbstractConfigBuilder< 10 | TConfigBase extends AbstractConfigBase, 11 | TConfig extends AbstractConfig, 12 | TBuilder extends AbstractConfigBuilder> { 13 | 14 | protected TConfigBase configBase; 15 | 16 | @SuppressWarnings("unchecked") 17 | public TBuilder setConfigBase(final TConfigBase configBase) { 18 | this.configBase = configBase; 19 | return (TBuilder) this; 20 | } 21 | 22 | public abstract TConfig createConfig(); 23 | 24 | public void checkNotNulls() { 25 | Preconditions.checkNotNull(configBase); 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /trainbenchmark-config/src/main/java/hu/bme/mit/trainbenchmark/constants/ExecutionPhase.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.constants; 2 | 3 | public enum ExecutionPhase { 4 | READ("Read"), // 5 | CHECK("Check"), // 6 | TRANSFORMATION("Transformation"), // 7 | RECHECK("Recheck"), // 8 | ; 9 | 10 | private String name; 11 | 12 | ExecutionPhase(final String name) { 13 | this.name = name; 14 | } 15 | 16 | @Override 17 | public String toString() { 18 | return name; 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /trainbenchmark-config/src/main/java/hu/bme/mit/trainbenchmark/constants/Position.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | 13 | package hu.bme.mit.trainbenchmark.constants; 14 | 15 | public enum Position { 16 | FAILURE, STRAIGHT, DIVERGING 17 | } 18 | -------------------------------------------------------------------------------- /trainbenchmark-config/src/main/java/hu/bme/mit/trainbenchmark/constants/Signal.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | 13 | package hu.bme.mit.trainbenchmark.constants; 14 | 15 | public enum Signal { 16 | FAILURE, STOP, GO 17 | } 18 | -------------------------------------------------------------------------------- /trainbenchmark-config/src/main/java/hu/bme/mit/trainbenchmark/constants/TrainBenchmarkConstants.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | 13 | package hu.bme.mit.trainbenchmark.constants; 14 | 15 | public class TrainBenchmarkConstants { 16 | 17 | public static final long RANDOM_SEED = 19871053l; 18 | public static final int DEFAULT_SEGMENT_LENGTH = 500; 19 | 20 | } 21 | -------------------------------------------------------------------------------- /trainbenchmark-config/src/main/java/hu/bme/mit/trainbenchmark/constants/TransformationStrategy.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | 13 | package hu.bme.mit.trainbenchmark.constants; 14 | 15 | public enum TransformationStrategy { 16 | FIXED, PROPORTIONAL, 17 | } 18 | -------------------------------------------------------------------------------- /trainbenchmark-config/src/main/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-config/src/main/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-format-emf-model/.classpath: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /trainbenchmark-format-emf-model/.gitignore: -------------------------------------------------------------------------------- 1 | !.project 2 | !.classpath 3 | /target 4 | -------------------------------------------------------------------------------- /trainbenchmark-format-emf-model/META-INF/MANIFEST.MF: -------------------------------------------------------------------------------- 1 | Manifest-Version: 1.0 2 | Bundle-ManifestVersion: 2 3 | Bundle-Name: Railway EMF Model 4 | Bundle-SymbolicName: trainbenchmark-format-emf-model;singleton:=true 5 | Bundle-Version: 1.0.0.qualifier 6 | -------------------------------------------------------------------------------- /trainbenchmark-format-emf-model/build.properties: -------------------------------------------------------------------------------- 1 | ############################################################################### 2 | # Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | # All rights reserved. This program and the accompanying materials 4 | # are made available under the terms of the Eclipse Public License v1.0 5 | # which accompanies this distribution, and is available at 6 | # http://www.eclipse.org/legal/epl-v10.html 7 | # 8 | # Contributors: 9 | # Benedek Izso - initial API and implementation 10 | # Gabor Szarnyas - initial API and implementation 11 | ############################################################################### 12 | # 13 | 14 | bin.includes = .,\ 15 | model/,\ 16 | META-INF/,\ 17 | plugin.xml,\ 18 | plugin.properties 19 | jars.compile.order = . 20 | source.. = src/main/java/ 21 | output.. = bin/ 22 | -------------------------------------------------------------------------------- /trainbenchmark-format-emf-model/plugin.properties: -------------------------------------------------------------------------------- 1 | ############################################################################### 2 | # Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | # All rights reserved. This program and the accompanying materials 4 | # are made available under the terms of the Eclipse Public License v1.0 5 | # which accompanies this distribution, and is available at 6 | # http://www.eclipse.org/legal/epl-v10.html 7 | # 8 | # Contributors: 9 | # Benedek Izso - initial API and implementation 10 | # Gabor Szarnyas - initial API and implementation 11 | ############################################################################### 12 | # 13 | 14 | pluginName = Railway Model 15 | providerName = www.example.org 16 | -------------------------------------------------------------------------------- /trainbenchmark-format-emf-model/plugin.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | 7 | 8 | 9 | 10 | 11 | 15 | 16 | 17 | 18 | -------------------------------------------------------------------------------- /trainbenchmark-format-emf/.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | -------------------------------------------------------------------------------- /trainbenchmark-format-emf/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compile project(':trainbenchmark-tool') 3 | compile project(':trainbenchmark-format-emf-model') 4 | } 5 | -------------------------------------------------------------------------------- /trainbenchmark-format-emf/src/main/java/hu/bme/mit/trainbenchmark/emf/EmfConstants.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.emf; 2 | 3 | public class EmfConstants { 4 | 5 | public static final String MODEL_EXTENSION = "xmi"; 6 | 7 | } 8 | -------------------------------------------------------------------------------- /trainbenchmark-format-emf/src/main/java/hu/bme/mit/trainbenchmark/emf/EmfUtil.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.emf; 2 | 3 | import org.eclipse.emf.ecore.resource.Resource; 4 | import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl; 5 | 6 | public class EmfUtil { 7 | 8 | public static void registerExtension() { 9 | Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put(EmfConstants.MODEL_EXTENSION, new XMIResourceFactoryImpl()); 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /trainbenchmark-format-emf/src/main/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-format-emf/src/main/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-format-graph-neo4j/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compile project(':trainbenchmark-config') 3 | compile group: 'org.neo4j', name: 'neo4j-cypher', version: neo4jVersion 4 | compile group: 'org.neo4j', name: 'neo4j-io', version: neo4jVersion 5 | compile group: 'org.neo4j', name: 'neo4j-kernel', version: neo4jVersion 6 | compile group: 'org.neo4j', name: 'neo4j-io', version: neo4jVersion, classifier: 'tests' 7 | compile group: 'org.neo4j', name: 'neo4j-kernel', version: neo4jVersion, classifier: 'tests' 8 | compile group: 'org.neo4j.procedure', name: 'apoc', version: neo4jApocVersion 9 | } 10 | 11 | -------------------------------------------------------------------------------- /trainbenchmark-format-graph-neo4j/src/main/java/hu/bme/mit/trainbenchmark/neo4j/apoc/ApocHelper.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.neo4j.apoc; 2 | 3 | import org.neo4j.graphdb.GraphDatabaseService; 4 | import org.neo4j.kernel.api.exceptions.KernelException; 5 | import org.neo4j.kernel.impl.proc.Procedures; 6 | import org.neo4j.kernel.internal.GraphDatabaseAPI; 7 | 8 | public class ApocHelper { 9 | 10 | // https://github.com/neo4j-contrib/neo4j-apoc-procedures/blob/a4423863ce77ef51c5d94cdbdc65d8a09172821b/src/test/java/apoc/util/TestUtil.java 11 | public static void registerProcedure(GraphDatabaseService db, Class...procedures) throws KernelException { 12 | Procedures proceduresService = ((GraphDatabaseAPI) db).getDependencyResolver().resolveDependency(Procedures.class); 13 | for (Class procedure : procedures) { 14 | proceduresService.registerProcedure(procedure); 15 | proceduresService.registerFunction(procedure); 16 | } 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /trainbenchmark-format-graph-neo4j/src/main/java/hu/bme/mit/trainbenchmark/neo4j/config/Neo4jDeployment.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.neo4j.config; 2 | 3 | public enum Neo4jDeployment { 4 | EMBEDDED("embedded"), 5 | IN_MEMORY("in-memory"); 6 | 7 | private String name; 8 | 9 | Neo4jDeployment(final String name) { 10 | this.name = name; 11 | } 12 | 13 | @Override 14 | public String toString() { 15 | return name; 16 | } 17 | 18 | 19 | } 20 | -------------------------------------------------------------------------------- /trainbenchmark-format-graph-neo4j/src/main/java/hu/bme/mit/trainbenchmark/neo4j/config/Neo4jGraphFormat.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.neo4j.config; 2 | 3 | public enum Neo4jGraphFormat { 4 | CSV("CSV"), // 5 | GRAPHML("GraphML"), // 6 | CYPHER("Cypher"), 7 | ; 8 | 9 | private String name; 10 | 11 | Neo4jGraphFormat(final String name) { 12 | this.name = name; 13 | } 14 | 15 | @Override 16 | public String toString() { 17 | return name; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /trainbenchmark-format-rdf/README.md: -------------------------------------------------------------------------------- 1 | #### Visualization script 2 | 3 | For visualizing RDF models, you can use the `graphviz` and `rapper` tools: 4 | 5 | ```bash 6 | sudo apt-get install -y rapper graphviz 7 | ``` 8 | 9 | Usage: 10 | 11 | ```bash 12 | MODEL=railway-repair-1 13 | rapper -i turtle $MODEL.ttl -o dot | dot -Tpdf > $MODEL.pdf 14 | ``` 15 | 16 | You may use `fdp`, `neato`, `twopi` or `circo` instead of `dot`. 17 | -------------------------------------------------------------------------------- /trainbenchmark-format-rdf/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compile project(':trainbenchmark-tool') 3 | } 4 | -------------------------------------------------------------------------------- /trainbenchmark-format-rdf/src/main/java/hu/bme/mit/trainbenchmark/rdf/RdfFormat.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.rdf; 2 | 3 | public enum RdfFormat { 4 | TURTLE("ttl"), NTRIPLES("nt"); 5 | 6 | private String extension; 7 | 8 | RdfFormat(final String extension) { 9 | this.extension = extension; 10 | } 11 | 12 | public String getExtension() { 13 | return extension; 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /trainbenchmark-format-rdf/src/main/resources/metamodel/railway-inferred.nt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-format-rdf/src/main/resources/metamodel/railway-inferred.nt -------------------------------------------------------------------------------- /trainbenchmark-format-rdf/src/main/resources/metamodel/railway-inferred.ttl: -------------------------------------------------------------------------------- 1 | @prefix : . 2 | @prefix xsd: . 3 | 4 | -------------------------------------------------------------------------------- /trainbenchmark-format-rdf/src/main/resources/metamodel/railway-metamodel.nt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-format-rdf/src/main/resources/metamodel/railway-metamodel.nt -------------------------------------------------------------------------------- /trainbenchmark-format-sql/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compile project(':trainbenchmark-tool') 3 | } 4 | -------------------------------------------------------------------------------- /trainbenchmark-format-sql/scripts/README.md: -------------------------------------------------------------------------------- 1 | The `mysql2sqlite.sh` script is distributed under the MIT license. Source: https://github.com/dumblob/mysql2sqlite 2 | -------------------------------------------------------------------------------- /trainbenchmark-format-sql/scripts/clean-mysql.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | sudo rm -rf /var/lib/mysql/trainbenchmark 4 | #echo "MySQL cleaned" 5 | -------------------------------------------------------------------------------- /trainbenchmark-format-sql/scripts/start-mysql.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | sudo service mysql start 4 | echo "SET GLOBAL max_heap_table_size=1073741824;" | mysql -u root 5 | #echo "MySQL started" 6 | -------------------------------------------------------------------------------- /trainbenchmark-format-sql/scripts/stop-mysql.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | sudo service mysql stop 4 | #echo "MySQL stopped" 5 | -------------------------------------------------------------------------------- /trainbenchmark-format-sql/src/main/resources/metamodel/railway-footer.sql: -------------------------------------------------------------------------------- 1 | 2 | COMMIT; 3 | CREATE INDEX segment_length_idx ON "Segment" ("length"); 4 | CREATE INDEX route_active_idx ON "Route" ("active"); 5 | CREATE INDEX semaphore_signal_idx ON "Semaphore" ("signal"); 6 | CREATE INDEX monitoredBy_idx ON "monitoredBy" ("Sensor_id", "TrackElement_id"); 7 | CREATE INDEX connectsTo_idx1 ON "connectsTo" ("TrackElement1_id"); 8 | CREATE INDEX connectsTo_idx2 ON "connectsTo" ("TrackElement2_id"); 9 | -------------------------------------------------------------------------------- /trainbenchmark-generator-emf/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.generator.emf.EmfGeneratorMain' } 6 | } 7 | 8 | dependencies { 9 | compile project(':trainbenchmark-tool') 10 | compile project(':trainbenchmark-format-emf') 11 | compile project(':trainbenchmark-generator') 12 | compile group: 'org.eclipse.emf', name: 'org.eclipse.emf.common', version: emfVersion 13 | compile group: 'org.eclipse.emf', name: 'org.eclipse.emf.ecore.xmi', version: emfVersion 14 | compile group: 'org.eclipse.emf', name: 'org.eclipse.emf.ecore', version: emfVersion 15 | } 16 | -------------------------------------------------------------------------------- /trainbenchmark-generator-emf/src/main/java/hu/bme/mit/trainbenchmark/generator/emf/config/EmfGeneratorConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.generator.emf.config; 2 | 3 | import hu.bme.mit.trainbenchmark.generator.config.GeneratorConfigBuilder; 4 | 5 | public class EmfGeneratorConfigBuilder 6 | extends GeneratorConfigBuilder { 7 | 8 | @Override 9 | public EmfGeneratorConfig createConfig() { 10 | checkNotNulls(); 11 | return new EmfGeneratorConfig(configBase); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /trainbenchmark-generator-emf/src/main/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-generator-emf/src/main/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-generator-emf/src/test/java/hu/bme/mit/trainbenchmark/generator/emf/test/EmfGeneratorTest.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.generator.emf.test; 2 | 3 | import hu.bme.mit.trainbenchmark.generator.ModelGenerator; 4 | import hu.bme.mit.trainbenchmark.generator.ScalableGeneratorFactory; 5 | import hu.bme.mit.trainbenchmark.generator.config.GeneratorConfigBase; 6 | import hu.bme.mit.trainbenchmark.generator.emf.EmfSerializer; 7 | import hu.bme.mit.trainbenchmark.generator.emf.config.EmfGeneratorConfig; 8 | import hu.bme.mit.trainbenchmark.generator.emf.config.EmfGeneratorConfigBuilder; 9 | import hu.bme.mit.trainbenchmark.generator.tests.GeneratorTest; 10 | 11 | public class EmfGeneratorTest extends GeneratorTest { 12 | 13 | @Override 14 | public void generate(final GeneratorConfigBase gcb) throws Exception { 15 | final EmfGeneratorConfig gc = new EmfGeneratorConfigBuilder().setConfigBase(gcb).createConfig(); 16 | final EmfSerializer serializer = new EmfSerializer(gc); 17 | final ModelGenerator generator = ScalableGeneratorFactory.createGenerator(serializer, gc); 18 | generator.generateModel(); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /trainbenchmark-generator-graph-cypher/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.generator.cypher.CypherGeneratorMain' } 6 | } 7 | 8 | dependencies { 9 | compile project(':trainbenchmark-generator') 10 | //compile project(':trainbenchmark-format-graph-neo4j') 11 | } 12 | -------------------------------------------------------------------------------- /trainbenchmark-generator-graph-cypher/src/main/java/hu/bme/mit/trainbenchmark/generator/cypher/config/CypherFormat.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.generator.cypher.config; 2 | 3 | public enum CypherFormat { 4 | BASIC("Basic"), // 5 | GRAPHFLOW("Graphflow"), // 6 | ; 7 | 8 | private String name; 9 | 10 | CypherFormat(final String name) { 11 | this.name = name; 12 | } 13 | 14 | @Override 15 | public String toString() { 16 | return name; 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /trainbenchmark-generator-graph-cypher/src/main/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-generator-graph-cypher/src/main/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-generator-graph-neo4j/.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | -------------------------------------------------------------------------------- /trainbenchmark-generator-graph-neo4j/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | mergeServiceFiles() 6 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.generator.graph.neo4j.Neo4jGraphGeneratorMain' } 7 | } 8 | 9 | dependencies { 10 | compile group: 'commons-io', name: 'commons-io', version: commonsIoVersion 11 | compile project(':trainbenchmark-generator') 12 | compile project(':trainbenchmark-format-graph-neo4j') 13 | } 14 | -------------------------------------------------------------------------------- /trainbenchmark-generator-graph-tinkerpop/.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | -------------------------------------------------------------------------------- /trainbenchmark-generator-graph-tinkerpop/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.generator.graph.tinkerpop.TinkerGraphGeneratorMain' } 6 | } 7 | 8 | dependencies { 9 | compile project(':trainbenchmark-generator') 10 | compile group: 'org.apache.tinkerpop', name: 'tinkergraph-gremlin', version: tinkerGraphVersion 11 | compile group: 'org.slf4j', name: 'slf4j-nop', version: slf4jVersion 12 | } 13 | -------------------------------------------------------------------------------- /trainbenchmark-generator-graph-tinkerpop/src/main/java/hu/bme/mit/trainbenchmark/generator/graph/tinkerpop/config/TinkerGraphFormat.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.generator.graph.tinkerpop.config; 2 | 3 | public enum TinkerGraphFormat { 4 | GRAPHML("GraphML"), // 5 | GRAPHSON("GraphSON"), // 6 | GRYO("Gryo"); 7 | 8 | private String name; 9 | 10 | TinkerGraphFormat(final String name) { 11 | this.name = name; 12 | } 13 | 14 | @Override 15 | public String toString() { 16 | return name; 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /trainbenchmark-generator-graph-tinkerpop/src/main/java/hu/bme/mit/trainbenchmark/generator/graph/tinkerpop/config/TinkerGraphGeneratorConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.generator.graph.tinkerpop.config; 2 | 3 | import com.google.common.base.Preconditions; 4 | 5 | import hu.bme.mit.trainbenchmark.generator.config.GeneratorConfigBuilder; 6 | 7 | public class TinkerGraphGeneratorConfigBuilder 8 | extends GeneratorConfigBuilder { 9 | 10 | protected TinkerGraphFormat graphFormat; 11 | 12 | public TinkerGraphGeneratorConfigBuilder setGraphFormat(TinkerGraphFormat graphFormat) { 13 | this.graphFormat = graphFormat; 14 | return this; 15 | } 16 | 17 | @Override 18 | public TinkerGraphGeneratorConfig createConfig() { 19 | return new TinkerGraphGeneratorConfig(configBase, graphFormat); 20 | } 21 | 22 | @Override 23 | public void checkNotNulls() { 24 | super.checkNotNulls(); 25 | Preconditions.checkNotNull(graphFormat); 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /trainbenchmark-generator-rdf/.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | -------------------------------------------------------------------------------- /trainbenchmark-generator-rdf/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.generator.rdf.RdfGeneratorMain' } 6 | } 7 | 8 | dependencies { 9 | compile project(':trainbenchmark-generator') 10 | compile project(':trainbenchmark-format-rdf') 11 | compile group: 'org.slf4j', name: 'slf4j-nop', version: slf4jVersion 12 | compile group: 'org.openrdf.sesame', name: 'sesame-model', version: sesameVersion 13 | compile group: 'org.openrdf.sesame', name: 'sesame-repository-sail', version: sesameVersion 14 | compile group: 'org.openrdf.sesame', name: 'sesame-sail-memory', version: sesameVersion 15 | compile group: 'org.openrdf.sesame', name: 'sesame-repository-contextaware', version: sesameVersion 16 | compile group: 'org.openrdf.sesame', name: 'sesame-rio-rdfxml', version: sesameVersion 17 | compile group: 'org.openrdf.sesame', name: 'sesame-rio-turtle', version: sesameVersion 18 | } 19 | -------------------------------------------------------------------------------- /trainbenchmark-generator-rdf/src/main/java/hu/bme/mit/trainbenchmark/generator/rdf/config/RdfGeneratorConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.generator.rdf.config; 2 | 3 | import com.google.common.base.Preconditions; 4 | 5 | import hu.bme.mit.trainbenchmark.generator.config.GeneratorConfigBuilder; 6 | import hu.bme.mit.trainbenchmark.rdf.RdfFormat; 7 | 8 | public class RdfGeneratorConfigBuilder extends GeneratorConfigBuilder { 9 | 10 | protected Boolean inferred; 11 | protected RdfFormat format; 12 | 13 | public RdfGeneratorConfigBuilder setInferred(Boolean inferred) { 14 | this.inferred = inferred; 15 | return this; 16 | } 17 | 18 | public RdfGeneratorConfigBuilder setFormat(RdfFormat format) { 19 | this.format = format; 20 | return this; 21 | } 22 | 23 | @Override 24 | public void checkNotNulls() { 25 | super.checkNotNulls(); 26 | Preconditions.checkNotNull(inferred); 27 | Preconditions.checkNotNull(format); 28 | } 29 | 30 | @Override 31 | public RdfGeneratorConfig createConfig() { 32 | checkNotNulls(); 33 | return new RdfGeneratorConfig(configBase, inferred, format); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /trainbenchmark-generator-rdf/src/main/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-generator-rdf/src/main/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-generator-sql/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.generator.sql.SqlGeneratorMain' } 6 | } 7 | 8 | dependencies { 9 | compile project(':trainbenchmark-generator') 10 | compile project(':trainbenchmark-format-sql') 11 | } 12 | -------------------------------------------------------------------------------- /trainbenchmark-generator-sql/src/main/java/hu/bme/mit/trainbenchmark/generator/sql/config/SqlGeneratorConfigBuilder.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | 13 | package hu.bme.mit.trainbenchmark.generator.sql.config; 14 | 15 | import hu.bme.mit.trainbenchmark.generator.config.GeneratorConfigBuilder; 16 | 17 | public class SqlGeneratorConfigBuilder extends GeneratorConfigBuilder { 18 | 19 | @Override 20 | public SqlGeneratorConfig createConfig() { 21 | checkNotNulls(); 22 | return new SqlGeneratorConfig(configBase); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /trainbenchmark-generator-sql/src/main/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-generator-sql/src/main/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-generator-sql/src/test/java/hu/bme/mit/trainbenchmark/generator/sql/SqlGeneratorTest.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.generator.sql; 2 | 3 | import hu.bme.mit.trainbenchmark.generator.ModelGenerator; 4 | import hu.bme.mit.trainbenchmark.generator.ScalableGeneratorFactory; 5 | import hu.bme.mit.trainbenchmark.generator.config.GeneratorConfigBase; 6 | import hu.bme.mit.trainbenchmark.generator.sql.config.SqlGeneratorConfig; 7 | import hu.bme.mit.trainbenchmark.generator.sql.config.SqlGeneratorConfigBuilder; 8 | import hu.bme.mit.trainbenchmark.generator.tests.GeneratorTest; 9 | 10 | public class SqlGeneratorTest extends GeneratorTest { 11 | 12 | @Override 13 | public void generate(final GeneratorConfigBase gcb) throws Exception { 14 | final SqlGeneratorConfig gc = new SqlGeneratorConfigBuilder().setConfigBase(gcb).createConfig(); 15 | final SqlSerializer serializer = new SqlSerializer(gc); 16 | final ModelGenerator generator = ScalableGeneratorFactory.createGenerator(serializer, gc); 17 | generator.generateModel(); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /trainbenchmark-generator/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compile project(':trainbenchmark-config') 3 | compile group: 'org.apache.commons', name: 'commons-exec', version: commonsExecVersion 4 | compile group: 'junit', name: 'junit', version: junitVersion 5 | } 6 | -------------------------------------------------------------------------------- /trainbenchmark-generator/src/main/java/hu/bme/mit/trainbenchmark/generator/ModelGenerator.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.generator; 2 | 3 | import java.io.FileNotFoundException; 4 | import java.io.IOException; 5 | 6 | import hu.bme.mit.trainbenchmark.generator.config.GeneratorConfig; 7 | 8 | public abstract class ModelGenerator { 9 | 10 | protected final ModelSerializer serializer; 11 | protected GeneratorConfig gc; 12 | 13 | public ModelGenerator(final ModelSerializer serializer, final GeneratorConfig gc) { 14 | this.serializer = serializer; 15 | this.gc = gc; 16 | } 17 | 18 | public void generateModel() throws Exception { 19 | final StringBuilder messageBuilder = new StringBuilder(); 20 | messageBuilder.append("Generating instance model, "); 21 | messageBuilder.append("generator: " + serializer.syntax() + ", "); 22 | messageBuilder.append("size: " + gc.getConfigBase().getSize()); 23 | messageBuilder.append("... "); 24 | System.out.print(messageBuilder.toString()); 25 | serializer.initModel(); 26 | constructModel(); 27 | serializer.persistModel(); 28 | System.out.println("Done."); 29 | } 30 | 31 | protected abstract void constructModel() throws FileNotFoundException, IOException; 32 | 33 | } 34 | -------------------------------------------------------------------------------- /trainbenchmark-generator/src/main/java/hu/bme/mit/trainbenchmark/generator/config/GeneratorConfig.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.generator.config; 2 | 3 | import hu.bme.mit.trainbenchmark.config.AbstractConfig; 4 | 5 | public abstract class GeneratorConfig extends AbstractConfig { 6 | 7 | public GeneratorConfig(final GeneratorConfigBase configBase) { 8 | super(configBase); 9 | } 10 | 11 | /** 12 | * @return The name of the project to be executed. Example: "emf" 13 | */ 14 | public abstract String getProjectName(); 15 | 16 | } 17 | -------------------------------------------------------------------------------- /trainbenchmark-generator/src/main/java/hu/bme/mit/trainbenchmark/generator/config/GeneratorConfigBaseBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.generator.config; 2 | 3 | import com.google.common.base.Preconditions; 4 | 5 | public final class GeneratorConfigBaseBuilder { 6 | private Scenario scenario; 7 | private Integer size; 8 | 9 | public GeneratorConfigBaseBuilder setScenario(Scenario scenario) { 10 | this.scenario = scenario; 11 | return this; 12 | } 13 | 14 | public GeneratorConfigBaseBuilder setSize(int size) { 15 | this.size = size; 16 | return this; 17 | } 18 | 19 | public GeneratorConfigBase createGeneratorConfigBase() { 20 | Preconditions.checkNotNull(scenario); 21 | Preconditions.checkNotNull(size); 22 | return new GeneratorConfigBase(scenario, size); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /trainbenchmark-generator/src/main/java/hu/bme/mit/trainbenchmark/generator/config/GeneratorConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.generator.config; 2 | 3 | import hu.bme.mit.trainbenchmark.config.AbstractConfigBuilder; 4 | 5 | public abstract class GeneratorConfigBuilder 6 | > 7 | extends AbstractConfigBuilder 8 | { 9 | 10 | } 11 | -------------------------------------------------------------------------------- /trainbenchmark-generator/src/main/java/hu/bme/mit/trainbenchmark/generator/config/Scenario.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.generator.config; 13 | 14 | public enum Scenario { 15 | BATCH("Batch"), // 16 | INJECT("Inject"), // 17 | REPAIR("Repair"), // 18 | MINIMAL("Minimal"); 19 | 20 | private String name; 21 | 22 | Scenario(final String name) { 23 | this.name = name; 24 | } 25 | 26 | @Override 27 | public String toString() { 28 | return name; 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /trainbenchmark-generator/src/main/java/hu/bme/mit/trainbenchmark/generator/minimal/MinimalModelGenerator.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.generator.minimal; 2 | 3 | import java.io.FileNotFoundException; 4 | import java.io.IOException; 5 | 6 | import hu.bme.mit.trainbenchmark.generator.ModelGenerator; 7 | import hu.bme.mit.trainbenchmark.generator.ModelSerializer; 8 | import hu.bme.mit.trainbenchmark.generator.config.GeneratorConfig; 9 | 10 | public abstract class MinimalModelGenerator extends ModelGenerator { 11 | 12 | public MinimalModelGenerator(final ModelSerializer serializer, final GeneratorConfig generatorConfig) { 13 | super(serializer, generatorConfig); 14 | } 15 | 16 | @Override 17 | protected void constructModel() throws FileNotFoundException, IOException { 18 | serializer.beginTransaction(); 19 | buildPatternModel(); 20 | serializer.endTransaction(); 21 | } 22 | 23 | protected abstract void buildPatternModel() throws FileNotFoundException, IOException; 24 | 25 | } 26 | -------------------------------------------------------------------------------- /trainbenchmark-generator/src/main/java/hu/bme/mit/trainbenchmark/generator/minimal/MinimalSwitchMonitoredGenerator.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.generator.minimal; 2 | 3 | import static hu.bme.mit.trainbenchmark.constants.ModelConstants.ELEMENTS; 4 | import static hu.bme.mit.trainbenchmark.constants.ModelConstants.REGION; 5 | import static hu.bme.mit.trainbenchmark.constants.ModelConstants.SWITCH; 6 | 7 | import java.io.FileNotFoundException; 8 | import java.io.IOException; 9 | 10 | import hu.bme.mit.trainbenchmark.generator.ModelSerializer; 11 | import hu.bme.mit.trainbenchmark.generator.config.GeneratorConfig; 12 | 13 | public class MinimalSwitchMonitoredGenerator extends MinimalModelGenerator { 14 | 15 | public MinimalSwitchMonitoredGenerator(final ModelSerializer serializer, final GeneratorConfig generatorConfig) { 16 | super(serializer, generatorConfig); 17 | } 18 | 19 | @Override 20 | protected void buildPatternModel() throws FileNotFoundException, IOException { 21 | final Object region = serializer.createVertex(REGION); 22 | final Object sw = serializer.createVertex(SWITCH); 23 | 24 | serializer.createEdge(ELEMENTS, region, sw); 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /trainbenchmark-generator/src/main/java/hu/bme/mit/trainbenchmark/generator/utils/ZipIterator.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.generator.utils; 2 | 3 | public interface ZipIterator { 4 | void each(T t, U u); 5 | } 6 | -------------------------------------------------------------------------------- /trainbenchmark-generator/src/main/java/hu/bme/mit/trainbenchmark/generator/utils/ZipUtils.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.generator.utils; 2 | 3 | import java.util.Iterator; 4 | import java.util.stream.Stream; 5 | 6 | public class ZipUtils { 7 | public static boolean zip(final Iterable ct, final Stream cu, final ZipIterator each) { 8 | final Iterator it = ct.iterator(); 9 | final Iterator iu = cu.iterator(); 10 | while (it.hasNext() && iu.hasNext()) { 11 | each.each(it.next(), iu.next()); 12 | } 13 | return !it.hasNext() && !iu.hasNext(); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /trainbenchmark-reporting/.gitignore: -------------------------------------------------------------------------------- 1 | Rplots.pdf 2 | 3 | -------------------------------------------------------------------------------- /trainbenchmark-reporting/build.gradle: -------------------------------------------------------------------------------- 1 | task plot(type: Exec) { 2 | commandLine 'Rscript', 'report.R' 3 | } 4 | 5 | task plotIndividual(type: Exec) { 6 | commandLine 'Rscript', 'individual.R' 7 | } -------------------------------------------------------------------------------- /trainbenchmark-reporting/install.R: -------------------------------------------------------------------------------- 1 | install.packages(c("ggplot2", "plyr", "ggrepel", "data.table", "arules", "purrr"), repos = "http://cran.rstudio.com/") 2 | -------------------------------------------------------------------------------- /trainbenchmark-reporting/reporting.Rproj: -------------------------------------------------------------------------------- 1 | Version: 1.0 2 | 3 | RestoreWorkspace: Default 4 | SaveWorkspace: Default 5 | AlwaysSaveHistory: Default 6 | 7 | EnableCodeIndexing: Yes 8 | UseSpacesForTab: Yes 9 | NumSpacesForTab: 2 10 | Encoding: UTF-8 11 | 12 | RnwWeave: Sweave 13 | LaTeX: pdfLaTeX 14 | -------------------------------------------------------------------------------- /trainbenchmark-reporting/tool-list.csv: -------------------------------------------------------------------------------- 1 | Tool 2 | EMF API 3 | Jena (Inferencing) 4 | Jena (No Inferencing) 5 | MySQL 6 | Neo4j (Core API-CSV) 7 | Neo4j (Cypher-GraphML) 8 | SQLite 9 | TinkerGraph 10 | VIATRA (Incremental) 11 | VIATRA (Local Search) 12 | -------------------------------------------------------------------------------- /trainbenchmark-reporting/tools.csv: -------------------------------------------------------------------------------- 1 | tool,format,storage 2 | EMF API,EMF,in-memory 3 | VIATRA (Incremental),EMF,in-memory 4 | VIATRA (Local Search),EMF,in-memory 5 | Neo4j (Core API-CSV),property graph,disk-resident 6 | Neo4j (Cypher-CSV),property graph,disk-resident 7 | Neo4j (Core API-GraphML),property graph,disk-resident 8 | Neo4j (Cypher-GraphML),property graph,disk-resident 9 | Neo4j (Core API-Binary),property graph,disk-resident 10 | Neo4j (Cypher-Binary),property graph,disk-resident 11 | TinkerGraph,property graph,in-memory 12 | Jena (Inferencing),RDF,in-memory 13 | Jena (No Inferencing),RDF,in-memory 14 | MySQL,SQL,disk-resident 15 | SQLite,SQL,in-memory 16 | -------------------------------------------------------------------------------- /trainbenchmark-scripts/diff.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | diff -x .gitignore src/ src-template/ 4 | -------------------------------------------------------------------------------- /trainbenchmark-scripts/src/.gitignore: -------------------------------------------------------------------------------- 1 | *.groovy 2 | -------------------------------------------------------------------------------- /trainbenchmark-server/build.gradle: -------------------------------------------------------------------------------- 1 | buildscript { 2 | dependencies { 3 | classpath group: 'org.akhikhl.gretty', name: 'gretty', version: '1.4.1' 4 | } 5 | repositories { 6 | jcenter() 7 | } 8 | } 9 | 10 | apply plugin: 'org.akhikhl.gretty' 11 | 12 | task page() { 13 | doLast { 14 | copy { 15 | from '../trainbenchmark-reporting' 16 | into 'src/main/webapp/diagrams' 17 | include '*.pdf' 18 | } 19 | 20 | copy { 21 | from '../diagrams' 22 | into 'src/main/webapp/diagrams' 23 | include '*.pdf' 24 | } 25 | 26 | appRun.contextPath = '' 27 | appRun.inplaceMode = 'hard' 28 | appRun.execute() 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /trainbenchmark-server/src/main/webapp/diagrams/.gitignore: -------------------------------------------------------------------------------- 1 | * 2 | !.gitignore 3 | -------------------------------------------------------------------------------- /trainbenchmark-server/src/main/webapp/index.html: -------------------------------------------------------------------------------- 1 | 10 | -------------------------------------------------------------------------------- /trainbenchmark-tool-emf/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compile project(':trainbenchmark-tool') 3 | compile project(':trainbenchmark-format-emf') 4 | } 5 | -------------------------------------------------------------------------------- /trainbenchmark-tool-emf/src/main/java/hu/bme/mit/trainbenchmark/benchmark/emf/comparators/EmfMatchComparator.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.emf.comparators; 13 | 14 | import hu.bme.mit.trainbenchmark.benchmark.emf.matches.EmfMatch; 15 | import hu.bme.mit.trainbenchmark.benchmark.matches.comparators.BaseMatchComparator; 16 | import hu.bme.mit.trainbenchmark.railway.RailwayElement; 17 | 18 | public class EmfMatchComparator extends BaseMatchComparator { 19 | 20 | public EmfMatchComparator() { 21 | super(new RailwayElementComparator()); 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /trainbenchmark-tool-emf/src/main/java/hu/bme/mit/trainbenchmark/benchmark/emf/comparators/RailwayElementComparator.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.emf.comparators; 13 | 14 | import java.util.Comparator; 15 | 16 | import hu.bme.mit.trainbenchmark.railway.RailwayElement; 17 | 18 | public class RailwayElementComparator implements Comparator { 19 | 20 | @Override 21 | public int compare(final RailwayElement e1, final RailwayElement e2) { 22 | final int id1 = e1.getId(); 23 | final int id2 = e2.getId(); 24 | return Integer.compare(id1, id2); 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /trainbenchmark-tool-emf/src/main/java/hu/bme/mit/trainbenchmark/benchmark/emf/driver/EmfDriverFactory.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.emf.driver; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.driver.DriverFactory; 4 | 5 | public class EmfDriverFactory extends DriverFactory { 6 | 7 | @Override 8 | public EmfDriver createInstance() throws Exception { 9 | return new EmfDriver(); 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /trainbenchmark-tool-emf/src/main/java/hu/bme/mit/trainbenchmark/benchmark/emf/matches/EmfMatch.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.emf.matches; 13 | 14 | import java.util.Arrays; 15 | 16 | import hu.bme.mit.trainbenchmark.benchmark.matches.BaseMatch; 17 | 18 | public abstract class EmfMatch extends BaseMatch { 19 | 20 | @Override 21 | public String toString() { 22 | return "EMFMatch [match=" + Arrays.toString(toArray()) + "]"; 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /trainbenchmark-tool-emf/src/main/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-tool-emf/src/main/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-tool-emfapi/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.benchmark.emfapi.EmfApiBenchmarkMain' } 6 | } 7 | 8 | dependencies { 9 | compile project(':trainbenchmark-tool-emf') 10 | } 11 | -------------------------------------------------------------------------------- /trainbenchmark-tool-emfapi/src/main/java/hu/bme/mit/trainbenchmark/benchmark/emfapi/EmfApiBenchmarkScenario.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.emfapi; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.emf.comparators.EmfMatchComparator; 4 | import hu.bme.mit.trainbenchmark.benchmark.emf.driver.EmfDriver; 5 | import hu.bme.mit.trainbenchmark.benchmark.emf.driver.EmfDriverFactory; 6 | import hu.bme.mit.trainbenchmark.benchmark.emf.matches.EmfMatch; 7 | import hu.bme.mit.trainbenchmark.benchmark.emfapi.config.EmfApiBenchmarkConfig; 8 | import hu.bme.mit.trainbenchmark.benchmark.emfapi.operations.EmfApiModelOperationFactory; 9 | import hu.bme.mit.trainbenchmark.benchmark.phases.BenchmarkScenario; 10 | 11 | public class EmfApiBenchmarkScenario 12 | extends BenchmarkScenario { 13 | 14 | public EmfApiBenchmarkScenario(final EmfApiBenchmarkConfig bc) throws Exception { 15 | super(new EmfDriverFactory(), new EmfApiModelOperationFactory(), new EmfMatchComparator(), bc); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /trainbenchmark-tool-emfapi/src/main/java/hu/bme/mit/trainbenchmark/benchmark/emfapi/config/EmfApiBenchmarkConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.emfapi.config; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBuilder; 4 | 5 | public class EmfApiBenchmarkConfigBuilder 6 | extends BenchmarkConfigBuilder { 7 | 8 | @Override 9 | public EmfApiBenchmarkConfig createConfig() { 10 | checkNotNulls(); 11 | return new EmfApiBenchmarkConfig(configBase); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /trainbenchmark-tool-emfapi/src/main/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-tool-emfapi/src/main/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-tool-ingraph/.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | /native 3 | results/ 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-ingraph/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.benchmark.ingraph.IngraphBenchmarkMain' } 6 | } 7 | 8 | repositories { 9 | mavenLocal() 10 | maven { url "https://dl.bintray.com/ftsrg/maven" } 11 | } 12 | 13 | dependencies { 14 | compile project(':trainbenchmark-tool') 15 | compile project(':trainbenchmark-tool-ingraph-query-plans') 16 | compile group: 'ingraph', name: 'ingraph-ire', version: ingraphVersion 17 | compile 'com.github.jbellis:jamm:0.3.1' 18 | } 19 | -------------------------------------------------------------------------------- /trainbenchmark-tool-ingraph/src/main/java/hu/bme/mit/trainbenchmark/benchmark/ingraph/IngraphUtils.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.ingraph; 2 | 3 | import java.lang.reflect.Method; 4 | 5 | import relalg.RelalgContainer; 6 | 7 | public class IngraphUtils { 8 | public static RelalgContainer getQueryPlan(final String name, final String variant) throws 9 | Exception { 10 | final String prefix = "ingraph.trainbenchmark."; 11 | final Class factoryClass = Class.forName(prefix + name + "QueryPlanFactory"); 12 | final Method declaredMethod = factoryClass.getDeclaredMethod(decapitalize(name) + variant); 13 | final Object factory = factoryClass.getConstructor().newInstance(); 14 | return (RelalgContainer) declaredMethod.invoke(factory); 15 | } 16 | 17 | private static String decapitalize(final String string) { 18 | return Character.toLowerCase(string.charAt(0)) + string.substring(1); 19 | } 20 | 21 | // static Map createIreTuple(Object pred, Object subj, Object obj) { 22 | // Map.Map1() 23 | // return new Map(1, 2, 3); 24 | // } 25 | } 26 | -------------------------------------------------------------------------------- /trainbenchmark-tool-ingraph/src/main/java/hu/bme/mit/trainbenchmark/benchmark/ingraph/config/IngraphBenchmarkConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.ingraph.config; 2 | 3 | import com.google.common.base.Preconditions; 4 | 5 | import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBuilder; 6 | 7 | public class IngraphBenchmarkConfigBuilder 8 | extends BenchmarkConfigBuilder { 9 | 10 | protected Integer messageSize; 11 | protected String queryVariant; 12 | 13 | @Override 14 | public void checkNotNulls() { 15 | super.checkNotNulls(); 16 | Preconditions.checkNotNull(messageSize); 17 | } 18 | 19 | public IngraphBenchmarkConfigBuilder setMessageSize(Integer messageSize) { 20 | this.messageSize = messageSize; 21 | return this; 22 | } 23 | 24 | public IngraphBenchmarkConfigBuilder setQueryVariant(String queryVariant) { 25 | this.queryVariant = queryVariant; 26 | return this; 27 | } 28 | 29 | @Override 30 | public IngraphBenchmarkConfig createConfig() { 31 | checkNotNulls(); 32 | return new IngraphBenchmarkConfig(configBase, messageSize, queryVariant, null); 33 | } 34 | 35 | } -------------------------------------------------------------------------------- /trainbenchmark-tool-ingraph/src/main/java/hu/bme/mit/trainbenchmark/benchmark/ingraph/driver/IngraphDriverFactory.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.ingraph.driver; 2 | 3 | import hu.bme.mit.ire.TransactionFactory; 4 | import hu.bme.mit.trainbenchmark.benchmark.driver.DriverFactory; 5 | import hu.bme.mit.trainbenchmark.benchmark.ingraph.config.IngraphBenchmarkConfig; 6 | 7 | public class IngraphDriverFactory extends DriverFactory { 8 | 9 | protected IngraphBenchmarkConfig bc; 10 | protected TransactionFactory transactionFactory; 11 | 12 | public IngraphDriverFactory(final IngraphBenchmarkConfig bc, final TransactionFactory transactionFactory) { 13 | this.bc = bc; 14 | this.transactionFactory = transactionFactory; 15 | } 16 | 17 | @Override 18 | public IngraphDriver createInstance() throws Exception { 19 | return new IngraphDriver(bc, transactionFactory); 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /trainbenchmark-tool-ingraph/src/main/java/hu/bme/mit/trainbenchmark/benchmark/ingraph/match/IngraphMatchComparator.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.ingraph.match; 13 | 14 | import hu.bme.mit.trainbenchmark.benchmark.comparators.LongComparator; 15 | import hu.bme.mit.trainbenchmark.benchmark.matches.comparators.BaseMatchComparator; 16 | 17 | public class IngraphMatchComparator extends BaseMatchComparator { 18 | 19 | public IngraphMatchComparator() { 20 | super(new LongComparator()); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /trainbenchmark-tool-ingraph/src/main/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.rootLogger=OFF 2 | -------------------------------------------------------------------------------- /trainbenchmark-tool-janusgraph/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.benchmark.janusgraph.JanusGraphBenchmarkMain' } 6 | } 7 | 8 | dependencies { 9 | compile project(':trainbenchmark-tool-tinkergraph') 10 | compile group: 'org.apache.tinkerpop', name: 'gremlin-server', version: tinkerGraphVersion 11 | compile group: 'org.janusgraph', name: 'janusgraph-core', version: janusGraph 12 | // compile group: 'org.janusgraph', name: 'janusgraph-berkeleyje', version: janusGraph 13 | } 14 | -------------------------------------------------------------------------------- /trainbenchmark-tool-janusgraph/conf/jgex-berkeleyje.properties: -------------------------------------------------------------------------------- 1 | gremlin.graph=org.janusgraph.core.JanusGraphFactory 2 | 3 | storage.backend=berkeleyje 4 | storage.directory=jgex/berkeleyje 5 | 6 | index.jgex.backend=lucene 7 | index.jgex.directory=jgex/lucene 8 | -------------------------------------------------------------------------------- /trainbenchmark-tool-janusgraph/conf/jgex-cassandra.properties: -------------------------------------------------------------------------------- 1 | gremlin.graph=org.janusgraph.core.JanusGraphFactory 2 | 3 | storage.backend=cassandra 4 | storage.cassandra.keyspace=jgex 5 | storage.hostname=127.0.0.1 6 | 7 | index.jgex.backend=elasticsearch 8 | index.jgex.index-name=jgex 9 | index.jgex.hostname=127.0.0.1 10 | -------------------------------------------------------------------------------- /trainbenchmark-tool-janusgraph/conf/jgex-inmemory.properties: -------------------------------------------------------------------------------- 1 | gremlin.graph=org.janusgraph.core.JanusGraphFactory 2 | 3 | storage.backend=inmemory 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-janusgraph/src/main/java/hu/bme/mit/trainbenchmark/benchmark/janusgraph/config/JanusGraphBenchmarkConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.janusgraph.config; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBuilder; 4 | 5 | public class JanusGraphBenchmarkConfigBuilder 6 | extends BenchmarkConfigBuilder { 7 | 8 | @Override 9 | public JanusGraphBenchmarkConfig createConfig() { 10 | checkNotNulls(); 11 | return new JanusGraphBenchmarkConfig(configBase); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /trainbenchmark-tool-janusgraph/src/main/java/hu/bme/mit/trainbenchmark/benchmark/janusgraph/driver/JanusGraphDriverFactory.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.janusgraph.driver; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.driver.DriverFactory; 4 | 5 | public class JanusGraphDriverFactory extends DriverFactory { 6 | 7 | @Override 8 | public JanusGraphDriver createInstance() throws Exception { 9 | return new JanusGraphDriver(); 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /trainbenchmark-tool-janusgraph/src/main/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-tool-janusgraph/src/main/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-tool-jena/.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | /target 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-jena/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.benchmark.jena.JenaBenchmarkMain' } 6 | } 7 | 8 | dependencies { 9 | compile project(':trainbenchmark-tool') 10 | compile project(':trainbenchmark-tool-rdf') 11 | compile group: 'org.apache.jena', name: 'jena-querybuilder', version: jenaVersion 12 | } 13 | -------------------------------------------------------------------------------- /trainbenchmark-tool-jena/src/main/java/hu/bme/mit/trainbenchmark/benchmark/jena/JenaBenchmarkScenario.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.jena; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.jena.comparators.JenaMatchComparator; 4 | import hu.bme.mit.trainbenchmark.benchmark.jena.config.JenaBenchmarkConfig; 5 | import hu.bme.mit.trainbenchmark.benchmark.jena.driver.JenaDriver; 6 | import hu.bme.mit.trainbenchmark.benchmark.jena.driver.JenaDriverFactory; 7 | import hu.bme.mit.trainbenchmark.benchmark.jena.matches.JenaMatch; 8 | import hu.bme.mit.trainbenchmark.benchmark.jena.operations.JenaModelOperationFactory; 9 | import hu.bme.mit.trainbenchmark.benchmark.phases.BenchmarkScenario; 10 | 11 | public class JenaBenchmarkScenario extends BenchmarkScenario { 12 | 13 | public JenaBenchmarkScenario(final JenaBenchmarkConfig bc) throws Exception { 14 | super(new JenaDriverFactory(bc.isInferencing()), new JenaModelOperationFactory(), new JenaMatchComparator(), bc); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /trainbenchmark-tool-jena/src/main/java/hu/bme/mit/trainbenchmark/benchmark/jena/comparators/JenaMatchComparator.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.jena.comparators; 13 | 14 | import org.apache.jena.rdf.model.Resource; 15 | 16 | import hu.bme.mit.trainbenchmark.benchmark.jena.matches.JenaMatch; 17 | import hu.bme.mit.trainbenchmark.benchmark.matches.comparators.BaseMatchComparator; 18 | 19 | public class JenaMatchComparator extends BaseMatchComparator { 20 | 21 | public JenaMatchComparator() { 22 | super(new ResourceComparator()); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /trainbenchmark-tool-jena/src/main/java/hu/bme/mit/trainbenchmark/benchmark/jena/config/JenaBenchmarkConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.jena.config; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.rdf.config.RdfBenchmarkConfigBuilder; 4 | 5 | public class JenaBenchmarkConfigBuilder 6 | extends RdfBenchmarkConfigBuilder { 7 | 8 | @Override 9 | public JenaBenchmarkConfig createConfig() { 10 | checkNotNulls(); 11 | return new JenaBenchmarkConfig(configBase, inferencing, format); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /trainbenchmark-tool-jena/src/main/java/hu/bme/mit/trainbenchmark/benchmark/jena/driver/JenaDriverFactory.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.jena.driver; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.rdf.driver.RdfDriverFactory; 4 | 5 | public class JenaDriverFactory extends RdfDriverFactory { 6 | 7 | public JenaDriverFactory(final boolean inferencing) { 8 | super(inferencing); 9 | } 10 | 11 | @Override 12 | public JenaDriver createInstance() throws Exception { 13 | return new JenaDriver(inferencing); 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /trainbenchmark-tool-jena/src/main/java/hu/bme/mit/trainbenchmark/benchmark/jena/transformations/JenaTransformation.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.jena.transformations; 13 | 14 | import hu.bme.mit.trainbenchmark.benchmark.jena.driver.JenaDriver; 15 | import hu.bme.mit.trainbenchmark.benchmark.operations.ModelTransformation; 16 | 17 | public abstract class JenaTransformation extends ModelTransformation { 18 | 19 | protected JenaTransformation(final JenaDriver driver) { 20 | super(driver); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /trainbenchmark-tool-jena/src/main/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | ############################################################################### 2 | # Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | # All rights reserved. This program and the accompanying materials 4 | # are made available under the terms of the Eclipse Public License v1.0 5 | # which accompanies this distribution, and is available at 6 | # http://www.eclipse.org/legal/epl-v10.html 7 | # 8 | # Contributors: 9 | # Benedek Izso - initial API and implementation 10 | # Gabor Szarnyas - initial API and implementation 11 | ############################################################################### 12 | log4j.rootLogger=OFF 13 | -------------------------------------------------------------------------------- /trainbenchmark-tool-mysql/.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | -------------------------------------------------------------------------------- /trainbenchmark-tool-mysql/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.benchmark.mysql.MySqlBenchmarkMain' } 6 | } 7 | 8 | dependencies { 9 | compile project(':trainbenchmark-tool') 10 | compile project(':trainbenchmark-tool-sql') 11 | compile group: 'mysql', name: 'mysql-connector-java', version: mySqlConnectorVersion 12 | } 13 | -------------------------------------------------------------------------------- /trainbenchmark-tool-mysql/src/main/java/hu/bme/mit/trainbenchmark/benchmark/mysql/MySqlBenchmarkScenario.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.mysql; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.comparators.LongMatchComparator; 4 | import hu.bme.mit.trainbenchmark.benchmark.mysql.config.MySqlBenchmarkConfig; 5 | import hu.bme.mit.trainbenchmark.benchmark.mysql.driver.MySqlDriver; 6 | import hu.bme.mit.trainbenchmark.benchmark.mysql.driver.MySqlDriverFactory; 7 | import hu.bme.mit.trainbenchmark.benchmark.mysql.operations.MySqlModelOperationFactory; 8 | import hu.bme.mit.trainbenchmark.benchmark.phases.BenchmarkScenario; 9 | import hu.bme.mit.trainbenchmark.benchmark.sql.matches.SqlMatch; 10 | 11 | public class MySqlBenchmarkScenario extends BenchmarkScenario { 12 | 13 | public MySqlBenchmarkScenario(final MySqlBenchmarkConfig bc) throws Exception { 14 | super(new MySqlDriverFactory(), new MySqlModelOperationFactory(), new LongMatchComparator(), bc); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /trainbenchmark-tool-mysql/src/main/java/hu/bme/mit/trainbenchmark/benchmark/mysql/config/MySqlBenchmarkConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.mysql.config; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBuilder; 4 | 5 | public class MySqlBenchmarkConfigBuilder 6 | extends BenchmarkConfigBuilder { 7 | 8 | @Override 9 | public MySqlBenchmarkConfig createConfig() { 10 | checkNotNulls(); 11 | return new MySqlBenchmarkConfig(configBase); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /trainbenchmark-tool-mysql/src/main/java/hu/bme/mit/trainbenchmark/benchmark/mysql/driver/MySqlDriverFactory.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.mysql.driver; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.driver.DriverFactory; 4 | 5 | public class MySqlDriverFactory extends DriverFactory { 6 | 7 | @Override 8 | public MySqlDriver createInstance() throws Exception { 9 | return new MySqlDriver(); 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /trainbenchmark-tool-mysql/src/main/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-tool-mysql/src/main/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/README.md: -------------------------------------------------------------------------------- 1 | # Neo4j implementation 2 | 3 | Neo4j cannot assign a specific id to a new node. 4 | 5 | This means that if we run multiple transformations (e.g. ConnectedSegmentsInject, which inserts new Segments), we cannot guarantee the precise number of matches. -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | mergeServiceFiles() 6 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.benchmark.neo4j.Neo4jBenchmarkMain' } 7 | } 8 | 9 | dependencies { 10 | compile project(':trainbenchmark-tool') 11 | compile project(':trainbenchmark-format-graph-neo4j') 12 | } 13 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/java/hu/bme/mit/trainbenchmark/benchmark/neo4j/Neo4jBenchmarkScenario.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.neo4j; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.neo4j.comparators.Neo4jMatchComparator; 4 | import hu.bme.mit.trainbenchmark.benchmark.neo4j.config.Neo4jBenchmarkConfig; 5 | import hu.bme.mit.trainbenchmark.benchmark.neo4j.driver.Neo4jDriver; 6 | import hu.bme.mit.trainbenchmark.benchmark.neo4j.driver.Neo4jDriverFactory; 7 | import hu.bme.mit.trainbenchmark.benchmark.neo4j.matches.Neo4jMatch; 8 | import hu.bme.mit.trainbenchmark.benchmark.neo4j.operations.Neo4jModelOperationFactory; 9 | import hu.bme.mit.trainbenchmark.benchmark.phases.BenchmarkScenario; 10 | 11 | public class Neo4jBenchmarkScenario extends BenchmarkScenario { 12 | 13 | public Neo4jBenchmarkScenario(final Neo4jBenchmarkConfig bc) throws Exception { 14 | super( 15 | new Neo4jDriverFactory( 16 | bc.getConfigBase().getModelDir(), 17 | bc.getDeployment(), 18 | bc.getGraphFormat() 19 | ), 20 | new Neo4jModelOperationFactory(bc.getEngine()), 21 | new Neo4jMatchComparator(), 22 | bc 23 | ); 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/java/hu/bme/mit/trainbenchmark/benchmark/neo4j/comparators/Neo4jMatchComparator.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.neo4j.comparators; 13 | 14 | import org.neo4j.graphdb.Node; 15 | 16 | import hu.bme.mit.trainbenchmark.benchmark.matches.comparators.BaseMatchComparator; 17 | import hu.bme.mit.trainbenchmark.benchmark.neo4j.matches.Neo4jMatch; 18 | 19 | public class Neo4jMatchComparator extends BaseMatchComparator { 20 | 21 | public Neo4jMatchComparator() { 22 | super(new NodeComparator()); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/java/hu/bme/mit/trainbenchmark/benchmark/neo4j/config/Neo4jEngine.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.neo4j.config; 2 | 3 | public enum Neo4jEngine { 4 | CORE_API("Core API"), CYPHER("Cypher"); 5 | 6 | private String name; 7 | 8 | Neo4jEngine(final String name) { 9 | this.name = name; 10 | } 11 | 12 | @Override 13 | public String toString() { 14 | return name; 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/java/hu/bme/mit/trainbenchmark/benchmark/neo4j/driver/Neo4jDriverFactory.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.neo4j.driver; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.driver.DriverFactory; 4 | import hu.bme.mit.trainbenchmark.neo4j.config.Neo4jDeployment; 5 | import hu.bme.mit.trainbenchmark.neo4j.config.Neo4jGraphFormat; 6 | 7 | public class Neo4jDriverFactory extends DriverFactory { 8 | 9 | protected final String modelDir; 10 | protected final Neo4jDeployment deployment; 11 | protected final Neo4jGraphFormat graphFormat; 12 | 13 | public Neo4jDriverFactory(final String modelDir, final Neo4jDeployment deployment, final Neo4jGraphFormat graphFormat) { 14 | super(); 15 | this.modelDir = modelDir; 16 | this.deployment = deployment; 17 | this.graphFormat = graphFormat; 18 | } 19 | 20 | @Override 21 | public Neo4jDriver createInstance() throws Exception { 22 | return new Neo4jDriver(modelDir, deployment, graphFormat); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/java/hu/bme/mit/trainbenchmark/benchmark/neo4j/queries/Neo4jQuery.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.neo4j.queries; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.neo4j.driver.Neo4jDriver; 4 | import hu.bme.mit.trainbenchmark.benchmark.neo4j.matches.Neo4jMatch; 5 | import hu.bme.mit.trainbenchmark.benchmark.operations.ModelQuery; 6 | import hu.bme.mit.trainbenchmark.constants.RailwayQuery; 7 | 8 | public abstract class Neo4jQuery extends ModelQuery { 9 | 10 | public Neo4jQuery(final RailwayQuery query, final Neo4jDriver driver) { 11 | super(query, driver); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/java/hu/bme/mit/trainbenchmark/benchmark/neo4j/transformations/Neo4jApiTransformation.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.neo4j.transformations; 13 | 14 | import hu.bme.mit.trainbenchmark.benchmark.neo4j.driver.Neo4jDriver; 15 | import hu.bme.mit.trainbenchmark.benchmark.neo4j.matches.Neo4jMatch; 16 | 17 | public abstract class Neo4jApiTransformation extends Neo4jTransformation { 18 | 19 | protected Neo4jApiTransformation(final Neo4jDriver driver) { 20 | super(driver); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/java/hu/bme/mit/trainbenchmark/benchmark/neo4j/transformations/Neo4jCypherTransformation.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.neo4j.transformations; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.neo4j.driver.Neo4jDriver; 4 | import hu.bme.mit.trainbenchmark.benchmark.neo4j.matches.Neo4jMatch; 5 | import hu.bme.mit.trainbenchmark.constants.RailwayOperation; 6 | import hu.bme.mit.trainbenchmark.neo4j.Neo4jConstants; 7 | import org.apache.commons.io.FileUtils; 8 | 9 | import java.io.File; 10 | import java.io.IOException; 11 | import java.nio.charset.StandardCharsets; 12 | 13 | public abstract class Neo4jCypherTransformation 14 | extends Neo4jTransformation { 15 | 16 | protected final String transformationDefinition; 17 | 18 | public Neo4jCypherTransformation(final Neo4jDriver driver, final String workspaceDir, 19 | final RailwayOperation operation) throws IOException { 20 | super(driver); 21 | this.transformationDefinition = FileUtils.readFileToString( 22 | new File(workspaceDir + Neo4jConstants.CYPHER_DIR 23 | + "transformations/" + operation + "Rhs." + Neo4jConstants.QUERY_EXTENSION), 24 | StandardCharsets.UTF_8); 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/java/hu/bme/mit/trainbenchmark/benchmark/neo4j/transformations/Neo4jTransformation.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.neo4j.transformations; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.neo4j.driver.Neo4jDriver; 4 | import hu.bme.mit.trainbenchmark.benchmark.neo4j.matches.Neo4jMatch; 5 | import hu.bme.mit.trainbenchmark.benchmark.operations.ModelTransformation; 6 | 7 | public abstract class Neo4jTransformation extends ModelTransformation { 8 | 9 | public Neo4jTransformation(final Neo4jDriver driver) { 10 | super(driver); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/queries/ActiveRoute.cypher: -------------------------------------------------------------------------------- 1 | MATCH (route:Route {active: true})-[:follows]->(swP:SwitchPosition)-[:target]->(sw:Switch) 2 | WHERE swP.position <> sw.currentPosition 3 | RETURN route, swP, sw 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/queries/ConnectedSegments.cypher: -------------------------------------------------------------------------------- 1 | MATCH 2 | (sensor:Sensor)<-[:monitoredBy]-(segment1:Segment), 3 | (segment1:Segment)-[:connectsTo]-> 4 | (segment2:Segment)-[:connectsTo]-> 5 | (segment3:Segment)-[:connectsTo]-> 6 | (segment4:Segment)-[:connectsTo]-> 7 | (segment5:Segment)-[:connectsTo]->(segment6:Segment), 8 | (segment2:Segment)-[:monitoredBy]->(sensor:Sensor), 9 | (segment3:Segment)-[:monitoredBy]->(sensor:Sensor), 10 | (segment4:Segment)-[:monitoredBy]->(sensor:Sensor), 11 | (segment5:Segment)-[:monitoredBy]->(sensor:Sensor), 12 | (segment6:Segment)-[:monitoredBy]->(sensor:Sensor) 13 | RETURN sensor, segment1, segment2, segment3, segment4, segment5, segment6 14 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/queries/ConnectedSegmentsInject.cypher: -------------------------------------------------------------------------------- 1 | MATCH 2 | (segment1:Segment)-[:connectsTo]->(segment3:Segment), 3 | (segment1)-[:monitoredBy]->(sensor:Sensor), 4 | (segment3)-[:monitoredBy]->(sensor) 5 | RETURN sensor, segment1, segment3 6 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/queries/PosLength.cypher: -------------------------------------------------------------------------------- 1 | MATCH (segment:Segment) 2 | WHERE segment.length <= 0 3 | RETURN segment, segment.length AS length 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/queries/PosLengthInject.cypher: -------------------------------------------------------------------------------- 1 | MATCH (segment:Segment) 2 | RETURN segment 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/queries/RouteLength.cypher: -------------------------------------------------------------------------------- 1 | MATCH 2 | (route:Route)-[:follows]->(swP1:SwitchPosition)-[:target]->(sw1:Switch), 3 | (route)-[:follows]->(swP2:SwitchPosition)-[:target]->(sw2:Switch) 4 | WHERE sw1.id < sw2.id 5 | MATCH p=(sw1)-[:connectsTo*]-(sw2) 6 | WITH route, nodes(p) AS tes 7 | // only the start and the end of the path are switches 8 | WHERE size(filter(te IN tes WHERE NOT (te:Segment))) = 2 9 | UNWIND tes AS te 10 | RETURN route, sum(te.length) AS length 11 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/queries/RouteReachability.cypher: -------------------------------------------------------------------------------- 1 | MATCH 2 | (route:Route)-[:follows]->(swP1:SwitchPosition)-[:target]->(sw1:Switch), 3 | (route)-[:follows]->(swP2:SwitchPosition)-[:target]->(sw2:Switch) 4 | WHERE NOT (sw1)-[:connectsTo*]-(sw2) 5 | RETURN route, swP1, swP2, sw1, sw2 6 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/queries/RouteSensor.cypher: -------------------------------------------------------------------------------- 1 | MATCH (route:Route)-[:follows]->(swP:SwitchPosition)-[:target]->(sw:Switch)-[:monitoredBy]->(sensor:Sensor) 2 | WHERE NOT (route)-[:requires]->(sensor) 3 | RETURN route, sensor, swP, sw 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/queries/RouteSensorInject.cypher: -------------------------------------------------------------------------------- 1 | MATCH (route)-[:requires]->(sensor) 2 | RETURN route, sensor 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/queries/SemaphoreNeighbor.cypher: -------------------------------------------------------------------------------- 1 | MATCH 2 | (semaphore:Semaphore)<-[:exit]-(route1:Route)-[:requires]->(sensor1:Sensor), 3 | (sensor1)<-[:monitoredBy]-(te1)-[:connectsTo]->(te2)-[:monitoredBy]->(sensor2:Sensor)<-[:requires]-(route2:Route) 4 | WHERE NOT (semaphore)<-[:entry]-(route2) 5 | AND route1 <> route2 6 | RETURN semaphore, route1, route2, sensor1, sensor2, te1, te2 7 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/queries/SemaphoreNeighborInject.cypher: -------------------------------------------------------------------------------- 1 | MATCH (route:Route)-[:entry]->(semaphore:Semaphore) 2 | RETURN route, semaphore 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/queries/SwitchMonitored.cypher: -------------------------------------------------------------------------------- 1 | MATCH (sw:Switch) 2 | WHERE NOT (sw)-[:monitoredBy]->() 3 | RETURN sw 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/queries/SwitchMonitoredInject.cypher: -------------------------------------------------------------------------------- 1 | MATCH (sw:Switch) 2 | RETURN sw 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/queries/SwitchSet.cypher: -------------------------------------------------------------------------------- 1 | MATCH (semaphore:Semaphore)<-[:entry]-(route:Route)-[:follows]->(swP:SwitchPosition)-[:target]->(sw:Switch) 2 | WHERE semaphore.signal = "GO" 3 | AND route.active = true 4 | AND sw.currentPosition <> swP.position 5 | RETURN semaphore, route, swP, sw, sw.currentPosition AS currentPosition, swP.position AS position 6 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/queries/SwitchSetInject.cypher: -------------------------------------------------------------------------------- 1 | MATCH (sw:Switch) 2 | RETURN sw 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/transformations/ConnectedSegmentsInjectRhs.cypher: -------------------------------------------------------------------------------- 1 | WITH $sensor AS sensor, $segment1 AS segment1, $segment3 AS segment3 2 | MATCH (segment1)-[c:connectsTo]->(segment3) 3 | CREATE 4 | (segment2:Segment {id: $id, length: $length})-[:monitoredBy]->(sensor), 5 | (segment1)-[:connectsTo]->(segment2), 6 | (segment2)-[:connectsTo]->(segment3) 7 | DELETE c 8 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/transformations/ConnectedSegmentsRepairRhs.cypher: -------------------------------------------------------------------------------- 1 | WITH $segment2 AS segment2 2 | DETACH DELETE segment2 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/transformations/PosLengthInjectRhs.cypher: -------------------------------------------------------------------------------- 1 | WITH $segment AS segment 2 | SET segment.length = 0 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/transformations/PosLengthRepairRhs.cypher: -------------------------------------------------------------------------------- 1 | WITH $segment AS segment 2 | SET segment.length = -segment.length + 1 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/transformations/RouteSensorInjectRhs.cypher: -------------------------------------------------------------------------------- 1 | WITH $route AS route, $sensor AS sensor 2 | MATCH (route)-[g:requires]->(sensor) 3 | DELETE g 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/transformations/RouteSensorRepairRhs.cypher: -------------------------------------------------------------------------------- 1 | WITH $route AS route, $sensor AS sensor 2 | CREATE (route)-[:requires]->(sensor) 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/transformations/SemaphoreNeighborInjectRhs.cypher: -------------------------------------------------------------------------------- 1 | WITH $route AS route, $semaphore AS semaphore 2 | MATCH (route)-[e:entry]->(semaphore) 3 | DELETE e 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/transformations/SemaphoreNeighborRepairRhs.cypher: -------------------------------------------------------------------------------- 1 | WITH $route2 AS route2, $semaphore AS semaphore 2 | MATCH (route2), (semaphore) 3 | WHERE NOT (route2)-[:entry]->(semaphore) 4 | CREATE (route2)-[:entry]->(semaphore) 5 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/transformations/SwitchMonitoredInjectRhs.cypher: -------------------------------------------------------------------------------- 1 | WITH $sw AS sw 2 | MATCH (sw)-[m:monitoredBy]->(:Sensor) 3 | DELETE m 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/transformations/SwitchMonitoredRepairRhs.cypher: -------------------------------------------------------------------------------- 1 | WITH $sw AS sw 2 | CREATE (sw)-[:monitoredBy]->(:Sensor {id: $id}) 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/transformations/SwitchSetInjectRhs.cypher: -------------------------------------------------------------------------------- 1 | WITH $sw AS sw 2 | SET sw.currentPosition = $currentPosition 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/main/resources/transformations/SwitchSetRepairRhs.cypher: -------------------------------------------------------------------------------- 1 | WITH $sw AS sw, $swP AS swP 2 | SET sw.currentPosition = swP.position 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-neo4j/src/test/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-tool-neo4j/src/test/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-tool-orientdb/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.benchmark.orientdb.OrientDbGraphBenchmarkMain' } 6 | } 7 | 8 | dependencies { 9 | compile project(':trainbenchmark-tool-tinkergraph') 10 | compile group: 'com.orientechnologies', name: 'orientdb-gremlin', version: orientDbVersion 11 | } 12 | -------------------------------------------------------------------------------- /trainbenchmark-tool-orientdb/conf/jgex-berkeleyje.properties: -------------------------------------------------------------------------------- 1 | gremlin.graph=org.janusgraph.core.JanusGraphFactory 2 | 3 | storage.backend=berkeleyje 4 | storage.directory=jgex/berkeleyje 5 | 6 | index.jgex.backend=lucene 7 | index.jgex.directory=jgex/lucene 8 | -------------------------------------------------------------------------------- /trainbenchmark-tool-orientdb/conf/jgex-cassandra.properties: -------------------------------------------------------------------------------- 1 | gremlin.graph=org.janusgraph.core.JanusGraphFactory 2 | 3 | storage.backend=cassandra 4 | storage.cassandra.keyspace=jgex 5 | storage.hostname=127.0.0.1 6 | 7 | index.jgex.backend=elasticsearch 8 | index.jgex.index-name=jgex 9 | index.jgex.hostname=127.0.0.1 10 | -------------------------------------------------------------------------------- /trainbenchmark-tool-orientdb/conf/jgex-inmemory.properties: -------------------------------------------------------------------------------- 1 | gremlin.graph=org.janusgraph.core.JanusGraphFactory 2 | 3 | storage.backend=inmemory 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-orientdb/src/main/java/hu/bme/mit/trainbenchmark/benchmark/orientdb/OrientDbBenchmarkScenario.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.orientdb; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.orientdb.config.OrientDbBenchmarkConfig; 4 | import hu.bme.mit.trainbenchmark.benchmark.orientdb.driver.OrientDbDriver; 5 | import hu.bme.mit.trainbenchmark.benchmark.orientdb.driver.OrientDbDriverFactory; 6 | import hu.bme.mit.trainbenchmark.benchmark.orientdb.operations.OrientDbModelOperationFactory; 7 | import hu.bme.mit.trainbenchmark.benchmark.phases.BenchmarkScenario; 8 | import hu.bme.mit.trainbenchmark.benchmark.tinkergraph.comparators.TinkerGraphMatchComparator; 9 | import hu.bme.mit.trainbenchmark.benchmark.tinkergraph.matches.TinkerGraphMatch; 10 | 11 | public class OrientDbBenchmarkScenario 12 | extends BenchmarkScenario { 13 | 14 | public OrientDbBenchmarkScenario(final OrientDbBenchmarkConfig bc) throws Exception { 15 | super(new OrientDbDriverFactory(), new OrientDbModelOperationFactory(bc.getEngine()), new TinkerGraphMatchComparator(), bc); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /trainbenchmark-tool-orientdb/src/main/java/hu/bme/mit/trainbenchmark/benchmark/orientdb/config/OrientDbBenchmarkConfigBuilder.java: -------------------------------------------------------------------------------- 1 | 2 | package hu.bme.mit.trainbenchmark.benchmark.orientdb.config; 3 | 4 | import com.google.common.base.Preconditions; 5 | import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBuilder; 6 | import hu.bme.mit.trainbenchmark.benchmark.tinkergraph.config.TinkerGraphEngine; 7 | 8 | public class OrientDbBenchmarkConfigBuilder 9 | extends BenchmarkConfigBuilder { 10 | 11 | protected TinkerGraphEngine engine; 12 | 13 | public OrientDbBenchmarkConfigBuilder setEngine(final TinkerGraphEngine engine) { 14 | this.engine = engine; 15 | return this; 16 | } 17 | 18 | @Override 19 | public OrientDbBenchmarkConfig createConfig() { 20 | checkNotNulls(); 21 | return new OrientDbBenchmarkConfig(configBase, engine); 22 | } 23 | 24 | @Override 25 | public void checkNotNulls() { 26 | super.checkNotNulls(); 27 | Preconditions.checkNotNull(engine); 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /trainbenchmark-tool-orientdb/src/main/java/hu/bme/mit/trainbenchmark/benchmark/orientdb/driver/OrientDbDriverFactory.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.orientdb.driver; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.driver.DriverFactory; 4 | 5 | public class OrientDbDriverFactory extends DriverFactory { 6 | 7 | @Override 8 | public OrientDbDriver createInstance() throws Exception { 9 | return new OrientDbDriver(); 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /trainbenchmark-tool-orientdb/src/main/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-tool-orientdb/src/main/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compile project(':trainbenchmark-tool') 3 | compile project(':trainbenchmark-format-rdf') 4 | } 5 | -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/src/main/java/hu/bme/mit/trainbenchmark/benchmark/rdf/config/RdfBenchmarkConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.rdf.config; 2 | 3 | import com.google.common.base.Preconditions; 4 | import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBuilder; 5 | import hu.bme.mit.trainbenchmark.rdf.RdfFormat; 6 | 7 | public abstract class RdfBenchmarkConfigBuilder> 8 | extends BenchmarkConfigBuilder { 9 | 10 | protected Boolean inferencing; 11 | protected RdfFormat format; 12 | 13 | public B setInferencing(final boolean inferencing) { 14 | this.inferencing = inferencing; 15 | return (B) this; 16 | } 17 | 18 | public B setFormat(RdfFormat format) { 19 | this.format = format; 20 | return (B) this; 21 | } 22 | 23 | @Override 24 | public void checkNotNulls() { 25 | super.checkNotNulls(); 26 | Preconditions.checkNotNull(inferencing); 27 | Preconditions.checkNotNull(format); 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/src/main/java/hu/bme/mit/trainbenchmark/benchmark/rdf/driver/RdfDriverFactory.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.rdf.driver; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.driver.DriverFactory; 4 | 5 | public abstract class RdfDriverFactory extends DriverFactory { 6 | 7 | protected final boolean inferencing; 8 | 9 | public RdfDriverFactory(final boolean inferencing) { 10 | this.inferencing = inferencing; 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/src/main/java/hu/bme/mit/trainbenchmark/benchmark/rdf/tests/RdfTest.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.rdf.tests; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.test.TrainBenchmarkTest; 4 | import hu.bme.mit.trainbenchmark.rdf.RdfFormat; 5 | import org.junit.runner.RunWith; 6 | import org.junit.runners.Parameterized; 7 | import org.junit.runners.Parameterized.Parameter; 8 | 9 | @RunWith(Parameterized.class) 10 | public abstract class RdfTest extends TrainBenchmarkTest { 11 | 12 | @Parameter(value = 0) 13 | public boolean inferencing; 14 | 15 | @Parameter(value = 1) 16 | public RdfFormat format; 17 | 18 | } 19 | -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/src/main/resources/queries/ConnectedSegments.sparql: -------------------------------------------------------------------------------- 1 | PREFIX base: 2 | PREFIX rdf: 3 | 4 | SELECT ?sensor ?segment1 ?segment2 ?segment3 ?segment4 ?segment5 ?segment6 5 | WHERE 6 | { 7 | ?sensor rdf:type base:Sensor . 8 | ?segment1 base:monitoredBy ?sensor . 9 | ?segment1 rdf:type base:Segment . 10 | 11 | ?segment1 base:connectsTo ?segment2 . 12 | ?segment2 base:monitoredBy ?sensor . 13 | ?segment2 rdf:type base:Segment . 14 | 15 | ?segment2 base:connectsTo ?segment3 . 16 | ?segment3 base:monitoredBy ?sensor . 17 | ?segment3 rdf:type base:Segment . 18 | 19 | ?segment3 base:connectsTo ?segment4 . 20 | ?segment4 rdf:type base:Segment . 21 | ?segment4 base:monitoredBy ?sensor . 22 | 23 | ?segment4 base:connectsTo ?segment5 . 24 | ?segment5 rdf:type base:Segment . 25 | ?segment5 base:monitoredBy ?sensor . 26 | 27 | ?segment5 base:connectsTo ?segment6 . 28 | ?segment6 rdf:type base:Segment . 29 | ?segment6 base:monitoredBy ?sensor . 30 | } 31 | -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/src/main/resources/queries/ConnectedSegmentsInject.sparql: -------------------------------------------------------------------------------- 1 | PREFIX base: 2 | PREFIX rdf: 3 | 4 | SELECT ?sensor ?segment1 ?segment3 5 | WHERE { 6 | ?segment1 base:connectsTo ?segment3 . 7 | ?segment1 base:monitoredBy ?sensor . 8 | ?segment3 base:monitoredBy ?sensor . 9 | 10 | ?sensor rdf:type base:Sensor . 11 | ?segment1 rdf:type base:Segment . 12 | ?segment3 rdf:type base:Segment . 13 | } 14 | -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/src/main/resources/queries/PosLength.sparql: -------------------------------------------------------------------------------- 1 | PREFIX base: 2 | PREFIX rdf: 3 | 4 | SELECT ?segment ?length 5 | WHERE 6 | { 7 | ?segment rdf:type base:Segment . 8 | ?segment base:length ?length . 9 | 10 | FILTER (?length <= 0) 11 | } 12 | -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/src/main/resources/queries/PosLengthInject.sparql: -------------------------------------------------------------------------------- 1 | PREFIX base: 2 | PREFIX rdf: 3 | 4 | SELECT ?segment 5 | WHERE { 6 | ?segment rdf:type base:Segment . 7 | } 8 | -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/src/main/resources/queries/RouteSensor.sparql: -------------------------------------------------------------------------------- 1 | PREFIX base: 2 | PREFIX rdf: 3 | 4 | SELECT ?route ?sensor ?swP ?sw 5 | WHERE 6 | { 7 | ?route base:follows ?swP . 8 | ?route rdf:type base:Route . 9 | ?swP rdf:type base:SwitchPosition . 10 | 11 | ?swP base:target ?sw . 12 | ?sw rdf:type base:Switch . 13 | 14 | ?sw base:monitoredBy ?sensor . 15 | ?sensor rdf:type base:Sensor . 16 | 17 | FILTER NOT EXISTS { 18 | ?route base:requires ?sensor . 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/src/main/resources/queries/RouteSensorInject.sparql: -------------------------------------------------------------------------------- 1 | PREFIX base: 2 | PREFIX rdf: 3 | 4 | SELECT ?route ?sensor 5 | WHERE { 6 | ?route base:requires ?sensor . 7 | ?route rdf:type base:Route . 8 | ?sensor rdf:type base:Sensor . 9 | } 10 | -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/src/main/resources/queries/SemaphoreNeighbor.sparql: -------------------------------------------------------------------------------- 1 | PREFIX base: 2 | PREFIX rdf: 3 | 4 | SELECT ?semaphore ?route1 ?route2 ?sensor1 ?sensor2 ?te1 ?te2 5 | WHERE 6 | { 7 | ?route1 base:exit ?semaphore . 8 | ?route1 rdf:type base:Route . 9 | ?semaphore rdf:type base:Semaphore . 10 | 11 | ?route1 base:requires ?sensor1 . 12 | ?sensor1 rdf:type base:Sensor . 13 | 14 | ?te1 base:monitoredBy ?sensor1 . 15 | ?te1 rdf:type base:TrackElement . 16 | 17 | ?te1 base:connectsTo ?te2 . 18 | ?te2 rdf:type base:TrackElement . 19 | 20 | ?te2 base:monitoredBy ?sensor2 . 21 | ?sensor2 rdf:type base:Sensor . 22 | 23 | ?route2 base:requires ?sensor2 . 24 | 25 | FILTER (?route1 != ?route2) . 26 | 27 | FILTER NOT EXISTS { 28 | ?route2 base:entry ?semaphore 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/src/main/resources/queries/SemaphoreNeighborInject.sparql: -------------------------------------------------------------------------------- 1 | PREFIX base: 2 | PREFIX rdf: 3 | 4 | SELECT ?route ?semaphore 5 | WHERE { 6 | ?route rdf:type base:Route . 7 | ?route base:entry ?semaphore . 8 | ?semaphore rdf:type base:Semaphore . 9 | } 10 | -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/src/main/resources/queries/SwitchMonitored.sparql: -------------------------------------------------------------------------------- 1 | PREFIX base: 2 | PREFIX rdf: 3 | 4 | SELECT ?sw 5 | WHERE 6 | { 7 | ?sw rdf:type base:Switch . 8 | 9 | FILTER NOT EXISTS { 10 | ?sw base:monitoredBy ?sensor . 11 | ?sensor rdf:type base:Sensor . 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/src/main/resources/queries/SwitchMonitoredInject.sparql: -------------------------------------------------------------------------------- 1 | PREFIX base: 2 | PREFIX rdf: 3 | 4 | SELECT ?sw 5 | WHERE { 6 | ?sw rdf:type base:Switch . 7 | } 8 | -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/src/main/resources/queries/SwitchSet.sparql: -------------------------------------------------------------------------------- 1 | PREFIX base: 2 | PREFIX rdf: 3 | 4 | SELECT ?semaphore ?route ?swP ?sw ?currentPosition ?position 5 | WHERE 6 | { 7 | ?route base:entry ?semaphore . 8 | ?route rdf:type base:Route . 9 | ?route base:active true . 10 | ?semaphore rdf:type base:Semaphore . 11 | 12 | ?route base:follows ?swP . 13 | ?swP rdf:type base:SwitchPosition . 14 | 15 | ?swP base:target ?sw . 16 | ?sw rdf:type base:Switch . 17 | 18 | ?semaphore base:signal base:SIGNAL_GO . 19 | ?sw base:currentPosition ?currentPosition . 20 | ?swP base:position ?position . 21 | 22 | FILTER (?currentPosition != ?position) 23 | } 24 | -------------------------------------------------------------------------------- /trainbenchmark-tool-rdf/src/main/resources/queries/SwitchSetInject.sparql: -------------------------------------------------------------------------------- 1 | PREFIX base: 2 | PREFIX rdf: 3 | 4 | SELECT ?sw 5 | WHERE { 6 | ?sw rdf:type base:Switch . 7 | } 8 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sesame/.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sesame/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.benchmark.sesame.SesameBenchmarkMain' } 6 | mergeServiceFiles() 7 | } 8 | 9 | dependencies { 10 | compile project(':trainbenchmark-tool-rdf') 11 | compile group: 'org.openrdf.sesame', name: 'sesame-model', version: sesameVersion 12 | compile group: 'org.openrdf.sesame', name: 'sesame-repository-sail', version: sesameVersion 13 | compile group: 'org.openrdf.sesame', name: 'sesame-runtime', version: sesameVersion 14 | compile group: 'org.openrdf.sesame', name: 'sesame-sail-memory', version: sesameVersion 15 | compile group: 'org.openrdf.sesame', name: 'sesame-repository-contextaware', version: sesameVersion 16 | compile group: 'org.openrdf.sesame', name: 'sesame-rio-rdfxml', version: sesameVersion 17 | compile group: 'org.openrdf.sesame', name: 'sesame-rio-turtle', version: sesameVersion 18 | } 19 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sesame/src/main/java/hu/bme/mit/trainbenchmark/benchmark/sesame/SesameBenchmarkScenario.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.sesame; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.phases.BenchmarkScenario; 4 | import hu.bme.mit.trainbenchmark.benchmark.sesame.comparators.SesameMatchComparator; 5 | import hu.bme.mit.trainbenchmark.benchmark.sesame.config.SesameBenchmarkConfig; 6 | import hu.bme.mit.trainbenchmark.benchmark.sesame.driver.SesameDriver; 7 | import hu.bme.mit.trainbenchmark.benchmark.sesame.driver.SesameDriverFactory; 8 | import hu.bme.mit.trainbenchmark.benchmark.sesame.matches.SesameMatch; 9 | import hu.bme.mit.trainbenchmark.benchmark.sesame.operations.SesameModelOperationFactory; 10 | 11 | public class SesameBenchmarkScenario 12 | extends BenchmarkScenario { 13 | 14 | public SesameBenchmarkScenario(final SesameBenchmarkConfig sbc) throws Exception { 15 | super(new SesameDriverFactory(sbc.isInferencing()), new SesameModelOperationFactory(), new SesameMatchComparator(), sbc); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sesame/src/main/java/hu/bme/mit/trainbenchmark/benchmark/sesame/comparators/SesameMatchComparator.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.sesame.comparators; 13 | 14 | import org.openrdf.model.URI; 15 | 16 | import hu.bme.mit.trainbenchmark.benchmark.matches.comparators.BaseMatchComparator; 17 | import hu.bme.mit.trainbenchmark.benchmark.sesame.matches.SesameMatch; 18 | 19 | public class SesameMatchComparator extends BaseMatchComparator { 20 | 21 | public SesameMatchComparator() { 22 | super(new UriComparator()); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sesame/src/main/java/hu/bme/mit/trainbenchmark/benchmark/sesame/config/SesameBenchmarkConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.sesame.config; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.rdf.config.RdfBenchmarkConfigBuilder; 4 | 5 | public class SesameBenchmarkConfigBuilder 6 | extends RdfBenchmarkConfigBuilder { 7 | 8 | @Override 9 | public SesameBenchmarkConfig createConfig() { 10 | checkNotNulls(); 11 | return new SesameBenchmarkConfig(configBase, inferencing, format); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sesame/src/main/java/hu/bme/mit/trainbenchmark/benchmark/sesame/driver/SesameDriverFactory.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.sesame.driver; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.rdf.driver.RdfDriverFactory; 4 | 5 | public class SesameDriverFactory extends RdfDriverFactory { 6 | 7 | public SesameDriverFactory(final boolean inferencing) { 8 | super(inferencing); 9 | } 10 | 11 | @Override 12 | public SesameDriver createInstance() throws Exception { 13 | return new SesameDriver(inferencing); 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sesame/src/main/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-tool-sesame/src/main/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-tool-sesame/src/test/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-tool-sesame/src/test/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compile project(':trainbenchmark-tool') 3 | compile project(':trainbenchmark-format-sql') 4 | } 5 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/queries/ConnectedSegmentsInject.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | mb1.Sensor_id AS sensor, 3 | ct.TrackElement1_id AS segment1, 4 | ct.TrackElement2_id AS segment3 5 | FROM Segment 6 | INNER JOIN connectsTo as ct ON Segment.id = ct.TrackElement1_id 7 | INNER JOIN monitoredBy as mb1 ON mb1.TrackElement_id = ct.TrackElement1_id -- segment1 8 | INNER JOIN monitoredBy as mb2 ON mb2.TrackElement_id = ct.TrackElement2_id -- segment3 9 | WHERE mb1.Sensor_id = mb2.Sensor_id; 10 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/queries/PosLength.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | id AS segment, 3 | length AS length 4 | FROM Segment 5 | WHERE length <= 0; 6 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/queries/PosLengthInject.sql: -------------------------------------------------------------------------------- 1 | SELECT id AS segment 2 | FROM Segment; 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/queries/RouteSensor.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | Route.id AS route, 3 | Sensor.id AS sensor, 4 | SwitchPosition.id AS swP, 5 | Switch.id as sw 6 | FROM Sensor 7 | INNER JOIN monitoredBy ON monitoredBy.Sensor_id = Sensor.id 8 | INNER JOIN Switch ON Switch.id = monitoredBy.TrackElement_id 9 | INNER JOIN SwitchPosition ON SwitchPosition.target = Switch.id 10 | INNER JOIN Route ON Route.id = SwitchPosition.route -- the "SwitchPosition.route" attribute is the inverse of the "Route.follows" edge 11 | LEFT OUTER JOIN requires ON requires.Route_id = Route.id 12 | AND requires.Sensor_id = Sensor.id 13 | WHERE requires.Sensor_id IS NULL 14 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/queries/RouteSensorInject.sql: -------------------------------------------------------------------------------- 1 | SELECT Route_id AS route, Sensor_id AS sensor 2 | FROM requires 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/queries/SemaphoreNeighbor.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | Route1.exit AS semaphore, 3 | Route1.id AS route1, 4 | Route2.id AS route2, 5 | requires1.Sensor_id AS sensor1, 6 | requires2.Sensor_id AS sensor2, 7 | ct.TrackElement1_id AS te1, 8 | ct.TrackElement2_id AS te2 9 | 10 | -- (route1) 11 | FROM Route AS Route1 12 | 13 | -- (route1)-[:requires]->(sensor1) 14 | INNER JOIN requires AS requires1 15 | ON Route1.id = requires1.Route_id 16 | 17 | -- (sensor1)<-[:monitoredBy]-(te1) 18 | INNER JOIN monitoredBy AS mb1 19 | ON requires1.Sensor_id = mb1.Sensor_id 20 | 21 | -- (te1)-[:connectsTo]->(te2) 22 | INNER JOIN connectsTo AS ct 23 | ON mb1.TrackElement_id = ct.TrackElement1_id 24 | 25 | -- (te2)-[:monitoredBy]->(sensor2) 26 | INNER JOIN monitoredBy AS mb2 27 | ON ct.TrackElement2_id = mb2.TrackElement_id 28 | 29 | -- (sensor2)<-[:requires]-(route2) 30 | INNER JOIN requires AS requires2 31 | ON mb2.Sensor_id = requires2.Sensor_id 32 | 33 | -- (route2) 34 | INNER JOIN Route AS Route2 35 | ON requires2.Route_id = Route2.id 36 | 37 | WHERE Route1.id != Route2.id 38 | AND Route1.exit IS NOT NULL -- semaphore 39 | AND (Route2.entry IS NULL OR Route2.entry != Route1.exit); 40 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/queries/SemaphoreNeighborInject.sql: -------------------------------------------------------------------------------- 1 | SELECT id AS route, entry AS semaphore 2 | FROM Route 3 | WHERE entry != 0; 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/queries/SwitchMonitored.sql: -------------------------------------------------------------------------------- 1 | SELECT Switch.id AS sw 2 | FROM Switch 3 | LEFT JOIN monitoredBy ON monitoredBy.TrackElement_id = Switch.id 4 | WHERE monitoredBy.TrackElement_id IS NULL; 5 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/queries/SwitchMonitoredInject.sql: -------------------------------------------------------------------------------- 1 | SELECT id AS sw 2 | FROM Switch; 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/queries/SwitchSet.sql: -------------------------------------------------------------------------------- 1 | SELECT 2 | Semaphore.id AS semaphore, 3 | Route.id AS route, 4 | SwitchPosition.id AS swP, 5 | Switch.id AS sw, 6 | SwitchPosition.position AS position, 7 | Switch.currentPosition AS currentPosition 8 | 9 | -- (route) 10 | FROM Route 11 | 12 | -- (route)-[:follows]->(swP) 13 | INNER JOIN SwitchPosition 14 | ON Route.id = SwitchPosition.route -- the "SwitchPosition.route" attribute is the inverse of the "Route.follows" edge 15 | 16 | -- (swP)-[:target]->(sw) 17 | INNER JOIN Switch 18 | ON SwitchPosition.target = Switch.id 19 | 20 | -- (route)-[:entry]->(semaphore) 21 | INNER JOIN Semaphore 22 | ON Route.entry = Semaphore.id 23 | 24 | WHERE Route.active = 1 25 | AND Switch.currentPosition != SwitchPosition.position 26 | AND Semaphore.signal = 2; 27 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/queries/SwitchSetInject.sql: -------------------------------------------------------------------------------- 1 | SELECT id AS sw 2 | FROM Switch; 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/transformations/ConnectedSegmentsInjectRhs.sql: -------------------------------------------------------------------------------- 1 | SET @sensor := ?; 2 | SET @segment1 := ?; 3 | SET @segment3 := ?; 4 | SET @length := ?; 5 | 6 | -- get (region) node 7 | SET @region := 8 | (SELECT region 9 | FROM TrackElement 10 | WHERE id = @segment1); 11 | 12 | -- delete (segment1)-[:connectsTo]->(segment3) edge 13 | DELETE FROM connectsTo 14 | WHERE TrackElement1_id = @segment1 AND TrackElement2_id = @segment3; 15 | 16 | -- insert new node (segment2) as a TrackElement and retrieve its id 17 | INSERT INTO TrackElement (region) VALUES (@region); 18 | 19 | SET @segment2 := (SELECT LAST_INSERT_ID()); 20 | 21 | -- insert (segment2) node as a Segment 22 | INSERT INTO Segment (id, length) 23 | VALUES (@segment2, @length); 24 | 25 | -- insert (segment1)-[:connectsTo]->(segment2) edge 26 | INSERT INTO connectsTo 27 | VALUES (@segment1, @segment2); 28 | 29 | -- insert (segment1)-[:connectsTo]->(segment3) edge 30 | INSERT INTO connectsTo 31 | VALUES (@segment2, @segment3); 32 | 33 | -- insert (segment2)-[:monitoredBy]->(sensor) edge 34 | INSERT INTO monitoredBy 35 | VALUES (@segment2, @sensor); 36 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/transformations/ConnectedSegmentsRepairRhs.sql: -------------------------------------------------------------------------------- 1 | SET @segment1 := ?; 2 | SET @segment2 := ?; 3 | SET @segment3 := ?; 4 | 5 | -- delete (segment2) node as segment 6 | DELETE FROM Segment WHERE id = @segment2; 7 | -- delete (segment2) node as TrackElement and sensor edge 8 | DELETE FROM TrackElement WHERE id = @segment2; 9 | 10 | -- delete (segment1)-[:connectsTo]->(segment2) edge 11 | DELETE FROM connectsTo WHERE TrackElement1_id = @segment1 AND TrackElement2_id = @segment2; 12 | -- delete (segment2)-[:connectsTo]->(segment3) edge 13 | DELETE FROM connectsTo WHERE TrackElement1_id = @segment2 AND TrackElement2_id = @segment3; 14 | 15 | -- delete (segment2)-[:monitoredBy]->(sensor) edge 16 | DELETE FROM monitoredBy WHERE TrackElement_id = @segment2 AND Sensor_id = @sensor; 17 | 18 | -- insert (segment1)-[:connectsTo]->(segment3) edge 19 | INSERT INTO connectsTo VALUES (@segment1, @segment3); 20 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/transformations/PosLengthInjectRhs.sql: -------------------------------------------------------------------------------- 1 | UPDATE Segment 2 | SET length = 0 3 | WHERE id = ?; 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/transformations/PosLengthRepairRhs.sql: -------------------------------------------------------------------------------- 1 | UPDATE Segment 2 | SET length = -length + 1 3 | WHERE id = ?; 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/transformations/RouteSensorInjectRhs.sql: -------------------------------------------------------------------------------- 1 | SET @route := ?; 2 | SET @sensor := ?; 3 | 4 | DELETE FROM requires 5 | WHERE Route_id = @route 6 | AND Sensor_id = @sensor; 7 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/transformations/RouteSensorRepairRhs.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO requires (Route_id, Sensor_id) 2 | VALUES (?, ?); 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/transformations/SemaphoreNeighborInjectRhs.sql: -------------------------------------------------------------------------------- 1 | -- (route)-[:entry]->(semaphore) edge 2 | UPDATE Route 3 | SET entry = NULL 4 | WHERE id = ? 5 | AND entry = ?; 6 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/transformations/SemaphoreNeighborRepairRhs.sql: -------------------------------------------------------------------------------- 1 | UPDATE Route 2 | SET entry = ? 3 | WHERE id = ?; 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/transformations/SwitchMonitoredInjectRhs.sql: -------------------------------------------------------------------------------- 1 | DELETE FROM monitoredBy 2 | WHERE monitoredBy.TrackElement_id = ?; 3 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/transformations/SwitchMonitoredRepairRhs.sql: -------------------------------------------------------------------------------- 1 | SET @switch := ?; 2 | SET @region := 3 | (SELECT region FROM TrackElement WHERE id = @switch); 4 | 5 | -- insert a (sensor) vertex and retrieve its id 6 | INSERT INTO Sensor (region) VALUES (@region); 7 | SET @sensor := 8 | (SELECT LAST_INSERT_ID()); 9 | 10 | INSERT INTO monitoredBy (TrackElement_id, Sensor_id) 11 | VALUES (@switch, @sensor); 12 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/transformations/SwitchSetInjectRhs.sql: -------------------------------------------------------------------------------- 1 | UPDATE Switch 2 | SET currentPosition = (currentPosition + 1) % 3 3 | WHERE id = ?; 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sql/src/main/resources/transformations/SwitchSetRepairRhs.sql: -------------------------------------------------------------------------------- 1 | UPDATE Switch 2 | SET currentPosition = ? 3 | WHERE Switch.id = ?; 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sqlite/.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sqlite/README.md: -------------------------------------------------------------------------------- 1 | # Train Benchmark SQLite implementation 2 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sqlite/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.benchmark.sqlite.SQLiteBenchmarkMain' } 6 | } 7 | 8 | dependencies { 9 | compile project(':trainbenchmark-tool') 10 | compile project(':trainbenchmark-tool-sql') 11 | compile group: 'org.xerial', name: 'sqlite-jdbc', version: sqliteVersion 12 | } 13 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sqlite/src/main/java/hu/bme/mit/trainbenchmark/benchmark/sqlite/SQLiteBenchmarkScenario.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.sqlite; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.comparators.LongMatchComparator; 4 | import hu.bme.mit.trainbenchmark.benchmark.phases.BenchmarkScenario; 5 | import hu.bme.mit.trainbenchmark.benchmark.sql.matches.SqlMatch; 6 | import hu.bme.mit.trainbenchmark.benchmark.sqlite.config.SQLiteBenchmarkConfig; 7 | import hu.bme.mit.trainbenchmark.benchmark.sqlite.driver.SQLiteDriver; 8 | import hu.bme.mit.trainbenchmark.benchmark.sqlite.driver.SQLiteDriverFactory; 9 | import hu.bme.mit.trainbenchmark.benchmark.sqlite.operations.SQLiteModelOperationFactory; 10 | 11 | public class SQLiteBenchmarkScenario extends BenchmarkScenario { 12 | 13 | public SQLiteBenchmarkScenario(final SQLiteBenchmarkConfig bc) throws Exception { 14 | super(new SQLiteDriverFactory(), new SQLiteModelOperationFactory(), new LongMatchComparator(), bc); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sqlite/src/main/java/hu/bme/mit/trainbenchmark/benchmark/sqlite/config/SQLiteBenchmarkConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.sqlite.config; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBuilder; 4 | 5 | public class SQLiteBenchmarkConfigBuilder 6 | extends BenchmarkConfigBuilder { 7 | 8 | @Override 9 | public SQLiteBenchmarkConfig createConfig() { 10 | checkNotNulls(); 11 | return new SQLiteBenchmarkConfig(configBase); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sqlite/src/main/java/hu/bme/mit/trainbenchmark/benchmark/sqlite/driver/SQLiteDriverFactory.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.sqlite.driver; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.driver.DriverFactory; 4 | 5 | public class SQLiteDriverFactory extends DriverFactory { 6 | 7 | @Override 8 | public SQLiteDriver createInstance() throws Exception { 9 | return new SQLiteDriver(); 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sqlite/src/main/resources/transformations/RouteSensorInjectRhs.sql: -------------------------------------------------------------------------------- 1 | DELETE FROM requires 2 | WHERE Route_id = (SELECT Value FROM Variables WHERE Name = 'route') 3 | AND Sensor_id = (SELECT Value FROM Variables WHERE Name = 'sensor'); 4 | -------------------------------------------------------------------------------- /trainbenchmark-tool-sqlite/src/main/resources/transformations/SwitchMonitoredRepairRhs.sql: -------------------------------------------------------------------------------- 1 | INSERT OR REPLACE INTO Variables VALUES ('region', 2 | (SELECT region 3 | FROM TrackElement 4 | WHERE id = (SELECT Value FROM Variables WHERE Name = 'switch')) 5 | ); 6 | 7 | -- insert a (sensor) vertex and retrieve its id 8 | INSERT INTO Sensor (region) VALUES ( 9 | (SELECT Value FROM Variables WHERE Name = 'region') 10 | ); 11 | 12 | INSERT INTO monitoredBy (TrackElement_id, Sensor_id) 13 | VALUES ( 14 | (SELECT Value FROM Variables WHERE Name = 'switch'), 15 | (SELECT MAX(id) FROM Sensor) 16 | ); 17 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.benchmark.tinkergraph.TinkerGraphBenchmarkMain' } 6 | } 7 | 8 | dependencies { 9 | compile project(':trainbenchmark-tool') 10 | compile group: 'org.apache.tinkerpop', name: 'tinkergraph-gremlin', version: tinkerGraphVersion 11 | compile group: 'org.apache.tinkerpop', name: 'gremlin-core', version: tinkerGraphVersion 12 | compile group: 'org.apache.tinkerpop', name: 'gremlin-groovy', version: tinkerGraphVersion 13 | compile group: 'org.slf4j', name: 'slf4j-nop', version: slf4jVersion 14 | } 15 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/java/hu/bme/mit/trainbenchmark/benchmark/tinkergraph/TinkerGraphBenchmarkScenario.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.tinkergraph; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.phases.BenchmarkScenario; 4 | import hu.bme.mit.trainbenchmark.benchmark.tinkergraph.comparators.TinkerGraphMatchComparator; 5 | import hu.bme.mit.trainbenchmark.benchmark.tinkergraph.config.TinkerGraphBenchmarkConfig; 6 | import hu.bme.mit.trainbenchmark.benchmark.tinkergraph.driver.GraphDriver; 7 | import hu.bme.mit.trainbenchmark.benchmark.tinkergraph.driver.TinkerGraphDriverFactory; 8 | import hu.bme.mit.trainbenchmark.benchmark.tinkergraph.matches.TinkerGraphMatch; 9 | import hu.bme.mit.trainbenchmark.benchmark.tinkergraph.operations.TinkerGraphModelOperationFactory; 10 | 11 | public class TinkerGraphBenchmarkScenario 12 | extends BenchmarkScenario { 13 | 14 | public TinkerGraphBenchmarkScenario(final TinkerGraphBenchmarkConfig bc) throws Exception { 15 | super(new TinkerGraphDriverFactory(), new TinkerGraphModelOperationFactory<>(bc.getEngine()), new TinkerGraphMatchComparator(), bc); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/java/hu/bme/mit/trainbenchmark/benchmark/tinkergraph/config/TinkerGraphBenchmarkConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.tinkergraph.config; 2 | 3 | import com.google.common.base.Preconditions; 4 | import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBuilder; 5 | 6 | public class TinkerGraphBenchmarkConfigBuilder 7 | extends BenchmarkConfigBuilder { 8 | 9 | protected TinkerGraphEngine engine; 10 | 11 | public TinkerGraphBenchmarkConfigBuilder setEngine(final TinkerGraphEngine engine) { 12 | this.engine = engine; 13 | return this; 14 | } 15 | 16 | @Override 17 | public TinkerGraphBenchmarkConfig createConfig() { 18 | checkNotNulls(); 19 | return new TinkerGraphBenchmarkConfig(configBase, engine); 20 | } 21 | 22 | @Override 23 | public void checkNotNulls() { 24 | super.checkNotNulls(); 25 | Preconditions.checkNotNull(engine); 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/java/hu/bme/mit/trainbenchmark/benchmark/tinkergraph/config/TinkerGraphEngine.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.tinkergraph.config; 2 | 3 | public enum TinkerGraphEngine { 4 | CORE_API("Core API"), GREMLIN("Gremlin"); 5 | 6 | private String name; 7 | 8 | TinkerGraphEngine(final String name) { 9 | this.name = name; 10 | } 11 | 12 | @Override 13 | public String toString() { 14 | return name; 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/java/hu/bme/mit/trainbenchmark/benchmark/tinkergraph/driver/TinkerGraphDriver.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.tinkergraph.driver; 2 | 3 | import org.apache.tinkerpop.gremlin.structure.Vertex; 4 | import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph; 5 | 6 | import java.io.IOException; 7 | 8 | public class TinkerGraphDriver extends GraphDriver { 9 | 10 | protected TinkerGraphDriver() throws IOException { 11 | graph = TinkerGraph.open(); 12 | graph.createIndex(LABEL, Vertex.class); // TODO does this make any difference? 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/java/hu/bme/mit/trainbenchmark/benchmark/tinkergraph/driver/TinkerGraphDriverFactory.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.tinkergraph.driver; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.driver.DriverFactory; 4 | 5 | public class TinkerGraphDriverFactory extends DriverFactory { 6 | 7 | @Override 8 | public TinkerGraphDriver createInstance() throws Exception { 9 | return new TinkerGraphDriver(); 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-tool-tinkergraph/src/main/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/resources/queries/ConnectedSegments.gremlin: -------------------------------------------------------------------------------- 1 | g.V() \ 2 | .hasLabel('Sensor').as('sensor') \ 3 | .in('monitoredBy').hasLabel('Segment').as('segment1') \ 4 | .out('connectsTo').hasLabel('Segment').as('segment2') \ 5 | .out('connectsTo').hasLabel('Segment').as('segment3') \ 6 | .out('connectsTo').hasLabel('Segment').as('segment4') \ 7 | .out('connectsTo').hasLabel('Segment').as('segment5') \ 8 | .out('connectsTo').hasLabel('Segment').as('segment6') \ 9 | .out('monitoredBy').as('sensor2').where('sensor', eq('sensor2')) \ 10 | .select('sensor', 'segment1', 'segment2', 'segment3', 'segment4', 'segment5', 'segment6') 11 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/resources/queries/ConnectedSegmentsInject.gremlin: -------------------------------------------------------------------------------- 1 | g.V() \ 2 | .hasLabel('Sensor').as('sensor') \ 3 | .in('monitoredBy').hasLabel('Segment').as('segment1') \ 4 | .select('sensor') \ 5 | .in('monitoredBy').hasLabel('Segment').as('segment3') \ 6 | .select('segment1') \ 7 | .out('connectsTo').as('segment32').where('segment3', eq('segment32')) \ 8 | .select('sensor', 'segment1', 'segment3') 9 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/resources/queries/PosLength.gremlin: -------------------------------------------------------------------------------- 1 | g.V() \ 2 | .hasLabel('Segment').has('length', lte(0)).as('segment') \ 3 | .values('length').as('length') \ 4 | .select('segment', 'length') 5 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/resources/queries/PosLengthInject.gremlin: -------------------------------------------------------------------------------- 1 | g.V().hasLabel('Segment').as('segment') 2 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/resources/queries/RouteSensor.gremlin: -------------------------------------------------------------------------------- 1 | g.V() \ 2 | .hasLabel('Route').as('route') \ 3 | .out('follows').hasLabel('SwitchPosition').as('swP') \ 4 | .out('target').hasLabel('Switch').as('sw') \ 5 | .out('monitoredBy').hasLabel('Sensor').as('sensor') \ 6 | .not(inE('requires').outV().as('route2').where('route2', eq('route'))) \ 7 | .select('route', 'sensor', 'swP', 'sw') 8 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/resources/queries/RouteSensorInject.gremlin: -------------------------------------------------------------------------------- 1 | g.V() \ 2 | .hasLabel('Route').as('route') \ 3 | .out('requires').hasLabel('Sensor').as('sensor') \ 4 | .select('route', 'sensor') 5 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/resources/queries/SemaphoreNeighbor.gremlin: -------------------------------------------------------------------------------- 1 | g.V() \ 2 | .hasLabel('Route').as('route1') \ 3 | .out('exit').hasLabel('Semaphore').as('semaphore') \ 4 | .select('route1').out('requires').hasLabel('Sensor').as('sensor1') \ 5 | .in('monitoredBy').as('te1').out('connectsTo').as('te2') \ 6 | .out('monitoredBy').hasLabel('Sensor').as('sensor2') \ 7 | .in('requires').hasLabel('Route').as('route2') \ 8 | .where('route2', neq('route1')) \ 9 | .select('route2').not(out('entry').as('semaphore2').where('semaphore2', eq('semaphore'))) \ 10 | .select('semaphore', 'route1', 'route2', 'sensor1', 'sensor2', 'te1', 'te2') 11 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/resources/queries/SemaphoreNeighborInject.gremlin: -------------------------------------------------------------------------------- 1 | g.V() \ 2 | .hasLabel('Route').as('route') \ 3 | .out('entry').hasLabel('Semaphore').as('semaphore') \ 4 | .select('route', 'semaphore') 5 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/resources/queries/SwitchMonitored.gremlin: -------------------------------------------------------------------------------- 1 | g.V().hasLabel('Switch').not(outE('monitoredBy')).as('sw') 2 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/resources/queries/SwitchMonitoredInject.gremlin: -------------------------------------------------------------------------------- 1 | g.V().hasLabel('Switch').as('sw') 2 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/resources/queries/SwitchSet.gremlin: -------------------------------------------------------------------------------- 1 | g.V() \ 2 | .hasLabel('Route').has('active', true) \ 3 | .as('route').out('entry').hasLabel('Semaphore') \ 4 | .as('semaphore').select('route').out('follows').hasLabel('SwitchPosition') \ 5 | .as('swP').values('position') \ 6 | .as('position').select('swP').out('target').hasLabel('Switch') \ 7 | .as('sw').values('currentPosition').as('currentPosition') \ 8 | .where('position', neq('currentPosition')) \ 9 | .select('semaphore', 'route', 'swP', 'sw', 'currentPosition', 'position') 10 | -------------------------------------------------------------------------------- /trainbenchmark-tool-tinkergraph/src/main/resources/queries/SwitchSetInject.gremlin: -------------------------------------------------------------------------------- 1 | g.V().hasLabel('Switch').as('sw') 2 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/.classpath: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/.gitignore: -------------------------------------------------------------------------------- 1 | !.project 2 | !.classpath 3 | !src-gen/hu/bme/mit/trainbenchmark/benchmark/viatra/*.java 4 | !src-gen/hu/bme/mit/trainbenchmark/benchmark/viatra/util/*.java 5 | src-gen/hu/bme/mit/trainbenchmark/benchmark/viatra/.gitignore 6 | src-gen/hu/bme/mit/trainbenchmark/benchmark/viatra/util/.gitignore 7 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/META-INF/MANIFEST.MF: -------------------------------------------------------------------------------- 1 | Manifest-Version: 1.0 2 | Bundle-ManifestVersion: 2 3 | Bundle-Name: Patterns 4 | Bundle-SymbolicName: trainbenchmark-tool-viatra-patterns;singleton:=true 5 | Bundle-Version: 1.0.0.qualifier 6 | Export-Package: hu.bme.mit.trainbenchmark.benchmark.viatra, 7 | hu.bme.mit.trainbenchmark.benchmark.viatra.util 8 | Require-Bundle: trainbenchmark-format-emf-model;bundle-version="1.0.0", 9 | org.eclipse.xtext.xbase.lib, 10 | org.eclipse.viatra.query.runtime 11 | Bundle-RequiredExecutionEnvironment: JavaSE-1.8 12 | Import-Package: org.apache.log4j 13 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compile group: 'log4j', name: 'log4j', version: '1.2.17' 3 | compile group: 'org.eclipse.viatra', name: 'viatra-query-runtime', version: viatraVersion 4 | compile group: 'org.eclipse.xtext', name: 'org.eclipse.xtext.xbase.lib', version: '2.10.0' 5 | compile project(':trainbenchmark-format-emf-model') 6 | } 7 | 8 | sourceSets { 9 | main { 10 | java { 11 | srcDirs = ['src', 'src-gen'] 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/build.properties: -------------------------------------------------------------------------------- 1 | bin.includes = META-INF/,\ 2 | plugin.xml,\ 3 | . 4 | source.. = src-gen/,\ 5 | src/ 6 | output.. = bin/ 7 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/src-gen/hu/bme/mit/trainbenchmark/benchmark/viatra/util/HasSensorProcessor.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Generated from platform:/resource/trainbenchmark-tool-viatra-patterns/src/hu/bme/mit/trainbenchmark/benchmark/viatra/SwitchMonitored.vql 3 | */ 4 | package hu.bme.mit.trainbenchmark.benchmark.viatra.util; 5 | 6 | import hu.bme.mit.trainbenchmark.benchmark.viatra.HasSensorMatch; 7 | import hu.bme.mit.trainbenchmark.railway.TrackElement; 8 | import org.eclipse.viatra.query.runtime.api.IMatchProcessor; 9 | 10 | /** 11 | * A match processor tailored for the hu.bme.mit.trainbenchmark.benchmark.viatra.hasSensor pattern. 12 | * 13 | * Clients should derive an (anonymous) class that implements the abstract process(). 14 | * 15 | */ 16 | @SuppressWarnings("all") 17 | public abstract class HasSensorProcessor implements IMatchProcessor { 18 | /** 19 | * Defines the action that is to be executed on each match. 20 | * @param pSw the value of pattern parameter sw in the currently processed match 21 | * 22 | */ 23 | public abstract void process(final TrackElement pSw); 24 | 25 | @Override 26 | public void process(final HasSensorMatch match) { 27 | process(match.getSw()); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/src-gen/hu/bme/mit/trainbenchmark/benchmark/viatra/util/PosLengthProcessor.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Generated from platform:/resource/trainbenchmark-tool-viatra-patterns/src/hu/bme/mit/trainbenchmark/benchmark/viatra/PosLength.vql 3 | */ 4 | package hu.bme.mit.trainbenchmark.benchmark.viatra.util; 5 | 6 | import hu.bme.mit.trainbenchmark.benchmark.viatra.PosLengthMatch; 7 | import hu.bme.mit.trainbenchmark.railway.Segment; 8 | import org.eclipse.viatra.query.runtime.api.IMatchProcessor; 9 | 10 | /** 11 | * A match processor tailored for the hu.bme.mit.trainbenchmark.benchmark.viatra.posLength pattern. 12 | * 13 | * Clients should derive an (anonymous) class that implements the abstract process(). 14 | * 15 | */ 16 | @SuppressWarnings("all") 17 | public abstract class PosLengthProcessor implements IMatchProcessor { 18 | /** 19 | * Defines the action that is to be executed on each match. 20 | * @param pSegment the value of pattern parameter segment in the currently processed match 21 | * 22 | */ 23 | public abstract void process(final Segment pSegment); 24 | 25 | @Override 26 | public void process(final PosLengthMatch match) { 27 | process(match.getSegment()); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/src/hu/bme/mit/trainbenchmark/benchmark/viatra/ConnectedSegments.vql: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra 2 | 3 | import "http://www.semanticweb.org/ontologies/2015/trainbenchmark" 4 | 5 | pattern connectedSegments(sensor, segment1, segment2, segment3, segment4, segment5, segment6) 6 | { 7 | Segment.connectsTo(segment1, segment2); 8 | Segment.connectsTo(segment2, segment3); 9 | Segment.connectsTo(segment3, segment4); 10 | Segment.connectsTo(segment4, segment5); 11 | Segment.connectsTo(segment5, segment6); 12 | Segment.monitoredBy(segment1, sensor); 13 | Segment.monitoredBy(segment2, sensor); 14 | Segment.monitoredBy(segment3, sensor); 15 | Segment.monitoredBy(segment4, sensor); 16 | Segment.monitoredBy(segment5, sensor); 17 | Segment.monitoredBy(segment6, sensor); 18 | } 19 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/src/hu/bme/mit/trainbenchmark/benchmark/viatra/ConnectedSegmentsInject.vql: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra 2 | 3 | import "http://www.semanticweb.org/ontologies/2015/trainbenchmark" 4 | 5 | pattern connectedSegmentsInject(sensor, segment1, segment3) 6 | { 7 | Segment.connectsTo(segment1, segment3); 8 | Segment.monitoredBy(segment1, sensor); 9 | Segment.monitoredBy(segment3, sensor); 10 | } 11 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/src/hu/bme/mit/trainbenchmark/benchmark/viatra/PosLength.vql: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra 2 | 3 | import "http://www.semanticweb.org/ontologies/2015/trainbenchmark" 4 | 5 | pattern posLength(segment) 6 | { 7 | Segment.length(segment, length); 8 | check(length <= 0); 9 | } 10 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/src/hu/bme/mit/trainbenchmark/benchmark/viatra/PosLengthInject.vql: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra 2 | 3 | import "http://www.semanticweb.org/ontologies/2015/trainbenchmark" 4 | 5 | pattern posLengthInject(segment) 6 | { 7 | Segment(segment); 8 | } 9 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/src/hu/bme/mit/trainbenchmark/benchmark/viatra/RouteSensor.vql: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra 2 | 3 | import "http://www.semanticweb.org/ontologies/2015/trainbenchmark" 4 | 5 | pattern routeSensor(route, sensor, swP, sw) 6 | { 7 | Route.follows(route, swP); 8 | SwitchPosition.target(swP, sw); 9 | TrackElement.monitoredBy(sw, sensor); 10 | 11 | neg find required(sensor, route); 12 | } 13 | 14 | pattern required(sensor, route) 15 | { 16 | Route.requires(route, sensor); 17 | } 18 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/src/hu/bme/mit/trainbenchmark/benchmark/viatra/RouteSensorInject.vql: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra 2 | 3 | import "http://www.semanticweb.org/ontologies/2015/trainbenchmark" 4 | 5 | pattern routeSensorInject(route, sensor) 6 | { 7 | Route.requires(route, sensor); 8 | } 9 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/src/hu/bme/mit/trainbenchmark/benchmark/viatra/SemaphoreNeighbor.vql: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra 2 | 3 | import "http://www.semanticweb.org/ontologies/2015/trainbenchmark" 4 | 5 | pattern semaphoreNeighbor(semaphore, route1, route2, sensor1, sensor2, te1, te2) 6 | { 7 | Route.exit(route1, semaphore); 8 | Route.requires(route1, sensor1); 9 | TrackElement.monitoredBy(te1, sensor1); 10 | TrackElement.connectsTo(te1, te2); 11 | TrackElement.monitoredBy(te2, sensor2); 12 | Route.requires(route2, sensor2); 13 | 14 | neg find entrySemaphore(route2, semaphore); 15 | 16 | route1 != route2; 17 | } 18 | 19 | pattern entrySemaphore(route, semaphore) 20 | { 21 | Route.entry(route, semaphore); 22 | } 23 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/src/hu/bme/mit/trainbenchmark/benchmark/viatra/SemaphoreNeighborInject.vql: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra 2 | 3 | import "http://www.semanticweb.org/ontologies/2015/trainbenchmark" 4 | 5 | pattern semaphoreNeighborInject(route, semaphore) 6 | { 7 | Route.entry(route, semaphore); 8 | } 9 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/src/hu/bme/mit/trainbenchmark/benchmark/viatra/SwitchMonitored.vql: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra 2 | 3 | import "http://www.semanticweb.org/ontologies/2015/trainbenchmark" 4 | 5 | pattern switchMonitored(sw) 6 | { 7 | Switch(sw); 8 | neg find hasSensor(sw); 9 | } 10 | 11 | pattern hasSensor(sw) 12 | { 13 | TrackElement.monitoredBy(sw, _); 14 | } 15 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/src/hu/bme/mit/trainbenchmark/benchmark/viatra/SwitchMonitoredInject.vql: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra 2 | 3 | import "http://www.semanticweb.org/ontologies/2015/trainbenchmark" 4 | 5 | pattern switchMonitoredInject(sw) 6 | { 7 | Switch(sw); 8 | } 9 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/src/hu/bme/mit/trainbenchmark/benchmark/viatra/SwitchSet.vql: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra 2 | 3 | import "http://www.semanticweb.org/ontologies/2015/trainbenchmark" 4 | 5 | pattern switchSet(semaphore, route, swP, sw) 6 | { 7 | Route.active(route, true); 8 | Route.entry(route, semaphore); 9 | Route.follows(route, swP); 10 | SwitchPosition.target(swP, sw); 11 | 12 | Semaphore.signal(semaphore, ::GO); 13 | SwitchPosition.position(swP, swpPosition); 14 | Switch.currentPosition(sw, swCurrentPosition); 15 | 16 | swpPosition != swCurrentPosition; 17 | } 18 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra-patterns/src/hu/bme/mit/trainbenchmark/benchmark/viatra/SwitchSetInject.vql: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra 2 | 3 | import "http://www.semanticweb.org/ontologies/2015/trainbenchmark" 4 | 5 | pattern switchSetInject(sw) 6 | { 7 | Switch(sw); 8 | } 9 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.github.johnrengelman.shadow' 2 | 3 | shadowJar { 4 | classifier = 'fat' 5 | manifest { attributes 'Main-Class': 'hu.bme.mit.trainbenchmark.benchmark.viatra.ViatraBenchmarkMain' } 6 | } 7 | 8 | dependencies { 9 | compile project(':trainbenchmark-tool-viatra-patterns') 10 | compile project(':trainbenchmark-tool-emf') 11 | compile project(':trainbenchmark-format-emf') 12 | compile project(':trainbenchmark-format-emf-model') 13 | } 14 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra/src/main/java/hu/bme/mit/trainbenchmark/benchmark/viatra/ViatraBenchmarkScenario.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra; 2 | 3 | import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch; 4 | 5 | import hu.bme.mit.trainbenchmark.benchmark.phases.BenchmarkScenario; 6 | import hu.bme.mit.trainbenchmark.benchmark.viatra.comparators.ViatraMatchComparator; 7 | import hu.bme.mit.trainbenchmark.benchmark.viatra.config.ViatraBenchmarkConfig; 8 | import hu.bme.mit.trainbenchmark.benchmark.viatra.driver.ViatraDriver; 9 | import hu.bme.mit.trainbenchmark.benchmark.viatra.driver.ViatraDriverFactory; 10 | import hu.bme.mit.trainbenchmark.benchmark.viatra.operations.ViatraModelOperationFactory; 11 | 12 | public class ViatraBenchmarkScenario 13 | extends BenchmarkScenario { 14 | 15 | public ViatraBenchmarkScenario(final ViatraBenchmarkConfig bc) throws Exception { 16 | super(new ViatraDriverFactory(bc.getBackend()), new ViatraModelOperationFactory(), new ViatraMatchComparator(), bc); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra/src/main/java/hu/bme/mit/trainbenchmark/benchmark/viatra/config/ViatraBackend.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra.config; 2 | 3 | public enum ViatraBackend { 4 | INCREMENTAL("Incremental"), 5 | LOCAL_SEARCH("Local Search"); 6 | 7 | private String name; 8 | 9 | ViatraBackend(final String name) { 10 | this.name = name; 11 | } 12 | 13 | @Override 14 | public String toString() { 15 | return name; 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra/src/main/java/hu/bme/mit/trainbenchmark/benchmark/viatra/config/ViatraBenchmarkConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra.config; 2 | 3 | import com.google.common.base.Preconditions; 4 | 5 | import hu.bme.mit.trainbenchmark.benchmark.config.BenchmarkConfigBuilder; 6 | 7 | public class ViatraBenchmarkConfigBuilder 8 | extends BenchmarkConfigBuilder { 9 | 10 | private ViatraBackend backend; 11 | 12 | public ViatraBenchmarkConfigBuilder setBackend(final ViatraBackend backend) { 13 | this.backend = backend; 14 | return this; 15 | } 16 | 17 | @Override 18 | public void checkNotNulls() { 19 | super.checkNotNulls(); 20 | Preconditions.checkNotNull(backend); 21 | } 22 | 23 | @Override 24 | public ViatraBenchmarkConfig createConfig() { 25 | checkNotNulls(); 26 | return new ViatraBenchmarkConfig(configBase, backend); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /trainbenchmark-tool-viatra/src/main/java/hu/bme/mit/trainbenchmark/benchmark/viatra/driver/ViatraDriverFactory.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.viatra.driver; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.driver.DriverFactory; 4 | import hu.bme.mit.trainbenchmark.benchmark.viatra.config.ViatraBackend; 5 | 6 | public class ViatraDriverFactory extends DriverFactory { 7 | 8 | protected final ViatraBackend backend; 9 | 10 | public ViatraDriverFactory(final ViatraBackend backend) { 11 | super(); 12 | this.backend = backend; 13 | } 14 | 15 | @Override 16 | public ViatraDriver createInstance() throws Exception { 17 | return new ViatraDriver(backend); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /trainbenchmark-tool/build.gradle: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compile project(':trainbenchmark-config') 3 | compile group: 'commons-io', name: 'commons-io', version: commonsIoVersion 4 | compile group: 'org.apache.commons', name: 'commons-exec', version: commonsExecVersion 5 | compile group: 'junit', name: 'junit', version: junitVersion 6 | compile group: 'org.hamcrest', name: 'hamcrest-junit', version: '1.0.0.0' 7 | compile group: 'in.ashwanthkumar', name: 'slack-java-webhook', version: '0.0.6' 8 | } 9 | -------------------------------------------------------------------------------- /trainbenchmark-tool/build.properties: -------------------------------------------------------------------------------- 1 | ############################################################################### 2 | # Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | # All rights reserved. This program and the accompanying materials 4 | # are made available under the terms of the Eclipse Public License v1.0 5 | # which accompanies this distribution, and is available at 6 | # http://www.eclipse.org/legal/epl-v10.html 7 | # 8 | # Contributors: 9 | # Benedek Izso - initial API and implementation 10 | # Gabor Szarnyas - initial API and implementation 11 | ############################################################################### 12 | bin.includes = META-INF/,\ 13 | . 14 | source.. = src/ 15 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/comparators/LongComparator.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.comparators; 13 | 14 | import java.util.Comparator; 15 | 16 | public class LongComparator implements Comparator { 17 | 18 | @Override 19 | public int compare(final Long l1, final Long l2) { 20 | return Long.compare(l1, l2); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/comparators/LongMatchComparator.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.comparators; 13 | 14 | import hu.bme.mit.trainbenchmark.benchmark.matches.LongMatch; 15 | import hu.bme.mit.trainbenchmark.benchmark.matches.comparators.BaseMatchComparator; 16 | 17 | public class LongMatchComparator extends BaseMatchComparator { 18 | 19 | public LongMatchComparator() { 20 | super(new LongComparator()); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/config/BenchmarkConfig.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.config; 2 | 3 | import hu.bme.mit.trainbenchmark.config.AbstractConfig; 4 | 5 | public abstract class BenchmarkConfig extends AbstractConfig { 6 | 7 | protected BenchmarkConfig(final BenchmarkConfigBase configBase) { 8 | super(configBase); 9 | } 10 | 11 | /** 12 | * @return The name of the tools for storing the benchmark results. Example: "Sesame (No Inferencing)" 13 | */ 14 | public abstract String getToolName(); 15 | 16 | /** 17 | * @return The name of the project to be executed. Example: "sesame" 18 | */ 19 | public abstract String getProjectName(); 20 | 21 | public String getDescription() { 22 | return ""; 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/config/BenchmarkConfigBuilder.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.config; 2 | 3 | import hu.bme.mit.trainbenchmark.config.AbstractConfigBuilder; 4 | 5 | public abstract class BenchmarkConfigBuilder 6 | > 7 | extends AbstractConfigBuilder 8 | { 9 | 10 | } 11 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/config/ModelSetConfig.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.config; 2 | 3 | public class ModelSetConfig { 4 | 5 | protected String modelVariant; 6 | protected Integer minSize; 7 | protected Integer maxSize; 8 | 9 | public ModelSetConfig(final String modelVariant, final Integer minSize, final Integer maxSize) { 10 | super(); 11 | this.modelVariant = modelVariant; 12 | this.minSize = minSize; 13 | this.maxSize = maxSize; 14 | } 15 | 16 | public String getModelVariant() { 17 | return modelVariant; 18 | } 19 | 20 | public Integer getMinSize() { 21 | return minSize; 22 | } 23 | 24 | public Integer getMaxSize() { 25 | return maxSize; 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/config/TransformationChangeSetStrategy.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.config; 2 | 3 | public enum TransformationChangeSetStrategy { 4 | NONE, 5 | FIXED, 6 | PROPORTIONAL 7 | } 8 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/driver/DriverFactory.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.driver; 13 | 14 | public abstract class DriverFactory { 15 | 16 | public abstract TDriver createInstance() throws Exception; 17 | 18 | } 19 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/ActiveRouteMatch.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.matches; 13 | 14 | public interface ActiveRouteMatch extends Match { 15 | 16 | Object getRoute(); 17 | 18 | Object getSwP(); 19 | 20 | Object getSw(); 21 | 22 | @Override 23 | default Object[] toArray() { 24 | return new Object[] { getRoute(), getSwP(), getSw() }; 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/BaseMatch.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.matches; 2 | 3 | import java.util.Arrays; 4 | import java.util.Objects; 5 | 6 | public abstract class BaseMatch implements Match { 7 | 8 | @Override 9 | public boolean equals(final Object obj) { 10 | return Arrays.equals(toArray(), ((Match) obj).toArray()); 11 | } 12 | 13 | @Override 14 | public int hashCode() { 15 | return Objects.hash(toArray()); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/ConnectedSegmentsInjectMatch.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.matches; 13 | 14 | public interface ConnectedSegmentsInjectMatch extends Match { 15 | 16 | Object getSensor(); 17 | 18 | Object getSegment1(); 19 | 20 | Object getSegment3(); 21 | 22 | default Object[] toArray() { 23 | return new Object[] { getSensor(), getSegment1(), getSegment3() }; 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/LongMatch.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.matches; 13 | 14 | import java.util.Arrays; 15 | 16 | /** 17 | * A match class for storing only the ids of the elements in the match. 18 | */ 19 | public abstract class LongMatch extends BaseMatch { 20 | 21 | protected Long[] match; 22 | 23 | public LongMatch() { 24 | super(); 25 | } 26 | 27 | @Override 28 | public String toString() { 29 | return "LongMatch [match=" + Arrays.toString(match) + "]"; 30 | } 31 | 32 | } -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/Match.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.matches; 2 | 3 | public interface Match { 4 | 5 | Object[] toArray(); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/PosLengthInjectMatch.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.matches; 13 | 14 | public interface PosLengthInjectMatch extends Match { 15 | 16 | Object getSegment(); 17 | 18 | default Object[] toArray() { 19 | return new Object[] { getSegment() }; 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/PosLengthMatch.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.matches; 13 | 14 | public interface PosLengthMatch extends Match { 15 | 16 | Object getSegment(); 17 | 18 | default Object[] toArray() { 19 | return new Object[] { getSegment() }; 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/RouteLengthMatch.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.matches; 13 | 14 | public interface RouteLengthMatch extends Match { 15 | 16 | Object getRoute(); 17 | 18 | Number getLength(); 19 | 20 | @Override 21 | default Object[] toArray() { 22 | return new Object[] { getRoute(), getLength() }; 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/RouteReachabilityMatch.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.matches; 13 | 14 | public interface RouteReachabilityMatch extends Match { 15 | 16 | Object getRoute(); 17 | 18 | Object getSwP1(); 19 | 20 | Object getSwP2(); 21 | 22 | Object getSw1(); 23 | 24 | Object getSw2(); 25 | 26 | @Override 27 | default Object[] toArray() { 28 | return new Object[] { getRoute(), getSwP1(), getSwP2(), getSw1(), getSw2() }; 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/RouteSensorInjectMatch.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.matches; 13 | 14 | public interface RouteSensorInjectMatch extends Match { 15 | 16 | Object getRoute(); 17 | 18 | Object getSensor(); 19 | 20 | default Object[] toArray() { 21 | return new Object[] { getRoute(), getSensor() }; 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/RouteSensorMatch.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.matches; 13 | 14 | public interface RouteSensorMatch extends Match { 15 | 16 | Object getRoute(); 17 | 18 | Object getSensor(); 19 | 20 | Object getSwP(); 21 | 22 | Object getSw(); 23 | 24 | @Override 25 | default Object[] toArray() { 26 | return new Object[] { getRoute(), getSensor(), getSwP(), getSw() }; 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/SemaphoreNeighborInjectMatch.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.matches; 13 | 14 | public interface SemaphoreNeighborInjectMatch extends Match { 15 | 16 | Object getRoute(); 17 | 18 | Object getSemaphore(); 19 | 20 | @Override 21 | default Object[] toArray() { 22 | return new Object[] { getRoute(), getSemaphore() }; 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/SwitchMonitoredInjectMatch.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.matches; 13 | 14 | public interface SwitchMonitoredInjectMatch extends Match { 15 | 16 | Object getSw(); 17 | 18 | default Object[] toArray() { 19 | return new Object[] { getSw() }; 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/SwitchMonitoredMatch.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.matches; 13 | 14 | public interface SwitchMonitoredMatch extends Match { 15 | 16 | Object getSw(); 17 | 18 | default Object[] toArray() { 19 | return new Object[] { getSw() }; 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/SwitchSetInjectMatch.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.matches; 13 | 14 | public interface SwitchSetInjectMatch extends Match { 15 | 16 | Object getSw(); 17 | 18 | default Object[] toArray() { 19 | return new Object[] { getSw() }; 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/matches/SwitchSetMatch.java: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * Copyright (c) 2010-2015, Benedek Izso, Gabor Szarnyas, Istvan Rath and Daniel Varro 3 | * All rights reserved. This program and the accompanying materials 4 | * are made available under the terms of the Eclipse Public License v1.0 5 | * which accompanies this distribution, and is available at 6 | * http://www.eclipse.org/legal/epl-v10.html 7 | * 8 | * Contributors: 9 | * Benedek Izso - initial API and implementation 10 | * Gabor Szarnyas - initial API and implementation 11 | *******************************************************************************/ 12 | package hu.bme.mit.trainbenchmark.benchmark.matches; 13 | 14 | public interface SwitchSetMatch extends Match { 15 | 16 | Object getSemaphore(); 17 | 18 | Object getRoute(); 19 | 20 | Object getSwP(); 21 | 22 | Object getSw(); 23 | 24 | default Object[] toArray() { 25 | return new Object[] { getSemaphore(), getRoute(), getSwP(), getSw() }; 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/operations/ModelOperationFactory.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.operations; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.driver.Driver; 4 | import hu.bme.mit.trainbenchmark.constants.RailwayOperation; 5 | 6 | public abstract class ModelOperationFactory { 7 | 8 | public abstract ModelOperation createOperation(final RailwayOperation operationEnum, final String workspaceDir, 9 | final TDriver driver) throws Exception; 10 | 11 | } 12 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/operations/ModelOperationRegistry.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.operations; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | public class ModelOperationRegistry { 7 | 8 | protected final List> operations; 9 | 10 | protected ModelOperationRegistry(ModelOperation[] operations) { 11 | this.operations = Arrays.asList(operations); 12 | } 13 | 14 | public static ModelOperationRegistry of(ModelOperation... operations) { 15 | return new ModelOperationRegistry(operations); 16 | } 17 | 18 | public void registerOperation(ModelOperation operation) { 19 | operations.add(operation); 20 | } 21 | 22 | public List> getOperations() { 23 | return operations; 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/phases/CleanupPhase.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.phases; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.runcomponents.BenchmarkBundle; 4 | 5 | public class CleanupPhase extends Phase { 6 | 7 | public CleanupPhase(final BenchmarkBundle bundle) { 8 | super(bundle); 9 | } 10 | 11 | @Override 12 | public void initialize() throws Exception { 13 | if (bundle != null) { 14 | bundle.cleanup(); 15 | } 16 | } 17 | 18 | @Override 19 | public void run() throws Exception { 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/phases/InitializeOperationsPhase.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.phases; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.runcomponents.BenchmarkBundle; 4 | 5 | public class InitializeOperationsPhase extends Phase { 6 | 7 | public InitializeOperationsPhase(final BenchmarkBundle bundle) { 8 | super(bundle); 9 | } 10 | 11 | @Override 12 | public void run() throws Exception { 13 | bundle.initializeDriver(); 14 | bundle.initializeOperations(); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/phases/PhaseExecutor.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.phases; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import com.google.common.base.Stopwatch; 6 | 7 | public class PhaseExecutor { 8 | 9 | public long execute(final Phase phase) throws Exception { 10 | phase.initialize(); 11 | 12 | final Stopwatch stopwatch = Stopwatch.createStarted(); 13 | phase.run(); 14 | stopwatch.stop(); 15 | 16 | phase.cleanup(); 17 | 18 | return stopwatch.elapsed(TimeUnit.NANOSECONDS); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/phases/QueryPhase.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.phases; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.runcomponents.BenchmarkBundle; 4 | 5 | public class QueryPhase extends Phase { 6 | 7 | public QueryPhase(BenchmarkBundle bundle) { 8 | super(bundle); 9 | } 10 | 11 | @Override 12 | public void run() throws Exception { 13 | bundle.query(); 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/phases/ReadPhase.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.phases; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.runcomponents.BenchmarkBundle; 4 | 5 | public class ReadPhase extends Phase { 6 | 7 | public ReadPhase(final BenchmarkBundle bundle) { 8 | super(bundle); 9 | } 10 | 11 | @Override 12 | public void run() throws Exception { 13 | bundle.read(); 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/phases/TransformationPhase.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.phases; 2 | 3 | import hu.bme.mit.trainbenchmark.benchmark.runcomponents.BenchmarkBundle; 4 | 5 | public class TransformationPhase extends Phase { 6 | 7 | public TransformationPhase(final BenchmarkBundle bundle) { 8 | super(bundle); 9 | } 10 | 11 | @Override 12 | public void initialize() throws Exception { 13 | bundle.shuffle(); 14 | } 15 | 16 | @Override 17 | public void run() throws Exception { 18 | bundle.transform(); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/java/hu/bme/mit/trainbenchmark/benchmark/runcomponents/RunResult.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.runcomponents; 2 | 3 | import java.util.LinkedList; 4 | import java.util.List; 5 | 6 | import com.google.common.collect.LinkedListMultimap; 7 | import com.google.common.collect.ListMultimap; 8 | 9 | import hu.bme.mit.trainbenchmark.constants.RailwayQuery; 10 | 11 | public class RunResult { 12 | 13 | protected ListMultimap matches = LinkedListMultimap.create(); 14 | 15 | protected Long readTime; 16 | protected List queryTimes = new LinkedList<>(); 17 | protected List transformationTimes = new LinkedList<>(); 18 | 19 | public RunResult() { 20 | } 21 | 22 | public ListMultimap getMatches() { 23 | return matches; 24 | } 25 | 26 | public Long getReadTime() { 27 | return readTime; 28 | } 29 | 30 | public void setReadTime(final Long readTime) { 31 | this.readTime = readTime; 32 | } 33 | 34 | public List getQueryTimes() { 35 | return queryTimes; 36 | } 37 | 38 | public List getTransformationTimes() { 39 | return transformationTimes; 40 | } 41 | 42 | } -------------------------------------------------------------------------------- /trainbenchmark-tool/src/main/resources/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ftsrg/trainbenchmark/9c76520dec5a26213707b0e1f04b263f16b340ee/trainbenchmark-tool/src/main/resources/.gitignore -------------------------------------------------------------------------------- /trainbenchmark-tool/src/test/java/hu/bme/mit/trainbenchmark/benchmark/runcomponents/test/BenchmarkReporterTest.java: -------------------------------------------------------------------------------- 1 | package hu.bme.mit.trainbenchmark.benchmark.runcomponents.test; 2 | 3 | import java.io.IOException; 4 | import java.net.SocketException; 5 | 6 | import org.junit.Ignore; 7 | import org.junit.Test; 8 | 9 | import hu.bme.mit.trainbenchmark.benchmark.runcomponents.BenchmarkReporter; 10 | 11 | public class BenchmarkReporterTest { 12 | 13 | @Ignore 14 | @Test 15 | public void test() throws SocketException, IOException { 16 | final String reportUrl = "https://hooks.slack.com/services/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"; 17 | BenchmarkReporter.reportReady(reportUrl); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /visualization/query-plans/RouteSensorA-ReteExpression.tex: -------------------------------------------------------------------------------- 1 | \getedges{route}{Route}{swP}{SwitchPosition}{\_e3}{follows} \join \getedges{swP}{SwitchPosition}{sw}{Switch}{\_e1}{target} \join \getedges{sw}{Switch}{sensor}{Sensor}{\_e2}{monitoredBy} \antijoin \getedges{route}{Route}{sensor}{Sensor}{\_e4}{requires} 2 | -------------------------------------------------------------------------------- /visualization/query-plans/RouteSensorB-ReteExpression.tex: -------------------------------------------------------------------------------- 1 | \getedges{swP}{SwitchPosition}{sw}{Switch}{\_e1}{target} \join \getedges{sw}{Switch}{sensor}{Sensor}{\_e2}{monitoredBy} \join \getedges{route}{Route}{swP}{SwitchPosition}{\_e3}{follows} \antijoin \getedges{route}{Route}{sensor}{Sensor}{\_e4}{requires} 2 | -------------------------------------------------------------------------------- /visualization/query-plans/RouteSensorC-ReteExpression.tex: -------------------------------------------------------------------------------- 1 | \getedges{route}{Route}{swP}{SwitchPosition}{\_e3}{follows} \join \getedges{sw}{Switch}{sensor}{Sensor}{\_e2}{monitoredBy} \antijoin \getedges{route}{Route}{sensor}{Sensor}{\_e4}{requires} \join \getedges{swP}{SwitchPosition}{sw}{Switch}{\_e1}{target} 2 | -------------------------------------------------------------------------------- /visualization/query-plans/SemaphoreNeighborA-ReteExpression.tex: -------------------------------------------------------------------------------- 1 | \selection{\var{route1} \neq \var{route2}} \Big(\getedges{te1}{TrackElement}{te2}{TrackElement}{ct}{connectsTo} \join \getedges{te1}{TrackElement}{sensor1}{Sensor}{mb1}{monitoredBy} \join \getedges{te2}{TrackElement}{sensor2}{Sensor}{mb2}{monitoredBy} \join \getedges{route1}{Route}{semaphore}{Semaphore}{exit}{exit} \join \getedges{route1}{Route}{sensor1}{Sensor}{g1}{requires} \join \getedges{route2}{Route}{sensor2}{Sensor}{g2}{requires}\Big) \antijoin \getedges{route2}{Route}{semaphore}{Semaphore}{entry}{entry} 2 | -------------------------------------------------------------------------------- /visualization/query-plans/SemaphoreNeighborB-ReteExpression.tex: -------------------------------------------------------------------------------- 1 | \selection{\var{route1} \neq \var{route2}} \Big(\getedges{te1}{TrackElement}{te2}{TrackElement}{ct}{connectsTo} \join \getedges{te1}{TrackElement}{sensor1}{Sensor}{mb1}{monitoredBy} \join \getedges{route1}{Route}{sensor1}{Sensor}{g1}{requires} \join \getedges{te2}{TrackElement}{sensor2}{Sensor}{mb2}{monitoredBy} \join \getedges{route2}{Route}{sensor2}{Sensor}{g2}{requires}\Big) \join \getedges{route1}{Route}{semaphore}{Semaphore}{exit}{exit} \antijoin \getedges{route2}{Route}{semaphore}{Semaphore}{entry}{entry} 2 | -------------------------------------------------------------------------------- /visualization/query-plans/SemaphoreNeighborC-ReteExpression.tex: -------------------------------------------------------------------------------- 1 | \selection{\var{route1} \neq \var{route2}} \Big(\getedges{te1}{TrackElement}{te2}{TrackElement}{ct}{connectsTo} \join \getedges{te1}{TrackElement}{sensor1}{Sensor}{mb1}{monitoredBy} \join \getedges{te2}{TrackElement}{sensor2}{Sensor}{mb2}{monitoredBy} \join \getedges{route1}{Route}{sensor1}{Sensor}{g1}{requires} \join \getedges{route1}{Route}{semaphore}{Semaphore}{exit}{exit} \join \getedges{route2}{Route}{sensor2}{Sensor}{g2}{requires}\Big) \antijoin \getedges{route2}{Route}{semaphore}{Semaphore}{entry}{entry} 2 | -------------------------------------------------------------------------------- /visualization/query-plans/SemaphoreNeighborD-ReteExpression.tex: -------------------------------------------------------------------------------- 1 | \selection{\var{route1} \neq \var{route2}} \Big(\getedges{te1}{TrackElement}{te2}{TrackElement}{ct}{connectsTo} \join \getedges{route1}{Route}{semaphore}{Semaphore}{exit}{exit} \join \getedges{route1}{Route}{sensor1}{Sensor}{g1}{requires} \join \getedges{te1}{TrackElement}{sensor1}{Sensor}{mb1}{monitoredBy} \join \getedges{te2}{TrackElement}{sensor2}{Sensor}{mb2}{monitoredBy} \join \getedges{route2}{Route}{sensor2}{Sensor}{g2}{requires}\Big) \antijoin \getedges{route2}{Route}{semaphore}{Semaphore}{entry}{entry} 2 | -------------------------------------------------------------------------------- /visualization/query-plans/SemaphoreNeighborE-ReteExpression.tex: -------------------------------------------------------------------------------- 1 | \selection{\var{route1} \neq \var{route2}} \Big(\getedges{route1}{Route}{semaphore}{Semaphore}{exit}{exit} \join \getedges{route2}{Route}{sensor2}{Sensor}{g2}{requires}\Big) \antijoin \getedges{route2}{Route}{semaphore}{Semaphore}{entry}{entry} \join \getedges{route1}{Route}{sensor1}{Sensor}{g1}{requires} \join \getedges{te1}{TrackElement}{sensor1}{Sensor}{mb1}{monitoredBy} \join \getedges{te1}{TrackElement}{te2}{TrackElement}{ct}{connectsTo} \join \getedges{te2}{TrackElement}{sensor2}{Sensor}{mb2}{monitoredBy} 2 | -------------------------------------------------------------------------------- /visualization/query-plans/SemaphoreNeighborF-ReteExpression.tex: -------------------------------------------------------------------------------- 1 | \selection{\var{route1} \neq \var{route2}} \Big(\getedges{te1}{TrackElement}{sensor1}{Sensor}{mb1}{monitoredBy} \join \getedges{te2}{TrackElement}{sensor2}{Sensor}{mb2}{monitoredBy} \join \getedges{route1}{Route}{sensor1}{Sensor}{g1}{requires} \join \getedges{route2}{Route}{sensor2}{Sensor}{g2}{requires}\Big) \join \getedges{route1}{Route}{semaphore}{Semaphore}{exit}{exit} \join \getedges{te1}{TrackElement}{te2}{TrackElement}{ct}{connectsTo} \antijoin \getedges{route2}{Route}{semaphore}{Semaphore}{entry}{entry} 2 | -------------------------------------------------------------------------------- /visualization/query-plans/convert.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | cd "$( cd "$( dirname "$0" )" && pwd )" 4 | 5 | cat template-header.html > visualization.html 6 | echo > body.html 7 | 8 | echo "
    " >> visualization.html 9 | for doc in *.tex; do 10 | filename="${doc%.*}" 11 | texfile="$filename.tex" 12 | pdffile="$filename.pdf" 13 | 14 | # only recompile files where the tex source is newer than the generated pdf 15 | if [ $texfile -nt $pdffile ]; then 16 | echo Compiling $texfile 17 | pdflatex -shell-escape -interaction=batchmode $filename.tex 1>/dev/null 18 | fi 19 | 20 | # toc 21 | echo "
  • $filename
    • " >> visualization.html 22 | 23 | # content 24 | echo "

    $filename

    " >> body.html 25 | echo " " >> body.html 26 | done 27 | echo "
" >> visualization.html 28 | 29 | cat body.html >> visualization.html 30 | cat template-footer.html >> visualization.html 31 | -------------------------------------------------------------------------------- /visualization/query-plans/template-footer.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /visualization/query-plans/template-header.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | ingraph visualization 8 | 9 | 10 | 11 |
12 | --------------------------------------------------------------------------------