diff options
author | OszkarSemerath <oszka@152.66.252.189> | 2017-09-27 22:47:51 +0200 |
---|---|---|
committer | OszkarSemerath <oszka@152.66.252.189> | 2017-09-27 22:47:51 +0200 |
commit | 0d4516ef455e916ffac2702d2bfe727c71789bc0 (patch) | |
tree | cb16562d8c29f2df497d876ab46ca1e1e99f8c0b /Tests | |
parent | Set thread stop signal to volatile (diff) | |
download | VIATRA-Generator-0d4516ef455e916ffac2702d2bfe727c71789bc0.tar.gz VIATRA-Generator-0d4516ef455e916ffac2702d2bfe727c71789bc0.tar.zst VIATRA-Generator-0d4516ef455e916ffac2702d2bfe727c71789bc0.zip |
Research paper measurement configuration updates
Diffstat (limited to 'Tests')
7 files changed, 646 insertions, 74 deletions
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.run/META-INF/MANIFEST.MF b/Tests/hu.bme.mit.inf.dslreasoner.run/META-INF/MANIFEST.MF index ae6765bd..e2918491 100644 --- a/Tests/hu.bme.mit.inf.dslreasoner.run/META-INF/MANIFEST.MF +++ b/Tests/hu.bme.mit.inf.dslreasoner.run/META-INF/MANIFEST.MF | |||
@@ -3,31 +3,32 @@ Bundle-ManifestVersion: 2 | |||
3 | Bundle-Name: Run | 3 | Bundle-Name: Run |
4 | Bundle-SymbolicName: hu.bme.mit.inf.dslreasoner.run;singleton:=true | 4 | Bundle-SymbolicName: hu.bme.mit.inf.dslreasoner.run;singleton:=true |
5 | Bundle-Version: 1.0.0.qualifier | 5 | Bundle-Version: 1.0.0.qualifier |
6 | Require-Bundle: hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage, | 6 | Require-Bundle: hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage, |
7 | hu.bme.mit.inf.dslreasoner.ecore2logic;bundle-version="1.0.0", | 7 | hu.bme.mit.inf.dslreasoner.ecore2logic;bundle-version="1.0.0", |
8 | hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0", | 8 | hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0", |
9 | com.google.guava, | 9 | com.google.guava, |
10 | org.eclipse.xtext.xbase.lib, | 10 | org.eclipse.xtext.xbase.lib, |
11 | org.eclipse.xtend.lib, | 11 | org.eclipse.xtend.lib, |
12 | org.eclipse.xtend.lib.macro, | 12 | org.eclipse.xtend.lib.macro, |
13 | org.eclipse.emf.ecore.xmi;bundle-version="2.11.1", | 13 | org.eclipse.emf.ecore.xmi;bundle-version="2.11.1", |
14 | hu.bme.mit.inf.dslreasoner.smt.reasoner;bundle-version="1.0.0", | 14 | hu.bme.mit.inf.dslreasoner.smt.reasoner;bundle-version="1.0.0", |
15 | hu.bme.mit.inf.dslreasoner.viatra2logic;bundle-version="1.0.0", | 15 | hu.bme.mit.inf.dslreasoner.viatra2logic;bundle-version="1.0.0", |
16 | org.eclipse.viatra.query.runtime;bundle-version="1.5.0", | 16 | org.eclipse.viatra.query.runtime;bundle-version="1.5.0", |
17 | org.eclipse.viatra.query.tooling.core;bundle-version="1.5.0", | 17 | org.eclipse.viatra.query.tooling.core;bundle-version="1.5.0", |
18 | org.eclipse.viatra.query.runtime.base.itc;bundle-version="1.5.0", | 18 | org.eclipse.viatra.query.runtime.base.itc;bundle-version="1.5.0", |
19 | hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner;bundle-version="1.0.0", | 19 | hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner;bundle-version="1.0.0", |
20 | org.eclipse.viatra.query.patternlanguage;bundle-version="1.5.0", | 20 | org.eclipse.viatra.query.patternlanguage;bundle-version="1.5.0", |
21 | org.eclipse.viatra.query.patternlanguage.emf;bundle-version="1.5.0", | 21 | org.eclipse.viatra.query.patternlanguage.emf;bundle-version="1.5.0", |
22 | hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatraquery;bundle-version="1.0.0", | 22 | hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatraquery;bundle-version="1.0.0", |
23 | org.junit;bundle-version="4.12.0", | 23 | org.junit;bundle-version="4.12.0", |
24 | hu.bme.mit.inf.dslreasoner.domains.transima.fam;bundle-version="1.0.0", | 24 | hu.bme.mit.inf.dslreasoner.domains.transima.fam;bundle-version="1.0.0", |
25 | hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph;bundle-version="1.0.0", | 25 | hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph;bundle-version="1.0.0", |
26 | org.eclipse.viatra.dse;bundle-version="0.15.0", | 26 | org.eclipse.viatra.dse;bundle-version="0.15.0", |
27 | hu.bme.mit.inf.dlsreasoner.alloy.reasoner;bundle-version="1.0.0", | 27 | hu.bme.mit.inf.dlsreasoner.alloy.reasoner;bundle-version="1.0.0", |
28 | hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic;bundle-version="1.0.0", | 28 | hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic;bundle-version="1.0.0", |
29 | org.eclipse.viatra.query.runtime.localsearch;bundle-version="1.5.0", | 29 | org.eclipse.viatra.query.runtime.localsearch;bundle-version="1.5.0", |
30 | hu.bme.mit.inf.dslreasoner.logic2ecore;bundle-version="1.0.0", | 30 | hu.bme.mit.inf.dslreasoner.logic2ecore;bundle-version="1.0.0", |
31 | hu.bme.mit.inf.dslreasoner.visualisation;bundle-version="1.0.0" | 31 | hu.bme.mit.inf.dslreasoner.visualisation;bundle-version="1.0.0", |
32 | hu.bme.mit.inf.dslreasoner.domains.alloyexamples;bundle-version="1.0.0" | ||
32 | Import-Package: org.apache.log4j | 33 | Import-Package: org.apache.log4j |
33 | Bundle-RequiredExecutionEnvironment: JavaSE-1.8 | 34 | Bundle-RequiredExecutionEnvironment: JavaSE-1.8 |
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/MetamodelLoader.xtend b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/MetamodelLoader.xtend index 60908365..10072f5a 100644 --- a/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/MetamodelLoader.xtend +++ b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/MetamodelLoader.xtend | |||
@@ -1,25 +1,30 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.run | 1 | package hu.bme.mit.inf.dslreasoner.run |
2 | 2 | ||
3 | import hu.bme.mit.inf.dslreasomer.domains.transima.fam.FunctionalArchitecture.FunctionalArchitecturePackage | 3 | import hu.bme.mit.inf.dslreasomer.domains.transima.fam.FunctionalArchitecture.FunctionalArchitecturePackage |
4 | import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.FileSystem | ||
5 | import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FilesystemPackage | ||
6 | import hu.bme.mit.inf.dslreasoner.domains.transima.fam.patterns.Pattern | ||
7 | import hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.YakindummPackage | ||
4 | import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor | 8 | import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor |
9 | import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.Patterns | ||
5 | import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor | 10 | import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor |
11 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationMethod | ||
12 | import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ModelGenerationMethodBasedGlobalConstraint | ||
13 | import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace | ||
14 | import java.util.Collection | ||
6 | import java.util.LinkedHashMap | 15 | import java.util.LinkedHashMap |
7 | import java.util.List | 16 | import java.util.List |
17 | import java.util.Set | ||
8 | import org.eclipse.emf.ecore.EAttribute | 18 | import org.eclipse.emf.ecore.EAttribute |
9 | import org.eclipse.emf.ecore.EClass | 19 | import org.eclipse.emf.ecore.EClass |
10 | import org.eclipse.emf.ecore.EEnum | 20 | import org.eclipse.emf.ecore.EEnum |
11 | import org.eclipse.emf.ecore.EEnumLiteral | 21 | import org.eclipse.emf.ecore.EEnumLiteral |
22 | import org.eclipse.emf.ecore.EObject | ||
12 | import org.eclipse.emf.ecore.EReference | 23 | import org.eclipse.emf.ecore.EReference |
13 | import hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.YakindummPackage | ||
14 | import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ModelGenerationMethodBasedGlobalConstraint | ||
15 | import org.eclipse.xtext.xbase.lib.Functions.Function1 | 24 | import org.eclipse.xtext.xbase.lib.Functions.Function1 |
16 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationMethod | 25 | import java.util.HashMap |
17 | import org.eclipse.emf.ecore.EObject | 26 | import org.eclipse.emf.ecore.EcorePackage |
18 | import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace | 27 | import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Ecore |
19 | import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.DiversityDescriptor | ||
20 | import java.util.Collection | ||
21 | import java.util.Set | ||
22 | import java.util.Collections | ||
23 | 28 | ||
24 | abstract class MetamodelLoader { | 29 | abstract class MetamodelLoader { |
25 | protected val ReasonerWorkspace workspace | 30 | protected val ReasonerWorkspace workspace |
@@ -65,7 +70,7 @@ class FAMLoader extends MetamodelLoader{ | |||
65 | } | 70 | } |
66 | 71 | ||
67 | override loadQueries(EcoreMetamodelDescriptor metamodel) { | 72 | override loadQueries(EcoreMetamodelDescriptor metamodel) { |
68 | val i = hu.bme.mit.inf.dslreasoner.domains.transima.fam.patterns.Pattern.instance | 73 | val i = Pattern.instance |
69 | val patterns = i.specifications.toList | 74 | val patterns = i.specifications.toList |
70 | val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name== "Constraint"]].toSet | 75 | val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name== "Constraint"]].toSet |
71 | val derivedFeatures = new LinkedHashMap | 76 | val derivedFeatures = new LinkedHashMap |
@@ -88,11 +93,12 @@ class FAMLoader extends MetamodelLoader{ | |||
88 | class YakinduLoader extends MetamodelLoader{ | 93 | class YakinduLoader extends MetamodelLoader{ |
89 | 94 | ||
90 | private var useSynchronization = true; | 95 | private var useSynchronization = true; |
96 | private var useComplexStates = false; | ||
91 | public static val patternsWithSynchronization = #[ | 97 | public static val patternsWithSynchronization = #[ |
92 | "synchHasNoOutgoing", "synchHasNoIncoming", "SynchronizedIncomingInSameRegion", "notSynchronizingStates", | 98 | "synchHasNoOutgoing", "synchHasNoIncoming", "SynchronizedIncomingInSameRegion", "notSynchronizingStates", |
93 | "hasMultipleOutgoingTrainsition", "hasMultipleIncomingTrainsition", "SynchronizedRegionsAreNotSiblings", | 99 | "hasMultipleOutgoingTrainsition", "hasMultipleIncomingTrainsition", "SynchronizedRegionsAreNotSiblings", |
94 | "SynchronizedRegionDoesNotHaveMultipleRegions", "synchThree", "twoSynch"] | 100 | "SynchronizedRegionDoesNotHaveMultipleRegions", "synchThree", "twoSynch","noSynch2","synch","noSynch4","noSynch3","noSynch"] |
95 | 101 | public static val patternsWithComplexStates =#["outgoingFromExit","outgoingFromFinal","choiceHasNoOutgoing","choiceHasNoIncoming"] | |
96 | new(ReasonerWorkspace workspace) { | 102 | new(ReasonerWorkspace workspace) { |
97 | super(workspace) | 103 | super(workspace) |
98 | } | 104 | } |
@@ -100,12 +106,19 @@ class YakinduLoader extends MetamodelLoader{ | |||
100 | public def setUseSynchronization(boolean useSynchronization) { | 106 | public def setUseSynchronization(boolean useSynchronization) { |
101 | this.useSynchronization = useSynchronization | 107 | this.useSynchronization = useSynchronization |
102 | } | 108 | } |
109 | public def setUseComplexStates(boolean useComplexStates) { | ||
110 | this.useComplexStates = useComplexStates | ||
111 | } | ||
103 | 112 | ||
104 | override loadMetamodel() { | 113 | override loadMetamodel() { |
105 | val useSynchInThisLoad = this.useSynchronization | 114 | val useSynchInThisLoad = this.useSynchronization |
115 | val useComplexStates = this.useComplexStates | ||
106 | 116 | ||
107 | val package = YakindummPackage.eINSTANCE | 117 | val package = YakindummPackage.eINSTANCE |
108 | val List<EClass> classes = package.EClassifiers.filter(EClass).filter[(useSynchInThisLoad) || (it.name != "Synchronization")].toList | 118 | val List<EClass> classes = package.EClassifiers.filter(EClass) |
119 | .filter[useSynchInThisLoad || (it.name != "Synchronization")] | ||
120 | .filter[useComplexStates || (it.name != "Choice" && it.name != "Exit" && it.name != "FinalState")] | ||
121 | .toList | ||
109 | val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList | 122 | val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList |
110 | val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList | 123 | val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList |
111 | val List<EReference> references = classes.map[EReferences].flatten.toList | 124 | val List<EReference> references = classes.map[EReferences].flatten.toList |
@@ -116,11 +129,17 @@ class YakinduLoader extends MetamodelLoader{ | |||
116 | override loadQueries(EcoreMetamodelDescriptor metamodel) { | 129 | override loadQueries(EcoreMetamodelDescriptor metamodel) { |
117 | val useSynchInThisLoad = this.useSynchronization | 130 | val useSynchInThisLoad = this.useSynchronization |
118 | 131 | ||
119 | val i = hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.Patterns.instance | 132 | val i = Patterns.instance |
120 | val patterns = i.specifications.filter[spec | | 133 | val patterns = i.specifications |
121 | useSynchInThisLoad || | 134 | .filter[spec | |
122 | !patternsWithSynchronization.exists[spec.fullyQualifiedName.endsWith(it)] | 135 | useSynchInThisLoad || |
123 | ].toList | 136 | !patternsWithSynchronization.exists[spec.fullyQualifiedName.endsWith(it)] |
137 | ] | ||
138 | .filter[spec | | ||
139 | useComplexStates || | ||
140 | !patternsWithComplexStates.exists[spec.fullyQualifiedName.endsWith(it)] | ||
141 | ] | ||
142 | .toList | ||
124 | val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name== "Constraint"]].toSet | 143 | val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name== "Constraint"]].toSet |
125 | val derivedFeatures = new LinkedHashMap | 144 | val derivedFeatures = new LinkedHashMap |
126 | val res = new ViatraQuerySetDescriptor( | 145 | val res = new ViatraQuerySetDescriptor( |
@@ -145,4 +164,99 @@ class YakinduLoader extends MetamodelLoader{ | |||
145 | override additionalConstraints() { //#[] | 164 | override additionalConstraints() { //#[] |
146 | #[[method | new SGraphInconsistencyDetector(method)]] | 165 | #[[method | new SGraphInconsistencyDetector(method)]] |
147 | } | 166 | } |
167 | } | ||
168 | |||
169 | class FileSystemLoader extends MetamodelLoader{ | ||
170 | |||
171 | new(ReasonerWorkspace workspace) { | ||
172 | super(workspace) | ||
173 | } | ||
174 | |||
175 | override loadMetamodel() { | ||
176 | val package = FilesystemPackage.eINSTANCE | ||
177 | val List<EClass> classes = package.EClassifiers.filter(EClass).toList | ||
178 | val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList | ||
179 | val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList | ||
180 | val List<EReference> references = classes.map[EReferences].flatten.toList | ||
181 | val List<EAttribute> attributes = classes.map[EAttributes].flatten.toList | ||
182 | return new EcoreMetamodelDescriptor(classes,#{},false,enums,literals,references,attributes) | ||
183 | } | ||
184 | |||
185 | override getRelevantTypes(EcoreMetamodelDescriptor descriptor) { | ||
186 | return null | ||
187 | } | ||
188 | |||
189 | override getRelevantReferences(EcoreMetamodelDescriptor descriptor) { | ||
190 | null | ||
191 | } | ||
192 | |||
193 | override loadQueries(EcoreMetamodelDescriptor metamodel) { | ||
194 | val patternGroup = FileSystem.instance | ||
195 | val patterns = patternGroup.specifications.toList | ||
196 | val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name == "Constraint"]].toSet | ||
197 | val derivedFeatures = new HashMap | ||
198 | derivedFeatures.put(patternGroup.live.internalQueryRepresentation,metamodel.references.filter[it.name == "live"].head) | ||
199 | return new ViatraQuerySetDescriptor( | ||
200 | patterns, | ||
201 | wfPatterns, | ||
202 | derivedFeatures | ||
203 | ) | ||
204 | |||
205 | } | ||
206 | |||
207 | override loadPartialModel() { | ||
208 | this.workspace.readModel(EObject,"fs.xmi").eResource.allContents.toList | ||
209 | } | ||
210 | |||
211 | override additionalConstraints() { | ||
212 | #[[method | new FileSystemInconsistencyDetector(method)]] | ||
213 | } | ||
214 | |||
215 | } | ||
216 | |||
217 | class EcoreLoader extends MetamodelLoader { | ||
218 | |||
219 | new(ReasonerWorkspace workspace) { | ||
220 | super(workspace) | ||
221 | } | ||
222 | |||
223 | override loadMetamodel() { | ||
224 | val package = EcorePackage.eINSTANCE | ||
225 | val List<EClass> classes = package.EClassifiers.filter(EClass).filter[it.name!="EFactory"].toList | ||
226 | val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList | ||
227 | val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList | ||
228 | val List<EReference> references = classes.map[EReferences].flatten.filter[it.name!="eFactoryInstance"].filter[!it.derived].toList | ||
229 | val List<EAttribute> attributes = #[] //classes.map[EAttributes].flatten.toList | ||
230 | return new EcoreMetamodelDescriptor(classes,#{},false,enums,literals,references,attributes) | ||
231 | } | ||
232 | |||
233 | override getRelevantTypes(EcoreMetamodelDescriptor descriptor) { | ||
234 | return null | ||
235 | } | ||
236 | |||
237 | override getRelevantReferences(EcoreMetamodelDescriptor descriptor) { | ||
238 | null | ||
239 | } | ||
240 | |||
241 | override loadQueries(EcoreMetamodelDescriptor metamodel) { | ||
242 | val patternGroup = Ecore.instance | ||
243 | val patterns = patternGroup.specifications.toList | ||
244 | val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name == "Constraint"]].toSet | ||
245 | val derivedFeatures = new HashMap | ||
246 | return new ViatraQuerySetDescriptor( | ||
247 | patterns, | ||
248 | wfPatterns, | ||
249 | derivedFeatures | ||
250 | ) | ||
251 | |||
252 | } | ||
253 | |||
254 | override loadPartialModel() { | ||
255 | this.workspace.readModel(EObject,"ecore.xmi").eResource.allContents.toList | ||
256 | } | ||
257 | |||
258 | override additionalConstraints() { | ||
259 | #[] | ||
260 | } | ||
261 | |||
148 | } \ No newline at end of file | 262 | } \ No newline at end of file |
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/RunMeasurements.xtend b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/RunMeasurements.xtend index e96a6bf6..8d96958d 100644 --- a/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/RunMeasurements.xtend +++ b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/RunMeasurements.xtend | |||
@@ -37,9 +37,12 @@ import org.eclipse.emf.ecore.EObject | |||
37 | import org.eclipse.emf.ecore.resource.Resource | 37 | import org.eclipse.emf.ecore.resource.Resource |
38 | import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl | 38 | import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl |
39 | import org.junit.Test | 39 | import org.junit.Test |
40 | import hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz.GraphvizVisualisation | ||
41 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretationSizePrinter | ||
42 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretation2Gml | ||
40 | 43 | ||
41 | enum UseSolver{Viatra, Smt, ViatraWithSmt, Alloy} | 44 | enum UseSolver{Viatra, Smt, ViatraWithSmt, Alloy} |
42 | enum Domain{FAM, Yakindu} | 45 | enum Domain{FAM, Yakindu, FileSystem,Ecore} |
43 | enum Diversity{No, Diverse} | 46 | enum Diversity{No, Diverse} |
44 | 47 | ||
45 | class RunMeasurements { | 48 | class RunMeasurements { |
@@ -70,8 +73,12 @@ class RunMeasurements { | |||
70 | if(dsl == Domain::FAM) { | 73 | if(dsl == Domain::FAM) { |
71 | return new FAMLoader(inputs) | 74 | return new FAMLoader(inputs) |
72 | } else if(dsl == Domain::Yakindu) { | 75 | } else if(dsl == Domain::Yakindu) { |
73 | return new YakinduLoader(inputs) | 76 | return new YakinduLoader(inputs) =>[it.useSynchronization = true useComplexStates = false] |
74 | } else throw new IllegalArgumentException('''Unknown domain: «dsl»''') | 77 | } else if(dsl == Domain::FileSystem){ |
78 | return new FileSystemLoader(inputs) | ||
79 | } else if(dsl == Domain::Ecore) { | ||
80 | return new EcoreLoader(inputs) | ||
81 | }else throw new IllegalArgumentException('''Unknown domain: «dsl»''') | ||
75 | } | 82 | } |
76 | def static init() { | 83 | def static init() { |
77 | LogiclanguagePackage.eINSTANCE.class | 84 | LogiclanguagePackage.eINSTANCE.class |
@@ -147,7 +154,7 @@ class RunMeasurements { | |||
147 | return solution | 154 | return solution |
148 | } else { | 155 | } else { |
149 | val viatraConfig = new ViatraReasonerConfiguration => [ | 156 | val viatraConfig = new ViatraReasonerConfiguration => [ |
150 | it.runtimeLimit = 20 | 157 | it.runtimeLimit = 400 |
151 | it.typeScopes.maxNewElements = size | 158 | it.typeScopes.maxNewElements = size |
152 | it.typeScopes.minNewElements = size | 159 | it.typeScopes.minNewElements = size |
153 | it.solutionScope.numberOfRequiredSolution = number | 160 | it.solutionScope.numberOfRequiredSolution = number |
@@ -156,6 +163,10 @@ class RunMeasurements { | |||
156 | it.typeInferenceMethod = TypeInferenceMethod.PreliminaryAnalysis | 163 | it.typeInferenceMethod = TypeInferenceMethod.PreliminaryAnalysis |
157 | it.searchSpaceConstraints.additionalGlobalConstraints += loader.additionalConstraints | 164 | it.searchSpaceConstraints.additionalGlobalConstraints += loader.additionalConstraints |
158 | it.stateCoderStrategy = StateCoderStrategy::Neighbourhood | 165 | it.stateCoderStrategy = StateCoderStrategy::Neighbourhood |
166 | it.debugCongiguration.partalInterpretationVisualisationFrequency = 100 | ||
167 | //it.debugCongiguration.partialInterpretatioVisualiser = | ||
168 | //new GraphvizVisualisation | ||
169 | //new PartialInterpretationSizePrinter | ||
159 | ] | 170 | ] |
160 | viatraConfig.diversityRequirement = diversityRequirement | 171 | viatraConfig.diversityRequirement = diversityRequirement |
161 | if (solver == UseSolver.Viatra) { | 172 | if (solver == UseSolver.Viatra) { |
@@ -189,13 +200,13 @@ class RunMeasurements { | |||
189 | } | 200 | } |
190 | 201 | ||
191 | static val monitoring = false | 202 | static val monitoring = false |
192 | static val clean = false | 203 | static val clean = true |
193 | static val domain = Domain::Yakindu | 204 | static val domain = Domain::FAM |
194 | static val solver = UseSolver::Viatra | 205 | static val solver = UseSolver::Viatra |
195 | static val diverse = true | 206 | static val diverse = false |
196 | static val wf = false | 207 | static val wf = true |
197 | public static var sizes = #[50] | 208 | public static var sizes = #[11,5,10,15,20,25,30,35,40,45,50,100,150,200,250,300,350,400,450,500] |
198 | static var int number = 3 | 209 | static var int number = 1 |
199 | 210 | ||
200 | def static void waitForEnter() { | 211 | def static void waitForEnter() { |
201 | if(monitoring) { | 212 | if(monitoring) { |
@@ -215,8 +226,8 @@ class RunMeasurements { | |||
215 | //println("- Queries loaded") | 226 | //println("- Queries loaded") |
216 | 227 | ||
217 | if(!wf) { | 228 | if(!wf) { |
218 | mm.attributes.forEach[it.lowerBound = 0] | 229 | // mm.attributes.forEach[it.lowerBound = 0] |
219 | mm.references.forEach[it.lowerBound = 0] | 230 | // mm.references.forEach[it.lowerBound = 0] |
220 | mm.references.removeAll(vq.derivedFeatures.values) | 231 | mm.references.removeAll(vq.derivedFeatures.values) |
221 | mm.attributes.removeAll(vq.derivedFeatures.values) | 232 | mm.attributes.removeAll(vq.derivedFeatures.values) |
222 | } | 233 | } |
@@ -252,6 +263,15 @@ class RunMeasurements { | |||
252 | val representationNumber = representationIndex + 1 | 263 | val representationNumber = representationIndex + 1 |
253 | if(representation instanceof PartialInterpretation) { | 264 | if(representation instanceof PartialInterpretation) { |
254 | r.workspace.writeModel(representation, '''solution«representationNumber».partialinterpretation''') | 265 | r.workspace.writeModel(representation, '''solution«representationNumber».partialinterpretation''') |
266 | val partialInterpretation2GML = new PartialInterpretation2Gml | ||
267 | val gml = partialInterpretation2GML.transform(representation) | ||
268 | r.workspace.writeText('''solution«representationNumber».gml''',gml) | ||
269 | if(representation.newElements.size <160) { | ||
270 | val visualiser = new GraphvizVisualisation | ||
271 | val visualisation = visualiser.visualiseConcretization(representation) | ||
272 | visualisation.writeToFile(r.workspace,'''solution«representationNumber»''') | ||
273 | } | ||
274 | |||
255 | } else { | 275 | } else { |
256 | r.workspace.writeText('''solution«representationNumber».txt''',representation.toString) | 276 | r.workspace.writeText('''solution«representationNumber».txt''',representation.toString) |
257 | } | 277 | } |
@@ -274,14 +294,14 @@ class RunMeasurements { | |||
274 | println("save") | 294 | println("save") |
275 | //val id = 50//args.get(0) | 295 | //val id = 50//args.get(0) |
276 | for(size : sizes) { | 296 | for(size : sizes) { |
277 | val run = (1..50).map['''r«it»'''] | 297 | val run = (1..10).map['''r«it»'''] |
278 | for(runIndex : run) { | 298 | for(runIndex : run) { |
279 | val runID = runIndex+"_"+size | 299 | val runID = runIndex+"_"+size |
280 | print(runID + ";") | 300 | print(runID + ";") |
281 | 301 | ||
282 | try { | 302 | try { |
283 | runMeasure(runID,size) | 303 | runMeasure(runID,size) |
284 | } catch(Exception e) {} | 304 | } catch(Exception e) {e.printStackTrace} |
285 | 305 | ||
286 | System.gc System.gc System.gc | 306 | System.gc System.gc System.gc |
287 | Thread.sleep(2000) | 307 | Thread.sleep(2000) |
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/RunModelExtension.xtend b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/RunModelExtension.xtend new file mode 100644 index 00000000..d8f75b89 --- /dev/null +++ b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/RunModelExtension.xtend | |||
@@ -0,0 +1,378 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.run | ||
2 | |||
3 | import hu.bme.mit.inf.dlsreasoner.alloy.reasoner.AlloySolver | ||
4 | import hu.bme.mit.inf.dlsreasoner.alloy.reasoner.AlloySolverConfiguration | ||
5 | import hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.Statechart | ||
6 | import hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.YakindummPackage | ||
7 | import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic | ||
8 | import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2LogicConfiguration | ||
9 | import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace | ||
10 | import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor | ||
11 | import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.Ecore2logicannotationsPackage | ||
12 | import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput | ||
13 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguagePackage | ||
14 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
15 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage | ||
16 | import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.ModelResult | ||
17 | import hu.bme.mit.inf.dslreasoner.logic.model.statistics.StatisticSections2Print | ||
18 | import hu.bme.mit.inf.dslreasoner.smt.reasoner.SMTSolver | ||
19 | import hu.bme.mit.inf.dslreasoner.smt.reasoner.SmtSolverConfiguration | ||
20 | import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2Logic | ||
21 | import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2LogicConfiguration | ||
22 | import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor | ||
23 | import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.Viatra2LogicAnnotationsPackage | ||
24 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeInferenceMethod | ||
25 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.InstanceModel2Logic | ||
26 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
27 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage | ||
28 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretation2Gml | ||
29 | import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.DiversityDescriptor | ||
30 | import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.StateCoderStrategy | ||
31 | import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasoner | ||
32 | import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration | ||
33 | import hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz.GraphvizVisualisation | ||
34 | import hu.bme.mit.inf.dslreasoner.workspace.FileSystemWorkspace | ||
35 | import java.io.BufferedReader | ||
36 | import java.io.InputStreamReader | ||
37 | import java.util.ArrayList | ||
38 | import java.util.Collections | ||
39 | import java.util.LinkedList | ||
40 | import java.util.List | ||
41 | import java.util.Random | ||
42 | import org.eclipse.emf.ecore.EObject | ||
43 | import org.eclipse.emf.ecore.resource.Resource | ||
44 | import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl | ||
45 | import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine | ||
46 | import org.eclipse.viatra.query.runtime.emf.EMFScope | ||
47 | import java.lang.invoke.VolatileCallSite | ||
48 | |||
49 | enum PartialModelSource { Homeworks, Random } | ||
50 | enum ValidationTechique {Alloy, Viatra} | ||
51 | |||
52 | class RunModelExtensionMeasurements { | ||
53 | val String id | ||
54 | |||
55 | new(String id) { | ||
56 | this.id = id | ||
57 | inputs = new FileSystemWorkspace('''initialModels/''',"") | ||
58 | workspace = new FileSystemWorkspace('''output_«id»/''',"") | ||
59 | } | ||
60 | |||
61 | // Workspace | ||
62 | val FileSystemWorkspace inputs | ||
63 | val FileSystemWorkspace workspace | ||
64 | |||
65 | // Mappers | ||
66 | val Ecore2Logic ecore2Logic = new Ecore2Logic | ||
67 | val Viatra2Logic viatra2Logic = new Viatra2Logic(ecore2Logic) | ||
68 | val InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic | ||
69 | |||
70 | // Solvers | ||
71 | val SMTSolver smtSolver = new SMTSolver | ||
72 | val ViatraReasoner viatraSolver = new ViatraReasoner | ||
73 | val ViatraReasoner viatraWithSmtSolver = new ViatraReasoner | ||
74 | val AlloySolver alloyReasoner = new AlloySolver | ||
75 | |||
76 | def dslLoader(Domain dsl) { | ||
77 | if(dsl == Domain::FAM) { | ||
78 | return new FAMLoader(inputs) | ||
79 | } else if(dsl == Domain::Yakindu) { | ||
80 | return new YakinduLoader(inputs) =>[it.useSynchronization = false useComplexStates = true] | ||
81 | } else if(dsl == Domain::FileSystem){ | ||
82 | return new FileSystemLoader(inputs) | ||
83 | } else if(dsl == Domain::Ecore) { | ||
84 | return new EcoreLoader(inputs) | ||
85 | }else throw new IllegalArgumentException('''Unknown domain: «dsl»''') | ||
86 | } | ||
87 | def static init() { | ||
88 | LogiclanguagePackage.eINSTANCE.class | ||
89 | LogicproblemPackage.eINSTANCE.class | ||
90 | PartialinterpretationPackage.eINSTANCE.class | ||
91 | Ecore2logicannotationsPackage.eINSTANCE.class | ||
92 | Viatra2LogicAnnotationsPackage.eINSTANCE.class | ||
93 | YakindummPackage.eINSTANCE.class | ||
94 | Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.put("*",new XMIResourceFactoryImpl) | ||
95 | } | ||
96 | |||
97 | def transformMMtoLogic(EcoreMetamodelDescriptor mm) { | ||
98 | ecore2Logic.transformMetamodel(mm,new Ecore2LogicConfiguration()) | ||
99 | } | ||
100 | def transformPSToLogic(List<EObject> objects, TracedOutput<LogicProblem, Ecore2Logic_Trace> metamodelProblem) { | ||
101 | instanceModel2Logic.transform(metamodelProblem,objects) | ||
102 | } | ||
103 | def transformQueriesToLogic(ViatraQuerySetDescriptor descriptor, TracedOutput<LogicProblem, Ecore2Logic_Trace> metamodelProblem) { | ||
104 | viatra2Logic.transformQueries(descriptor,metamodelProblem,new Viatra2LogicConfiguration) | ||
105 | } | ||
106 | |||
107 | def executeSolver( | ||
108 | LogicProblem problem, | ||
109 | ViatraQuerySetDescriptor vq, | ||
110 | MetamodelLoader loader, | ||
111 | DiversityDescriptor diversityRequirement, | ||
112 | int size, | ||
113 | UseSolver solver) | ||
114 | { | ||
115 | if(solver == UseSolver.Smt) { | ||
116 | val smtConfig = new SmtSolverConfiguration() => [ | ||
117 | it.typeScopes.maxNewElements = size | ||
118 | it.typeScopes.minNewElements = size | ||
119 | it.solutionScope.numberOfRequiredSolution = 1 | ||
120 | it.solverPath = '''"D:/Programs/Z3/4.3/z3.exe"''' | ||
121 | ] | ||
122 | val solution = this.smtSolver.solve( | ||
123 | problem, | ||
124 | smtConfig, | ||
125 | this.workspace | ||
126 | ) | ||
127 | return solution | ||
128 | } if(solver==UseSolver::Alloy) { | ||
129 | val alloyConfig = new AlloySolverConfiguration => [ | ||
130 | it.typeScopes.maxNewElements = size | ||
131 | it.typeScopes.minNewElements = size | ||
132 | it.solutionScope.numberOfRequiredSolution = 1 | ||
133 | it.typeScopes.maxNewIntegers = 0 | ||
134 | it.writeToFile = true | ||
135 | ] | ||
136 | val solution = this.alloyReasoner.solve( | ||
137 | problem, | ||
138 | alloyConfig, | ||
139 | this.workspace | ||
140 | ) | ||
141 | return solution | ||
142 | } else { | ||
143 | val viatraConfig = new ViatraReasonerConfiguration => [ | ||
144 | it.runtimeLimit = 400 | ||
145 | it.typeScopes.maxNewElements = size | ||
146 | it.typeScopes.minNewElements = size | ||
147 | it.solutionScope.numberOfRequiredSolution = 1 | ||
148 | it.existingQueries = vq.patterns.map[it.internalQueryRepresentation] | ||
149 | it.nameNewElements = false | ||
150 | it.typeInferenceMethod = TypeInferenceMethod.PreliminaryAnalysis | ||
151 | it.searchSpaceConstraints.additionalGlobalConstraints += loader.additionalConstraints | ||
152 | it.stateCoderStrategy = StateCoderStrategy::Neighbourhood | ||
153 | it.debugCongiguration.partalInterpretationVisualisationFrequency = 100 | ||
154 | //it.debugCongiguration.partialInterpretatioVisualiser = | ||
155 | //new GraphvizVisualisation | ||
156 | //new PartialInterpretationSizePrinter | ||
157 | ] | ||
158 | viatraConfig.diversityRequirement = diversityRequirement | ||
159 | if (solver == UseSolver.Viatra) { | ||
160 | val solution = this.viatraSolver.solve( | ||
161 | problem, | ||
162 | viatraConfig, | ||
163 | this.workspace | ||
164 | ) | ||
165 | return solution | ||
166 | } else if(solver == UseSolver.ViatraWithSmt) { | ||
167 | val inconsistency = new SmtSolverConfiguration() => [ | ||
168 | it.solverPath = '''"D:/Programs/Z3/4.3/z3.exe"''' | ||
169 | it.runtimeLimit = 10 | ||
170 | ] | ||
171 | val solution = this.viatraWithSmtSolver.solve( | ||
172 | problem, | ||
173 | viatraConfig =>[ | ||
174 | it.internalConsistencyCheckerConfiguration.internalIncosnsitencyDetector = smtSolver | ||
175 | it.internalConsistencyCheckerConfiguration.internalInconsistencDetectorConfiguration = inconsistency | ||
176 | ], | ||
177 | this.workspace | ||
178 | ) | ||
179 | return solution | ||
180 | } | ||
181 | } | ||
182 | } | ||
183 | |||
184 | def public static loadPartialModels(int size, int max) { | ||
185 | if(partialModelSource === PartialModelSource::Homeworks) { | ||
186 | val hfs = new FileSystemWorkspace("D:/Eclipse/GIT/RemoHF/Extracted/output","") | ||
187 | val allFileNames = hfs.allFiles.toList | ||
188 | |||
189 | |||
190 | val models = allFileNames.map[hfs.readModel(Statechart,it)] | ||
191 | //println("loaded") | ||
192 | val filtered = if(size===-1) { | ||
193 | models | ||
194 | } else { | ||
195 | models.filter[it.eAllContents.size + 1 >= size].toList | ||
196 | } | ||
197 | //println("filtered") | ||
198 | |||
199 | val selected = if(max!==-1) { | ||
200 | Collections.shuffle(filtered); | ||
201 | filtered.subList(0,max) | ||
202 | } else { | ||
203 | filtered | ||
204 | } | ||
205 | //println("selected "+ selected.size) | ||
206 | val collected = selected.map[ | ||
207 | val r = new LinkedList | ||
208 | r.add(it) | ||
209 | r.addAll(it.eAllContents.toIterable) | ||
210 | return r | ||
211 | ].toList | ||
212 | //println("collected to lists") | ||
213 | |||
214 | val list = new ArrayList(collected.size) | ||
215 | for(s : collected) { | ||
216 | list.add(s.prune(size)) | ||
217 | } | ||
218 | //println("pruned to " + size) | ||
219 | |||
220 | return list | ||
221 | } else if(partialModelSource === PartialModelSource::Random) { | ||
222 | |||
223 | } | ||
224 | } | ||
225 | |||
226 | static val Random pruningRandom = new Random(0) | ||
227 | // def private void prune(EObject root, int targetSize) { | ||
228 | // var size = root.eAllContents.size + 1 | ||
229 | // while(size>targetSize) { | ||
230 | // val leafs = root.eAllContents.filter[it.eContents.empty].toList | ||
231 | // val leafToRemove = leafs.get(pruningRandom.nextInt(leafs.size)) | ||
232 | // EcoreUtil.delete(leafToRemove) | ||
233 | // size-- | ||
234 | // } | ||
235 | // } | ||
236 | def static private prune(List<EObject> objects, int targetSize) { | ||
237 | if(targetSize !== -1) { | ||
238 | var size = objects.size | ||
239 | while(size>targetSize) { | ||
240 | val leafs = objects.filter[!it.eAllContents.toList.exists[child | objects.contains(child)]].toList | ||
241 | if(leafs.exists[it instanceof Statechart]) { | ||
242 | println("Gebasz!") | ||
243 | } | ||
244 | objects.remove(leafs.get(pruningRandom.nextInt(leafs.size))) | ||
245 | size-- | ||
246 | } | ||
247 | if(!objects.exists[it instanceof Statechart]) { | ||
248 | println("Gebasz2!") | ||
249 | } | ||
250 | |||
251 | } | ||
252 | return objects; | ||
253 | } | ||
254 | |||
255 | static val partialModelSource = PartialModelSource::Homeworks | ||
256 | static val monitoring = false | ||
257 | static val clean = true | ||
258 | public static var sizes = #[-1/*,5,10,15,20,25,30,35,40,45,50*/] | ||
259 | |||
260 | def static void waitForEnter() { | ||
261 | if(monitoring) { | ||
262 | println(''' Press ENTER to continue''') | ||
263 | (new BufferedReader(new InputStreamReader(System.in))).readLine | ||
264 | } | ||
265 | } | ||
266 | |||
267 | def static runMeasure(String id, int size){ | ||
268 | init | ||
269 | |||
270 | val partialModels = loadPartialModels(size,-1) | ||
271 | var pmIndex = 1 | ||
272 | |||
273 | for(partialModel : partialModels) { | ||
274 | |||
275 | val pmID = id+"_"+(pmIndex++) | ||
276 | val r = new RunModelExtensionMeasurements(pmID) | ||
277 | r.workspace.initAndClear | ||
278 | print(pmID + ";") | ||
279 | print(partialModel.size + ";") | ||
280 | //println("- init") | ||
281 | val dsl = r.dslLoader(Domain::Yakindu) | ||
282 | val mm = dsl.loadMetamodel() | ||
283 | val vq = dsl.loadQueries(mm) | ||
284 | //println("- Queries loaded") | ||
285 | |||
286 | val metamodelProblem = r.transformMMtoLogic(mm) | ||
287 | r.transformPSToLogic(partialModel,metamodelProblem) | ||
288 | r.transformQueriesToLogic(vq,metamodelProblem) | ||
289 | val logicProblem = metamodelProblem.output | ||
290 | |||
291 | //println("- DSL -> Logic problem transformation finished") | ||
292 | |||
293 | waitForEnter | ||
294 | |||
295 | val ValidationTechique validationTechnique = ValidationTechique::Viatra | ||
296 | if(validationTechnique === ValidationTechique::Alloy) { | ||
297 | val solution = r.executeSolver(logicProblem, vq, dsl, null, 0, UseSolver::Alloy) | ||
298 | |||
299 | print(solution.class.simpleName+";"); | ||
300 | print(solution.statistics.transformationTime+";") | ||
301 | print(solution.statistics.solverTime+";") | ||
302 | print((new StatisticSections2Print).transformStatisticDatas2CSV(solution.statistics.entries)) | ||
303 | |||
304 | waitForEnter | ||
305 | |||
306 | if(solution instanceof ModelResult) { | ||
307 | val representations = solution.representation | ||
308 | for(representationIndex : 0..<representations.size) { | ||
309 | val representation = representations.get(representationIndex) | ||
310 | val representationNumber = representationIndex + 1 | ||
311 | if(representation instanceof PartialInterpretation) { | ||
312 | r.workspace.writeModel(representation, '''solution«representationNumber».partialinterpretation''') | ||
313 | val partialInterpretation2GML = new PartialInterpretation2Gml | ||
314 | val gml = partialInterpretation2GML.transform(representation) | ||
315 | r.workspace.writeText('''solution«representationNumber».gml''',gml) | ||
316 | if(representation.newElements.size <160) { | ||
317 | val visualiser = new GraphvizVisualisation | ||
318 | val visualisation = visualiser.visualiseConcretization(representation) | ||
319 | visualisation.writeToFile(r.workspace,'''solution«representationNumber»''') | ||
320 | } | ||
321 | |||
322 | } else { | ||
323 | r.workspace.writeText('''solution«representationNumber».txt''',representation.toString) | ||
324 | } | ||
325 | } | ||
326 | println('''saved''') | ||
327 | } else { | ||
328 | val partial = logicProblem//.eContainer | ||
329 | r.workspace.writeModel(partial, "solution.partialinterpretation") | ||
330 | println('''saved''') | ||
331 | } | ||
332 | } else if(validationTechnique === ValidationTechique::Viatra) { | ||
333 | val validationPatterns = vq.validationPatterns | ||
334 | val resource = partialModel.head.eResource | ||
335 | |||
336 | val startTime = System.currentTimeMillis | ||
337 | val ViatraQueryEngine engine = ViatraQueryEngine.on(new EMFScope(resource) ) | ||
338 | val matchers = new ArrayList(validationPatterns.size) | ||
339 | val validationResult = new ArrayList(validationPatterns.size) | ||
340 | for(validationPattern : validationPatterns) { | ||
341 | val matcher = validationPattern.getMatcher(engine) | ||
342 | matchers += matcher | ||
343 | validationResult += matcher.hasMatch | ||
344 | } | ||
345 | val finishTime = System.currentTimeMillis-startTime | ||
346 | |||
347 | print(finishTime + ";") | ||
348 | print(!validationResult.exists[it] + ";") | ||
349 | for(patternResult : validationResult) { | ||
350 | print(patternResult + ";") | ||
351 | } | ||
352 | println | ||
353 | } | ||
354 | |||
355 | System.gc System.gc System.gc | ||
356 | Thread.sleep(2000) | ||
357 | } | ||
358 | } | ||
359 | |||
360 | def static void main(String[] args) { | ||
361 | //val id = 50//args.get(0) | ||
362 | for(size : sizes) { | ||
363 | val run = (1..1).map['''r«it»'''] | ||
364 | for(runIndex : run) { | ||
365 | val runID = runIndex+"_"+size | ||
366 | |||
367 | |||
368 | try { | ||
369 | runMeasure(runID,size) | ||
370 | } catch(Exception e) {e.printStackTrace} | ||
371 | |||
372 | System.gc System.gc System.gc | ||
373 | Thread.sleep(2000) | ||
374 | } | ||
375 | } | ||
376 | |||
377 | } | ||
378 | } \ No newline at end of file | ||
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/SGraphInconsistencyDetector.xtend b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/SGraphInconsistencyDetector.xtend index 230bb692..4022804c 100644 --- a/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/SGraphInconsistencyDetector.xtend +++ b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/SGraphInconsistencyDetector.xtend | |||
@@ -13,7 +13,7 @@ class SGraphInconsistencyDetector extends ModelGenerationMethodBasedGlobalConstr | |||
13 | var ViatraQueryMatcher<?> entryHasNoOutgoing | 13 | var ViatraQueryMatcher<?> entryHasNoOutgoing |
14 | var ViatraQueryMatcher<?> choiceHasNoOutgiong | 14 | var ViatraQueryMatcher<?> choiceHasNoOutgiong |
15 | var ViatraQueryMatcher<?> choiceHasNoIncoming | 15 | var ViatraQueryMatcher<?> choiceHasNoIncoming |
16 | //var ViatraQueryMatcher<?> noSynch | 16 | var ViatraQueryMatcher<?> noSynch |
17 | var ViatraQueryMatcher<?> synchronizationHasNoOutgoing | 17 | var ViatraQueryMatcher<?> synchronizationHasNoOutgoing |
18 | 18 | ||
19 | var ViatraQueryMatcher<?> synchronizedSiblingRegions | 19 | var ViatraQueryMatcher<?> synchronizedSiblingRegions |
@@ -47,15 +47,12 @@ class SGraphInconsistencyDetector extends ModelGenerationMethodBasedGlobalConstr | |||
47 | it.fullyQualifiedName.equals("unfinishedBy_pattern_hu_bme_mit_inf_dslreasoner_partialsnapshot_mavo_yakindu_choiceHasNoOutgoing") | 47 | it.fullyQualifiedName.equals("unfinishedBy_pattern_hu_bme_mit_inf_dslreasoner_partialsnapshot_mavo_yakindu_choiceHasNoOutgoing") |
48 | ].head.getMatcher(context.queryEngine) | 48 | ].head.getMatcher(context.queryEngine) |
49 | 49 | ||
50 | // this.choiceHasNoIncoming = method.unfinishedWF.filter[ | ||
51 | // it.fullyQualifiedName.equals("unfinishedBy_pattern_hu_bme_mit_inf_dslreasoner_partialsnapshot_mavo_yakindu_choiceHasNoIncoming") | ||
52 | // ].head.getMatcher(context.queryEngine) | ||
53 | } catch(Exception e) { } | 50 | } catch(Exception e) { } |
54 | try{ | 51 | try{ |
55 | // this.noSynch = method.unfinishedWF.filter[ | 52 | this.noSynch = method.unfinishedWF.filter[ |
56 | // it.fullyQualifiedName.equals("unfinishedBy_pattern_hu_bme_mit_inf_dslreasoner_partialsnapshot_mavo_yakindu_noSynch") | 53 | it.fullyQualifiedName.equals("unfinishedBy_pattern_hu_bme_mit_inf_dslreasoner_partialsnapshot_mavo_yakindu_noSynch") |
57 | // ].head.getMatcher(context.queryEngine) | 54 | ].head.getMatcher(context.queryEngine) |
58 | // | 55 | |
59 | this.synchronizedSiblingRegions = method.unfinishedWF.filter[ | 56 | this.synchronizedSiblingRegions = method.unfinishedWF.filter[ |
60 | it.fullyQualifiedName.equals("unfinishedBy_pattern_hu_bme_mit_inf_dslreasoner_partialsnapshot_mavo_yakindu_SynchronizedRegionDoesNotHaveMultipleRegions") | 57 | it.fullyQualifiedName.equals("unfinishedBy_pattern_hu_bme_mit_inf_dslreasoner_partialsnapshot_mavo_yakindu_SynchronizedRegionDoesNotHaveMultipleRegions") |
61 | ].head.getMatcher(context.queryEngine) | 58 | ].head.getMatcher(context.queryEngine) |
@@ -68,15 +65,13 @@ class SGraphInconsistencyDetector extends ModelGenerationMethodBasedGlobalConstr | |||
68 | 65 | ||
69 | override checkGlobalConstraint(ThreadContext context) { | 66 | override checkGlobalConstraint(ThreadContext context) { |
70 | if(noEntry !== null) { | 67 | if(noEntry !== null) { |
71 | var requiredNewObjects = | 68 | var requiredNewObjects = noEntry.countMatches*2 +entryHasNoOutgoing.countMatches + noStateInRegion.countMatches |
72 | noEntry.countMatches*2 + | 69 | if(choiceHasNoOutgiong!=null) { |
73 | entryHasNoOutgoing.countMatches + | 70 | requiredNewObjects+=choiceHasNoOutgiong.countMatches |
74 | choiceHasNoOutgiong.countMatches+ | 71 | } |
75 | //choiceHasNoIncoming.countMatches+ | ||
76 | noStateInRegion.countMatches | ||
77 | if(synchronizationHasNoOutgoing!= null) { | 72 | if(synchronizationHasNoOutgoing!= null) { |
78 | requiredNewObjects += | 73 | requiredNewObjects += |
79 | //noSynch.countMatches*2 + | 74 | noSynch.countMatches*2 + |
80 | synchronizationHasNoOutgoing.countMatches + | 75 | synchronizationHasNoOutgoing.countMatches + |
81 | synchronizedSiblingRegions.countMatches*4 | 76 | synchronizedSiblingRegions.countMatches*4 |
82 | } | 77 | } |
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/SimpleRun.xtend b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/SimpleRun.xtend index d73303fa..d0f88b65 100644 --- a/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/SimpleRun.xtend +++ b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/SimpleRun.xtend | |||
@@ -73,7 +73,7 @@ class SimpleRun { | |||
73 | it.existingQueries = queries.patterns.map[it.internalQueryRepresentation] | 73 | it.existingQueries = queries.patterns.map[it.internalQueryRepresentation] |
74 | it.debugCongiguration.logging = false | 74 | it.debugCongiguration.logging = false |
75 | it.debugCongiguration.partalInterpretationVisualisationFrequency = 1 | 75 | it.debugCongiguration.partalInterpretationVisualisationFrequency = 1 |
76 | it.debugCongiguration.partialInterpretatioVisualiser = null//new GraphvizVisualisation | 76 | it.debugCongiguration.partialInterpretatioVisualiser = new GraphvizVisualisation |
77 | ] | 77 | ] |
78 | solution = reasoner.solve(logicProblem,viatraConfig,workspace) | 78 | solution = reasoner.solve(logicProblem,viatraConfig,workspace) |
79 | /*/ | 79 | /*/ |
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/VisualiseAllModelInDirectory.xtend b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/VisualiseAllModelInDirectory.xtend new file mode 100644 index 00000000..f0059a85 --- /dev/null +++ b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/VisualiseAllModelInDirectory.xtend | |||
@@ -0,0 +1,64 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.run | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage | ||
4 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
5 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage | ||
6 | import hu.bme.mit.inf.dslreasoner.workspace.FileSystemWorkspace | ||
7 | import java.io.File | ||
8 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguagePackage | ||
9 | import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.Ecore2logicannotationsPackage | ||
10 | import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.Viatra2LogicAnnotationsPackage | ||
11 | import org.eclipse.emf.ecore.resource.Resource | ||
12 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretation2Gml | ||
13 | import hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz.GraphvizVisualisation | ||
14 | import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl | ||
15 | |||
16 | class VisualiseAllModelInDirectory { | ||
17 | def static void main(String[] args) { | ||
18 | LogiclanguagePackage.eINSTANCE.class | ||
19 | LogicproblemPackage.eINSTANCE.class | ||
20 | PartialinterpretationPackage.eINSTANCE.class | ||
21 | Ecore2logicannotationsPackage.eINSTANCE.class | ||
22 | Viatra2LogicAnnotationsPackage.eINSTANCE.class | ||
23 | Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.put("*",new XMIResourceFactoryImpl) | ||
24 | |||
25 | //"D:/Data/ICSE18/Yakindu-WF/Largest-by-Graph-Solver".visualiseModel | ||
26 | // val folderName = new File("D:/Data/ICSE18/FAM+WF/Largest-by-Graph-Solver") | ||
27 | // for(subFolderName : folderName.listFiles) { | ||
28 | // subFolderName.absolutePath.visualiseModel | ||
29 | // } | ||
30 | } | ||
31 | |||
32 | def static visualiseModel(String folderName) { | ||
33 | val file = new File(folderName+"/"+"solution1.partialinterpretation") | ||
34 | val hasSource = file.exists | ||
35 | |||
36 | |||
37 | if(hasSource) { | ||
38 | val hasPng = new File(folderName+"/"+"solution1.png").exists | ||
39 | val hasGml = new File(folderName+"/"+"solution1.gml").exists | ||
40 | |||
41 | val workspace = new FileSystemWorkspace(folderName,"") | ||
42 | val model = workspace.readModel(PartialInterpretation,"solution1.partialinterpretation") | ||
43 | |||
44 | if(!hasGml) { | ||
45 | val partialInterpretation2GML = new PartialInterpretation2Gml | ||
46 | val gmlText = partialInterpretation2GML.transform(model) | ||
47 | workspace.writeText('''solution1.gml''',gmlText) | ||
48 | println('''solution1.gml''') | ||
49 | } | ||
50 | |||
51 | if(!hasPng && model.newElements.size <160) { | ||
52 | val visualiser = new GraphvizVisualisation | ||
53 | val visualisation = visualiser.visualiseConcretization(model) | ||
54 | visualisation.writeToFile(workspace,"solution1") | ||
55 | println("solution1.png") | ||
56 | println("Need png!") | ||
57 | } | ||
58 | |||
59 | println('''«folderName» visualised''') | ||
60 | } else { | ||
61 | println('''«folderName» missing''') | ||
62 | } | ||
63 | } | ||
64 | } | ||