diff --git a/src/main/java/de/hhu/stups/codegenerator/definitions/SetDefinition.java b/src/main/java/de/hhu/stups/codegenerator/definitions/SetDefinition.java index 6751cc8a12180c084aa801842609cb8e40fa044c..7b746ae0cf5268ce42250853d47b335a3daff449 100644 --- a/src/main/java/de/hhu/stups/codegenerator/definitions/SetDefinition.java +++ b/src/main/java/de/hhu/stups/codegenerator/definitions/SetDefinition.java @@ -38,10 +38,6 @@ public class SetDefinition { this.elementToBitArr = elementToBitArr; } - public void setVariations() { - throw new RuntimeException("should variation generation be done here?"); - } - public SetDefinition getPowSetDefinition(ST setElementNameGenerator) { int maxCard = elements.size(); //TODO: limit may become configurable? @@ -95,10 +91,6 @@ public class SetDefinition { this.isConstant = true; this.elementToBitArr = new HashMap<>(); } - public List<List<String>> getSubSets() { - if (subSets == null) setVariations(); - return this.subSets; - } public Map<Integer, String> elementsIndexed() { return listIndexed(elements); @@ -108,13 +100,6 @@ public class SetDefinition { return elementsIndexed().keySet().stream().collect(Collectors.toMap(Function.identity(), idx -> elementToBitArr.get(elements.get(idx)))); } - public Map<Integer, List<String>> subSetsIndexed() { return listIndexed(getSubSets()); } - - public Map<Integer, boolean[]> subSetVecsIndexed() { - if (subSetVecs == null) setVariations(); - return listIndexed(subSetVecs); - } - private <T> Map<Integer, T> listIndexed(List<T> list) { return IntStream.range(0, list.size()).boxed() .collect(Collectors.toMap(Function.identity(), list::get)); diff --git a/src/main/java/de/hhu/stups/codegenerator/definitions/SetDefinitions.java b/src/main/java/de/hhu/stups/codegenerator/definitions/SetDefinitions.java index 11fd571d2194ad20ee33f7de48f665aca206346e..4dcbfa0a97acf9a6f29834911073bc02adfb1b9d 100644 --- a/src/main/java/de/hhu/stups/codegenerator/definitions/SetDefinitions.java +++ b/src/main/java/de/hhu/stups/codegenerator/definitions/SetDefinitions.java @@ -26,6 +26,10 @@ public class SetDefinitions { } } + public void deleteDefinition(BType type) { + setDefinitions.remove(type.toString()); + } + public boolean containsDefinition(BType type) { //EnumeratedSetElementType and others does not implement hash return setDefinitions.containsKey(type.toString()); diff --git a/src/main/java/de/hhu/stups/codegenerator/generators/ExpressionGenerator.java b/src/main/java/de/hhu/stups/codegenerator/generators/ExpressionGenerator.java index 45c8a708037e6bed6b83f82aa56f62426f9e30ff..813cff5623857c9e06cc890ca0ed1c379a91331e 100644 --- a/src/main/java/de/hhu/stups/codegenerator/generators/ExpressionGenerator.java +++ b/src/main/java/de/hhu/stups/codegenerator/generators/ExpressionGenerator.java @@ -477,14 +477,13 @@ public class ExpressionGenerator { private void addElementToConstSet(ExprNode expr) { if (!(expr.getType() instanceof SetType)) return; BType subType = ((SetType) expr.getType()).getSubType(); - typeGenerator.addSetDefinition(subType, true); //making sure that a setDef for this type exists - SetDefinition setDef = this.setDefinitions.getDefinition(subType); - if (!setDef.isConstant()) return; + SetDefinition setDef = typeGenerator.addSetDefinition(subType, true); //create const-setDef is necessary + if (!setDef.isConstant()) return; //skip if a dynamic set of this type is already present if (expr instanceof ExpressionOperatorNode) { ExpressionOperatorNode opNode = (ExpressionOperatorNode) expr; switch (opNode.getOperator()) { case SET_ENUMERATION: - opNode.getExpressionNodes().stream().forEach(this::getExprAsElementString); + opNode.getExpressionNodes().forEach(this::getExprAsElementString); break; case COUPLE: ST relElementGenerator = currentGroup.getInstanceOf("relation_element_name"); diff --git a/src/main/java/de/hhu/stups/codegenerator/generators/MachineGenerator.java b/src/main/java/de/hhu/stups/codegenerator/generators/MachineGenerator.java index 3b3df434a7f62344e32372ec918471019648f18e..694804bb9a0f871132148a7ef330132d5fa71b33 100755 --- a/src/main/java/de/hhu/stups/codegenerator/generators/MachineGenerator.java +++ b/src/main/java/de/hhu/stups/codegenerator/generators/MachineGenerator.java @@ -368,7 +368,7 @@ public class MachineGenerator implements AbstractVisitor<String, Void> { TemplateHandler.add(getter, "variable", (variable.getKind().equals(DeclarationNode.Kind.ENUMERATED_SET) ? "_": "") + nameHandler.handleIdentifier(variable.getName(), NameHandler.IdentifierHandlingEnum.FUNCTION_NAMES)); TemplateHandler.add(getter, "isConstant", DeclarationNode.Kind.CONSTANT.equals(variable.getKind())); TemplateHandler.add(getter, "machine", nameHandler.handle(variable.getSurroundingMachineNode().getName())); - TemplateHandler.add(getter, "returnType", typeGenerator.generate(variable.getType())); + TemplateHandler.add(getter, "returnType", typeGenerator.generate(variable.getType(), true)); // marking as const since return-type of getters is already processed TemplateHandler.add(getter, "isConstant", variable.getKind().equals(DeclarationNode.Kind.CONSTANT) || variable.getKind().equals(DeclarationNode.Kind.ENUMERATED_SET)); TemplateHandler.add(getter, "machineName", machineNode.getName()); return getter.render(); diff --git a/src/main/java/de/hhu/stups/codegenerator/generators/SubstitutionGenerator.java b/src/main/java/de/hhu/stups/codegenerator/generators/SubstitutionGenerator.java index 2ccb3a7ce1f2c2050ff88a868ba8c9d739d2279a..57cc0be538f18717a16232652d5c6767fc0d7e8a 100644 --- a/src/main/java/de/hhu/stups/codegenerator/generators/SubstitutionGenerator.java +++ b/src/main/java/de/hhu/stups/codegenerator/generators/SubstitutionGenerator.java @@ -189,7 +189,7 @@ public class SubstitutionGenerator { private String generateConstantInitialization(MachineNode node, DeclarationNode constant) { ST initialization = currentGroup.getInstanceOf("constant_initialization"); TemplateHandler.add(initialization, "identifier", nameHandler.handleIdentifier(constant.getName(), NameHandler.IdentifierHandlingEnum.FUNCTION_NAMES)); - TemplateHandler.add(initialization, "type", typeGenerator.generate(constant.getType())); + TemplateHandler.add(initialization, "type", typeGenerator.generate(constant.getType(), true)); List<PredicateNode> equalProperties = predicateGenerator.extractEqualProperties(node, constant); if(equalProperties.isEmpty()) { return ""; diff --git a/src/main/java/de/hhu/stups/codegenerator/generators/TypeGenerator.java b/src/main/java/de/hhu/stups/codegenerator/generators/TypeGenerator.java index 039835d4399dd202b0fb46aa257730c2e520b040..d6e1463fc9bb8e2b822c1c80095773043af4701b 100644 --- a/src/main/java/de/hhu/stups/codegenerator/generators/TypeGenerator.java +++ b/src/main/java/de/hhu/stups/codegenerator/generators/TypeGenerator.java @@ -168,7 +168,11 @@ public class TypeGenerator { public SetDefinition addSetDefinition(BType type) { return this.addSetDefinition(type, false); } public SetDefinition addSetDefinition(BType type, boolean constant) { - if (this.setDefinitions.containsDefinition(type)) return this.setDefinitions.getDefinition(type); //TODO: const check + SetDefinition existingDef = this.setDefinitions.getDefinition(type); + if (existingDef != null) { + if (constant || !existingDef.isConstant()) return existingDef; //returns dynamic set if it exists, even if constant set is 'requested'. Caller needs to check for that. (we only keep const-definitions if there is no dynamic one) + else this.setDefinitions.deleteDefinition(type); //dynamic set found after const-set -> overwrite + } List<String> variants; String name = null; diff --git a/src/main/resources/de/hhu/stups/codegenerator/RustTemplate_e.stg b/src/main/resources/de/hhu/stups/codegenerator/RustTemplate_e.stg index 77f849e2d6f2e515ddecfc6bb7591363b24d80ac..5ba037c0917ca192535e9c1980460d98bb9070d1 100644 --- a/src/main/resources/de/hhu/stups/codegenerator/RustTemplate_e.stg +++ b/src/main/resources/de/hhu/stups/codegenerator/RustTemplate_e.stg @@ -224,7 +224,7 @@ self.<identifier> = <set_enumeration(type=type, enums=enums)>; iteration_construct_enumeration(otherIterationConstructs, type, identifier, set, body) ::= << //iteration_construct_enumeration <otherIterationConstructs> -for <identifier> in <set>.clone().iter().cloned() { +for <identifier> in <set>.clone().iter() { <body> } >> @@ -241,7 +241,7 @@ iteration_construct_assignment(otherIterationConstructs, type, identifier, set, iteration_construct_subset(otherIterationConstructs, type, identifier, set, body) ::= << //iteration_construct_subset <otherIterationConstructs> -for <identifier> in <set>.pow().iter().cloned() { +for <identifier> in <set>.pow().iter() { <body> } >> @@ -264,7 +264,7 @@ let_expression_predicate_body(otherIterationConstructs, identifier, val) ::= << >> set_comprehension(type, identifier, isRelation, leftType, rightType, subType, comprehension) ::= << -let mut <identifier> = <if(isRelation)>BRelation::\<<leftType>, <rightType>\><else>BSet::\<<subType>\><endif>::new(vec![]); +let mut <identifier> = <if(isRelation)><relation_type(leftType, rightType)><else><set_type(subType)><endif>::empty(); <comprehension> >> @@ -272,24 +272,24 @@ set_comprehension_predicate(otherIterationConstructs, set, element, emptyPredica //set_comprehension_predicate TODO: FASTER! <otherIterationConstructs> <if(emptyPredicate)> -<set> = <set>._union(&<if(isRelation)>BRelation::\<<leftType>, <rightType>\><else>BSet::\<<subType>\><endif>::new(vec![<element>])); +<set> = <set>.union(&<if(isRelation)>brel![<relation_type(leftType, rightType)><else>bset![<set_type(subType)><endif>, <element>]); <else> <if(hasCondition)> if <conditionalPredicate> { if <predicate> { - <set> = <set>._union(&<if(isRelation)>BRelation::\<<leftType>, <rightType>\><else>BSet::\<<subType>\><endif>::new(vec![<element>])); + <set> = <set>.union(&<if(isRelation)>brel![<relation_type(leftType, rightType)><else>bset![<set_type(subType)><endif>, <element>]); } } <else> if <predicate> { - <set> = <set>._union(&<if(isRelation)>BRelation::\<<leftType>, <rightType>\><else>BSet::\<<subType>\><endif>::new(vec![<element>])); + <set> = <set>.union(&<if(isRelation)>brel![<relation_type(leftType, rightType)><else>bset![<set_type(subType)><endif>, <element>]); } <endif> <endif> >> lambda(type, identifier, lambda, leftType, rightType) ::= << -let mut <identifier> = BRelation::\<<leftType>, <rightType>\>::new(vec![]); +let mut <identifier> = <relation_type(leftType, rightType)>::empty(); <lambda> >> @@ -297,10 +297,10 @@ lambda_expression(otherIterationConstructs, relation, element, expression, empty //lambda_expression TODO: FASTER <otherIterationConstructs> <if(emptyPredicate)> -<relation> = <relation>._union(&BRelation::\<<leftType>, <rightType>\>::new(vec![BTuple::new(<element>.clone(), <expression>)])); +<relation> = <relation>.union(&BRelation::\<<leftType>, <rightType>\>::new(vec![BTuple::new(<element>.clone(), <expression>)])); <else> if <predicate> { - <relation> = <relation>._union(&BRelation::\<<leftType>, <rightType>\>::new(vec![BTuple::new(<element>.clone(), <expression>)])); + <relation> = <relation>.union(&BRelation::\<<leftType>, <rightType>\>::new(vec![BTuple::new(<element>.clone(), <expression>)])); } <endif> >> @@ -1158,10 +1158,10 @@ parameter_combination_predicate(otherIterationConstructs, set, element, emptyPre //parameter_combination_predicate TODO: FASTER <otherIterationConstructs> <if(emptyPredicate)> -<set> = <set>._union(&BSet::new(vec![<element>])); +<set> = <set>.union(&BSet::new(vec![<element>])); <else> if <predicate> { - <set> = <set>._union(&BSet::new(vec![<element>])); + <set> = <set>.union(&BSet::new(vec![<element>])); } <endif> >> diff --git a/src/test/java/de/hhu/stups/codegenerator/rust_embedded/TestBenchmarks.java b/src/test/java/de/hhu/stups/codegenerator/rust_embedded/TestBenchmarks.java index 6539d70fc494ec0746cf9b1f50e7b6071851ded7..3aad2d1df2c4881e96ccd55f951a10034c7fa60e 100644 --- a/src/test/java/de/hhu/stups/codegenerator/rust_embedded/TestBenchmarks.java +++ b/src/test/java/de/hhu/stups/codegenerator/rust_embedded/TestBenchmarks.java @@ -44,4 +44,19 @@ public class TestBenchmarks extends TestRSE { public void testCruise_finite_deterministic() throws Exception { testRSE("Cruise_finite1_deterministic_exec", "Cruise_finite1_deterministic_execAddition.strs"); } + + @Test + public void testScheduler_deterministic() throws Exception { + testRSE("scheduler_deterministic_exec", "scheduler_deterministic_execAddition.strs"); + } + + @Test + public void testTrafficLight() throws Exception { + testRSE("TrafficLightExec", "TrafficLightExecAddition.strs"); + } + + @Test + public void testTrain_1_beebook_deterministic_exec() throws Exception { + testRSE("Train_1_beebook_deterministic_exec", "Train_1_beebook_deterministic_execAddition.strs"); + } } diff --git a/src/test/resources/de/hhu/stups/codegenerator/TrafficLightExec.out b/src/test/resources/de/hhu/stups/codegenerator/TrafficLightExec.out new file mode 100644 index 0000000000000000000000000000000000000000..798bfa894d6002e4066dc3dc1d46adfa6cea86a0 --- /dev/null +++ b/src/test/resources/de/hhu/stups/codegenerator/TrafficLightExec.out @@ -0,0 +1 @@ +red;red diff --git a/src/test/resources/de/hhu/stups/codegenerator/TrafficLightExecAddition.strs b/src/test/resources/de/hhu/stups/codegenerator/TrafficLightExecAddition.strs new file mode 100644 index 0000000000000000000000000000000000000000..4b2137ee4ab0b1651f443b8f19a9bba6d26ff8ac --- /dev/null +++ b/src/test/resources/de/hhu/stups/codegenerator/TrafficLightExecAddition.strs @@ -0,0 +1,6 @@ +fn main() { + let mut exec = TrafficLightExec::new(); + exec.simulate(); + println!("{:?};", exec._TrafficLight.get_tl_peds()); + println!("{:?}", exec._TrafficLight.get_tl_cars()); +} diff --git a/src/test/resources/de/hhu/stups/codegenerator/Train_1_beebook_deterministic_exec.out b/src/test/resources/de/hhu/stups/codegenerator/Train_1_beebook_deterministic_exec.out new file mode 100644 index 0000000000000000000000000000000000000000..8e07fd7157e504df4888ba8bf8cad3e793ef09da --- /dev/null +++ b/src/test/resources/de/hhu/stups/codegenerator/Train_1_beebook_deterministic_exec.out @@ -0,0 +1 @@ +0;0;9 diff --git a/src/test/resources/de/hhu/stups/codegenerator/Train_1_beebook_deterministic_execAddition.strs b/src/test/resources/de/hhu/stups/codegenerator/Train_1_beebook_deterministic_execAddition.strs new file mode 100644 index 0000000000000000000000000000000000000000..6e0a9f81ad197d56d08a462dc233555aba4799f4 --- /dev/null +++ b/src/test/resources/de/hhu/stups/codegenerator/Train_1_beebook_deterministic_execAddition.strs @@ -0,0 +1,7 @@ +fn main() { + let mut exec = Train_1_beebook_deterministic_exec::new(); + exec.simulate(); + println!("{};", exec._Train_1_beebook_deterministic.get_resbl().card()); + println!("{};", exec._Train_1_beebook_deterministic.get_resrt().card()); + println!("{}", exec._Train_1_beebook_deterministic.get_TRK().card()); +} diff --git a/src/test/resources/de/hhu/stups/codegenerator/scheduler_deterministic_exec.out b/src/test/resources/de/hhu/stups/codegenerator/scheduler_deterministic_exec.out new file mode 100644 index 0000000000000000000000000000000000000000..53b24a3b41b2bd8fd5d913a5f5ba4cbd822ed93d --- /dev/null +++ b/src/test/resources/de/hhu/stups/codegenerator/scheduler_deterministic_exec.out @@ -0,0 +1 @@ +200000;0;0;0 diff --git a/src/test/resources/de/hhu/stups/codegenerator/scheduler_deterministic_execAddition.strs b/src/test/resources/de/hhu/stups/codegenerator/scheduler_deterministic_execAddition.strs new file mode 100644 index 0000000000000000000000000000000000000000..8e967254bfb6b84175c9e5059bc49ca4a47471e3 --- /dev/null +++ b/src/test/resources/de/hhu/stups/codegenerator/scheduler_deterministic_execAddition.strs @@ -0,0 +1,8 @@ +fn main() { + let mut exec = scheduler_deterministic_exec::new(); + exec.simulate(); + println!("{};", exec.get_counter()); + println!("{};", exec._scheduler_deterministic.get_active().card()); + println!("{};", exec._scheduler_deterministic.get__ready().card()); + println!("{}", exec._scheduler_deterministic.get_waiting().card()); +}