-"""
-Copyright (c) 2015 SONATA-NFV and Paderborn University
-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, Paderborn University
-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).
-"""
-"""
-Playground for resource models created by University of Paderborn.
-"""
+# Copyright (c) 2015 SONATA-NFV and Paderborn University
+# 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, Paderborn University
+# 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 json
import logging
fl_cu = self._get_flavor(d).get("compute")
# check for over provisioning
if self.dc_alloc_cu + fl_cu > self.dc_max_cu and self.raise_no_cpu_resources_left:
- raise NotEnoughResourcesAvailable("Not enough compute resources left.")
+ raise NotEnoughResourcesAvailable(
+ "Not enough compute resources left.")
self.dc_alloc_cu += fl_cu
def _allocate_mem(self, d):
fl_mu = self._get_flavor(d).get("memory")
# check for over provisioning
if self.dc_alloc_mu + fl_mu > self.dc_max_mu and self.raise_no_mem_resources_left:
- raise NotEnoughResourcesAvailable("Not enough memory resources left.")
+ raise NotEnoughResourcesAvailable(
+ "Not enough memory resources left.")
self.dc_alloc_mu += fl_mu
def free(self, d):
# 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)
+ cpu_period, cpu_quota = self._calculate_cpu_cfs_values(
+ cpu_time_percentage)
# apply limits to container if changed
if d.resources['cpu_period'] != cpu_period or d.resources['cpu_quota'] != 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))
+ d.updateCpuLimit(cpu_period=int(cpu_period),
+ cpu_quota=int(cpu_quota))
def _compute_single_cu(self):
"""
# 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)])
+ 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):
"""
# (see: https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt)
# Attention minimum cpu_quota is 1ms (micro)
cpu_period = CPU_PERIOD # lets consider a fixed period of 1000000 microseconds for now
- cpu_quota = cpu_period * cpu_time_percentage # calculate the fraction of cpu time for this container
- # ATTENTION >= 1000 to avoid a invalid argument system error ... no idea why
+ # calculate the fraction of cpu time for this container
+ cpu_quota = cpu_period * cpu_time_percentage
+ # ATTENTION >= 1000 to avoid a invalid argument system error ... no
+ # idea why
if cpu_quota < 1000:
cpu_quota = 1000
LOG.warning("Increased CPU quota to avoid system error.")
# get memory amount for entire emulation
e_mem = self.registrar.e_mem
# calculate amount of memory for a single mu
- self.single_mu = float(e_mem) / sum([rm.dc_max_mu for rm in list(self.registrar.resource_models)])
+ self.single_mu = float(
+ e_mem) / sum([rm.dc_max_mu for rm in list(self.registrar.resource_models)])
# calculate mem for given flavor
mem_limit = self.single_mu * number_mu
mem_limit = self._calculate_mem_limit_value(mem_limit)
# apply to container if changed
if d.resources['mem_limit'] != mem_limit:
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.name, mem_limit / 1024 / 1024, self.mem_op_factor))
d.updateMemoryLimit(mem_limit=mem_limit)
def _calculate_mem_limit_value(self, mem_limit):
mem_limit = 4
LOG.warning("Increased MEM limit because it was less than 4.0 MB.")
# to byte!
- return int(mem_limit*1024*1024)
+ return int(mem_limit * 1024 * 1024)
def get_state_dict(self):
"""
if path is None:
return
# we have a path: write out RM info
- l = dict()
- l["t"] = time.time()
- l["container_state"] = d.getStatus()
- l["action"] = action
- l["rm_state"] = self.get_state_dict()
+ logd = dict()
+ logd["t"] = time.time()
+ logd["container_state"] = d.getStatus()
+ logd["action"] = action
+ logd["rm_state"] = self.get_state_dict()
# append to logfile
with open(path, "a") as f:
- f.write("%s\n" % json.dumps(l))
+ f.write("%s\n" % json.dumps(logd))
class UpbOverprovisioningCloudDcRM(UpbSimpleCloudDcRM):
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
# 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))
+ 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
+ return float(e_cpu) / sum([rm.dc_max_cu for rm in list(
+ self.registrar.resource_models)]) * self.cpu_op_factor
class UpbDummyRM(UpbSimpleCloudDcRM):
"""
No limits. But log allocations.
"""
+
def __init__(self, *args, **kvargs):
super(UpbDummyRM, self).__init__(*args, **kvargs)
self.raise_no_cpu_resources_left = False
def _apply_limits(self):
# do nothing here
pass
-
projects / osm / vim-emu.git / blobdiff