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         public boolean checkExtendVM(int sizeDiff, int ramDiff, int CPUDiff) {
 110                 return ((sizeDiff <= availableSize()) && (ramDiff <= availableRAM()) && (CPUDiff <= availableCPU()));
 111         }
 112
 113         private int availableSize() {
 114                 return maxSize - reservedSize;
 115         }
 116
 117         private int availableRAM() {
 118                 return maxRAM - reservedRAM;
 119         }
 120
 121         private int availableCPU() {
 122                 return maxCPU - reservedCPU;
 123         }
 124
 125         public int getCurrentSize() {
 126                 int currSize = initialSize;
 127                 for (VirtualMachine vm : VMs.values())
 128                         currSize += vm.getSize();
 129                 return currSize;
 130         }
 131
 132         public int getCurrentRam() {
 133                 int currRAM = initialRAM;
 134                 for (VirtualMachine vm : VMs.values())
 135                         currRAM += vm.getRAM();
 136                 return currRAM;
 137         }
 138
 139         public int getCurrentCPU() {
 140                 int currCPU = initialCPU;
 141                 for (VirtualMachine vm : VMs.values())
 142                         currCPU += vm.getCPU();
 143                 return currCPU;
 144         }
 145
 146         public double getSizeUtilization() {
 147                 return ((double) (getCurrentSize() - initialSize) / (maxSize - initialSize)) * 100;
 148         }
 149
 150         public double getRamUtilization() {
 151                 return ((double) (getCurrentRam() - initialRAM) / (maxRAM - initialRAM)) * 100;
 152         }
 153
 154         public double getCpuUtilization() {
 155                 return ((double) (getCurrentCPU() - initialCPU) / (maxCPU - initialCPU)) * 100;
 156         }
 157
 158         public double getAverageUtilization() {
 159                 return (getSizeUtilization() + getRamUtilization() + getCpuUtilization()) / 3.0;
 160         }
 161
 162         public int getId() {
 163                 return id;
 164         }
 165
 166         public boolean isRunning() {
 167                 return running;
 168         }
 169
 170         public VirtualMachine getVirtualMachine(int id) {
 171                 return VMs.get(id);
 172         }
 173
 174         public VirtualMachine getLatestVM() {
 175                 VirtualMachine vm = null;
 176                 for (Iterator<VirtualMachine> it = VMs.values().iterator(); it.hasNext();) {
 177                         vm = it.next();
 178                 }
 179                 return vm;
 180         }
 181
 182         public Integer getLatestVMID() {
 183                 return getLatestVM().getId();
 184         }
 185
 186         /**
 187          * return a list of all VMs running on this PM.
 188          *
 189          * @return a HashMap with all VMs running on this PM.
 190          */
 191         public HashMap<Integer, VirtualMachine> getVirtualMachines() {
 192                 return VMs;
 193         }
 194
 195         public int countCurrentlyRunningVMs() {
 196                 return VMs.values().size();
 197         }
 198
 199         public int getReservedSize() {
 200                 return reservedSize;
 201         }
 202
 203         public int getReservedRAM() {
 204                 return reservedRAM;
 205         }
 206
 207         public int getReservedCPU() {
 208                 return reservedCPU;
 209         }
 210
 211         public int getTotalVMs() {
 212                 return totalVMs;
 213         }
 214
 215         @Override
 216         public int compareTo(PhysicalMachine other) {
 217                 if (this == other)
 218                         return EQUAL;
 219
 220                 if (getAverageUtilization() < other.getAverageUtilization())
 221                         return BEFORE;
 222                 else if (getAverageUtilization() > other.getAverageUtilization())
 223                         return AFTER;
 224                 else
 225                         return EQUAL;
 226         }
 227 }