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 size;
  22         private int RAM;
  23         private int CPU;
  24
  25         private final int initialSize = 850;
  26         private final int initialRAM = 300;
  27         private final int initialCPU = 500;
  28
  29         private boolean running = false;
  30
  31         public PhysicalMachine() {
  32                 id = count;
  33                 count++;
  34         }
  35
  36         public void start() {
  37                 size = initialSize;
  38                 RAM = initialRAM;
  39                 CPU = initialCPU;
  40                 running = true;
  41         }
  42
  43         public void stop() throws VMsRunningException {
  44                 if (VMs.size() > 0)
  45                         throw new VMsRunningException(
  46                                         "PM cannot be stopped. Some VMs still running");
  47
  48                 VMs = new HashMap<Integer, VirtualMachine>();
  49                 size = 0;
  50                 RAM = 0;
  51                 CPU = 0;
  52                 running = false;
  53         }
  54
  55         public double getConsumption() {
  56                 if (running)
  57                         return 200.0 + 0.3 * (CPU - initialCPU);
  58                 else
  59                         return 0.0;
  60         }
  61
  62         public VirtualMachine startVirtualMachine(int sz, int ram, int cpu,
  63                         VMType type) {
  64                 if (checkVM(sz, ram, cpu)) {
  65                         VirtualMachine vm = new VirtualMachine(sz, ram, cpu, this, type);
  66                         VMs.put(vm.getId(), vm);
  67                         size = size + vm.getSize();
  68                         RAM = RAM + vm.getRAM();
  69                         CPU = CPU + vm.getCPU();
  70                         return vm;
  71                 } else
  72                         return null;
  73         }
  74
  75         public void stopVirtualMachine(VirtualMachine vm)
  76                         throws ActiveApplicationsException {
  77                 if (VMs.containsKey(vm.getId())) {
  78                         if (vm.getApplications().size() != 0) {
  79                                 throw new ActiveApplicationsException(
  80                                                 "Applications must be migrated before stopping a VM, VM id "
  81                                                                 + vm.getId());
  82                         } else {
  83                                 VMs.remove(vm.getId());
  84                                 size = size - vm.getSize();
  85                                 RAM = RAM - vm.getRAM();
  86                                 CPU = CPU - vm.getCPU();
  87                         }
  88                 }
  89         }
  90
  91         public boolean checkVM(int size, int RAM, int CPU) {
  92                 return (size <= availableSize()) && (RAM <= availableRAM())
  93                                 && (CPU <= availableCPU());
  94         }
  95
  96         private int availableSize() {
  97                 return maxSize - size;
  98         }
  99
 100         private int availableRAM() {
 101                 return maxRAM - RAM;
 102         }
 103
 104         private int availableCPU() {
 105                 return maxCPU - CPU;
 106         }
 107
 108         public int getCurrentSize() {
 109                 int currSize = initialSize;
 110                 for (VirtualMachine vm : VMs.values())
 111                         currSize += vm.getSize();
 112                 return currSize;
 113         }
 114
 115         public int getCurrentRam() {
 116                 int currRAM = initialRAM;
 117                 for (VirtualMachine vm : VMs.values())
 118                         currRAM += vm.getRAM();
 119                 return currRAM;
 120         }
 121
 122         public int getCurrentCpu() {
 123                 int currCPU = initialCPU;
 124                 for (VirtualMachine vm : VMs.values())
 125                         currCPU += vm.getCPU();
 126                 return currCPU;
 127         }
 128
 129         public double getSizeUtilization() {
 130                 return ((double) (size - initialSize) / (maxSize - initialSize)) * 100;
 131         }
 132
 133         public double getRamUtilization() {
 134                 return ((double) (RAM - initialRAM) / (maxRAM - initialRAM)) * 100;
 135         }
 136
 137         public double getCpuUtilization() {
 138                 return ((double) (CPU - initialCPU) / (maxCPU - initialCPU)) * 100;
 139         }
 140
 141         public double getAverageUtilization() {
 142                 return (getSizeUtilization() + getRamUtilization() + getCpuUtilization()) / 3.0;
 143         }
 144
 145         public int getId() {
 146                 return id;
 147         }
 148
 149         public boolean isRunning() {
 150                 return running;
 151         }
 152
 153         public VirtualMachine getVirtualMachine(int id) {
 154                 return VMs.get(id);
 155         }
 156
 157         public int countCurrentlyRunningVMs() {
 158                 return VMs.values().size();
 159         }
 160 }