1 files changed, 117 insertions, 0 deletions

diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/generator/CpsGenerator.xtend b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/generator/CpsGenerator.xtend
new file mode 100644
index 00000000..e8d29949
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/generator/CpsGenerator.xtend
@@ -0,0 +1,117 @@
+package hu.bme.mit.inf.dslreasoner.domains.cps.generator
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.CpsFactory
+import hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem
+import hu.bme.mit.inf.dslreasoner.domains.cps.HostType
+import java.util.Collection
+import java.util.Random
+import org.eclipse.emf.common.util.URI
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl
+
+class CpsGenerator {
+        extension val CpsFactory = CpsFactory.eINSTANCE
+
+        static val MIN_MEMORY = 1
+        static val MAX_MEMORY = 6
+        static val MIN_HDD = 1
+        static val MAX_HDD = 30
+        static val HIGH_CPU_FRACTION = 4
+        static val MIN_REPLICAS = 1
+        static val MAX_REPLICAS = 4
+
+        val Random random
+        val int applicationTypeCount
+        val int demandFactor
+        val boolean populateAppInstances
+
+        new(long randomSeed, int applicationTypeCount, int demandFactor) {
+                this(randomSeed, applicationTypeCount, demandFactor, false)
+        }
+
+        new(long randomSeed, int applicationTypeCount, int demandFactor, boolean populateAppInstances) {
+                this.random = new Random(randomSeed)
+                this.applicationTypeCount = applicationTypeCount
+                this.demandFactor = demandFactor
+                this.populateAppInstances = populateAppInstances
+        }
+
+        def generateCpsProblem() {
+                val resourceSet = new ResourceSetImpl
+                val resource = resourceSet.createResource(URI.createFileURI("dummy.dummyext"))
+                createCyberPhysicalSystem => [
+                        val cps = it
+                        resource.contents += cps
+                        createLowCpuHostTypes
+                        val highCpuHostTypes = createHighCpuHostTypes
+                        for (var int i = 0; i < applicationTypeCount; i++) {
+                                if (i % HIGH_CPU_FRACTION == 0) {
+                                        createRandomApplicationType(highCpuHostTypes)
+                                } else {
+                                        createRandomApplicationType(hostTypes)
+                                }
+                        }
+                        for (var int i = 0; i < demandFactor; i++) {
+                                requests += createRequest => [
+                                        for (appType : cps.applicationTypes) {
+                                                requirements += createRequirement => [
+                                                        count = nextInt(CpsGenerator.MIN_REPLICAS, CpsGenerator.MAX_REPLICAS)
+                                                        type = appType
+                                                        if (populateAppInstances) {
+                                                                for (j : 0 ..< count) {
+                                                                        val app = createApplicationInstance
+                                                                        app.type = appType
+                                                                        appType.instances += app
+                                                                        instances += app
+                                                                }
+                                                        }
+                                                ]
+                                        }
+                                ]
+                        }
+                ]
+        }
+
+        private def void createRandomApplicationType(CyberPhysicalSystem it, Collection<HostType> allowedHostTypes) {
+                val appType = createApplicationType
+                val memory = nextInt(MIN_MEMORY, MAX_MEMORY)
+                val hdd = nextInt(MIN_HDD, MAX_HDD)
+                for (hostType : allowedHostTypes) {
+                        appType.requirements += createResourceRequirement => [
+                                it.hostType = hostType
+                                requiredMemory = memory
+                                requiredHdd = hdd
+                        ]
+                }
+                applicationTypes += appType
+        }
+
+        private def createLowCpuHostTypes(CyberPhysicalSystem it) {
+                #[
+                        createHostType(2, 8, 75), // m5d.large
+                        createHostType(4, 16, 150), // m5d.xlarge
+                        createHostType(3, 16, 75), // r5d.large
+                        createHostType(6, 32, 150) // r5d.xlarge
+                ]
+        }
+
+        private def createHighCpuHostTypes(CyberPhysicalSystem it) {
+                #[
+                        createHostType(2, 4, 50), // c5d.large
+                        createHostType(4, 8, 100) // c5d.xlarge
+                ]
+        }
+
+        private def createHostType(CyberPhysicalSystem it, int cost, int memory, int hdd) {
+                val hostType = createHostType => [
+                        it.cost = cost
+                        defaultMemory = memory
+                        defaultHdd = hdd
+                ]
+                hostTypes += hostType
+                hostType
+        }
+
+        private def nextInt(int lower, int upper) {
+                lower + random.nextInt(upper - lower + 1)
+        }
+}