]> git.somenet.org - pub/jan/lsdc.git/blob - src/at/ac/tuwien/lsdc/sched/SchedulerA.java
Adding insourcing of events
[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                 List<Application> apps = getApplications(events);
62                 
63                 for (Application app : apps) {
64                         boolean appDeployed = false;
65
66                         if (manager.getPMs().size() == 0) {
67                                 PhysicalMachine pm = manager.startPhysicalMachine();
68                                 boolean enoughResources = pm.checkVM(app.getSize(), app.getRam(), app.getCpu());
69
70                                 if (enoughResources) {
71                                         appDeployed = startApp(pm, app);
72 //                                      log.info("Application " + app.toString() + " started on new pm " + pm.getId());
73                                 } else {
74 //                                      log.info("Application " + app.toString() + " cannot be run on pm "
75 //                                                      + pm.getId() + ", too little space");
76                                 }
77                         } else {
78                                 // sorting physical machines by resource utilization
79                                 // (descending)
80                                 List<PhysicalMachine> sortedPMs = manager.getSortedPMs();
81                                 Collections.reverse(sortedPMs);
82
83                                 for (PhysicalMachine pm : sortedPMs) {
84
85                                         boolean enoughResources = pm.checkVM(app.getSize(), app.getRam(), app.getCpu());
86
87                                         if (enoughResources) {
88                                                 appDeployed = startApp(pm, app);
89 //                                              log.info("Application " + app.toString() + " started new vm "
90 //                                                              + pm.getLatestVMID() + " on pm " + pm.getId());
91                                                 break;
92                                         }
93                                 }
94                                 if (!appDeployed && (manager.getPMs().size() < manager.getMaxPMs())) {
95
96                                         PhysicalMachine pm = manager.startPhysicalMachine();
97                                         boolean enoughResources = pm.checkVM(app.getSize(), app.getRam(), app.getCpu());
98
99                                         if (enoughResources) {
100                                                 appDeployed = startApp(pm, app);
101 //                                              log.info("Application " + app.toString() + " started on new pm "
102 //                                                              + pm.getId());
103                                         } else {
104 //                                              log.warn("Application " + app.toString() + " cannot be run on pm "
105 //                                                              + pm.getId() + ", too little space");
106                                         }
107                                 }
108                         }
109                         if (!appDeployed) {
110                                 if (federation.askToOutsource(app)) {
111                                         insertOutsourcedStartEvent(currTime + 1, app);
112                                         appDeployed = true;
113                                 } else
114                                         delayedApps.add(app);
115                         }
116                         if(appDeployed) {
117                                 if(manager.countCurrentlyRunningPMs() < manager.getMaxPMs()) {
118                                         Application application = federation.askToInsource();
119                                         if(application != null) {
120                                                 insertInsourcedStartEvent(currTime + 1, application);
121                                         }
122                                 }
123                         }
124                         else
125                                 log.warn("Application " + app.toString() + " could not be deployed on any pm");
126                 }
127
128         }
129         
130         private boolean startApp(PhysicalMachine pm, Application app) {
131                 VirtualMachine vm = pm.startVirtualMachine(app.getSize(), app.getRam(),
132                                 app.getCpu(), vmType);
133                 vm.startApplication(app);
134                 insertStopEvent(currTime + app.getDuration(), app);
135                 return true;
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         public List<Application> getApplications(LinkedList<SchedulerEvent> events) {
150                 List<Application> apps = new LinkedList<Application>();
151                 for(SchedulerEvent evt: events) {
152                         apps.add(evt.getApp());
153                 }
154                 return apps;
155         }
156
157         @Override
158         protected String getSchedulerType() {
159                 return SchedulerType.A.toString();
160         }
161
162 }