* Manuel Peuster (mpeuster)
* Steven Van Rossem (stevenvanrossem)
-
### Dependencies
* needs the latest [Dockernet](https://github.com/mpeuster/dockernet) to be installed on the system
* pyaml
help="Name of compute instance e.g. 'vnf1'")
parser.add_argument(
"--image","-i", dest="image",
- help="Name of container image to be used e.g. 'ubuntu'")
+ help="Name of container image to be used e.g. 'ubuntu:trusty'")
parser.add_argument(
"--dcmd", "-c", dest="docker_command",
help="Startup command of the container e.g. './start.sh'")
raise Exception("Container with name %s already exists." % name)
# set default parameter
if image is None:
- image = "ubuntu"
+ image = "ubuntu:trusty"
if network is None:
network = {} # {"ip": "10.0.0.254/8"}
if isinstance(network, dict):
self.deactivate_mem_limit = deactivate_mem_limit
self.single_cu = 0
self.single_mu = 0
- super(self.__class__, self).__init__()
+ self.cpu_op_factor = 1.0 # over provisioning factor
+ self.mem_op_factor = 1.0
+ self.raise_no_cpu_resources_left = True
+ self.raise_no_mem_resources_left = True
+ super(UpbSimpleCloudDcRM, self).__init__()
def allocate(self, d):
"""
"""
fl_cu = self._get_flavor(d).get("compute")
# check for over provisioning
- if self.dc_alloc_cu + fl_cu > self.dc_max_cu:
+ if self.dc_alloc_cu + fl_cu > self.dc_max_cu and self.raise_no_cpu_resources_left:
raise Exception("Not enough compute resources left.")
self.dc_alloc_cu += fl_cu
"""
fl_mu = self._get_flavor(d).get("memory")
# check for over provisioning
- if self.dc_alloc_mu + fl_mu > self.dc_max_mu:
+ if self.dc_alloc_mu + fl_mu > self.dc_max_mu and self.raise_no_mem_resources_left:
raise Exception("Not enough memory resources left.")
self.dc_alloc_mu += fl_mu
"""
Recalculate real resource limits for all allocated containers and apply them
to their cgroups.
- We have to recalculate for all to allow e.g. overprovisioning models.
+ We have to recalculate for all containers to allow e.g. over provisioning models.
:return:
"""
for d in self._allocated_compute_instances.itervalues():
:return:
"""
number_cu = self._get_flavor(d).get("compute")
- # get cpu time fraction for entire emulation
- e_cpu = self.registrar.e_cpu
# calculate cpu time fraction of a single compute unit
- self.single_cu = float(e_cpu) / sum([rm.dc_max_cu for rm in list(self.registrar.resource_models)])
+ self.single_cu = self._compute_single_cu()
# calculate cpu time fraction for container with given flavor
cpu_time_percentage = self.single_cu * number_cu
# calculate input values for CFS scheduler bandwidth limitation
cpu_period, cpu_quota = self._calculate_cpu_cfs_values(cpu_time_percentage)
# apply limits to container if changed
if d.cpu_period != cpu_period or d.cpu_quota != cpu_quota:
- LOG.debug("Setting CPU limit for %r: cpu_quota = cpu_period * limit = %f * %f = %f" % (
- d.name, cpu_period, cpu_time_percentage, cpu_quota))
+ LOG.debug("Setting CPU limit for %r: cpu_quota = cpu_period * limit = %f * %f = %f (op_factor=%f)" % (
+ d.name, cpu_period, cpu_time_percentage, cpu_quota, self.cpu_op_factor))
d.updateCpuLimit(cpu_period=int(cpu_period), cpu_quota=int(cpu_quota))
+ def _compute_single_cu(self):
+ """
+ Calculate percentage of CPU time of a singe CU unit.
+ :return:
+ """
+ # get cpu time fraction for entire emulation
+ e_cpu = self.registrar.e_cpu
+ # calculate
+ return float(e_cpu) / sum([rm.dc_max_cu for rm in list(self.registrar.resource_models)])
+
def _calculate_cpu_cfs_values(self, cpu_time_percentage):
"""
Calculate cpu period and quota for CFS
mem_limit = self._calculate_mem_limit_value(mem_limit)
# apply to container if changed
if d.mem_limit != mem_limit:
- LOG.debug("Setting MEM limit for %r: mem_limit = %f MB" % (d.name, mem_limit/1024/1024))
+ LOG.debug("Setting MEM limit for %r: mem_limit = %f MB (op_factor=%f)" %
+ (d.name, mem_limit/1024/1024, self.mem_op_factor))
d.updateMemoryLimit(mem_limit=mem_limit)
def _calculate_mem_limit_value(self, mem_limit):
r["dc_alloc_mu"] = self.dc_alloc_mu
r["single_cu_percentage"] = self.single_cu
r["single_mu_percentage"] = self.single_mu
+ r["cpu_op_factor"] = self.cpu_op_factor
+ r["mem_op_factor"] = self.mem_op_factor
r["allocation_state"] = allocation_state
return r
# append to logfile
with open(path, "a") as f:
f.write("%s\n" % json.dumps(l))
+
+
+class UpbOverprovisioningCloudDcRM(UpbSimpleCloudDcRM):
+ """
+ This will be an example resource model that limits the overall
+ resources that can be deployed per data center.
+ Allows over provisioning. Might result in reducing resources of single
+ containers whenever a data-center is over provisioned.
+ """
+ # TODO add parts for memory
+ def __init__(self, *args, **kvargs):
+ super(UpbOverprovisioningCloudDcRM, self).__init__(*args, **kvargs)
+ self.raise_no_cpu_resources_left = False
+
+ def _compute_single_cu(self):
+ """
+ Calculate percentage of CPU time of a singe CU unit.
+ Take scale-down facte for over provisioning into account.
+ :return:
+ """
+ # get cpu time fraction for entire emulation
+ e_cpu = self.registrar.e_cpu
+ # calculate over provisioning scale factor
+ self.cpu_op_factor = float(self.dc_max_cu) / (max(self.dc_max_cu, self.dc_alloc_cu))
+ # calculate
+ return float(e_cpu) / sum([rm.dc_max_cu for rm in list(self.registrar.resource_models)]) * self.cpu_op_factor
+
from emuvim.dcemulator.net import DCNetwork
from emuvim.api.zerorpc.compute import ZeroRpcApiEndpoint
from emuvim.api.sonata import SonataDummyGatekeeperEndpoint
-from emuvim.dcemulator.resourcemodel.upb.simple import UpbSimpleCloudDcRM
+from emuvim.dcemulator.resourcemodel.upb.simple import UpbSimpleCloudDcRM, UpbOverprovisioningCloudDcRM
logging.basicConfig(level=logging.INFO)
# create and assign resource models for each DC
rm1 = UpbSimpleCloudDcRM(max_cu=4, max_mu=1024)
- rm2 = UpbSimpleCloudDcRM(max_cu=6)
+ rm2 = UpbOverprovisioningCloudDcRM(max_cu=4)
dc1.assignResourceModel(rm1)
dc2.assignResourceModel(rm2)
dc1.startCompute("vnf2", flavor_name="tiny")
dc1.startCompute("vnf3", flavor_name="small")
dc2.startCompute("vnf4", flavor_name="medium")
+ dc2.startCompute("vnf5", flavor_name="medium")
+ dc2.startCompute("vnf6", flavor_name="medium")
print "... done."
time.sleep(5)
print "Removing instances ..."
self.h.append(self.net.addHost('h%d' % i))
# add some dockers
for i in range(0, ndockers):
- self.d.append(self.net.addDocker('d%d' % i, dimage="ubuntu"))
+ self.d.append(self.net.addDocker('d%d' % i, dimage="ubuntu:trusty"))
def startNet(self):
self.net.start()
import os
from emuvim.test.base import SimpleTestTopology
from emuvim.dcemulator.resourcemodel import BaseResourceModel, ResourceFlavor
-from emuvim.dcemulator.resourcemodel.upb.simple import UpbSimpleCloudDcRM
+from emuvim.dcemulator.resourcemodel.upb.simple import UpbSimpleCloudDcRM, UpbOverprovisioningCloudDcRM
from emuvim.dcemulator.resourcemodel import ResourceModelRegistrar
Test the UpbSimpleCloudDc resource model.
"""
- def testAllocation(self):
+ def testAllocationComputations(self):
"""
Test the allocation procedures and correct calculations.
:return:
self.assertEqual(float(c2.cpu_quota) / c2.cpu_period, E_CPU / MAX_CU * 1) # validate compute result
self.assertEqual(float(c2.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 128) # validate memory result
-
c3 = createDummyContainerObject("c3", flavor="medium")
- res = rm.allocate(c3) # calculate allocation
+ rm.allocate(c3) # calculate allocation
self.assertEqual(float(c3.cpu_quota) / c3.cpu_period, E_CPU / MAX_CU * 4) # validate compute result
self.assertEqual(float(c3.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 256) # validate memory result
-
c4 = createDummyContainerObject("c4", flavor="large")
rm.allocate(c4) # calculate allocation
self.assertEqual(float(c4.cpu_quota) / c4.cpu_period, E_CPU / MAX_CU * 8) # validate compute result
self.assertEqual(float(c4.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 512) # validate memory result
-
c5 = createDummyContainerObject("c5", flavor="xlarge")
rm.allocate(c5) # calculate allocation
self.assertEqual(float(c5.cpu_quota) / c5.cpu_period, E_CPU / MAX_CU * 16) # validate compute result
self.stopNet()
+class testUpbOverprovisioningCloudDcRM(SimpleTestTopology):
+ """
+ Test the UpbOverprovisioningCloudDc resource model.
+ """
+
+ def testAllocationComputations(self):
+ """
+ Test the allocation procedures and correct calculations.
+ :return:
+ """
+ # config
+ E_CPU = 1.0
+ MAX_CU = 3
+ E_MEM = 512
+ MAX_MU = 2048
+ # create dummy resource model environment
+ reg = ResourceModelRegistrar(dc_emulation_max_cpu=E_CPU, dc_emulation_max_mem=E_MEM)
+ rm = UpbOverprovisioningCloudDcRM(max_cu=MAX_CU, max_mu=MAX_MU)
+ reg.register("test_dc", rm)
+
+ c1 = createDummyContainerObject("c1", flavor="small")
+ rm.allocate(c1) # calculate allocation
+ self.assertAlmostEqual(float(c1.cpu_quota) / c1.cpu_period, E_CPU / MAX_CU * 1.0, places=5)
+ self.assertAlmostEqual(float(c1.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 128)
+ self.assertAlmostEqual(rm.cpu_op_factor, 1.0)
+
+ c2 = createDummyContainerObject("c2", flavor="small")
+ rm.allocate(c2) # calculate allocation
+ self.assertAlmostEqual(float(c2.cpu_quota) / c2.cpu_period, E_CPU / MAX_CU * 1.0, places=5)
+ self.assertAlmostEqual(float(c2.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 128)
+ self.assertAlmostEqual(rm.cpu_op_factor, 1.0)
+
+ c3 = createDummyContainerObject("c3", flavor="small")
+ rm.allocate(c3) # calculate allocation
+ self.assertAlmostEqual(float(c3.cpu_quota) / c3.cpu_period, E_CPU / MAX_CU * 1.0, places=5)
+ self.assertAlmostEqual(float(c3.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 128)
+ self.assertAlmostEqual(rm.cpu_op_factor, 1.0)
+
+ # from this container onwards, we should go to over provisioning mode:
+ c4 = createDummyContainerObject("c4", flavor="small")
+ rm.allocate(c4) # calculate allocation
+ self.assertAlmostEqual(float(c4.cpu_quota) / c4.cpu_period, E_CPU / MAX_CU * (float(3) / 4), places=5)
+ self.assertAlmostEqual(float(c4.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 128, places=5)
+ self.assertAlmostEqual(rm.cpu_op_factor, 0.75)
+
+ c5 = createDummyContainerObject("c5", flavor="small")
+ rm.allocate(c5) # calculate allocation
+ self.assertAlmostEqual(float(c5.cpu_quota) / c5.cpu_period, E_CPU / MAX_CU * (float(3) / 5), places=5)
+ self.assertAlmostEqual(float(c5.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 128)
+ self.assertAlmostEqual(rm.cpu_op_factor, 0.6)
+
+
import requests
import subprocess
import os
+import unittest
from emuvim.test.base import SimpleTestTopology
from emuvim.api.sonata import SonataDummyGatekeeperEndpoint
class testSonataDummyGatekeeper(SimpleTestTopology):
+ @unittest.skip("disabled test since ubuntu:trusty not used in current example package")
def testAPI(self):
# create network
self.createNet(nswitches=0, ndatacenter=2, nhosts=2, ndockers=0)
projects / osm / vim-emu.git / commitdiff