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

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