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
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
package hu.bme.mit.inf.dslreasoner.domains.cps.queries
import "http://www.eclipse.org/emf/2002/Ecore"
import "http://www.example.org/cps"
private pattern cpsApplications(Cps : CyberPhysicalSystem, AppInstance : ApplicationInstance) {
CyberPhysicalSystem.applicationTypes.instances(Cps, AppInstance);
}
private pattern cpsHosts(Cps : CyberPhysicalSystem, HostInstance : HostInstance) {
CyberPhysicalSystem.hostTypes.instances(Cps, HostInstance);
}
private pattern totalMemory(Host : HostInstance, Memory : EInt) {
HostInstance.type.defaultMemory(Host, Memory);
}
private pattern totalHdd(Host : HostInstance, Hdd : EInt) {
HostInstance.type.defaultHdd(Host, Hdd);
}
private pattern availableMemory(Host : HostInstance, Memory : java Integer) {
find totalMemory(Host, TotalMemory);
RequiredMemory == sum find memoryRequirement(Host, _, #_);
Memory == eval(TotalMemory - RequiredMemory);
}
private pattern memoryRequirement(Host : HostInstance, App : ApplicationInstance, Memory : EInt) {
find resourceRequirement(Host, App, Req);
ResourceRequirement.requiredMemory(Req, Memory);
}
private pattern availableHdd(Host : HostInstance, Hdd : java Integer) {
find totalHdd(Host, TotalHdd);
RequiredHdd == sum find hddRequirement(Host, _, #_);
Hdd == eval(TotalHdd - RequiredHdd);
}
private pattern hddRequirement(Host : HostInstance, App : ApplicationInstance, Hdd : EInt) {
find resourceRequirement(Host, App, Req);
ResourceRequirement.requiredHdd(Req, Hdd);
}
pattern resourceRequirement(Host : HostInstance, App : ApplicationInstance, Req : ResourceRequirement) {
ApplicationInstance.allocatedTo(App, Host);
ApplicationInstance.type.requirements(App, Req);
HostInstance.type(Host, HostType);
ResourceRequirement.hostType(Req, HostType);
}
@Constraint(severity = "error", key = {Host, App},
message = "Application instance must be allocated to a supported host type.")
pattern allocationWithoutResourceRequirement(Host : HostInstance, App : ApplicationInstance) {
ApplicationInstance.allocatedTo(App, Host);
neg find resourceRequirement(Host, App, _);
}
@Constraint(severity = "error", key = {Host},
message = "Insufficient memory available on host.")
pattern notEnoughAvailableMemory(Host : HostInstance) {
find availableMemory(Host, Memory);
check(Memory < 0);
}
@Constraint(severity = "error", key = {Host},
message = "Insufficient HDD available on host.")
pattern notEnoughAvailableHdd(Host : HostInstance) {
find availableHdd(Host, Hdd);
check(Hdd < 0);
}
@Constraint(severity = "error", key = {Req, App},
message = "Requirement must be satisfied by the required application type.")
pattern instanceDoesNotSatisfyRequirement(Req : Requirement, App : ApplicationInstance) {
Requirement.instances(Req, App);
neg find satisfyingInstance(Req, App);
}
private pattern satisfyingInstance(Req : Requirement, App : ApplicationInstance) {
Requirement.instances(Req, App);
Requirement.type(Req, Type);
ApplicationInstance.type(App, Type);
}
@Constraint(severity = "error", key = {Req},
message = "Requirement is not satisfied by enough application instances.")
pattern requirementNotSatisfied(Req : Requirement) {
Instances == count find satisfyingInstance(Req, _);
Requirement.count(Req, RequiredCount);
check(Instances < RequiredCount);
}
@Constraint(severity = "error", key = {Req},
message = "Redundant instances must not be allocated to the same host.")
pattern redundantInstancesOnSameHost(Req : Requirement) {
Requirement.instances(Req, App1);
Requirement.instances(Req, App2);
App1 != App2;
ApplicationInstance.allocatedTo(App1, Host);
ApplicationInstance.allocatedTo(App2, Host);
}
//
// Metrics
//
// Free memory
pattern averageFreeMemoryMetric(Average : java Double) {
Average == avg find freeMemoryPercentage(_, #_);
}
private pattern freeMemoryPercentage(Host : HostInstance, Free : java Double) {
find totalMemory(Host, Total);
find availableMemory(Host, Available);
Free == eval((Available as double) / Total);
}
// Free HDD
pattern averageFreeHddMetric(Average : java Double) {
Average == avg find freeHddPercentage(_, #_);
}
private pattern freeHddPercentage(Host : HostInstance, Free : java Double) {
find totalHdd(Host, Total);
find availableHdd(Host, Available);
Free == eval((Available as double) / Total);
}
// Total cost
pattern costMetric(Cost : java Integer) {
Cost == sum find cpsCost(_, #_);
}
pattern cpsCost(Cps : CyberPhysicalSystem, Cost : java Integer) {
AppCount == count find cpsApplications(Cps, _);
HostCost == sum find hostInstanceCost(Cps, _, #_);
Cost == eval(5 * AppCount + HostCost);
}
private pattern hostInstanceCost(Cps : CyberPhysicalSystem, Host : HostInstance, Cost : EInt) {
find cpsHosts(Cps, Host);
HostInstance.type.cost(Host, Cost);
}
//
// Transformation rule preconditions for rule-based DSE
//
pattern allocate(App : ApplicationInstance, Host : HostInstance) {
ApplicationInstance.type.requirements(App, Req);
ResourceRequirement.hostType.instances(Req, Host);
find unallocatedAppInstance(App);
find availableMemory(Host, AvailableMem);
find availableHdd(Host, AvailableHdd);
ResourceRequirement.requiredMemory(Req, RequiredMem);
ResourceRequirement.requiredHdd(Req, RequiredHdd);
check(AvailableMem >= RequiredMem);
check(AvailableHdd >= RequiredHdd);
neg ApplicationInstance.requirement.instances.allocatedTo(App, Host);
}
pattern unallocateAppInstance(App : ApplicationInstance) {
ApplicationInstance.allocatedTo(App, _);
}
pattern createHostInstance(HostType : HostType) {
find unallocatedAppInstance(App);
ApplicationInstance.type.requirements.hostType(App, HostType);
}
pattern removeHostInstance(HostInstance : HostInstance) {
neg HostInstance.applications(HostInstance, _);
}
private pattern unallocatedAppInstance(App : ApplicationInstance) {
neg ApplicationInstance.allocatedTo(App, _);
}
private pattern requiredAppInstances(Req : Requirement, Remaining : java Integer) {
Instances == count find satisfyingInstance(Req, _);
Requirement.count(Req, RequiredCount);
Remaining == eval(RequiredCount - Instances);
}
private pattern noHostToAllocateTo(App : ApplicationInstance) {
find unallocatedAppInstance(App);
neg find allocate(App, _);
}
pattern guidanceObjective(Value : java Integer) {
UnallocatedInstances == count find unallocatedAppInstance(_);
RequiredInstances == sum find requiredAppInstances(_, #_);
NoHostToAllocate == count find noHostToAllocateTo(_);
Value == eval(2 * UnallocatedInstances + 4 * RequiredInstances + NoHostToAllocate);
}
|
