X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=src%2Femuvim%2Ftest%2Funittests%2Ftest_resourcemodel.py;h=4a21feeabc8e30b6ff43f946464501e905f96efd;hb=3e16acbebd2c6669c1bbe5a7e3bb313aa1494e20;hp=165893de9f3b3dbe278756bafdf8c7530a220e1d;hpb=19f830b3624710e82d494cb28d8755fdbcb40e9d;p=osm%2Fvim-emu.git diff --git a/src/emuvim/test/unittests/test_resourcemodel.py b/src/emuvim/test/unittests/test_resourcemodel.py old mode 100644 new mode 100755 index 165893d..4a21fee --- a/src/emuvim/test/unittests/test_resourcemodel.py +++ b/src/emuvim/test/unittests/test_resourcemodel.py @@ -1,3 +1,31 @@ +""" +Copyright (c) 2015 SONATA-NFV +ALL RIGHTS RESERVED. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +Neither the name of the SONATA-NFV [, ANY ADDITIONAL AFFILIATION] +nor the names of its contributors may be used to endorse or promote +products derived from this software without specific prior written +permission. + +This work has been performed in the framework of the SONATA project, +funded by the European Commission under Grant number 671517 through +the Horizon 2020 and 5G-PPP programmes. The authors would like to +acknowledge the contributions of their colleagues of the SONATA +partner consortium (www.sonata-nfv.eu). +""" + import time import os import unittest @@ -68,17 +96,24 @@ def createDummyContainerObject(name, flavor): class DummyContainer(object): def __init__(self): - self.cpu_period = -1 - self.cpu_quota = -1 - self.mem_limit = -1 - self.memswap_limit = -1 + # take defaukt values from son-emu + self.resources = dict( + cpu_period = -1, + cpu_quota = -1, + mem_limit = -1, + memswap_limit = -1 + ) + #self.cpu_period = self.resources['cpu_period'] + #self.cpu_quota = self.resources['cpu_quota'] + #self.mem_limit = self.resources['mem_limit'] + #self.memswap_limit = self.resources['memswap_limit'] def updateCpuLimit(self, cpu_period, cpu_quota): - self.cpu_period = cpu_period - self.cpu_quota = cpu_quota + self.resources['cpu_period'] = cpu_period + self.resources['cpu_quota'] = cpu_quota def updateMemoryLimit(self, mem_limit): - self.mem_limit = mem_limit + self.resources['mem_limit'] = mem_limit d = DummyContainer() d.name = name @@ -110,28 +145,28 @@ class testUpbSimpleCloudDcRM(SimpleTestTopology): c1 = createDummyContainerObject("c1", flavor="tiny") rm.allocate(c1) # calculate allocation - self.assertEqual(float(c1.cpu_quota) / c1.cpu_period, E_CPU / MAX_CU * 0.5) # validate compute result - self.assertEqual(float(c1.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 32) # validate memory result + self.assertEqual(float(c1.resources['cpu_quota']) / c1.resources['cpu_period'], E_CPU / MAX_CU * 0.5) # validate compute result + self.assertEqual(float(c1.resources['mem_limit']/1024/1024), float(E_MEM) / MAX_MU * 32) # validate memory result c2 = createDummyContainerObject("c2", flavor="small") rm.allocate(c2) # calculate allocation - 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 + self.assertEqual(float(c2.resources['cpu_quota']) / c2.resources['cpu_period'], E_CPU / MAX_CU * 1) # validate compute result + self.assertEqual(float(c2.resources['mem_limit']/1024/1024), float(E_MEM) / MAX_MU * 128) # validate memory result c3 = createDummyContainerObject("c3", flavor="medium") 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 + self.assertEqual(float(c3.resources['cpu_quota']) / c3.resources['cpu_period'], E_CPU / MAX_CU * 4) # validate compute result + self.assertEqual(float(c3.resources['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 + self.assertEqual(float(c4.resources['cpu_quota']) / c4.resources['cpu_period'], E_CPU / MAX_CU * 8) # validate compute result + self.assertEqual(float(c4.resources['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.assertEqual(float(c5.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 1024) # validate memory result + self.assertEqual(float(c5.resources['cpu_quota']) / c5.resources['cpu_period'], E_CPU / MAX_CU * 16) # validate compute result + self.assertEqual(float(c5.resources['mem_limit']/1024/1024), float(E_MEM) / MAX_MU * 1024) # validate memory result def testAllocationCpuLimit(self): @@ -245,7 +280,7 @@ class testUpbSimpleCloudDcRM(SimpleTestTopology): # check if there is a real limitation set for containers cgroup # deactivated for now, seems not to work in docker-in-docker setup used in CI - self.assertEqual(float(tc1.cpu_quota)/tc1.cpu_period, 0.005) + self.assertEqual(float(tc1.resources['cpu_quota'])/tc1.resources['cpu_period'], 0.005) # check if free was called during stopCompute self.dc[0].stopCompute("tc1") @@ -278,33 +313,33 @@ class testUpbOverprovisioningCloudDcRM(SimpleTestTopology): 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(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.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(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.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(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.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(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.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(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)