diff options
Diffstat (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder')
2 files changed, 335 insertions, 0 deletions
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/IdentifierBasedStateCoderFactory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/IdentifierBasedStateCoderFactory.xtend new file mode 100644 index 00000000..c421ace6 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/IdentifierBasedStateCoderFactory.xtend | |||
@@ -0,0 +1,129 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.statecoder | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
5 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink | ||
6 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
7 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation | ||
8 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation | ||
9 | import java.util.ArrayList | ||
10 | import java.util.Comparator | ||
11 | import java.util.LinkedList | ||
12 | import java.util.List | ||
13 | import java.util.SortedSet | ||
14 | import java.util.TreeSet | ||
15 | import org.eclipse.emf.common.notify.Notifier | ||
16 | import org.eclipse.viatra.dse.statecode.IStateCoder | ||
17 | import org.eclipse.viatra.dse.statecode.IStateCoderFactory | ||
18 | import org.eclipse.viatra.query.runtime.api.IPatternMatch | ||
19 | import org.eclipse.xtend.lib.annotations.Accessors | ||
20 | import org.eclipse.xtend.lib.annotations.Data | ||
21 | |||
22 | class IdentifierBasedStateCoderFactory implements IStateCoderFactory{ | ||
23 | |||
24 | val List<IdentifierBasedStateCoder> statecoders = new LinkedList | ||
25 | synchronized override createStateCoder() { | ||
26 | val res = new IdentifierBasedStateCoder | ||
27 | statecoders += res | ||
28 | return res | ||
29 | } | ||
30 | def getSumStatecoderRuntime() { | ||
31 | statecoders.map[statecoderRuntime].reduce[p1, p2|p1+p2] | ||
32 | } | ||
33 | } | ||
34 | |||
35 | @Data | ||
36 | class RelationStatecoder { | ||
37 | String relationName | ||
38 | SortedSet<Pair<Integer,Integer>> links; | ||
39 | |||
40 | static val comparator= new Comparator<Pair<Integer,Integer>>() { | ||
41 | override compare(Pair<Integer, Integer> o1, Pair<Integer, Integer> o2) { | ||
42 | if(o1.key > o2.key) { | ||
43 | return 1 | ||
44 | } else if(o1.key < o2.key) { | ||
45 | return -1 | ||
46 | } else { | ||
47 | return Integer.compare(o1.value,o2.value) | ||
48 | } | ||
49 | } | ||
50 | } | ||
51 | |||
52 | new(String relationName) { | ||
53 | this.relationName = relationName | ||
54 | links = new TreeSet(comparator) | ||
55 | } | ||
56 | } | ||
57 | |||
58 | @Data | ||
59 | class IdentifierBasedStateCode { | ||
60 | int numberOfNewElement | ||
61 | SortedSet<RelationStatecoder> relationStatecoders | ||
62 | |||
63 | private static val comparator = new Comparator<RelationStatecoder>() { | ||
64 | override compare(RelationStatecoder o1, RelationStatecoder o2) { | ||
65 | o1.relationName.compareTo(o2.relationName) | ||
66 | } | ||
67 | } | ||
68 | |||
69 | public new(int numberOfNewElements) { | ||
70 | this.numberOfNewElement = numberOfNewElements | ||
71 | this.relationStatecoders = new TreeSet(comparator) | ||
72 | } | ||
73 | } | ||
74 | |||
75 | class IdentifierBasedStateCoder implements IStateCoder{ | ||
76 | var PartialInterpretation model = null | ||
77 | |||
78 | @Accessors(PUBLIC_GETTER) var long statecoderRuntime = 0 | ||
79 | |||
80 | override createActivationCode(IPatternMatch match) { | ||
81 | val startTime = System.nanoTime | ||
82 | val res = new ArrayList(match.parameterNames.size) | ||
83 | var index = 0 | ||
84 | while(index < match.parameterNames.size) { | ||
85 | res.add(getID(match.get(index))) | ||
86 | index++ | ||
87 | } | ||
88 | statecoderRuntime += (System.nanoTime - startTime) | ||
89 | return match.specification.fullyQualifiedName -> res | ||
90 | } | ||
91 | |||
92 | override createStateCode() { | ||
93 | val startTime = System.nanoTime | ||
94 | val res = new IdentifierBasedStateCode(model.newElements.size) | ||
95 | for(relation : model.partialrelationinterpretation) { | ||
96 | val relationCoder = new RelationStatecoder(relation.interpretationOf.name) | ||
97 | for(link: relation.relationlinks.filter(BinaryElementRelationLink)) { | ||
98 | relationCoder.links+=link.param1.ID -> link.param2.ID | ||
99 | } | ||
100 | res.relationStatecoders+=relationCoder | ||
101 | } | ||
102 | statecoderRuntime += (System.nanoTime - startTime) | ||
103 | return res | ||
104 | } | ||
105 | |||
106 | def getID(Object element) { | ||
107 | if(element instanceof DefinedElement) { | ||
108 | val container = element.eContainer | ||
109 | if(container instanceof LogicProblem) { | ||
110 | return -container.elements.indexOf(element)-1 | ||
111 | } else if(container instanceof PartialInterpretation){ | ||
112 | return container.newElements.indexOf(element)+1 | ||
113 | } | ||
114 | } else if(element instanceof PartialInterpretation || element instanceof LogicProblem) { | ||
115 | return 0 | ||
116 | } else if(element instanceof PartialRelationInterpretation) { | ||
117 | return element.interpretationOf.name.hashCode | ||
118 | } else if(element instanceof PartialTypeInterpratation) { | ||
119 | return element.interpretationOf.name.hashCode | ||
120 | } else { | ||
121 | println(element) | ||
122 | throw new UnsupportedOperationException('''Unsupported type: «element.class.simpleName»''') | ||
123 | } | ||
124 | } | ||
125 | |||
126 | override init(Notifier notifier) { | ||
127 | model = notifier as PartialInterpretation | ||
128 | } | ||
129 | } \ No newline at end of file | ||
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend new file mode 100644 index 00000000..5fb85b0c --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend | |||
@@ -0,0 +1,206 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.statecoder | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.AbstractNodeDescriptor | ||
4 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PartialInterpretation2ImmutableTypeLattice | ||
5 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
6 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage | ||
7 | import java.util.ArrayList | ||
8 | import java.util.LinkedList | ||
9 | import java.util.List | ||
10 | import java.util.Map | ||
11 | import org.eclipse.emf.common.notify.Notifier | ||
12 | import org.eclipse.emf.ecore.EClass | ||
13 | import org.eclipse.emf.ecore.EObject | ||
14 | import org.eclipse.emf.ecore.EStructuralFeature | ||
15 | import org.eclipse.viatra.dse.statecode.IStateCoder | ||
16 | import org.eclipse.viatra.dse.statecode.IStateCoderFactory | ||
17 | import org.eclipse.viatra.query.runtime.api.IPatternMatch | ||
18 | import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine | ||
19 | import org.eclipse.viatra.query.runtime.base.api.FeatureListener | ||
20 | import org.eclipse.viatra.query.runtime.base.api.IndexingLevel | ||
21 | import org.eclipse.viatra.query.runtime.base.api.InstanceListener | ||
22 | import org.eclipse.viatra.query.runtime.emf.EMFBaseIndexWrapper | ||
23 | import org.eclipse.viatra.query.runtime.emf.EMFScope | ||
24 | import org.eclipse.xtend.lib.annotations.Accessors | ||
25 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement | ||
26 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
27 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation | ||
28 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation | ||
29 | import java.util.Set | ||
30 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration | ||
31 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration | ||
32 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PartialInterpretation2NeighbourhoodRepresentation | ||
33 | |||
34 | class NeighbourhoodBasedStateCoderFactory implements IStateCoderFactory { | ||
35 | val List<NeighbourhoodBasedPartialInterpretationStateCoder> statecoders = new LinkedList | ||
36 | |||
37 | val int range | ||
38 | val int parallels | ||
39 | val int maxNumber | ||
40 | val Set<TypeDeclaration> relevantTypes | ||
41 | val Set<RelationDeclaration> relevantRelations | ||
42 | |||
43 | public new() { | ||
44 | this.range = PartialInterpretation2NeighbourhoodRepresentation::FixPointRage | ||
45 | this.parallels = PartialInterpretation2NeighbourhoodRepresentation::FullParallels | ||
46 | this.maxNumber = PartialInterpretation2NeighbourhoodRepresentation::MaxNumbers | ||
47 | this.relevantTypes = null | ||
48 | this.relevantRelations = null | ||
49 | } | ||
50 | |||
51 | public new(int range, int parallels, int maxNumber, Set<TypeDeclaration> relevantTypes, Set<RelationDeclaration> relevantRelations) { | ||
52 | this.range = range | ||
53 | this.parallels = parallels | ||
54 | this.maxNumber = maxNumber | ||
55 | this.relevantTypes = relevantTypes | ||
56 | this.relevantRelations = relevantRelations | ||
57 | } | ||
58 | |||
59 | synchronized override createStateCoder() { | ||
60 | val res = new NeighbourhoodBasedPartialInterpretationStateCoder(statecoders.size, | ||
61 | range,parallels,maxNumber,relevantTypes,relevantRelations) | ||
62 | statecoders += res | ||
63 | return res | ||
64 | } | ||
65 | def getSumStatecoderRuntime() { | ||
66 | statecoders.map[statecoderRuntime].reduce[p1, p2|p1+p2] | ||
67 | } | ||
68 | } | ||
69 | |||
70 | class NeighbourhoodBasedPartialInterpretationStateCoder implements IStateCoder{ | ||
71 | val int id; | ||
72 | val int range | ||
73 | val int parallels | ||
74 | val int maxNumber | ||
75 | val Set<TypeDeclaration> relevantTypes | ||
76 | val Set<RelationDeclaration> relevantRelations | ||
77 | |||
78 | val calculator = | ||
79 | new PartialInterpretation2ImmutableTypeLattice | ||
80 | var PartialInterpretation target | ||
81 | |||
82 | private var Map<DefinedElement, ? extends AbstractNodeDescriptor> nodeRepresentations = null | ||
83 | private var Map<? extends AbstractNodeDescriptor, Integer> modelRepresentation = null | ||
84 | |||
85 | /*public new(int id) { | ||
86 | this.id = id | ||
87 | this.range = PartialInterpretation2NeighbourhoodRepresentation::FixPointRage | ||
88 | this.parallels = PartialInterpretation2NeighbourhoodRepresentation::FullParallels | ||
89 | this.maxNumber = maxNumber = PartialInterpretation2NeighbourhoodRepresentation::MaxNumbers | ||
90 | this.relevantTypes = relevantTypes | ||
91 | this.relevantRelations = relevantRelations | ||
92 | }*/ | ||
93 | |||
94 | public new(int id, int range, int parallels, int maxNumber, Set<TypeDeclaration> relevantTypes, Set<RelationDeclaration> relevantRelations) { | ||
95 | this.id = id | ||
96 | this.range = range | ||
97 | this.parallels = parallels | ||
98 | this.maxNumber = maxNumber | ||
99 | this.relevantTypes = relevantTypes | ||
100 | this.relevantRelations = relevantRelations | ||
101 | } | ||
102 | |||
103 | @Accessors(PUBLIC_GETTER) var long statecoderRuntime = 0 | ||
104 | |||
105 | // val range = -1 | ||
106 | // val par = Integer.MAX_VALUE | ||
107 | //val deeprepresentation = false | ||
108 | |||
109 | ///////// | ||
110 | // Caching version | ||
111 | ///////// | ||
112 | synchronized private def refreshStateCodes() { | ||
113 | if(this.nodeRepresentations === null || this.modelRepresentation === null) { | ||
114 | val startTime = System.nanoTime | ||
115 | //relevantObjects.forEach[println(it)] | ||
116 | val code = calculator.createRepresentation(target,range,parallels,maxNumber,relevantTypes,relevantRelations) | ||
117 | this.modelRepresentation = code.modelRepresentation | ||
118 | this.nodeRepresentations = code.nodeRepresentations | ||
119 | statecoderRuntime += (System.nanoTime - startTime) | ||
120 | } | ||
121 | } | ||
122 | synchronized override createActivationCode(IPatternMatch match) { | ||
123 | refreshStateCodes | ||
124 | |||
125 | val startTime = System.nanoTime | ||
126 | val size = match.specification.parameters.size | ||
127 | val res = new ArrayList(size) | ||
128 | var int index = 0 | ||
129 | while(index < size) { | ||
130 | res.add(getCode(match.get(index))) | ||
131 | index++ | ||
132 | } | ||
133 | statecoderRuntime += (System.nanoTime - startTime) | ||
134 | return match.specification.fullyQualifiedName->res.hashCode | ||
135 | } | ||
136 | |||
137 | def private getCode(Object o) { | ||
138 | if(o instanceof DefinedElement) { | ||
139 | this.nodeRepresentations.get(o) | ||
140 | } else if(o instanceof PartialInterpretation || o instanceof LogicProblem) { | ||
141 | return null | ||
142 | } else if(o instanceof PartialRelationInterpretation) { | ||
143 | return o.interpretationOf.name | ||
144 | } else if(o instanceof PartialTypeInterpratation) { | ||
145 | return o.interpretationOf.name | ||
146 | } else { | ||
147 | throw new UnsupportedOperationException('''Unsupported type: «o.class.simpleName»''') | ||
148 | } | ||
149 | } | ||
150 | |||
151 | synchronized override createStateCode() { | ||
152 | refreshStateCodes | ||
153 | return this.modelRepresentation.hashCode | ||
154 | } | ||
155 | ///////// | ||
156 | // Caching version | ||
157 | ///////// | ||
158 | |||
159 | ///////// | ||
160 | // Recalculating version | ||
161 | ///////// | ||
162 | // synchronized override createActivationCode(IPatternMatch match) { | ||
163 | // val nodes = calculator.createRepresentation(getRelevantObjects().toList,range,par).nodeRepresentations | ||
164 | // val res = match.toArray.map[objectInMatch | | ||
165 | // nodes.get(objectInMatch) | ||
166 | // ] | ||
167 | // return res | ||
168 | // } | ||
169 | // | ||
170 | // override createStateCode() { | ||
171 | // return this.calculator.createRepresentation(getRelevantObjects().toList,range,par).modelRepresentation | ||
172 | // } | ||
173 | ///////// | ||
174 | // Recalculating version | ||
175 | ///////// | ||
176 | |||
177 | override init(Notifier notifier) { | ||
178 | this.target = notifier as PartialInterpretation | ||
179 | val queryEngine = ViatraQueryEngine.on(new EMFScope(notifier)) | ||
180 | val baseIndex = queryEngine.getBaseIndex() as EMFBaseIndexWrapper | ||
181 | val navigationHelper = baseIndex.getNavigationHelper(); | ||
182 | |||
183 | val classes = PartialinterpretationPackage.eINSTANCE.EClassifiers.filter(EClass).toSet | ||
184 | val features = classes.map[it.EAllStructuralFeatures].flatten.toSet | ||
185 | navigationHelper.registerObservedTypes( | ||
186 | classes, | ||
187 | null, | ||
188 | features, | ||
189 | IndexingLevel.FULL); | ||
190 | |||
191 | |||
192 | navigationHelper.addFeatureListener(features, new FeatureListener() { | ||
193 | override public void featureInserted(EObject host, EStructuralFeature feature, Object value) { invalidate } | ||
194 | override public void featureDeleted(EObject host, EStructuralFeature feature, Object value) { invalidate } | ||
195 | }); | ||
196 | navigationHelper.addInstanceListener(classes, new InstanceListener() { | ||
197 | override public void instanceInserted(EClass clazz, EObject instance) { invalidate } | ||
198 | override public void instanceDeleted(EClass clazz, EObject instance) { invalidate } | ||
199 | }); | ||
200 | } | ||
201 | |||
202 | synchronized def public invalidate() { | ||
203 | this.nodeRepresentations = null | ||
204 | this.modelRepresentation = null | ||
205 | } | ||
206 | } | ||