aboutsummaryrefslogtreecommitdiffstats
path: root/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CpsToLpTranslator.java
diff options
context:
space:
mode:
Diffstat (limited to 'Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CpsToLpTranslator.java')
-rw-r--r--Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CpsToLpTranslator.java505
1 files changed, 0 insertions, 505 deletions
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
deleted file mode 100644
index 20afeee6..00000000
--- a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CpsToLpTranslator.java
+++ /dev/null
@@ -1,505 +0,0 @@
1package hu.bme.mit.inf.dslreasoner.domains.cps.cplex;
2
3import com.google.common.base.Objects;
4import com.google.common.collect.ImmutableList;
5import com.google.common.collect.ImmutableMap;
6import hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationType;
7import hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem;
8import hu.bme.mit.inf.dslreasoner.domains.cps.HostType;
9import hu.bme.mit.inf.dslreasoner.domains.cps.Request;
10import hu.bme.mit.inf.dslreasoner.domains.cps.Requirement;
11import hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement;
12import java.util.Collection;
13import java.util.List;
14import java.util.Map;
15import org.eclipse.emf.common.util.EList;
16import org.eclipse.xtend2.lib.StringConcatenation;
17import org.eclipse.xtext.xbase.lib.CollectionLiterals;
18import org.eclipse.xtext.xbase.lib.ExclusiveRange;
19import org.eclipse.xtext.xbase.lib.Functions.Function1;
20import org.eclipse.xtext.xbase.lib.IterableExtensions;
21import org.eclipse.xtext.xbase.lib.ListExtensions;
22import org.eclipse.xtext.xbase.lib.Pair;
23
24@SuppressWarnings("all")
25public class CpsToLpTranslator {
26 private static final double MINIMUM_MEMORY_USAGE = 0.25;
27
28 private static final double MINIMUM_HDD_USAGE = 0.25;
29
30 private final CyberPhysicalSystem cps;
31
32 private final Map<Requirement, ? extends List<String>> appInstances;
33
34 private final Map<HostType, ? extends List<String>> hostInstances;
35
36 private final boolean breakSymmetry;
37
38 public CpsToLpTranslator(final CyberPhysicalSystem cps, final int hostInstanceCount, final boolean breakSymmetry) {
39 this.cps = cps;
40 this.appInstances = this.createAppInstances();
41 this.hostInstances = this.createHostInstances(hostInstanceCount);
42 this.breakSymmetry = breakSymmetry;
43 }
44
45 private ImmutableMap<Requirement, ImmutableList<String>> createAppInstances() {
46 ImmutableMap<Requirement, ImmutableList<String>> _xblockexpression = null;
47 {
48 final ImmutableMap.Builder<Requirement, ImmutableList<String>> builder = ImmutableMap.<Requirement, ImmutableList<String>>builder();
49 int i = 0;
50 Iterable<Requirement> _requirements = this.getRequirements();
51 for (final Requirement req : _requirements) {
52 {
53 final ImmutableList.Builder<String> listBuilder = ImmutableList.<String>builder();
54 for (int j = 0; (j < req.getCount()); j++) {
55 StringConcatenation _builder = new StringConcatenation();
56 _builder.append("r");
57 _builder.append(i);
58 _builder.append("a");
59 _builder.append(j);
60 listBuilder.add(_builder.toString());
61 }
62 builder.put(req, listBuilder.build());
63 i++;
64 }
65 }
66 _xblockexpression = builder.build();
67 }
68 return _xblockexpression;
69 }
70
71 private ImmutableMap<HostType, ImmutableList<String>> createHostInstances(final int hostInstanceCount) {
72 ImmutableMap<HostType, ImmutableList<String>> _xblockexpression = null;
73 {
74 final ImmutableMap.Builder<HostType, ImmutableList<String>> builder = ImmutableMap.<HostType, ImmutableList<String>>builder();
75 int i = 0;
76 EList<HostType> _hostTypes = this.cps.getHostTypes();
77 for (final HostType hostType : _hostTypes) {
78 {
79 final ImmutableList.Builder<String> listBuilder = ImmutableList.<String>builder();
80 for (int j = 0; (j < hostInstanceCount); j++) {
81 StringConcatenation _builder = new StringConcatenation();
82 _builder.append("h");
83 _builder.append(i);
84 _builder.append("i");
85 _builder.append(j);
86 listBuilder.add(_builder.toString());
87 }
88 builder.put(hostType, listBuilder.build());
89 i++;
90 }
91 }
92 _xblockexpression = builder.build();
93 }
94 return _xblockexpression;
95 }
96
97 public CharSequence getLpProblem() {
98 StringConcatenation _builder = new StringConcatenation();
99 _builder.append("Minimize");
100 _builder.newLine();
101 _builder.append("\t");
102 _builder.append("total_cost: ");
103 CharSequence _objective = this.getObjective();
104 _builder.append(_objective, "\t");
105 _builder.newLineIfNotEmpty();
106 _builder.append("Subject To");
107 _builder.newLine();
108 _builder.append("\t");
109 CharSequence _constraints = this.getConstraints();
110 _builder.append(_constraints, "\t");
111 _builder.newLineIfNotEmpty();
112 _builder.append("Bounds");
113 _builder.newLine();
114 _builder.append("\t");
115 CharSequence _bounds = this.getBounds();
116 _builder.append(_bounds, "\t");
117 _builder.newLineIfNotEmpty();
118 _builder.append("Binary");
119 _builder.newLine();
120 _builder.append("\t");
121 CharSequence _binaryVariables = this.getBinaryVariables();
122 _builder.append(_binaryVariables, "\t");
123 _builder.newLineIfNotEmpty();
124 _builder.append("End");
125 _builder.newLine();
126 return _builder;
127 }
128
129 private CharSequence getObjective() {
130 StringConcatenation _builder = new StringConcatenation();
131 {
132 Iterable<Pair<HostType, String>> _hostInstancesWithType = this.getHostInstancesWithType();
133 boolean _hasElements = false;
134 for(final Pair<HostType, String> pair : _hostInstancesWithType) {
135 if (!_hasElements) {
136 _hasElements = true;
137 } else {
138 _builder.appendImmediate(" + ", "");
139 }
140 int _cost = pair.getKey().getCost();
141 _builder.append(_cost);
142 _builder.append(" ");
143 CharSequence _existsVariable = this.getExistsVariable(pair.getValue());
144 _builder.append(_existsVariable);
145 }
146 }
147 return _builder;
148 }
149
150 private CharSequence getConstraints() {
151 StringConcatenation _builder = new StringConcatenation();
152 {
153 Iterable<Pair<ApplicationType, String>> _appInstancesWithType = this.getAppInstancesWithType();
154 for(final Pair<ApplicationType, String> appPair : _appInstancesWithType) {
155 String _value = appPair.getValue();
156 _builder.append(_value);
157 _builder.append("_allocated: ");
158 {
159 Iterable<String> _possibleHostInstances = this.getPossibleHostInstances(appPair.getKey());
160 boolean _hasElements = false;
161 for(final String host : _possibleHostInstances) {
162 if (!_hasElements) {
163 _hasElements = true;
164 } else {
165 _builder.appendImmediate(" + ", "");
166 }
167 CharSequence _allocatedToVariable = this.getAllocatedToVariable(appPair.getValue(), host);
168 _builder.append(_allocatedToVariable);
169 }
170 }
171 _builder.append(" = 1");
172 _builder.newLineIfNotEmpty();
173 {
174 Iterable<String> _possibleHostInstances_1 = this.getPossibleHostInstances(appPair.getKey());
175 for(final String host_1 : _possibleHostInstances_1) {
176 String _value_1 = appPair.getValue();
177 _builder.append(_value_1);
178 _builder.append("_to_");
179 _builder.append(host_1);
180 _builder.append("_exists: ");
181 CharSequence _existsVariable = this.getExistsVariable(host_1);
182 _builder.append(_existsVariable);
183 _builder.append(" - ");
184 CharSequence _allocatedToVariable_1 = this.getAllocatedToVariable(appPair.getValue(), host_1);
185 _builder.append(_allocatedToVariable_1);
186 _builder.append(" >= 0");
187 _builder.newLineIfNotEmpty();
188 }
189 }
190 }
191 }
192 {
193 Iterable<Pair<HostType, String>> _hostInstancesWithType = this.getHostInstancesWithType();
194 for(final Pair<HostType, String> hostPair : _hostInstancesWithType) {
195 String _value_2 = hostPair.getValue();
196 _builder.append(_value_2);
197 _builder.append("_mem_use: ");
198 {
199 Iterable<Pair<ResourceRequirement, String>> _possibleAppInstancesWithRequirements = this.getPossibleAppInstancesWithRequirements(hostPair.getKey());
200 boolean _hasElements_1 = false;
201 for(final Pair<ResourceRequirement, String> appPair_1 : _possibleAppInstancesWithRequirements) {
202 if (!_hasElements_1) {
203 _hasElements_1 = true;
204 } else {
205 _builder.appendImmediate(" + ", "");
206 }
207 int _requiredMemory = appPair_1.getKey().getRequiredMemory();
208 _builder.append(_requiredMemory);
209 _builder.append(" ");
210 CharSequence _allocatedToVariable_2 = this.getAllocatedToVariable(appPair_1.getValue(), hostPair.getValue());
211 _builder.append(_allocatedToVariable_2);
212 }
213 }
214 _builder.append(" - ");
215 int _defaultMemory = hostPair.getKey().getDefaultMemory();
216 _builder.append(_defaultMemory);
217 _builder.append(" ");
218 CharSequence _memoryUsageVariable = this.getMemoryUsageVariable(hostPair.getValue());
219 _builder.append(_memoryUsageVariable);
220 _builder.append(" = 0");
221 _builder.newLineIfNotEmpty();
222 String _value_3 = hostPair.getValue();
223 _builder.append(_value_3);
224 _builder.append("_hdd_use: ");
225 {
226 Iterable<Pair<ResourceRequirement, String>> _possibleAppInstancesWithRequirements_1 = this.getPossibleAppInstancesWithRequirements(hostPair.getKey());
227 boolean _hasElements_2 = false;
228 for(final Pair<ResourceRequirement, String> appPair_2 : _possibleAppInstancesWithRequirements_1) {
229 if (!_hasElements_2) {
230 _hasElements_2 = true;
231 } else {
232 _builder.appendImmediate(" + ", "");
233 }
234 int _requiredHdd = appPair_2.getKey().getRequiredHdd();
235 _builder.append(_requiredHdd);
236 _builder.append(" ");
237 CharSequence _allocatedToVariable_3 = this.getAllocatedToVariable(appPair_2.getValue(), hostPair.getValue());
238 _builder.append(_allocatedToVariable_3);
239 }
240 }
241 _builder.append(" - ");
242 int _defaultHdd = hostPair.getKey().getDefaultHdd();
243 _builder.append(_defaultHdd);
244 _builder.append(" ");
245 CharSequence _hddUsageVariable = this.getHddUsageVariable(hostPair.getValue());
246 _builder.append(_hddUsageVariable);
247 _builder.append(" = 0");
248 _builder.newLineIfNotEmpty();
249 }
250 }
251 _builder.append("average_mem: ");
252 {
253 Iterable<String> _allHostInstances = this.getAllHostInstances();
254 boolean _hasElements_3 = false;
255 for(final String host_2 : _allHostInstances) {
256 if (!_hasElements_3) {
257 _hasElements_3 = true;
258 } else {
259 _builder.appendImmediate(" + ", "");
260 }
261 CharSequence _memoryUsageVariable_1 = this.getMemoryUsageVariable(host_2);
262 _builder.append(_memoryUsageVariable_1);
263 _builder.append(" - ");
264 _builder.append(CpsToLpTranslator.MINIMUM_MEMORY_USAGE);
265 _builder.append(" ");
266 CharSequence _existsVariable_1 = this.getExistsVariable(host_2);
267 _builder.append(_existsVariable_1);
268 }
269 }
270 _builder.append(" >= 0");
271 _builder.newLineIfNotEmpty();
272 _builder.append("average_hdd: ");
273 {
274 Iterable<String> _allHostInstances_1 = this.getAllHostInstances();
275 boolean _hasElements_4 = false;
276 for(final String host_3 : _allHostInstances_1) {
277 if (!_hasElements_4) {
278 _hasElements_4 = true;
279 } else {
280 _builder.appendImmediate(" + ", "");
281 }
282 CharSequence _memoryUsageVariable_2 = this.getMemoryUsageVariable(host_3);
283 _builder.append(_memoryUsageVariable_2);
284 _builder.append(" - ");
285 _builder.append(CpsToLpTranslator.MINIMUM_HDD_USAGE);
286 _builder.append(" ");
287 CharSequence _existsVariable_2 = this.getExistsVariable(host_3);
288 _builder.append(_existsVariable_2);
289 }
290 }
291 _builder.append(" >= 0");
292 _builder.newLineIfNotEmpty();
293 {
294 final Function1<Requirement, Boolean> _function = (Requirement it) -> {
295 int _count = it.getCount();
296 return Boolean.valueOf((_count > 1));
297 };
298 Iterable<Pair<Integer, Requirement>> _indexed = IterableExtensions.<Requirement>indexed(IterableExtensions.<Requirement>filter(this.getRequirements(), _function));
299 for(final Pair<Integer, Requirement> reqPair : _indexed) {
300 {
301 final Function1<ResourceRequirement, List<String>> _function_1 = (ResourceRequirement it) -> {
302 return this.hostInstances.get(it.getHostType());
303 };
304 Iterable<String> _flatMap = IterableExtensions.<ResourceRequirement, String>flatMap(reqPair.getValue().getType().getRequirements(), _function_1);
305 for(final String host_4 : _flatMap) {
306 _builder.append("r");
307 Integer _key = reqPair.getKey();
308 _builder.append(_key);
309 _builder.append("_");
310 _builder.append(host_4);
311 _builder.append("_redundant: ");
312 {
313 List<String> _get = this.appInstances.get(reqPair.getValue());
314 boolean _hasElements_5 = false;
315 for(final String app : _get) {
316 if (!_hasElements_5) {
317 _hasElements_5 = true;
318 } else {
319 _builder.appendImmediate(" + ", "");
320 }
321 CharSequence _allocatedToVariable_4 = this.getAllocatedToVariable(app, host_4);
322 _builder.append(_allocatedToVariable_4);
323 }
324 }
325 _builder.append(" <= 1");
326 _builder.newLineIfNotEmpty();
327 }
328 }
329 }
330 }
331 {
332 if (this.breakSymmetry) {
333 {
334 Collection<? extends List<String>> _values = this.hostInstances.values();
335 for(final List<String> hosts : _values) {
336 {
337 int _size = hosts.size();
338 int _minus = (_size - 1);
339 ExclusiveRange _doubleDotLessThan = new ExclusiveRange(0, _minus, true);
340 for(final Integer i : _doubleDotLessThan) {
341 String _get_1 = hosts.get(((i).intValue() + 1));
342 _builder.append(_get_1);
343 _builder.append("_after_");
344 String _get_2 = hosts.get((i).intValue());
345 _builder.append(_get_2);
346 _builder.append(": ");
347 CharSequence _existsVariable_3 = this.getExistsVariable(hosts.get((i).intValue()));
348 _builder.append(_existsVariable_3);
349 _builder.append(" - ");
350 CharSequence _existsVariable_4 = this.getExistsVariable(hosts.get(((i).intValue() + 1)));
351 _builder.append(_existsVariable_4);
352 _builder.append(" >= 0");
353 _builder.newLineIfNotEmpty();
354 }
355 }
356 }
357 }
358 }
359 }
360 return _builder;
361 }
362
363 private CharSequence getBounds() {
364 StringConcatenation _builder = new StringConcatenation();
365 {
366 Iterable<String> _allHostInstances = this.getAllHostInstances();
367 for(final String host : _allHostInstances) {
368 _builder.append("0 <= ");
369 CharSequence _memoryUsageVariable = this.getMemoryUsageVariable(host);
370 _builder.append(_memoryUsageVariable);
371 _builder.append(" <= 1");
372 _builder.newLineIfNotEmpty();
373 _builder.append("0 <= ");
374 CharSequence _hddUsageVariable = this.getHddUsageVariable(host);
375 _builder.append(_hddUsageVariable);
376 _builder.append(" <= 1");
377 _builder.newLineIfNotEmpty();
378 }
379 }
380 return _builder;
381 }
382
383 private CharSequence getBinaryVariables() {
384 StringConcatenation _builder = new StringConcatenation();
385 {
386 Iterable<String> _allHostInstances = this.getAllHostInstances();
387 for(final String host : _allHostInstances) {
388 CharSequence _existsVariable = this.getExistsVariable(host);
389 _builder.append(_existsVariable);
390 _builder.newLineIfNotEmpty();
391 }
392 }
393 {
394 Iterable<Pair<ApplicationType, String>> _appInstancesWithType = this.getAppInstancesWithType();
395 for(final Pair<ApplicationType, String> appPair : _appInstancesWithType) {
396 {
397 Iterable<String> _possibleHostInstances = this.getPossibleHostInstances(appPair.getKey());
398 for(final String host_1 : _possibleHostInstances) {
399 CharSequence _allocatedToVariable = this.getAllocatedToVariable(appPair.getValue(), host_1);
400 _builder.append(_allocatedToVariable);
401 _builder.newLineIfNotEmpty();
402 }
403 }
404 }
405 }
406 return _builder;
407 }
408
409 private Iterable<Requirement> getRequirements() {
410 final Function1<Request, EList<Requirement>> _function = (Request it) -> {
411 return it.getRequirements();
412 };
413 return IterableExtensions.<Request, Requirement>flatMap(this.cps.getRequests(), _function);
414 }
415
416 private Iterable<String> getAllHostInstances() {
417 final Function1<List<String>, List<String>> _function = (List<String> it) -> {
418 return it;
419 };
420 return IterableExtensions.flatMap(this.hostInstances.values(), _function);
421 }
422
423 private Iterable<Pair<HostType, String>> getHostInstancesWithType() {
424 final Function1<Map.Entry<HostType, ? extends List<String>>, List<Pair<HostType, String>>> _function = (Map.Entry<HostType, ? extends List<String>> pair) -> {
425 final Function1<String, Pair<HostType, String>> _function_1 = (String it) -> {
426 HostType _key = pair.getKey();
427 return Pair.<HostType, String>of(_key, it);
428 };
429 return ListExtensions.<String, Pair<HostType, String>>map(pair.getValue(), _function_1);
430 };
431 return IterableExtensions.flatMap(this.hostInstances.entrySet(), _function);
432 }
433
434 private Iterable<Pair<ApplicationType, String>> getAppInstancesWithType() {
435 final Function1<Map.Entry<Requirement, ? extends List<String>>, List<Pair<ApplicationType, String>>> _function = (Map.Entry<Requirement, ? extends List<String>> pair) -> {
436 final Function1<String, Pair<ApplicationType, String>> _function_1 = (String it) -> {
437 ApplicationType _type = pair.getKey().getType();
438 return Pair.<ApplicationType, String>of(_type, it);
439 };
440 return ListExtensions.<String, Pair<ApplicationType, String>>map(pair.getValue(), _function_1);
441 };
442 return IterableExtensions.flatMap(this.appInstances.entrySet(), _function);
443 }
444
445 private Iterable<String> getPossibleHostInstances(final ApplicationType appType) {
446 final Function1<ResourceRequirement, List<String>> _function = (ResourceRequirement req) -> {
447 return this.hostInstances.get(req.getHostType());
448 };
449 return IterableExtensions.<ResourceRequirement, String>flatMap(appType.getRequirements(), _function);
450 }
451
452 private Iterable<Pair<ResourceRequirement, String>> getPossibleAppInstancesWithRequirements(final HostType hostType) {
453 final Function1<Map.Entry<Requirement, ? extends List<String>>, List<Pair<ResourceRequirement, String>>> _function = (Map.Entry<Requirement, ? extends List<String>> pair) -> {
454 List<Pair<ResourceRequirement, String>> _xblockexpression = null;
455 {
456 final Function1<ResourceRequirement, Boolean> _function_1 = (ResourceRequirement it) -> {
457 HostType _hostType = it.getHostType();
458 return Boolean.valueOf(Objects.equal(_hostType, hostType));
459 };
460 final ResourceRequirement resourceReq = IterableExtensions.<ResourceRequirement>findFirst(pair.getKey().getType().getRequirements(), _function_1);
461 List<Pair<ResourceRequirement, String>> _xifexpression = null;
462 if ((resourceReq == null)) {
463 _xifexpression = CollectionLiterals.<Pair<ResourceRequirement, String>>emptyList();
464 } else {
465 final Function1<String, Pair<ResourceRequirement, String>> _function_2 = (String it) -> {
466 return Pair.<ResourceRequirement, String>of(resourceReq, it);
467 };
468 _xifexpression = ListExtensions.<String, Pair<ResourceRequirement, String>>map(pair.getValue(), _function_2);
469 }
470 _xblockexpression = _xifexpression;
471 }
472 return _xblockexpression;
473 };
474 return IterableExtensions.flatMap(this.appInstances.entrySet(), _function);
475 }
476
477 private CharSequence getExistsVariable(final String hostInstance) {
478 StringConcatenation _builder = new StringConcatenation();
479 _builder.append(hostInstance);
480 _builder.append("_exists");
481 return _builder;
482 }
483
484 private CharSequence getMemoryUsageVariable(final String hostInstance) {
485 StringConcatenation _builder = new StringConcatenation();
486 _builder.append(hostInstance);
487 _builder.append("_mem");
488 return _builder;
489 }
490
491 private CharSequence getHddUsageVariable(final String hostInstance) {
492 StringConcatenation _builder = new StringConcatenation();
493 _builder.append(hostInstance);
494 _builder.append("_hdd");
495 return _builder;
496 }
497
498 private CharSequence getAllocatedToVariable(final String appInstance, final String hostInstance) {
499 StringConcatenation _builder = new StringConcatenation();
500 _builder.append(appInstance);
501 _builder.append("_to_");
502 _builder.append(hostInstance);
503 return _builder;
504 }
505}