]> git.somenet.org - pub/jan/lsdc.git/blob - src/at/ac/tuwien/lsdc/sched/SchedulerA.java
fixed scenario params in build.xml
[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                                 log.warn("Application " + app.toString() + " could not be deployed on any pm");
118                 }
119
120         }
121         
122         private boolean startApp(PhysicalMachine pm, Application app) {
123                 VirtualMachine vm = pm.startVirtualMachine(app.getSize(), app.getRam(),
124                                 app.getCpu(), vmType);
125                 vm.startApplication(app);
126                 insertStopEvent(currTime + app.getDuration(), app);
127                 return true;
128         }
129
130         // sorting applications by amount of resources (descending)
131         private List<Application> sortApps(LinkedList<SchedulerEvent> events) {
132                 List<Application> sortedApps = new LinkedList<Application>();
133                 for (SchedulerEvent evt : events) {
134                         sortedApps.add(evt.getApp());
135                 }
136                 Collections.sort(sortedApps, new ApplicationResourceComparator());
137                 Collections.reverse(sortedApps);
138                 return sortedApps;
139         }
140         
141         public List<Application> getApplications(LinkedList<SchedulerEvent> events) {
142                 List<Application> apps = new LinkedList<Application>();
143                 for(SchedulerEvent evt: events) {
144                         apps.add(evt.getApp());
145                 }
146                 return apps;
147         }
148
149         @Override
150         protected String getSchedulerType() {
151                 return SchedulerType.A.toString();
152         }
153
154 }