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("PM cannot be stopped. Some VMs still running");
  46
  47                 VMs = new HashMap<Integer, VirtualMachine>();
  48                 size = 0;
  49                 RAM = 0;
  50                 CPU = 0;
  51                 running = false;
  52         }
  53
  54         public double getConsumption() {
  55                 return 200 + 0.3 * (CPU - initialCPU);
  56         }
  57
  58         public VirtualMachine startVirtualMachine(int sz, int ram, int cpu, VMType type) {
  59                 if (checkVM(sz, ram, cpu)) {
  60                         VirtualMachine vm = new VirtualMachine(sz, ram, cpu, this, type);
  61                         VMs.put(vm.getId(), vm);
  62                         size = size + vm.getSize();
  63                         RAM = RAM + vm.getRAM();
  64                         CPU = CPU + vm.getCPU();
  65                         return vm;
  66                 } else
  67                         return null;
  68         }
  69
  70         public void stopVirtualMachine(VirtualMachine vm) throws ActiveApplicationsException {
  71                 if (VMs.containsKey(vm.getId())) {
  72                         if (vm.getApplications().size() != 0) {
  73                                 throw new ActiveApplicationsException("Applications must be migrated before stopping a vm, vm id "+vm.getId());
  74                         } else {
  75                                 VMs.remove(vm.getId());
  76                                 size = size - vm.getSize();
  77                                 RAM = RAM - vm.getRAM();
  78                                 CPU = CPU - vm.getCPU();
  79                         }
  80                 }
  81         }
  82
  83         public boolean checkVM(int size, int RAM, int CPU) {
  84                 return (size <= availableSize()) && (RAM <= availableRAM())
  85                                 && (CPU <= availableCPU());
  86         }
  87
  88         private int availableSize() {
  89                 return maxSize - size;
  90         }
  91
  92         private int availableRAM() {
  93                 return maxRAM - RAM;
  94         }
  95
  96         private int availableCPU() {
  97                 return maxCPU - CPU;
  98         }
  99
 100         public double getSizeUtilization() {
 101                 return ((double)(size - initialSize) / (maxSize - initialSize)) * 100;
 102         }
 103
 104         public double getRamUtilization() {
 105                 return ((double)(RAM - initialRAM) / (maxRAM - initialRAM)) * 100;
 106         }
 107
 108         public double getCpuUtilization() {
 109                 return ((double)(CPU - initialCPU) / (maxCPU - initialCPU)) * 100;
 110         }
 111
 112         public double getAverageUtilization() {
 113                 return (getSizeUtilization() + getRamUtilization() + getCpuUtilization()) / 3.0;
 114         }
 115
 116         public int getId() {
 117                 return id;
 118         }
 119
 120         public boolean isRunning() {
 121                 return running;
 122         }
 123
 124         public VirtualMachine getVirtualMachine(int id) {
 125                 return VMs.get(id);
 126         }
 127 }