From fd3684b5440dacca0c4bf4be15930555a79e2100 Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Tue, 21 May 2019 17:00:01 -0400 Subject: VIATRA DSE and COIN-OR CBC implementations of CPS case study --- .../domains/cps/cplex/.CbcCpsMain.xtendbin | Bin 0 -> 5693 bytes .../domains/cps/cplex/.CpsToLpTranslator.xtendbin | Bin 0 -> 11104 bytes .../inf/dslreasoner/domains/cps/cplex/.gitignore | 2 + .../dslreasoner/domains/cps/cplex/CbcCpsMain.java | 77 ++++ .../domains/cps/cplex/CpsToLpTranslator.java | 505 +++++++++++++++++++++ .../domains/cps/dse/.CpsStateCoder.xtendbin | Bin 0 -> 7626 bytes .../domains/cps/dse/.RuleBasedCpsMain.xtendbin | Bin 0 -> 5189 bytes .../domains/cps/dse/.RuleBasedCpsSolver.xtendbin | Bin 0 -> 7336 bytes .../mit/inf/dslreasoner/domains/cps/dse/.gitignore | 3 + .../dslreasoner/domains/cps/dse/CpsStateCoder.java | 316 +++++++++++++ .../domains/cps/dse/RuleBasedCpsMain.java | 46 ++ .../domains/cps/dse/RuleBasedCpsSolver.java | 93 ++++ .../domains/cps/generator/.CpsGenerator.xtendbin | Bin 0 -> 8807 bytes .../domains/cps/generator/CpsGenerator.java | 154 +++++++ 14 files changed, 1196 insertions(+) create mode 100644 Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.CbcCpsMain.xtendbin create mode 100644 Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.CpsToLpTranslator.xtendbin create mode 100644 Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.gitignore create mode 100644 Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CbcCpsMain.java create mode 100644 Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CpsToLpTranslator.java create mode 100644 Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.CpsStateCoder.xtendbin create mode 100644 Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.RuleBasedCpsMain.xtendbin create mode 100644 Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.RuleBasedCpsSolver.xtendbin create mode 100644 Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.gitignore create mode 100644 Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/CpsStateCoder.java create mode 100644 Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/RuleBasedCpsMain.java create mode 100644 Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/RuleBasedCpsSolver.java create mode 100644 Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/.CpsGenerator.xtendbin create mode 100644 Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/CpsGenerator.java (limited to 'Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen') diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.CbcCpsMain.xtendbin b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.CbcCpsMain.xtendbin new file mode 100644 index 00000000..3f9e895d Binary files /dev/null and b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.CbcCpsMain.xtendbin differ diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.CpsToLpTranslator.xtendbin b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.CpsToLpTranslator.xtendbin new file mode 100644 index 00000000..d8814a3b Binary files /dev/null and b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.CpsToLpTranslator.xtendbin differ diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.gitignore b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.gitignore new file mode 100644 index 00000000..9f908c7a --- /dev/null +++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.gitignore @@ -0,0 +1,2 @@ +/.CpsToLpTranslator.java._trace +/.CbcCpsMain.java._trace diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CbcCpsMain.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CbcCpsMain.java new file mode 100644 index 00000000..d36cdccd --- /dev/null +++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CbcCpsMain.java @@ -0,0 +1,77 @@ +package hu.bme.mit.inf.dslreasoner.domains.cps.cplex; + +import hu.bme.mit.inf.dslreasoner.domains.cps.CpsPackage; +import hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem; +import hu.bme.mit.inf.dslreasoner.domains.cps.cplex.CpsToLpTranslator; +import hu.bme.mit.inf.dslreasoner.domains.cps.generator.CpsGenerator; +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.FileReader; +import java.io.FileWriter; +import java.util.Map; +import java.util.concurrent.TimeUnit; +import java.util.function.Consumer; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl; +import org.eclipse.xtext.xbase.lib.Exceptions; +import org.eclipse.xtext.xbase.lib.InputOutput; + +@SuppressWarnings("all") +public class CbcCpsMain { + private static final String PROBLEM_FILE = "problem.lp"; + + private static final String SOLUTION_FILE = "solution.txt"; + + private CbcCpsMain() { + new IllegalStateException("This is a static utility class and should not be instantiated directly."); + } + + public static void main(final String[] args) { + try { + Map _extensionToFactoryMap = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap(); + XMIResourceFactoryImpl _xMIResourceFactoryImpl = new XMIResourceFactoryImpl(); + _extensionToFactoryMap.put(Resource.Factory.Registry.DEFAULT_EXTENSION, _xMIResourceFactoryImpl); + EPackage.Registry.INSTANCE.put(CpsPackage.eNS_URI, CpsPackage.eINSTANCE); + final CpsGenerator generator = new CpsGenerator(1, 4, 1); + final CyberPhysicalSystem problem = generator.generateCpsProblem(); + final CpsToLpTranslator toLp = new CpsToLpTranslator(problem, 10, true); + final CharSequence lp = toLp.getLpProblem(); + FileWriter _fileWriter = new FileWriter(CbcCpsMain.PROBLEM_FILE); + final BufferedWriter writer = new BufferedWriter(_fileWriter); + try { + writer.append(lp); + } finally { + writer.close(); + } + final Process process = new ProcessBuilder().inheritIO().command("cbc", CbcCpsMain.PROBLEM_FILE, "solve", "solu", CbcCpsMain.SOLUTION_FILE).start(); + boolean _waitFor = process.waitFor(120, TimeUnit.SECONDS); + boolean _not = (!_waitFor); + if (_not) { + System.err.println("Timeout reached"); + process.destroyForcibly(); + System.exit((-1)); + } + int _exitValue = process.exitValue(); + boolean _notEquals = (_exitValue != 0); + if (_notEquals) { + int _exitValue_1 = process.exitValue(); + String _plus = ("Unexpected exit value " + Integer.valueOf(_exitValue_1)); + System.err.println(_plus); + System.exit((-1)); + } + FileReader _fileReader = new FileReader(CbcCpsMain.SOLUTION_FILE); + final BufferedReader reader = new BufferedReader(_fileReader); + try { + final Consumer _function = (String it) -> { + InputOutput.println(it); + }; + reader.lines().forEach(_function); + } finally { + reader.close(); + } + } catch (Throwable _e) { + throw Exceptions.sneakyThrow(_e); + } + } +} diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CpsToLpTranslator.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CpsToLpTranslator.java new file mode 100644 index 00000000..20afeee6 --- /dev/null +++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CpsToLpTranslator.java @@ -0,0 +1,505 @@ +package hu.bme.mit.inf.dslreasoner.domains.cps.cplex; + +import com.google.common.base.Objects; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationType; +import hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem; +import hu.bme.mit.inf.dslreasoner.domains.cps.HostType; +import hu.bme.mit.inf.dslreasoner.domains.cps.Request; +import hu.bme.mit.inf.dslreasoner.domains.cps.Requirement; +import hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement; +import java.util.Collection; +import java.util.List; +import java.util.Map; +import org.eclipse.emf.common.util.EList; +import org.eclipse.xtend2.lib.StringConcatenation; +import org.eclipse.xtext.xbase.lib.CollectionLiterals; +import org.eclipse.xtext.xbase.lib.ExclusiveRange; +import org.eclipse.xtext.xbase.lib.Functions.Function1; +import org.eclipse.xtext.xbase.lib.IterableExtensions; +import org.eclipse.xtext.xbase.lib.ListExtensions; +import org.eclipse.xtext.xbase.lib.Pair; + +@SuppressWarnings("all") +public class CpsToLpTranslator { + private static final double MINIMUM_MEMORY_USAGE = 0.25; + + private static final double MINIMUM_HDD_USAGE = 0.25; + + private final CyberPhysicalSystem cps; + + private final Map> appInstances; + + private final Map> hostInstances; + + private final boolean breakSymmetry; + + public CpsToLpTranslator(final CyberPhysicalSystem cps, final int hostInstanceCount, final boolean breakSymmetry) { + this.cps = cps; + this.appInstances = this.createAppInstances(); + this.hostInstances = this.createHostInstances(hostInstanceCount); + this.breakSymmetry = breakSymmetry; + } + + private ImmutableMap> createAppInstances() { + ImmutableMap> _xblockexpression = null; + { + final ImmutableMap.Builder> builder = ImmutableMap.>builder(); + int i = 0; + Iterable _requirements = this.getRequirements(); + for (final Requirement req : _requirements) { + { + final ImmutableList.Builder listBuilder = ImmutableList.builder(); + for (int j = 0; (j < req.getCount()); j++) { + StringConcatenation _builder = new StringConcatenation(); + _builder.append("r"); + _builder.append(i); + _builder.append("a"); + _builder.append(j); + listBuilder.add(_builder.toString()); + } + builder.put(req, listBuilder.build()); + i++; + } + } + _xblockexpression = builder.build(); + } + return _xblockexpression; + } + + private ImmutableMap> createHostInstances(final int hostInstanceCount) { + ImmutableMap> _xblockexpression = null; + { + final ImmutableMap.Builder> builder = ImmutableMap.>builder(); + int i = 0; + EList _hostTypes = this.cps.getHostTypes(); + for (final HostType hostType : _hostTypes) { + { + final ImmutableList.Builder listBuilder = ImmutableList.builder(); + for (int j = 0; (j < hostInstanceCount); j++) { + StringConcatenation _builder = new StringConcatenation(); + _builder.append("h"); + _builder.append(i); + _builder.append("i"); + _builder.append(j); + listBuilder.add(_builder.toString()); + } + builder.put(hostType, listBuilder.build()); + i++; + } + } + _xblockexpression = builder.build(); + } + return _xblockexpression; + } + + public CharSequence getLpProblem() { + StringConcatenation _builder = new StringConcatenation(); + _builder.append("Minimize"); + _builder.newLine(); + _builder.append("\t"); + _builder.append("total_cost: "); + CharSequence _objective = this.getObjective(); + _builder.append(_objective, "\t"); + _builder.newLineIfNotEmpty(); + _builder.append("Subject To"); + _builder.newLine(); + _builder.append("\t"); + CharSequence _constraints = this.getConstraints(); + _builder.append(_constraints, "\t"); + _builder.newLineIfNotEmpty(); + _builder.append("Bounds"); + _builder.newLine(); + _builder.append("\t"); + CharSequence _bounds = this.getBounds(); + _builder.append(_bounds, "\t"); + _builder.newLineIfNotEmpty(); + _builder.append("Binary"); + _builder.newLine(); + _builder.append("\t"); + CharSequence _binaryVariables = this.getBinaryVariables(); + _builder.append(_binaryVariables, "\t"); + _builder.newLineIfNotEmpty(); + _builder.append("End"); + _builder.newLine(); + return _builder; + } + + private CharSequence getObjective() { + StringConcatenation _builder = new StringConcatenation(); + { + Iterable> _hostInstancesWithType = this.getHostInstancesWithType(); + boolean _hasElements = false; + for(final Pair pair : _hostInstancesWithType) { + if (!_hasElements) { + _hasElements = true; + } else { + _builder.appendImmediate(" + ", ""); + } + int _cost = pair.getKey().getCost(); + _builder.append(_cost); + _builder.append(" "); + CharSequence _existsVariable = this.getExistsVariable(pair.getValue()); + _builder.append(_existsVariable); + } + } + return _builder; + } + + private CharSequence getConstraints() { + StringConcatenation _builder = new StringConcatenation(); + { + Iterable> _appInstancesWithType = this.getAppInstancesWithType(); + for(final Pair appPair : _appInstancesWithType) { + String _value = appPair.getValue(); + _builder.append(_value); + _builder.append("_allocated: "); + { + Iterable _possibleHostInstances = this.getPossibleHostInstances(appPair.getKey()); + boolean _hasElements = false; + for(final String host : _possibleHostInstances) { + if (!_hasElements) { + _hasElements = true; + } else { + _builder.appendImmediate(" + ", ""); + } + CharSequence _allocatedToVariable = this.getAllocatedToVariable(appPair.getValue(), host); + _builder.append(_allocatedToVariable); + } + } + _builder.append(" = 1"); + _builder.newLineIfNotEmpty(); + { + Iterable _possibleHostInstances_1 = this.getPossibleHostInstances(appPair.getKey()); + for(final String host_1 : _possibleHostInstances_1) { + String _value_1 = appPair.getValue(); + _builder.append(_value_1); + _builder.append("_to_"); + _builder.append(host_1); + _builder.append("_exists: "); + CharSequence _existsVariable = this.getExistsVariable(host_1); + _builder.append(_existsVariable); + _builder.append(" - "); + CharSequence _allocatedToVariable_1 = this.getAllocatedToVariable(appPair.getValue(), host_1); + _builder.append(_allocatedToVariable_1); + _builder.append(" >= 0"); + _builder.newLineIfNotEmpty(); + } + } + } + } + { + Iterable> _hostInstancesWithType = this.getHostInstancesWithType(); + for(final Pair hostPair : _hostInstancesWithType) { + String _value_2 = hostPair.getValue(); + _builder.append(_value_2); + _builder.append("_mem_use: "); + { + Iterable> _possibleAppInstancesWithRequirements = this.getPossibleAppInstancesWithRequirements(hostPair.getKey()); + boolean _hasElements_1 = false; + for(final Pair appPair_1 : _possibleAppInstancesWithRequirements) { + if (!_hasElements_1) { + _hasElements_1 = true; + } else { + _builder.appendImmediate(" + ", ""); + } + int _requiredMemory = appPair_1.getKey().getRequiredMemory(); + _builder.append(_requiredMemory); + _builder.append(" "); + CharSequence _allocatedToVariable_2 = this.getAllocatedToVariable(appPair_1.getValue(), hostPair.getValue()); + _builder.append(_allocatedToVariable_2); + } + } + _builder.append(" - "); + int _defaultMemory = hostPair.getKey().getDefaultMemory(); + _builder.append(_defaultMemory); + _builder.append(" "); + CharSequence _memoryUsageVariable = this.getMemoryUsageVariable(hostPair.getValue()); + _builder.append(_memoryUsageVariable); + _builder.append(" = 0"); + _builder.newLineIfNotEmpty(); + String _value_3 = hostPair.getValue(); + _builder.append(_value_3); + _builder.append("_hdd_use: "); + { + Iterable> _possibleAppInstancesWithRequirements_1 = this.getPossibleAppInstancesWithRequirements(hostPair.getKey()); + boolean _hasElements_2 = false; + for(final Pair appPair_2 : _possibleAppInstancesWithRequirements_1) { + if (!_hasElements_2) { + _hasElements_2 = true; + } else { + _builder.appendImmediate(" + ", ""); + } + int _requiredHdd = appPair_2.getKey().getRequiredHdd(); + _builder.append(_requiredHdd); + _builder.append(" "); + CharSequence _allocatedToVariable_3 = this.getAllocatedToVariable(appPair_2.getValue(), hostPair.getValue()); + _builder.append(_allocatedToVariable_3); + } + } + _builder.append(" - "); + int _defaultHdd = hostPair.getKey().getDefaultHdd(); + _builder.append(_defaultHdd); + _builder.append(" "); + CharSequence _hddUsageVariable = this.getHddUsageVariable(hostPair.getValue()); + _builder.append(_hddUsageVariable); + _builder.append(" = 0"); + _builder.newLineIfNotEmpty(); + } + } + _builder.append("average_mem: "); + { + Iterable _allHostInstances = this.getAllHostInstances(); + boolean _hasElements_3 = false; + for(final String host_2 : _allHostInstances) { + if (!_hasElements_3) { + _hasElements_3 = true; + } else { + _builder.appendImmediate(" + ", ""); + } + CharSequence _memoryUsageVariable_1 = this.getMemoryUsageVariable(host_2); + _builder.append(_memoryUsageVariable_1); + _builder.append(" - "); + _builder.append(CpsToLpTranslator.MINIMUM_MEMORY_USAGE); + _builder.append(" "); + CharSequence _existsVariable_1 = this.getExistsVariable(host_2); + _builder.append(_existsVariable_1); + } + } + _builder.append(" >= 0"); + _builder.newLineIfNotEmpty(); + _builder.append("average_hdd: "); + { + Iterable _allHostInstances_1 = this.getAllHostInstances(); + boolean _hasElements_4 = false; + for(final String host_3 : _allHostInstances_1) { + if (!_hasElements_4) { + _hasElements_4 = true; + } else { + _builder.appendImmediate(" + ", ""); + } + CharSequence _memoryUsageVariable_2 = this.getMemoryUsageVariable(host_3); + _builder.append(_memoryUsageVariable_2); + _builder.append(" - "); + _builder.append(CpsToLpTranslator.MINIMUM_HDD_USAGE); + _builder.append(" "); + CharSequence _existsVariable_2 = this.getExistsVariable(host_3); + _builder.append(_existsVariable_2); + } + } + _builder.append(" >= 0"); + _builder.newLineIfNotEmpty(); + { + final Function1 _function = (Requirement it) -> { + int _count = it.getCount(); + return Boolean.valueOf((_count > 1)); + }; + Iterable> _indexed = IterableExtensions.indexed(IterableExtensions.filter(this.getRequirements(), _function)); + for(final Pair reqPair : _indexed) { + { + final Function1> _function_1 = (ResourceRequirement it) -> { + return this.hostInstances.get(it.getHostType()); + }; + Iterable _flatMap = IterableExtensions.flatMap(reqPair.getValue().getType().getRequirements(), _function_1); + for(final String host_4 : _flatMap) { + _builder.append("r"); + Integer _key = reqPair.getKey(); + _builder.append(_key); + _builder.append("_"); + _builder.append(host_4); + _builder.append("_redundant: "); + { + List _get = this.appInstances.get(reqPair.getValue()); + boolean _hasElements_5 = false; + for(final String app : _get) { + if (!_hasElements_5) { + _hasElements_5 = true; + } else { + _builder.appendImmediate(" + ", ""); + } + CharSequence _allocatedToVariable_4 = this.getAllocatedToVariable(app, host_4); + _builder.append(_allocatedToVariable_4); + } + } + _builder.append(" <= 1"); + _builder.newLineIfNotEmpty(); + } + } + } + } + { + if (this.breakSymmetry) { + { + Collection> _values = this.hostInstances.values(); + for(final List hosts : _values) { + { + int _size = hosts.size(); + int _minus = (_size - 1); + ExclusiveRange _doubleDotLessThan = new ExclusiveRange(0, _minus, true); + for(final Integer i : _doubleDotLessThan) { + String _get_1 = hosts.get(((i).intValue() + 1)); + _builder.append(_get_1); + _builder.append("_after_"); + String _get_2 = hosts.get((i).intValue()); + _builder.append(_get_2); + _builder.append(": "); + CharSequence _existsVariable_3 = this.getExistsVariable(hosts.get((i).intValue())); + _builder.append(_existsVariable_3); + _builder.append(" - "); + CharSequence _existsVariable_4 = this.getExistsVariable(hosts.get(((i).intValue() + 1))); + _builder.append(_existsVariable_4); + _builder.append(" >= 0"); + _builder.newLineIfNotEmpty(); + } + } + } + } + } + } + return _builder; + } + + private CharSequence getBounds() { + StringConcatenation _builder = new StringConcatenation(); + { + Iterable _allHostInstances = this.getAllHostInstances(); + for(final String host : _allHostInstances) { + _builder.append("0 <= "); + CharSequence _memoryUsageVariable = this.getMemoryUsageVariable(host); + _builder.append(_memoryUsageVariable); + _builder.append(" <= 1"); + _builder.newLineIfNotEmpty(); + _builder.append("0 <= "); + CharSequence _hddUsageVariable = this.getHddUsageVariable(host); + _builder.append(_hddUsageVariable); + _builder.append(" <= 1"); + _builder.newLineIfNotEmpty(); + } + } + return _builder; + } + + private CharSequence getBinaryVariables() { + StringConcatenation _builder = new StringConcatenation(); + { + Iterable _allHostInstances = this.getAllHostInstances(); + for(final String host : _allHostInstances) { + CharSequence _existsVariable = this.getExistsVariable(host); + _builder.append(_existsVariable); + _builder.newLineIfNotEmpty(); + } + } + { + Iterable> _appInstancesWithType = this.getAppInstancesWithType(); + for(final Pair appPair : _appInstancesWithType) { + { + Iterable _possibleHostInstances = this.getPossibleHostInstances(appPair.getKey()); + for(final String host_1 : _possibleHostInstances) { + CharSequence _allocatedToVariable = this.getAllocatedToVariable(appPair.getValue(), host_1); + _builder.append(_allocatedToVariable); + _builder.newLineIfNotEmpty(); + } + } + } + } + return _builder; + } + + private Iterable getRequirements() { + final Function1> _function = (Request it) -> { + return it.getRequirements(); + }; + return IterableExtensions.flatMap(this.cps.getRequests(), _function); + } + + private Iterable getAllHostInstances() { + final Function1, List> _function = (List it) -> { + return it; + }; + return IterableExtensions.flatMap(this.hostInstances.values(), _function); + } + + private Iterable> getHostInstancesWithType() { + final Function1>, List>> _function = (Map.Entry> pair) -> { + final Function1> _function_1 = (String it) -> { + HostType _key = pair.getKey(); + return Pair.of(_key, it); + }; + return ListExtensions.>map(pair.getValue(), _function_1); + }; + return IterableExtensions.flatMap(this.hostInstances.entrySet(), _function); + } + + private Iterable> getAppInstancesWithType() { + final Function1>, List>> _function = (Map.Entry> pair) -> { + final Function1> _function_1 = (String it) -> { + ApplicationType _type = pair.getKey().getType(); + return Pair.of(_type, it); + }; + return ListExtensions.>map(pair.getValue(), _function_1); + }; + return IterableExtensions.flatMap(this.appInstances.entrySet(), _function); + } + + private Iterable getPossibleHostInstances(final ApplicationType appType) { + final Function1> _function = (ResourceRequirement req) -> { + return this.hostInstances.get(req.getHostType()); + }; + return IterableExtensions.flatMap(appType.getRequirements(), _function); + } + + private Iterable> getPossibleAppInstancesWithRequirements(final HostType hostType) { + final Function1>, List>> _function = (Map.Entry> pair) -> { + List> _xblockexpression = null; + { + final Function1 _function_1 = (ResourceRequirement it) -> { + HostType _hostType = it.getHostType(); + return Boolean.valueOf(Objects.equal(_hostType, hostType)); + }; + final ResourceRequirement resourceReq = IterableExtensions.findFirst(pair.getKey().getType().getRequirements(), _function_1); + List> _xifexpression = null; + if ((resourceReq == null)) { + _xifexpression = CollectionLiterals.>emptyList(); + } else { + final Function1> _function_2 = (String it) -> { + return Pair.of(resourceReq, it); + }; + _xifexpression = ListExtensions.>map(pair.getValue(), _function_2); + } + _xblockexpression = _xifexpression; + } + return _xblockexpression; + }; + return IterableExtensions.flatMap(this.appInstances.entrySet(), _function); + } + + private CharSequence getExistsVariable(final String hostInstance) { + StringConcatenation _builder = new StringConcatenation(); + _builder.append(hostInstance); + _builder.append("_exists"); + return _builder; + } + + private CharSequence getMemoryUsageVariable(final String hostInstance) { + StringConcatenation _builder = new StringConcatenation(); + _builder.append(hostInstance); + _builder.append("_mem"); + return _builder; + } + + private CharSequence getHddUsageVariable(final String hostInstance) { + StringConcatenation _builder = new StringConcatenation(); + _builder.append(hostInstance); + _builder.append("_hdd"); + return _builder; + } + + private CharSequence getAllocatedToVariable(final String appInstance, final String hostInstance) { + StringConcatenation _builder = new StringConcatenation(); + _builder.append(appInstance); + _builder.append("_to_"); + _builder.append(hostInstance); + return _builder; + } +} diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.CpsStateCoder.xtendbin b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.CpsStateCoder.xtendbin new file mode 100644 index 00000000..cdfe3921 Binary files /dev/null and b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.CpsStateCoder.xtendbin differ diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.RuleBasedCpsMain.xtendbin b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.RuleBasedCpsMain.xtendbin new file mode 100644 index 00000000..9be64b30 Binary files /dev/null and b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.RuleBasedCpsMain.xtendbin differ diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.RuleBasedCpsSolver.xtendbin b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.RuleBasedCpsSolver.xtendbin new file mode 100644 index 00000000..02fb74ef Binary files /dev/null and b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.RuleBasedCpsSolver.xtendbin differ diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.gitignore b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.gitignore new file mode 100644 index 00000000..e24f10f4 --- /dev/null +++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.gitignore @@ -0,0 +1,3 @@ +/.RuleBasedCpsSolver.java._trace +/.RuleBasedCpsMain.java._trace +/.CpsStateCoder.java._trace diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/CpsStateCoder.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/CpsStateCoder.java new file mode 100644 index 00000000..3ae8e828 --- /dev/null +++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/CpsStateCoder.java @@ -0,0 +1,316 @@ +package hu.bme.mit.inf.dslreasoner.domains.cps.dse; + +import com.google.common.base.Objects; +import hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance; +import hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem; +import hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance; +import hu.bme.mit.inf.dslreasoner.domains.cps.HostType; +import hu.bme.mit.inf.dslreasoner.domains.cps.Request; +import hu.bme.mit.inf.dslreasoner.domains.cps.Requirement; +import java.util.Arrays; +import org.eclipse.emf.common.notify.Notifier; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.ecore.resource.ResourceSet; +import org.eclipse.viatra.dse.statecode.IStateCoder; +import org.eclipse.viatra.dse.statecode.IStateCoderFactory; +import org.eclipse.viatra.query.runtime.api.IPatternMatch; +import org.eclipse.xtend2.lib.StringConcatenation; +import org.eclipse.xtend2.lib.StringConcatenationClient; +import org.eclipse.xtext.xbase.lib.IterableExtensions; + +@SuppressWarnings("all") +public class CpsStateCoder implements IStateCoder { + public static class Factory implements IStateCoderFactory { + @Override + public IStateCoder createStateCoder() { + return new CpsStateCoder(); + } + } + + private CyberPhysicalSystem cps; + + protected CpsStateCoder() { + } + + @Override + public void init(final Notifier notifier) { + CyberPhysicalSystem _switchResult = null; + boolean _matched = false; + if (notifier instanceof ResourceSet) { + _matched=true; + _switchResult = this.getCpsFromResourceSet(((ResourceSet)notifier)); + } + if (!_matched) { + if (notifier instanceof Resource) { + _matched=true; + _switchResult = this.getCpsFromResource(((Resource)notifier)); + } + } + if (!_matched) { + if (notifier instanceof CyberPhysicalSystem) { + _matched=true; + _switchResult = ((CyberPhysicalSystem)notifier); + } + } + if (!_matched) { + throw new IllegalArgumentException("notifier is not a CyberPhysicalSystem"); + } + this.cps = _switchResult; + } + + private CyberPhysicalSystem getCpsFromResourceSet(final ResourceSet resourceSet) { + CyberPhysicalSystem _xblockexpression = null; + { + boolean _isEmpty = resourceSet.getResources().isEmpty(); + if (_isEmpty) { + throw new IllegalArgumentException("No Resource in ResourceSet"); + } + final Resource resource = IterableExtensions.head(resourceSet.getResources()); + _xblockexpression = this.getCpsFromResource(resource); + } + return _xblockexpression; + } + + private CyberPhysicalSystem getCpsFromResource(final Resource resource) { + CyberPhysicalSystem _xblockexpression = null; + { + boolean _isEmpty = resource.getContents().isEmpty(); + if (_isEmpty) { + throw new IllegalArgumentException("No EObject in Resource"); + } + final EObject cps = IterableExtensions.head(resource.getContents()); + CyberPhysicalSystem _xifexpression = null; + if ((cps instanceof CyberPhysicalSystem)) { + _xifexpression = ((CyberPhysicalSystem)cps); + } else { + throw new IllegalArgumentException("EObject in Resource is not a CyberPhysicalSystem"); + } + _xblockexpression = _xifexpression; + } + return _xblockexpression; + } + + @Override + public String createStateCode() { + StringConcatenation _builder = new StringConcatenation(); + StringConcatenationClient _createRequestsCode = this.createRequestsCode(); + _builder.append(_createRequestsCode); + CharSequence _createHostTypesCode = this.createHostTypesCode(); + _builder.append(_createHostTypesCode); + return _builder.toString(); + } + + private StringConcatenationClient createRequestsCode() { + StringConcatenationClient _client = new StringConcatenationClient() { + @Override + protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) { + { + EList _requests = CpsStateCoder.this.cps.getRequests(); + for(final Request request : _requests) { + StringConcatenationClient _createRequestCode = CpsStateCoder.this.createRequestCode(request); + _builder.append(_createRequestCode); + } + } + } + }; + return _client; + } + + private StringConcatenationClient createRequestCode(final Request request) { + StringConcatenationClient _client = new StringConcatenationClient() { + @Override + protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) { + _builder.append("["); + { + EList _requirements = request.getRequirements(); + for(final Requirement requirement : _requirements) { + StringConcatenationClient _createRequirementCode = CpsStateCoder.this.createRequirementCode(requirement); + _builder.append(_createRequirementCode); + } + } + _builder.append("]"); + } + }; + return _client; + } + + private StringConcatenationClient createRequirementCode(final Requirement requirement) { + StringConcatenationClient _client = new StringConcatenationClient() { + @Override + protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) { + _builder.append("["); + { + EList _instances = requirement.getInstances(); + boolean _hasElements = false; + for(final ApplicationInstance app : _instances) { + if (!_hasElements) { + _hasElements = true; + } else { + _builder.appendImmediate(",", ""); + } + String _createAppCode = CpsStateCoder.this.createAppCode(app); + _builder.append(_createAppCode); + } + } + _builder.append("]"); + } + }; + return _client; + } + + private String createAppCode(final ApplicationInstance app) { + String _xifexpression = null; + HostInstance _allocatedTo = app.getAllocatedTo(); + boolean _tripleEquals = (_allocatedTo == null); + if (_tripleEquals) { + _xifexpression = "-"; + } else { + _xifexpression = this.createMatchArgumentCode(app.getAllocatedTo()); + } + return _xifexpression; + } + + private CharSequence createHostTypesCode() { + StringConcatenation _builder = new StringConcatenation(); + _builder.append("("); + { + EList _hostTypes = this.cps.getHostTypes(); + boolean _hasElements = false; + for(final HostType hostType : _hostTypes) { + if (!_hasElements) { + _hasElements = true; + } else { + _builder.appendImmediate(",", ""); + } + int _size = hostType.getInstances().size(); + _builder.append(_size); + } + } + _builder.append(")"); + return _builder; + } + + @Override + public String createActivationCode(final IPatternMatch match) { + StringConcatenation _builder = new StringConcatenation(); + String _simpleName = match.specification().getSimpleName(); + _builder.append(_simpleName); + _builder.append("("); + { + Object[] _array = match.toArray(); + boolean _hasElements = false; + for(final Object arg : _array) { + if (!_hasElements) { + _hasElements = true; + } else { + _builder.appendImmediate(",", ""); + } + String _createMatchArgumentCode = this.createMatchArgumentCode(arg); + _builder.append(_createMatchArgumentCode); + } + } + _builder.append(")"); + return _builder.toString(); + } + + protected String _createMatchArgumentCode(final Requirement requirement) { + String _xblockexpression = null; + { + final EObject request = requirement.eContainer(); + String _xifexpression = null; + if ((request instanceof Request)) { + String _xblockexpression_1 = null; + { + EObject _eContainer = ((Request)request).eContainer(); + boolean _notEquals = (!Objects.equal(_eContainer, this.cps)); + if (_notEquals) { + throw new IllegalArgumentException("Request is not contained in the CPS"); + } + final int requestIndex = this.cps.getRequests().indexOf(request); + final int requirementIndex = ((Request)request).getRequirements().indexOf(requirement); + String _plus = (Integer.valueOf(requestIndex) + "."); + _xblockexpression_1 = (_plus + Integer.valueOf(requirementIndex)); + } + _xifexpression = _xblockexpression_1; + } else { + throw new IllegalArgumentException("Requirement is not contained in a request"); + } + _xblockexpression = _xifexpression; + } + return _xblockexpression; + } + + protected String _createMatchArgumentCode(final ApplicationInstance app) { + String _xblockexpression = null; + { + final Requirement requirement = app.getRequirement(); + if ((requirement == null)) { + throw new IllegalArgumentException("Application instance is not associated with a requirement"); + } + final int instanceIndex = requirement.getInstances().indexOf(app); + String _createMatchArgumentCode = this.createMatchArgumentCode(requirement); + String _plus = (_createMatchArgumentCode + "."); + _xblockexpression = (_plus + Integer.valueOf(instanceIndex)); + } + return _xblockexpression; + } + + protected String _createMatchArgumentCode(final HostInstance host) { + String _xblockexpression = null; + { + final EObject hostType = host.eContainer(); + String _xifexpression = null; + if ((hostType instanceof HostType)) { + String _xblockexpression_1 = null; + { + final int hostIndex = ((HostType)hostType).getInstances().indexOf(host); + String _createMatchArgumentCode = this.createMatchArgumentCode(hostType); + String _plus = (_createMatchArgumentCode + "."); + _xblockexpression_1 = (_plus + Integer.valueOf(hostIndex)); + } + _xifexpression = _xblockexpression_1; + } else { + throw new IllegalArgumentException("Host is not contained in a host type"); + } + _xblockexpression = _xifexpression; + } + return _xblockexpression; + } + + protected String _createMatchArgumentCode(final HostType hostType) { + String _xblockexpression = null; + { + EObject _eContainer = hostType.eContainer(); + boolean _notEquals = (!Objects.equal(_eContainer, this.cps)); + if (_notEquals) { + throw new IllegalArgumentException("Host type is not contained in the CPS"); + } + final int hostTypeIndex = this.cps.getHostTypes().indexOf(hostType); + _xblockexpression = Integer.valueOf(hostTypeIndex).toString(); + } + return _xblockexpression; + } + + protected String _createMatchArgumentCode(final Object object) { + throw new IllegalArgumentException("Unknown match argument: "); + } + + protected String createMatchArgumentCode(final Object app) { + if (app instanceof ApplicationInstance) { + return _createMatchArgumentCode((ApplicationInstance)app); + } else if (app instanceof HostInstance) { + return _createMatchArgumentCode((HostInstance)app); + } else if (app instanceof HostType) { + return _createMatchArgumentCode((HostType)app); + } else if (app instanceof Requirement) { + return _createMatchArgumentCode((Requirement)app); + } else if (app != null) { + return _createMatchArgumentCode(app); + } else { + throw new IllegalArgumentException("Unhandled parameter types: " + + Arrays.asList(app).toString()); + } + } +} diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/RuleBasedCpsMain.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/RuleBasedCpsMain.java new file mode 100644 index 00000000..7d81f84b --- /dev/null +++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/RuleBasedCpsMain.java @@ -0,0 +1,46 @@ +package hu.bme.mit.inf.dslreasoner.domains.cps.dse; + +import hu.bme.mit.inf.dslreasoner.domains.cps.CpsPackage; +import hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem; +import hu.bme.mit.inf.dslreasoner.domains.cps.dse.RuleBasedCpsSolver; +import hu.bme.mit.inf.dslreasoner.domains.cps.generator.CpsGenerator; +import hu.bme.mit.inf.dslreasoner.domains.cps.queries.CpsQueries; +import java.util.Map; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.emf.ecore.EStructuralFeature; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl; +import org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory; +import org.eclipse.viatra.addon.querybasedfeatures.runtime.handler.QueryBasedFeatures; +import org.eclipse.viatra.dse.api.DesignSpaceExplorer; +import org.eclipse.viatra.query.runtime.extensibility.SingletonQueryGroupProvider; +import org.eclipse.viatra.query.runtime.registry.IQuerySpecificationRegistry; +import org.eclipse.viatra.query.runtime.registry.QuerySpecificationRegistry; +import org.eclipse.viatra.query.runtime.registry.connector.QueryGroupProviderSourceConnector; + +@SuppressWarnings("all") +public class RuleBasedCpsMain { + private RuleBasedCpsMain() { + new IllegalStateException("This is a static utility class and should not be instantiated directly."); + } + + public static void main(final String[] args) { + DesignSpaceExplorer.turnOnLogging(DesignSpaceExplorer.DseLoggingLevel.VERBOSE_FULL); + Map _extensionToFactoryMap = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap(); + XMIResourceFactoryImpl _xMIResourceFactoryImpl = new XMIResourceFactoryImpl(); + _extensionToFactoryMap.put(Resource.Factory.Registry.DEFAULT_EXTENSION, _xMIResourceFactoryImpl); + QueryBasedFeatureSettingDelegateFactory _queryBasedFeatureSettingDelegateFactory = new QueryBasedFeatureSettingDelegateFactory(); + EStructuralFeature.Internal.SettingDelegate.Factory.Registry.INSTANCE.put(QueryBasedFeatures.ANNOTATION_SOURCE, _queryBasedFeatureSettingDelegateFactory); + EPackage.Registry.INSTANCE.put(CpsPackage.eNS_URI, CpsPackage.eINSTANCE); + IQuerySpecificationRegistry _instance = QuerySpecificationRegistry.getInstance(); + CpsQueries _instance_1 = CpsQueries.instance(); + SingletonQueryGroupProvider _singletonQueryGroupProvider = new SingletonQueryGroupProvider(_instance_1); + QueryGroupProviderSourceConnector _queryGroupProviderSourceConnector = new QueryGroupProviderSourceConnector("CpsQueries", _singletonQueryGroupProvider, + true); + _instance.addSource(_queryGroupProviderSourceConnector); + final CpsGenerator generator = new CpsGenerator(1, 4, 1); + final CyberPhysicalSystem problem = generator.generateCpsProblem(); + final RuleBasedCpsSolver solver = new RuleBasedCpsSolver(); + solver.solve(problem); + } +} diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/RuleBasedCpsSolver.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/RuleBasedCpsSolver.java new file mode 100644 index 00000000..fd348752 --- /dev/null +++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/RuleBasedCpsSolver.java @@ -0,0 +1,93 @@ +package hu.bme.mit.inf.dslreasoner.domains.cps.dse; + +import hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance; +import hu.bme.mit.inf.dslreasoner.domains.cps.CpsFactory; +import hu.bme.mit.inf.dslreasoner.domains.cps.CpsPackage; +import hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem; +import hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance; +import hu.bme.mit.inf.dslreasoner.domains.cps.dse.CpsStateCoder; +import hu.bme.mit.inf.dslreasoner.domains.cps.queries.Allocate; +import hu.bme.mit.inf.dslreasoner.domains.cps.queries.AverageFreeHddMetric; +import hu.bme.mit.inf.dslreasoner.domains.cps.queries.AverageFreeMemoryMetric; +import hu.bme.mit.inf.dslreasoner.domains.cps.queries.CostMetric; +import hu.bme.mit.inf.dslreasoner.domains.cps.queries.CreateHostInstance; +import hu.bme.mit.inf.dslreasoner.domains.cps.queries.GuidanceObjective; +import hu.bme.mit.inf.dslreasoner.domains.cps.queries.RequirementNotSatisfied; +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.CompositeDirectionalThresholdObjective; +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveKind; +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveThreshold; +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.QueryBasedObjective; +import java.util.Collection; +import java.util.function.Consumer; +import org.eclipse.emf.common.util.EList; +import org.eclipse.viatra.dse.api.DesignSpaceExplorer; +import org.eclipse.viatra.dse.api.Solution; +import org.eclipse.viatra.dse.evolutionary.EvolutionaryStrategy; +import org.eclipse.viatra.dse.evolutionary.EvolutionaryStrategyBuilder; +import org.eclipse.viatra.dse.objectives.Fitness; +import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRuleFactory; +import org.eclipse.xtext.xbase.lib.Extension; +import org.eclipse.xtext.xbase.lib.InputOutput; + +@SuppressWarnings("all") +public class RuleBasedCpsSolver { + @Extension + private final BatchTransformationRuleFactory _batchTransformationRuleFactory = new BatchTransformationRuleFactory(); + + @Extension + private final CpsFactory _cpsFactory = CpsFactory.eINSTANCE; + + public void solve(final CyberPhysicalSystem problem) { + final DesignSpaceExplorer dse = new DesignSpaceExplorer(); + dse.addMetaModelPackage(CpsPackage.eINSTANCE); + dse.setInitialModel(problem.eResource().getResourceSet()); + final Consumer _function = (RequirementNotSatisfied.Match it) -> { + final ApplicationInstance app = this._cpsFactory.createApplicationInstance(); + EList _instances = it.getReq().getType().getInstances(); + _instances.add(app); + EList _instances_1 = it.getReq().getInstances(); + _instances_1.add(app); + }; + dse.addTransformationRule(this._batchTransformationRuleFactory.createRule(RequirementNotSatisfied.instance()).action(_function).build()); + final Consumer _function_1 = (Allocate.Match it) -> { + ApplicationInstance _app = it.getApp(); + _app.setAllocatedTo(it.getHost()); + }; + dse.addTransformationRule(this._batchTransformationRuleFactory.createRule(Allocate.instance()).action(_function_1).build()); + final Consumer _function_2 = (CreateHostInstance.Match it) -> { + EList _instances = it.getHostType().getInstances(); + HostInstance _createHostInstance = this._cpsFactory.createHostInstance(); + _instances.add(_createHostInstance); + }; + dse.addTransformationRule(this._batchTransformationRuleFactory.createRule(CreateHostInstance.instance()).action(_function_2).build()); + GuidanceObjective _instance = GuidanceObjective.instance(); + ObjectiveThreshold.Inclusive _inclusive = new ObjectiveThreshold.Inclusive(0); + QueryBasedObjective _queryBasedObjective = new QueryBasedObjective(_instance, ObjectiveKind.LOWER_IS_BETTER, _inclusive, 0); + AverageFreeMemoryMetric _instance_1 = AverageFreeMemoryMetric.instance(); + ObjectiveThreshold.Inclusive _inclusive_1 = new ObjectiveThreshold.Inclusive(0.75); + QueryBasedObjective _queryBasedObjective_1 = new QueryBasedObjective(_instance_1, ObjectiveKind.LOWER_IS_BETTER, _inclusive_1, 0); + AverageFreeHddMetric _instance_2 = AverageFreeHddMetric.instance(); + ObjectiveThreshold.Inclusive _inclusive_2 = new ObjectiveThreshold.Inclusive(0.75); + QueryBasedObjective _queryBasedObjective_2 = new QueryBasedObjective(_instance_2, ObjectiveKind.LOWER_IS_BETTER, _inclusive_2, 0); + CompositeDirectionalThresholdObjective _compositeDirectionalThresholdObjective = new CompositeDirectionalThresholdObjective("Composite", _queryBasedObjective, _queryBasedObjective_1, _queryBasedObjective_2); + dse.addObjective(_compositeDirectionalThresholdObjective); + CostMetric _instance_3 = CostMetric.instance(); + QueryBasedObjective _queryBasedObjective_3 = new QueryBasedObjective(_instance_3, ObjectiveKind.LOWER_IS_BETTER, + ObjectiveThreshold.NO_THRESHOLD, 0); + dse.addObjective(_queryBasedObjective_3); + dse.setMaxNumberOfThreads(1); + CpsStateCoder.Factory _factory = new CpsStateCoder.Factory(); + dse.setStateCoderFactory(_factory); + final EvolutionaryStrategy strategy = EvolutionaryStrategyBuilder.createNsga2Strategy(25); + dse.startExplorationWithTimeout(strategy, ((2 * 60) * 1000)); + Collection _solutions = dse.getSolutions(); + for (final Solution solution : _solutions) { + Object _stateCode = solution.getStateCode(); + String _plus = ("Found solution: " + _stateCode); + String _plus_1 = (_plus + " "); + Fitness _fitness = solution.getArbitraryTrajectory().getFitness(); + String _plus_2 = (_plus_1 + _fitness); + InputOutput.println(_plus_2); + } + } +} diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/.CpsGenerator.xtendbin b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/.CpsGenerator.xtendbin new file mode 100644 index 00000000..d975ffab Binary files /dev/null and b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/.CpsGenerator.xtendbin differ diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/CpsGenerator.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/CpsGenerator.java new file mode 100644 index 00000000..e59ef004 --- /dev/null +++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/CpsGenerator.java @@ -0,0 +1,154 @@ +package hu.bme.mit.inf.dslreasoner.domains.cps.generator; + +import hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationType; +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 hu.bme.mit.inf.dslreasoner.domains.cps.Request; +import hu.bme.mit.inf.dslreasoner.domains.cps.Requirement; +import hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Random; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.common.util.URI; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl; +import org.eclipse.xtext.xbase.lib.CollectionLiterals; +import org.eclipse.xtext.xbase.lib.Extension; +import org.eclipse.xtext.xbase.lib.ObjectExtensions; +import org.eclipse.xtext.xbase.lib.Procedures.Procedure1; + +@SuppressWarnings("all") +public class CpsGenerator { + @Extension + private final CpsFactory _cpsFactory = CpsFactory.eINSTANCE; + + private static final int MIN_MEMORY = 1; + + private static final int MAX_MEMORY = 6; + + private static final int MIN_HDD = 1; + + private static final int MAX_HDD = 30; + + private static final int HIGH_CPU_FRACTION = 4; + + private static final int MIN_REPLICAS = 1; + + private static final int MAX_REPLICAS = 4; + + private final Random random; + + private final int applicationTypeCount; + + private final int demandFactor; + + public CpsGenerator(final long randomSeed, final int applicationTypeCount, final int demandFactor) { + Random _random = new Random(randomSeed); + this.random = _random; + this.applicationTypeCount = applicationTypeCount; + this.demandFactor = demandFactor; + } + + public CyberPhysicalSystem generateCpsProblem() { + CyberPhysicalSystem _xblockexpression = null; + { + final ResourceSetImpl resourceSet = new ResourceSetImpl(); + final Resource resource = resourceSet.createResource(URI.createFileURI("dummy.dummyext")); + CyberPhysicalSystem _createCyberPhysicalSystem = this._cpsFactory.createCyberPhysicalSystem(); + final Procedure1 _function = (CyberPhysicalSystem it) -> { + final CyberPhysicalSystem cps = it; + EList _contents = resource.getContents(); + _contents.add(cps); + this.createLowCpuHostTypes(it); + final List highCpuHostTypes = this.createHighCpuHostTypes(it); + for (int i = 0; (i < this.applicationTypeCount); i++) { + if (((i % CpsGenerator.HIGH_CPU_FRACTION) == 0)) { + this.createRandomApplicationType(it, highCpuHostTypes); + } else { + this.createRandomApplicationType(it, it.getHostTypes()); + } + } + for (int i = 0; (i < this.demandFactor); i++) { + EList _requests = it.getRequests(); + Request _createRequest = this._cpsFactory.createRequest(); + final Procedure1 _function_1 = (Request it_1) -> { + EList _applicationTypes = cps.getApplicationTypes(); + for (final ApplicationType appType : _applicationTypes) { + EList _requirements = it_1.getRequirements(); + Requirement _createRequirement = this._cpsFactory.createRequirement(); + final Procedure1 _function_2 = (Requirement it_2) -> { + it_2.setCount(this.nextInt(CpsGenerator.MIN_REPLICAS, CpsGenerator.MAX_REPLICAS)); + it_2.setType(appType); + }; + Requirement _doubleArrow = ObjectExtensions.operator_doubleArrow(_createRequirement, _function_2); + _requirements.add(_doubleArrow); + } + }; + Request _doubleArrow = ObjectExtensions.operator_doubleArrow(_createRequest, _function_1); + _requests.add(_doubleArrow); + } + }; + _xblockexpression = ObjectExtensions.operator_doubleArrow(_createCyberPhysicalSystem, _function); + } + return _xblockexpression; + } + + private void createRandomApplicationType(final CyberPhysicalSystem it, final Collection allowedHostTypes) { + final ApplicationType appType = this._cpsFactory.createApplicationType(); + final int memory = this.nextInt(CpsGenerator.MIN_MEMORY, CpsGenerator.MAX_MEMORY); + final int hdd = this.nextInt(CpsGenerator.MIN_HDD, CpsGenerator.MAX_HDD); + for (final HostType hostType : allowedHostTypes) { + EList _requirements = appType.getRequirements(); + ResourceRequirement _createResourceRequirement = this._cpsFactory.createResourceRequirement(); + final Procedure1 _function = (ResourceRequirement it_1) -> { + it_1.setHostType(hostType); + it_1.setRequiredMemory(memory); + it_1.setRequiredHdd(hdd); + }; + ResourceRequirement _doubleArrow = ObjectExtensions.operator_doubleArrow(_createResourceRequirement, _function); + _requirements.add(_doubleArrow); + } + EList _applicationTypes = it.getApplicationTypes(); + _applicationTypes.add(appType); + } + + private List createLowCpuHostTypes(final CyberPhysicalSystem it) { + HostType _createHostType = this.createHostType(it, 2, 8, 75); + HostType _createHostType_1 = this.createHostType(it, 4, 16, 150); + HostType _createHostType_2 = this.createHostType(it, 3, 16, 75); + HostType _createHostType_3 = this.createHostType(it, 6, 32, 150); + return Collections.unmodifiableList(CollectionLiterals.newArrayList(_createHostType, _createHostType_1, _createHostType_2, _createHostType_3)); + } + + private List createHighCpuHostTypes(final CyberPhysicalSystem it) { + HostType _createHostType = this.createHostType(it, 2, 4, 50); + HostType _createHostType_1 = this.createHostType(it, 4, 8, 100); + return Collections.unmodifiableList(CollectionLiterals.newArrayList(_createHostType, _createHostType_1)); + } + + private HostType createHostType(final CyberPhysicalSystem it, final int cost, final int memory, final int hdd) { + HostType _xblockexpression = null; + { + HostType _createHostType = this._cpsFactory.createHostType(); + final Procedure1 _function = (HostType it_1) -> { + it_1.setCost(cost); + it_1.setDefaultMemory(memory); + it_1.setDefaultHdd(hdd); + }; + final HostType hostType = ObjectExtensions.operator_doubleArrow(_createHostType, _function); + EList _hostTypes = it.getHostTypes(); + _hostTypes.add(hostType); + _xblockexpression = hostType; + } + return _xblockexpression; + } + + private int nextInt(final int lower, final int upper) { + int _nextInt = this.random.nextInt(((upper - lower) + 1)); + return (lower + _nextInt); + } +} -- cgit v1.2.3-54-g00ecf