def testAllocationMemLimit(self):
"""
Test MEM allocation limit
:return:
"""
# config
E_CPU = 1.0
MAX_CU = 500
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 = UpbSimpleCloudDcRM(max_cu=MAX_CU, max_mu=MAX_MU)
reg.register("test_dc", rm)
# test over provisioning exeption
exception = False
try:
c6 = createDummyContainerObject("c6", flavor="xlarge")
c7 = createDummyContainerObject("c7", flavor="xlarge")
c8 = createDummyContainerObject("c8", flavor="xlarge")
rm.allocate(c6) # calculate allocation
rm.allocate(c7) # calculate allocation
rm.allocate(c8) # calculate allocation
except NotEnoughResourcesAvailable as e:
self.assertIn("Not enough memory", e.message)
exception = True
self.assertTrue(exception)
def testAllocationMemLimit(self):
"""
Test MEM allocation limit
:return:
"""
# config
E_CPU = 1.0
MAX_CU = 500
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 = UpbSimpleCloudDcRM(max_cu=MAX_CU, max_mu=MAX_MU)
reg.register("test_dc", rm)
# test over provisioning exeption
exception = False
try:
c6 = createDummyContainerObject("c6", flavor="xlarge")
c7 = createDummyContainerObject("c7", flavor="xlarge")
c8 = createDummyContainerObject("c8", flavor="xlarge")
rm.allocate(c6) # calculate allocation
rm.allocate(c7) # calculate allocation
rm.allocate(c8) # calculate allocation
except NotEnoughResourcesAvailable as e:
self.assertIn("Not enough memory", str(e))
exception = True
self.assertTrue(exception)
def testAllocationComputations(self):
"""
Test the allocation procedures and correct calculations.
:return:
"""
# config
E_CPU = 1.0
MAX_CU = 100
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 = UpbSimpleCloudDcRM(max_cu=MAX_CU, max_mu=MAX_MU)
reg.register("test_dc", rm)
c1 = createDummyContainerObject("c1", flavor="tiny")
rm.allocate(c1) # calculate allocation
# validate compute result
self.assertEqual(float(
c1.resources['cpu_quota']) / c1.resources['cpu_period'], E_CPU / MAX_CU * 0.5)
# validate memory result
self.assertEqual(
float(c1.resources['mem_limit'] / 1024 / 1024), float(E_MEM) / MAX_MU * 32)
c2 = createDummyContainerObject("c2", flavor="small")
rm.allocate(c2) # calculate allocation
# validate compute result
self.assertEqual(float(
c2.resources['cpu_quota']) / c2.resources['cpu_period'], E_CPU / MAX_CU * 1)
# validate memory result
self.assertEqual(
float(c2.resources['mem_limit'] / 1024 / 1024), float(E_MEM) / MAX_MU * 128)
c3 = createDummyContainerObject("c3", flavor="medium")
rm.allocate(c3) # calculate allocation
# validate compute result
self.assertEqual(float(
c3.resources['cpu_quota']) / c3.resources['cpu_period'], E_CPU / MAX_CU * 4)
# validate memory result
self.assertEqual(
float(c3.resources['mem_limit'] / 1024 / 1024), float(E_MEM) / MAX_MU * 256)
c4 = createDummyContainerObject("c4", flavor="large")
rm.allocate(c4) # calculate allocation
# validate compute result
self.assertEqual(float(
c4.resources['cpu_quota']) / c4.resources['cpu_period'], E_CPU / MAX_CU * 8)
# validate memory result
self.assertEqual(
float(c4.resources['mem_limit'] / 1024 / 1024), float(E_MEM) / MAX_MU * 512)
c5 = createDummyContainerObject("c5", flavor="xlarge")
rm.allocate(c5) # calculate allocation
# validate compute result
self.assertEqual(float(
c5.resources['cpu_quota']) / c5.resources['cpu_period'], E_CPU / MAX_CU * 16)
# validate memory result
self.assertEqual(
float(c5.resources['mem_limit'] / 1024 / 1024), float(E_MEM) / MAX_MU * 1024)
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.resources['cpu_quota']) / c1.resources['cpu_period'], E_CPU / MAX_CU * 1.0, places=5)
self.assertAlmostEqual(
float(c1.resources['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.resources['cpu_quota']) / c2.resources['cpu_period'], E_CPU / MAX_CU * 1.0, places=5)
self.assertAlmostEqual(
float(c2.resources['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.resources['cpu_quota']) / c3.resources['cpu_period'], E_CPU / MAX_CU * 1.0, places=5)
self.assertAlmostEqual(
float(c3.resources['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.resources['cpu_quota']) / c4.resources['cpu_period'], E_CPU / MAX_CU * (float(3) / 4), places=5)
self.assertAlmostEqual(float(
c4.resources['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.resources['cpu_quota']) / c5.resources['cpu_period'], E_CPU / MAX_CU * (float(3) / 5), places=5)
self.assertAlmostEqual(
float(c5.resources['mem_limit'] / 1024 / 1024), float(E_MEM) / MAX_MU * 128)
self.assertAlmostEqual(rm.cpu_op_factor, 0.6)
def testFree(self):
"""
Test the free procedure.
:return:
"""
# create dummy resource model environment
reg = ResourceModelRegistrar(dc_emulation_max_cpu=1.0,
dc_emulation_max_mem=512)
rm = UpbSimpleCloudDcRM(max_cu=100, max_mu=100)
reg.register("test_dc", rm)
c1 = createDummyContainerObject("c6", flavor="tiny")
rm.allocate(c1) # calculate allocation
self.assertTrue(rm.dc_alloc_cu == 0.5)
rm.free(c1)
self.assertTrue(rm.dc_alloc_cu == 0)
def testFree(self):
"""
Test the free procedure.
:return:
"""
# create dummy resource model environment
reg = ResourceModelRegistrar(
dc_emulation_max_cpu=1.0, dc_emulation_max_mem=512)
rm = UpbSimpleCloudDcRM(max_cu=100, max_mu=100)
reg.register("test_dc", rm)
c1 = createDummyContainerObject("c6", flavor="tiny")
rm.allocate(c1) # calculate allocation
self.assertTrue(rm.dc_alloc_cu == 0.5)
rm.free(c1)
self.assertTrue(rm.dc_alloc_cu == 0)
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 = UpbDummyRM(max_cu=MAX_CU, max_mu=MAX_MU)
reg.register("test_dc", rm)
c1 = createDummyContainerObject("c1", flavor="small")
rm.allocate(c1) # calculate allocation
self.assertEqual(len(rm._allocated_compute_instances), 1)
c2 = createDummyContainerObject("c2", flavor="small")
rm.allocate(c2) # calculate allocation
self.assertEqual(len(rm._allocated_compute_instances), 2)
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 = UpbDummyRM(max_cu=MAX_CU, max_mu=MAX_MU)
reg.register("test_dc", rm)
c1 = createDummyContainerObject("c1", flavor="small")
rm.allocate(c1) # calculate allocation
self.assertEqual(len(rm._allocated_compute_instances), 1)
c2 = createDummyContainerObject("c2", flavor="small")
rm.allocate(c2) # calculate allocation
self.assertEqual(len(rm._allocated_compute_instances), 2)
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.resources['cpu_quota']) /
c1.resources['cpu_period'],
E_CPU / MAX_CU * 1.0,
places=5)
self.assertAlmostEqual(float(c1.resources['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.resources['cpu_quota']) /
c2.resources['cpu_period'],
E_CPU / MAX_CU * 1.0,
places=5)
self.assertAlmostEqual(float(c2.resources['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.resources['cpu_quota']) /
c3.resources['cpu_period'],
E_CPU / MAX_CU * 1.0,
places=5)
self.assertAlmostEqual(float(c3.resources['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.resources['cpu_quota']) /
c4.resources['cpu_period'],
E_CPU / MAX_CU * (float(3) / 4),
places=5)
self.assertAlmostEqual(float(c4.resources['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.resources['cpu_quota']) /
c5.resources['cpu_period'],
E_CPU / MAX_CU * (float(3) / 5),
places=5)
self.assertAlmostEqual(float(c5.resources['mem_limit'] / 1024 / 1024),
float(E_MEM) / MAX_MU * 128)
self.assertAlmostEqual(rm.cpu_op_factor, 0.6)
def testAllocationComputations(self):
"""
Test the allocation procedures and correct calculations.
:return:
"""
# config
E_CPU = 1.0
MAX_CU = 100
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 = UpbSimpleCloudDcRM(max_cu=MAX_CU, max_mu=MAX_MU)
reg.register("test_dc", rm)
c1 = createDummyContainerObject("c1", flavor="tiny")
rm.allocate(c1) # calculate allocation
# validate compute result
self.assertEqual(
float(c1.resources['cpu_quota']) / c1.resources['cpu_period'],
E_CPU / MAX_CU * 0.5)
# validate memory result
self.assertEqual(float(c1.resources['mem_limit'] / 1024 / 1024),
float(E_MEM) / MAX_MU * 32)
c2 = createDummyContainerObject("c2", flavor="small")
rm.allocate(c2) # calculate allocation
# validate compute result
self.assertEqual(
float(c2.resources['cpu_quota']) / c2.resources['cpu_period'],
E_CPU / MAX_CU * 1)
# validate memory result
self.assertEqual(float(c2.resources['mem_limit'] / 1024 / 1024),
float(E_MEM) / MAX_MU * 128)
c3 = createDummyContainerObject("c3", flavor="medium")
rm.allocate(c3) # calculate allocation
# validate compute result
self.assertEqual(
float(c3.resources['cpu_quota']) / c3.resources['cpu_period'],
E_CPU / MAX_CU * 4)
# validate memory result
self.assertEqual(float(c3.resources['mem_limit'] / 1024 / 1024),
float(E_MEM) / MAX_MU * 256)
c4 = createDummyContainerObject("c4", flavor="large")
rm.allocate(c4) # calculate allocation
# validate compute result
self.assertEqual(
float(c4.resources['cpu_quota']) / c4.resources['cpu_period'],
E_CPU / MAX_CU * 8)
# validate memory result
self.assertEqual(float(c4.resources['mem_limit'] / 1024 / 1024),
float(E_MEM) / MAX_MU * 512)
c5 = createDummyContainerObject("c5", flavor="xlarge")
rm.allocate(c5) # calculate allocation
# validate compute result
self.assertEqual(
float(c5.resources['cpu_quota']) / c5.resources['cpu_period'],
E_CPU / MAX_CU * 16)
# validate memory result
self.assertEqual(float(c5.resources['mem_limit'] / 1024 / 1024),
float(E_MEM) / MAX_MU * 1024)