src/emuvim/dcemulator/resourcemodel/upb/simple.py

   1 """
   2 Playground for resource models created by University of Paderborn.
   3 """
   4 import logging
   5 from emuvim.dcemulator.resourcemodel import BaseResourceModel
   6
   7 LOG = logging.getLogger("rm.upb.simple")
   8 LOG.setLevel(logging.DEBUG)
   9
  10
  11 class UpbSimpleCloudDcRM(BaseResourceModel):
  12     """
  13     This will be an example resource model that limits the overall
  14     resources that can be deployed per data center.
  15     No over provisioning. Resources are fixed throughout entire container
  16     lifetime.
  17     """
  18
  19     def __init__(self, max_cu=32, max_mu=1024):
  20         """
  21         Initialize model.
  22         :param max_cu: Maximum number of compute units available in this DC.
  23         :param max_mu: Maximum memory of entire dc.
  24         :return:
  25         """
  26         self.dc_max_cu = max_cu
  27         self.dc_max_mu = max_mu
  28         self.dc_alloc_cu = 0
  29         self.dc_alloc_mu = 0
  30         super(self.__class__, self).__init__()
  31
  32     def allocate(self, name, flavor_name):
  33         """
  34         Calculate resources for container with given flavor.
  35         :param name: Container name.
  36         :param flavor_name: Flavor name.
  37         :return:
  38         """
  39         # bookkeeping and flavor handling
  40         if flavor_name not in self._flavors:
  41             raise Exception("Flavor %r does not exist" % flavor_name)
  42         fl = self._flavors.get(flavor_name)
  43         self.allocated_compute_instances[name] = flavor_name
  44         # calc and return
  45         return self._allocate_cpu(fl), self._allocate_mem(fl), -1.0  # return 3tuple (cpu, memory, disk)
  46
  47     def free(self, name):
  48         """
  49         Free resources of given container.
  50         :param name: Container name.
  51         :return:
  52         """
  53         if name not in self.allocated_compute_instances:
  54             return False
  55         # bookkeeping
  56         self._free_cpu(self._flavors.get(self.allocated_compute_instances[name]))
  57         self._free_mem(self._flavors.get(self.allocated_compute_instances[name]))
  58         del self.allocated_compute_instances[name]
  59         # we don't have to calculate anything special here in this simple model
  60         return True
  61
  62     def _allocate_cpu(self, flavor):
  63         """
  64         Allocate CPU time.
  65         :param flavor: flavor dict
  66         :return: cpu time fraction
  67         """
  68         fl_cu = flavor.get("compute")
  69         # check for over provisioning
  70         if self.dc_alloc_cu + fl_cu > self.dc_max_cu:
  71             raise Exception("Not enough compute resources left.")
  72         self.dc_alloc_cu += fl_cu
  73         # get cpu time fraction for entire emulation
  74         e_cpu = self.registrar.e_cpu
  75         # calculate cpu time fraction of a single compute unit
  76         cu = float(e_cpu) / sum([rm.dc_max_cu for rm in list(self.registrar.resource_models)])
  77         # calculate cpu time fraction for container with given flavor
  78         return cu * fl_cu
  79
  80     def _free_cpu(self, flavor):
  81         """
  82         Free CPU allocation.
  83         :param flavor: flavor dict
  84         :return:
  85         """
  86         self.dc_alloc_cu -= flavor.get("compute")
  87
  88     def _allocate_mem(self, flavor):
  89         """
  90         Allocate mem.
  91         :param flavor: flavor dict
  92         :return: mem limit in MB
  93         """
  94         fl_mu = flavor.get("memory")
  95         # check for over provisioning
  96         if self.dc_alloc_mu + fl_mu > self.dc_max_mu:
  97             raise Exception("Not enough memory resources left.")
  98         self.dc_alloc_mu += fl_mu
  99         # get cpu time fraction for entire emulation
 100         e_mem = self.registrar.e_mem
 101         # calculate cpu time fraction of a single compute unit
 102         mu = float(e_mem) / sum([rm.dc_max_mu for rm in list(self.registrar.resource_models)])
 103         # calculate cpu time fraction for container with given flavor
 104         return mu * fl_mu
 105
 106     def _free_mem(self, flavor):
 107         """
 108         Free memory allocation
 109         :param flavor: flavor dict
 110         :return:
 111         """
 112         self.dc_alloc_mu -= flavor.get("memory")