]> git.somenet.org - pub/jan/lsdc.git/blob - src/at/ac/tuwien/lsdc/sched/SchedulerA.java
moved sorting of PMs into MachineManager
[pub/jan/lsdc.git] / src / at / ac / tuwien / lsdc / sched / SchedulerA.java
1 package at.ac.tuwien.lsdc.sched;
2
3 import java.io.File;
4 import java.io.IOException;
5 import java.util.Collections;
6 import java.util.LinkedList;
7 import java.util.List;
8
9 import org.slf4j.Logger;
10 import org.slf4j.LoggerFactory;
11
12 import at.ac.tuwien.lsdc.exception.ActiveApplicationsException;
13 import at.ac.tuwien.lsdc.exception.VMsRunningException;
14 import at.ac.tuwien.lsdc.types.Application;
15 import at.ac.tuwien.lsdc.types.ApplicationResourceComparator;
16 import at.ac.tuwien.lsdc.types.PhysicalMachine;
17 import at.ac.tuwien.lsdc.types.ScenarioType;
18 import at.ac.tuwien.lsdc.types.SchedulerEvent;
19 import at.ac.tuwien.lsdc.types.SchedulerType;
20 import at.ac.tuwien.lsdc.types.VirtualMachine;
21 import at.ac.tuwien.lsdc.types.VirtualMachine.VMType;
22
23 public class SchedulerA extends AbstractScheduler {
24
25         private static final Logger log = LoggerFactory.getLogger(SchedulerA.class);
26
27         public SchedulerA(int numPMs, int numCloudPartners, File schedulerLog, ScenarioType scenario)
28                         throws IOException {
29                 super(numPMs, numCloudPartners, schedulerLog, scenario);
30
31                 this.vmType = VMType.NonResizable;
32         }
33
34         @Override
35         protected void handleEndEvents(LinkedList<SchedulerEvent> events) {
36                 for (SchedulerEvent evt : events) {
37                         VirtualMachine vm = evt.getApp().getRunningOn();
38                         vm.stopApplication(evt.getApp());
39                         PhysicalMachine pm = vm.getRunningOn();
40                         try {
41                                 pm.stopVirtualMachine(vm);
42                                 if (pm.countCurrentlyRunningVMs() == 0) {
43                                         try {
44                                                 manager.stopPhysicalMachine(pm.getId());
45                                         } catch (VMsRunningException e) {
46                                                 log.warn("PM " + pm.getId() + " could not be stopped, " + e.getMessage());
47                                         }
48                                 }
49                                 log.info("application stopped at timestamp " + currTime + ", " + "vm "
50                                                 + vm.getPositionOnPM() + ", pm " + pm.getId());
51                         } catch (ActiveApplicationsException e) {
52                                 log.warn("VM " + vm.getId() + "could not be stopped, " + e.getMessage());
53                         }
54                 }
55         }
56
57         @Override
58         protected void handleStartEvents(LinkedList<SchedulerEvent> events) {
59                 // sorting applications by amount of resources (descending)
60                 List<Application> sortedApps = sortApps(events);
61
62                 for (Application app : sortedApps) {
63                         boolean appDeployed = false;
64
65                         if (manager.getPMs().size() == 0) {
66                                 PhysicalMachine pm = manager.startPhysicalMachine();
67                                 boolean enoughResources = pm.checkVM(app.getSize(), app.getRam(), app.getCpu());
68
69                                 if (enoughResources) {
70                                         VirtualMachine vm = pm.startVirtualMachine(app.getSize(), app.getRam(),
71                                                         app.getCpu(), vmType);
72                                         vm.startApplication(app);
73                                         insertStopEvent(currTime + app.getDuration(), app);
74                                         appDeployed = true;
75                                         log.info("Application " + app.toString() + " started on new pm " + pm.getId());
76                                 } else {
77                                         log.warn("Application " + app.toString() + " cannot be run on empty pm "
78                                                         + pm.getId());
79                                 }
80                         } else {
81                                 // sorting physical machines by resource utilization
82                                 // (descending)
83                                 List<PhysicalMachine> sortedPMs = manager.getSortedPMs();
84                                 Collections.reverse(sortedPMs);
85
86                                 for (PhysicalMachine pm : sortedPMs) {
87
88                                         boolean enoughResources = pm.checkVM(app.getSize(), app.getRam(), app.getCpu());
89
90                                         if (enoughResources) {
91                                                 VirtualMachine vm = pm.startVirtualMachine(app.getSize(), app.getRam(),
92                                                                 app.getCpu(), vmType);
93                                                 vm.startApplication(app);
94                                                 insertStopEvent(currTime + app.getDuration(), app);
95                                                 appDeployed = true;
96                                                 log.info("Application " + app.toString() + " started new vm "
97                                                                 + vm.getPositionOnPM() + " on pm " + pm.getId());
98                                                 break;
99                                         }
100                                 }
101                                 if (!appDeployed && (manager.getPMs().size() < manager.getMaxPMs())) {
102
103                                         PhysicalMachine pm = manager.startPhysicalMachine();
104                                         boolean enoughResources = pm.checkVM(app.getSize(), app.getRam(), app.getCpu());
105
106                                         if (enoughResources) {
107                                                 VirtualMachine vm = pm.startVirtualMachine(app.getSize(), app.getRam(),
108                                                                 app.getCpu(), vmType);
109                                                 vm.startApplication(app);
110                                                 insertStopEvent(currTime + app.getDuration(), app);
111                                                 appDeployed = true;
112                                                 log.info("Application " + app.toString() + " started on new pm "
113                                                                 + pm.getId());
114                                         } else {
115                                                 log.warn("Application " + app.toString() + " cannot be run on empty pm "
116                                                                 + pm.getId());
117                                         }
118                                 }
119                         }
120                         if (!appDeployed) {
121                                 if (federation.askToOutsource(app)) {
122                                         insertOutsourcedStartEvent(currTime + 1, app);
123                                         appDeployed = true;
124                                 } else
125                                         delayedApps.add(app);
126                         }
127                         if (!appDeployed)
128                                 log.warn("Application " + app.toString() + " could not be deployed on any pm");
129                 }
130
131         }
132
133         @Override
134         protected void runMigration() {
135                 // Scheduler A doesn't support Migration, nothing to do here
136         }
137
138         // sorting applications by amount of resources (descending)
139         private List<Application> sortApps(LinkedList<SchedulerEvent> events) {
140                 List<Application> sortedApps = new LinkedList<Application>();
141                 for (SchedulerEvent evt : events) {
142                         sortedApps.add(evt.getApp());
143                 }
144                 Collections.sort(sortedApps, new ApplicationResourceComparator());
145                 Collections.reverse(sortedApps);
146                 return sortedApps;
147         }
148
149         @Override
150         protected String getSchedulerType() {
151                 return SchedulerType.A.toString();
152         }
153
154 }