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