Formalize CPS case study for optimization

1 files changed, 132 insertions, 0 deletions

diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
new file mode 100644
index 00000000..7f7cc5a4
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
@@ -0,0 +1,132 @@
+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);
+}
+
+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);
+}