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/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 ++++++ 7 files changed, 458 insertions(+) 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 (limited to 'Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse') 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); + } + } +} -- cgit v1.2.3-70-g09d2