]> git.somenet.org - pub/jan/lsdc.git/blob - src/at/ac/tuwien/lsdc/sched/SchedulerB.java
fixed scenario params in build.xml
[pub/jan/lsdc.git] / src / at / ac / tuwien / lsdc / sched / SchedulerB.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.OutOfPMsException;
13 import at.ac.tuwien.lsdc.exception.VMResizeException;
14 import at.ac.tuwien.lsdc.types.Application;
15 import at.ac.tuwien.lsdc.types.PhysicalMachine;
16 import at.ac.tuwien.lsdc.types.ScenarioType;
17 import at.ac.tuwien.lsdc.types.SchedulerEvent;
18 import at.ac.tuwien.lsdc.types.SchedulerType;
19 import at.ac.tuwien.lsdc.types.VirtualMachine;
20 import at.ac.tuwien.lsdc.types.VirtualMachine.VMType;
21
22 /**
23  * Scheduler B.
24  *
25  * Initial State: All PMs switched off. If an application arrives, try to modify size, CPU and RAM
26  * of an existing VM to run the application. If no VM is running, create a new one (start a new PM
27  * if necessary). If the application has finished decrease the size, CPU and RAM of the VM. If no
28  * applications are running on a VM, shut down the VM. If no VM is running on a PM, shut down the
29  * PM. Try to get a maximum of utilization on every PM. Migration: Try to move applications from VMs
30  * to other VMs to get a better utilization and to use less PMs.
31  *
32  * @author jan
33  *
34  */
35 public class SchedulerB extends AbstractSchedulerWithMigration {
36         /**
37          * Logger.
38          */
39         private static final Logger LOG = LoggerFactory.getLogger(SchedulerB.class);
40
41         public SchedulerB(int numPMs, int numCloudPartners, File schedulerLog, ScenarioType scenario)
42                         throws IOException {
43                 super(numPMs, numCloudPartners, schedulerLog, scenario);
44                 vmType = VMType.Resizable;
45         }
46
47         @Override
48         protected boolean deployApp(VirtualMachine vm, Application app) {
49                 if (!vm.enoughResources(app)) {
50                         try {
51                                 vm.resizeVM(vm.getSize() + app.getSize(), vm.getRAM() + app.getRam(), vm.getCPU()
52                                                 + app.getCpu());
53                         } catch (VMResizeException ex) {
54                                 return false;
55                         }
56                 }
57                 vm.startApplication(app);
58                 app.setRunningOn(vm);
59                 return true;
60         }
61
62         /**
63          * Cleanup completed apps. Downsize VMs and if an VM becomes empty, shut down VM + PM.
64          *
65          * @param events list of all events that happened in this timeslot.
66          */
67         @Override
68         protected void handleEndEvents(LinkedList<SchedulerEvent> events) {
69                 LOG.debug("stopApps():" + events);
70                 for (SchedulerEvent evt : events) {
71                         VirtualMachine vm = evt.getApp().getRunningOn();
72                         evt.getApp().setRunningOn(null);
73                         vm.stopApplication(evt.getApp());
74                         try {
75                                 vm.resizeVM(vm.getSize() - evt.getApp().getSize(), vm.getRAM()
76                                                 - evt.getApp().getRam(), vm.getCPU() - evt.getApp().getCpu());
77                         } catch (VMResizeException e) {
78                                 // LOG.error("failed to resize VM: " + e.getVm(), e);
79                         }
80                         if (vm.getApplications().size() == 0) {
81                                 PhysicalMachine pm = vm.getRunningOn();
82                                 pm.stopVirtualMachine(vm);
83                                 manager.stopPhysicalMachine(pm.getId());
84                         }
85                 }
86         }
87
88         /**
89          * Try to start all Apps. Upsize the VM, if not possible start another PM, if not possible,
90          * delay start.
91          *
92          * @param events list of all events that happened in this timeslot.
93          */
94         @Override
95         protected void handleStartEvents(LinkedList<SchedulerEvent> events) {
96                 LOG.debug("startApps():" + events);
97                 boolean deployed = false;
98                 for (SchedulerEvent evt : events) {
99                         deployed = false;
100                         VirtualMachine vm = null;
101                         List<PhysicalMachine> sortedPMs = manager.getSortedPMs();
102                         Collections.reverse(sortedPMs);
103                         for (PhysicalMachine pm : sortedPMs) {
104                                 if (pm.isRunning() && (pm.getTotalVMs() > 0)) {
105                                         vm = pm.getVirtualMachines().values().iterator().next();
106                                         deployed = deployApp(vm, evt.getApp());
107                                         if (deployed)
108                                                 break;
109                                 }
110                         }
111                         if (!deployed) {
112                                 try {
113                                         vm = manager.startPhysicalMachine().startVirtualMachine(evt.getApp().getSize(),
114                                                         evt.getApp().getRam(), evt.getApp().getCpu(), vmType);
115                                         deployed = deployApp(vm, evt.getApp());
116                                 } catch (OutOfPMsException e) {
117                                         if (federation.askToOutsource(evt.getApp())) {
118                                                 insertOutsourcedStartEvent(currTime + 1, evt.getApp());
119                                         } else {
120                                                 LOG.info("delaying the start of:" + evt.getApp());
121                                                 delayedApps.add(evt.getApp());
122                                                 return;
123                                         }
124                                 }
125                         }
126                         if (deployed)
127                                 insertStopEvent(currTime + evt.getApp().getDuration(), evt.getApp());
128                 }
129         }
130
131         @Override
132         protected String getSchedulerType() {
133                 return SchedulerType.B.toString();
134         }
135
136 }