src/at/ac/tuwien/lsdc/types/PhysicalMachine.java

   1 package at.ac.tuwien.lsdc.types;
   2
   3 import java.util.HashMap;
   4 import java.util.Iterator;
   5
   6 import at.ac.tuwien.lsdc.exception.ActiveApplicationsException;
   7 import at.ac.tuwien.lsdc.exception.VMsRunningException;
   8 import at.ac.tuwien.lsdc.types.VirtualMachine.VMType;
   9
  10 public class PhysicalMachine implements Comparable<PhysicalMachine> {
  11
  12         final int BEFORE = -1;
  13         final int EQUAL = 0;
  14         final int AFTER = 1;
  15
  16         private static int count = 0;
  17
  18         private HashMap<Integer, VirtualMachine> VMs = new HashMap<Integer, VirtualMachine>();
  19
  20         private int id;
  21
  22         private final int maxSize = 50000;
  23         private final int maxRAM = 4700;
  24         private final int maxCPU = 2400;
  25
  26         private int reservedSize;
  27         private int reservedRAM;
  28         private int reservedCPU;
  29
  30         private final int initialSize = 850;
  31         private final int initialRAM = 300;
  32         private final int initialCPU = 500;
  33
  34         private int totalVMs = 0;
  35
  36         private boolean running = false;
  37
  38         public PhysicalMachine() {
  39                 id = count;
  40                 count++;
  41         }
  42
  43         public void start() {
  44                 reservedSize = initialSize;
  45                 reservedRAM = initialRAM;
  46                 reservedCPU = initialCPU;
  47                 running = true;
  48         }
  49
  50         public void stop() throws VMsRunningException {
  51                 if (VMs.size() > 0)
  52                         throw new VMsRunningException("PM cannot be stopped. Some VMs still running");
  53
  54                 VMs = new HashMap<Integer, VirtualMachine>();
  55                 reservedSize = 0;
  56                 reservedRAM = 0;
  57                 reservedCPU = 0;
  58                 running = false;
  59         }
  60
  61         public double getConsumption() {
  62                 if (running)
  63                         return 200.0 + 0.3 * (getCurrentCPU() - initialCPU);
  64                 else
  65                         return 0.0;
  66         }
  67
  68         // Creates a VirtualMachine of maximum possible Size
  69         public VirtualMachine startVirtualMachine(VMType type) {
  70                 VirtualMachine vm = new VirtualMachine(maxSize - initialSize - VirtualMachine.initialSize,
  71                                 maxRAM - initialRAM - VirtualMachine.initialRAM, maxCPU - initialCPU
  72                                                 - VirtualMachine.initialCPU, this, type);
  73                 return vm;
  74         }
  75
  76         public VirtualMachine startVirtualMachine(int sz, int ram, int cpu, VMType type) {
  77                 if (checkVM(sz, ram, cpu)) {
  78                         VirtualMachine vm = new VirtualMachine(sz, ram, cpu, this, type);
  79                         VMs.put(vm.getId(), vm);
  80                         reservedSize = reservedSize + vm.getReservedSize();
  81                         reservedRAM = reservedRAM + vm.getReservedRAM();
  82                         reservedCPU = reservedCPU + vm.getReservedCPU();
  83                         totalVMs++;
  84                         return vm;
  85                 } else
  86                         return null;
  87         }
  88
  89         public void stopVirtualMachine(VirtualMachine vm) throws ActiveApplicationsException {
  90                 if (VMs.containsKey(vm.getId())) {
  91                         if (vm.getApplications().size() != 0) {
  92                                 throw new ActiveApplicationsException(
  93                                                 "Applications must be migrated before stopping a VM, VM id " + vm.getId());
  94                         } else {
  95                                 VMs.remove(vm.getId());
  96                                 reservedSize = reservedSize - vm.getReservedSize();
  97                                 reservedRAM = reservedRAM - vm.getReservedRAM();
  98                                 reservedCPU = reservedCPU - vm.getReservedCPU();
  99                         }
 100                 }
 101         }
 102
 103         public boolean checkVM(int size, int RAM, int CPU) {
 104                 return ((VirtualMachine.initialSize + size) <= availableSize())
 105                                 && ((VirtualMachine.initialRAM + RAM) <= availableRAM())
 106                                 && ((VirtualMachine.initialCPU + CPU) <= availableCPU());
 107         }
 108
 109         private int availableSize() {
 110                 return maxSize - reservedSize;
 111         }
 112
 113         private int availableRAM() {
 114                 return maxRAM - reservedRAM;
 115         }
 116
 117         private int availableCPU() {
 118                 return maxCPU - reservedCPU;
 119         }
 120
 121         public int getCurrentSize() {
 122                 int currSize = initialSize;
 123                 for (VirtualMachine vm : VMs.values())
 124                         currSize += vm.getSize();
 125                 return currSize;
 126         }
 127
 128         public int getCurrentRam() {
 129                 int currRAM = initialRAM;
 130                 for (VirtualMachine vm : VMs.values())
 131                         currRAM += vm.getRAM();
 132                 return currRAM;
 133         }
 134
 135         public int getCurrentCPU() {
 136                 int currCPU = initialCPU;
 137                 for (VirtualMachine vm : VMs.values())
 138                         currCPU += vm.getCPU();
 139                 return currCPU;
 140         }
 141
 142         public double getSizeUtilization() {
 143                 return ((double) (getCurrentSize() - initialSize) / (maxSize - initialSize)) * 100;
 144         }
 145
 146         public double getRamUtilization() {
 147                 return ((double) (getCurrentRam() - initialRAM) / (maxRAM - initialRAM)) * 100;
 148         }
 149
 150         public double getCpuUtilization() {
 151                 return ((double) (getCurrentCPU() - initialCPU) / (maxCPU - initialCPU)) * 100;
 152         }
 153
 154         public double getAverageUtilization() {
 155                 return (getSizeUtilization() + getRamUtilization() + getCpuUtilization()) / 3.0;
 156         }
 157
 158         public int getId() {
 159                 return id;
 160         }
 161
 162         public boolean isRunning() {
 163                 return running;
 164         }
 165
 166         public VirtualMachine getVirtualMachine(int id) {
 167                 return VMs.get(id);
 168         }
 169
 170         public VirtualMachine getLatestVM() {
 171                 VirtualMachine vm = null;
 172                 for(Iterator<VirtualMachine> it = VMs.values().iterator(); it.hasNext(); ) {
 173                         vm = it.next();
 174                 }
 175                 return vm;
 176         }
 177
 178         public Integer getLatestVMID() {
 179                 return getLatestVM().getId();
 180         }
 181
 182         /**
 183          * return a list of all VMs running on this PM.
 184          *
 185          * @return a HashMap with all VMs running on this PM.
 186          */
 187         public HashMap<Integer, VirtualMachine> getVirtualMachines() {
 188                 return VMs;
 189         }
 190
 191         public int countCurrentlyRunningVMs() {
 192                 return VMs.values().size();
 193         }
 194
 195         public int getReservedSize() {
 196                 return reservedSize;
 197         }
 198
 199         public int getReservedRAM() {
 200                 return reservedRAM;
 201         }
 202
 203         public int getReservedCPU() {
 204                 return reservedCPU;
 205         }
 206
 207         public int getTotalVMs() {
 208                 return totalVMs;
 209         }
 210
 211         @Override
 212         public int compareTo(PhysicalMachine other) {
 213                 if (this == other)
 214                         return EQUAL;
 215
 216                 if (getAverageUtilization() < other.getAverageUtilization())
 217                         return BEFORE;
 218                 else if (getAverageUtilization() > other.getAverageUtilization())
 219                         return AFTER;
 220                 else
 221                         return EQUAL;
 222         }
 223 }