1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
import com.google.common.collect.HashMultiset
import com.google.common.collect.ImmutableSet
import com.google.common.collect.Multiset
import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.AbstractNodeDescriptor
import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.NeighbourhoodWithTraces
import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PartialInterpretation2ImmutableTypeLattice
import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.DiversityDescriptor
import java.util.Collection
import java.util.HashSet
import java.util.Map
import java.util.Set
import org.eclipse.viatra.dse.base.ThreadContext
import org.eclipse.xtend.lib.annotations.Accessors
interface DiversityChecker {
public static val NO_DIVERSITY_CHECKER = new DiversityChecker {
override isActive() {
false
}
override getTotalRuntime() {
0
}
override getSuccessRate() {
1.0
}
override newSolution(ThreadContext threadContext, Object solutionId, Collection<Object> dominatedSolutionIds) {
true
}
}
def boolean isActive()
def long getTotalRuntime()
def double getSuccessRate()
def boolean newSolution(ThreadContext threadContext, Object solutionId, Collection<Object> dominatedSolutionIds)
static def of(DiversityDescriptor descriptor) {
if (descriptor.ensureDiversity) {
new NodewiseDiversityChecker(descriptor)
} else {
NO_DIVERSITY_CHECKER
}
}
}
abstract class AbstractDiversityChecker implements DiversityChecker {
val DiversityDescriptor descriptor
val PartialInterpretation2ImmutableTypeLattice solutionCoder = new PartialInterpretation2ImmutableTypeLattice
@Accessors(PUBLIC_GETTER) var long totalRuntime = 0
var int allCheckCount = 0
var int successfulCheckCount = 0
protected new(DiversityDescriptor descriptor) {
if (!descriptor.ensureDiversity) {
throw new IllegalArgumentException(
"Diversity description should enforce diversity or NO_DIVERSITY_CHECKER should be used instead.")
}
this.descriptor = descriptor
}
override isActive() {
true
}
override getTotalRuntime() {
throw new UnsupportedOperationException("TODO: auto-generated method stub")
}
override getSuccessRate() {
(allCheckCount as double) / (successfulCheckCount as double)
}
override newSolution(ThreadContext threadContext, Object solutionId, Collection<Object> dominatedSolutionIds) {
val start = System.nanoTime
val model = threadContext.model as PartialInterpretation
val representation = solutionCoder.createRepresentation(model, descriptor.range, descriptor.parallels,
descriptor.maxNumber, descriptor.relevantTypes, descriptor.relevantRelations)
val isDifferent = internalNewSolution(representation, solutionId, dominatedSolutionIds)
totalRuntime += System.nanoTime - start
allCheckCount++
if (isDifferent) {
successfulCheckCount++
}
isDifferent
}
protected abstract def boolean internalNewSolution(
NeighbourhoodWithTraces<Map<? extends AbstractNodeDescriptor, Integer>, AbstractNodeDescriptor> representation,
Object solutionId, Collection<Object> dominatedSolutionIds)
}
class NodewiseDiversityChecker extends AbstractDiversityChecker {
var Multiset<Integer> nodeCodes = HashMultiset.create
val Map<Object, Set<Integer>> tracedNodeCodes = newHashMap
new(DiversityDescriptor descriptor) {
super(descriptor)
}
override protected internalNewSolution(
NeighbourhoodWithTraces<Map<? extends AbstractNodeDescriptor, Integer>, AbstractNodeDescriptor> representation,
Object solutionId, Collection<Object> dominatedSolutionIds) {
val nodeCodesInSolution = ImmutableSet.copyOf(representation.modelRepresentation.keySet.map[hashCode])
val remainingNodeCodes = if (dominatedSolutionIds.empty) {
nodeCodes
} else {
getRemainingNodeCodes(dominatedSolutionIds)
}
val hasNewCode = nodeCodesInSolution.exists[!remainingNodeCodes.contains(it)]
if (hasNewCode) {
nodeCodes = remainingNodeCodes
nodeCodes.addAll(nodeCodesInSolution)
for (dominatedSolutionId : dominatedSolutionIds) {
tracedNodeCodes.remove(dominatedSolutionId)
}
tracedNodeCodes.put(solutionId, nodeCodesInSolution)
}
hasNewCode
}
private def getRemainingNodeCodes(Collection<Object> dominatedSolutionIds) {
// TODO Optimize multiset operations.
val copyOfNodeCodes = HashMultiset.create(nodeCodes)
for (dominatedSolutionId : dominatedSolutionIds) {
val dominatedModelCode = tracedNodeCodes.get(dominatedSolutionId)
if (dominatedModelCode === null) {
throw new IllegalArgumentException("Unknown dominated solution: " + dominatedSolutionId)
}
copyOfNodeCodes.removeAll(dominatedModelCode)
}
copyOfNodeCodes
}
}
class GraphwiseDiversityChecker extends AbstractDiversityChecker {
var Set<Integer> modelCodes = newHashSet
val Map<Object, Integer> tracedModelCodes = newHashMap
new(DiversityDescriptor descriptor) {
super(descriptor)
}
override protected internalNewSolution(
NeighbourhoodWithTraces<Map<? extends AbstractNodeDescriptor, Integer>, AbstractNodeDescriptor> representation,
Object solutionId, Collection<Object> dominatedSolutionIds) {
val modelCodeOfSolution = representation.modelRepresentation.hashCode
val remainingModelCodes = if (dominatedSolutionIds.empty) {
modelCodes
} else {
getRemainingModelCodes(dominatedSolutionIds)
}
val isNewCode = !remainingModelCodes.contains(modelCodeOfSolution)
if (isNewCode) {
modelCodes = remainingModelCodes
modelCodes += modelCodeOfSolution
for (dominatedSolutionId : dominatedSolutionIds) {
tracedModelCodes.remove(dominatedSolutionId)
}
tracedModelCodes.put(solutionId, modelCodeOfSolution)
}
isNewCode
}
private def getRemainingModelCodes(Collection<Object> dominatedSolutionIds) {
val copyOfModelCodes = new HashSet(modelCodes)
for (dominatedSolutionId : dominatedSolutionIds) {
val dominatedModelCode = tracedModelCodes.get(dominatedSolutionId)
if (dominatedModelCode === null) {
throw new IllegalArgumentException("Unknown dominated solution: " + dominatedSolutionId)
}
copyOfModelCodes -= dominatedModelCode
}
copyOfModelCodes
}
}
|
