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
|
package hu.bme.mit.inf.dslreasoner.domains.cps.queries
import "http://www.eclipse.org/emf/2002/Ecore"
import "http://www.example.org/cps"
@QueryBasedFeature(feature = "applications")
pattern cpsApplications(Cps : CyberPhysicalSystem, AppInstance : ApplicationInstance) {
CyberPhysicalSystem.applicationTypes.instances(Cps, AppInstance);
}
@QueryBasedFeature(feature = "hosts")
pattern cpsHosts(Cps : CyberPhysicalSystem, HostInstance : HostInstance) {
CyberPhysicalSystem.hostTypes.instances(Cps, HostInstance);
}
@QueryBasedFeature(feature = "totalMemory")
pattern totalMemory(Host : HostInstance, Memory : EInt) {
HostInstance.type.defaultMemory(Host, Memory);
}
@QueryBasedFeature(feature = "totalHdd")
pattern totalHdd(Host : HostInstance, Hdd : EInt) {
HostInstance.type.defaultHdd(Host, Hdd);
}
@QueryBasedFeature(feature = "availableMemory")
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);
}
@QueryBasedFeature(feature = "availableHdd")
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);
}
private 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);
}
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);
}
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);
}
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);
}
|
