def cginit(mem, mem_core, cpu, cpu_cores):
"""Initialize core and system cgroups."""
if cpu_cores > 0:
tm_cpu_shares = sysinfo.bogomips_linux(range(0, cpu_cores))
tm_core_cpu_shares = int(tm_cpu_shares * 0.01)
tm_apps_cpu_shares = tm_cpu_shares - tm_core_cpu_shares
total_cores = sysinfo.cpu_count()
system_cores = range(cpu_cores, total_cores)
system_cpu_shares = sysinfo.bogomips_linux(system_cores)
_LOGGER.info(
'Configuring CPU limits: '
'treadmill cores: %d, '
'treadmill: %d, '
'treadmill core: %d, '
'treadmill apps: %d', cpu_cores, tm_cpu_shares,
tm_core_cpu_shares, tm_apps_cpu_shares)
else:
total_cores = sysinfo.cpu_count()
total_cpu_shares = sysinfo.bogomips_linux(range(0, total_cores))
tm_cpu_shares = int(total_cpu_shares * utils.cpu_units(cpu) /
100.0)
system_cpu_shares = int(total_cpu_shares - tm_cpu_shares)
tm_core_cpu_shares = int(tm_cpu_shares * 0.01)
tm_apps_cpu_shares = tm_cpu_shares - tm_core_cpu_shares
_LOGGER.info(
'Configuring CPU limits: '
'total: %d, '
'treadmill: %d, '
'system: %d, '
'treadmill core: %d, '
'treadmill apps: %d', total_cpu_shares, tm_cpu_shares,
system_cpu_shares, tm_core_cpu_shares, tm_apps_cpu_shares)
tm_mem = utils.size_to_bytes(mem)
tm_core_mem = utils.size_to_bytes(mem_core)
total_physical_mem = sysinfo.mem_info().total * 1024
if tm_mem <= 0:
# For readability, instead of + tm_mem (negative).
real_tm_mem = total_physical_mem - abs(tm_mem)
else:
real_tm_mem = tm_mem
_LOGGER.info(
'Configuring memory limits: '
'total: %s, '
'treadmill total: %s, '
'treadmill core: %s',
utils.bytes_to_readable(total_physical_mem, 'B'),
utils.bytes_to_readable(real_tm_mem, 'B'),
utils.bytes_to_readable(tm_core_mem, 'B'))
cgutils.create_treadmill_cgroups(system_cpu_shares, tm_cpu_shares,
tm_core_cpu_shares,
tm_apps_cpu_shares, cpu_cores,
real_tm_mem, tm_core_mem)
def root():
"""Root handler."""
mem = sysinfo.mem_info()
return flask.jsonify({
'hostname': sysinfo.hostname(),
'cpu': sysinfo.cpu_count(),
'memory': mem.total,
})
def _parse_cpuset_cpus(cpuset_cpus):
"""Parse cpuset cores.
"""
if not cpuset_cpus or cpuset_cpus == '-':
return None
cores_max = sysinfo.cpu_count() - 1
return ','.join([
'{}{}'.format(entry, cores_max) if entry.endswith('-') else entry
for entry in cpuset_cpus.split(',')
])
def _total_cpu_cores(cpuset_cpus):
"""Parse cpuset cores to get total core index
"""
total_cores = sysinfo.cpu_count()
if not cpuset_cpus or cpuset_cpus == '-':
return set(range(total_cores))
cores_max = sysinfo.cpu_count() - 1
total_cores = set()
for entry in cpuset_cpus.split(','):
if '-' not in entry:
total_cores.add(int(entry))
else:
items = entry.split('-')
# add max value if missing
if items[1] == '':
items[1] = cores_max
for i in range(int(items[0]), int(items[1]) + 1):
total_cores.add(i)
return total_cores
def create_treadmill_cgroups(system_cpu_shares, treadmill_cpu_shares,
treadmill_core_cpu_shares,
treadmill_apps_cpu_shares, treadmill_cpu_cores,
treadmill_mem, treadmill_core_mem):
"""This is the core cgroup setup. Should be applied to a cleaned env."""
create('cpu', 'system')
create('cpu', 'treadmill')
create('cpu', 'treadmill/core')
create('cpu', 'treadmill/apps')
cgroups.set_value('cpu', 'treadmill', 'cpu.shares', treadmill_cpu_shares)
cgroups.set_value('cpu', 'system', 'cpu.shares', system_cpu_shares)
cgroups.set_value('cpu', 'treadmill/core', 'cpu.shares',
treadmill_core_cpu_shares)
cgroups.set_value('cpu', 'treadmill/apps', 'cpu.shares',
treadmill_apps_cpu_shares)
create('cpuacct', 'system')
create('cpuacct', 'treadmill')
create('cpuacct', 'treadmill/core')
create('cpuacct', 'treadmill/apps')
create('cpuset', 'system')
create('cpuset', 'treadmill')
mems = cgroups.get_value('cpuset', '', 'cpuset.mems')
cgroups.set_value('cpuset', 'system', 'cpuset.mems', mems)
cgroups.set_value('cpuset', 'treadmill', 'cpuset.mems', mems)
cores_max = sysinfo.cpu_count() - 1
if treadmill_cpu_cores > cores_max:
raise exc.TreadmillError('Not enough cpu cores.')
if treadmill_cpu_cores > 0:
cgroups.set_value('cpuset', 'treadmill', 'cpuset.cpus',
'%d-%d' % (0, treadmill_cpu_cores - 1))
cgroups.set_value('cpuset', 'system', 'cpuset.cpus',
'%d-%d' % (treadmill_cpu_cores, cores_max))
else:
cgroups.set_value('cpuset', 'treadmill', 'cpuset.cpus',
'%d-%d' % (0, cores_max))
cgroups.set_value('cpuset', 'system', 'cpuset.cpus',
'%d-%d' % (0, cores_max))
create('memory', 'system')
create('memory', 'treadmill')
if cgroups.get_value('memory', 'treadmill', 'memory.use_hierarchy') != 1:
cgroups.set_value('memory', 'treadmill', 'memory.use_hierarchy', '1')
set_memory_hardlimit('treadmill', treadmill_mem)
oom_value = 'oom_kill_disable 0\nunder_oom 0\n'
if cgroups.get_data('memory', 'treadmill',
'memory.oom_control') != oom_value:
cgroups.set_value('memory', 'treadmill', 'memory.oom_control', '0')
create('memory', 'treadmill/core')
create('memory', 'treadmill/apps')
set_memory_hardlimit('treadmill/core', treadmill_core_mem)
cgroups.set_value('memory', 'treadmill/core', 'memory.soft_limit_in_bytes',
treadmill_core_mem)
# It is possible to use qualifiers in the input, for calculation of the
# difference, get memory limits in bytes as defined in cgroup.
total_mem_bytes = cgroups.get_value('memory', 'treadmill',
'memory.limit_in_bytes')
core_mem_bytes = cgroups.get_value('memory', 'treadmill/core',
'memory.limit_in_bytes')
apps_mem_bytes = (total_mem_bytes - core_mem_bytes)
set_memory_hardlimit('treadmill/apps', apps_mem_bytes)
def _cgroup_init(treadmill_core_cpu_shares,
treadmill_core_cpuset_cpus,
treadmill_apps_cpuset_cpus,
treadmill_core_memory_limit):
# calculate CPU shares allocation
total_cores = sysinfo.cpu_count()
total_cpu_shares = sysinfo.bogomips(six.moves.range(total_cores))
core_cpu_shares = int(
total_cpu_shares *
utils.cpu_units(treadmill_core_cpu_shares) / 100.0
)
apps_cpu_shares = total_cpu_shares - core_cpu_shares
_LOGGER.info(
'Configuring CPU shares: '
'total: %d, '
'treadmill core: %d, '
'treadmill apps: %d',
total_cpu_shares,
core_cpu_shares,
apps_cpu_shares
)
# calculate memory allocation
core_memory = utils.size_to_bytes(treadmill_core_memory_limit)
total_physical_mem = sysinfo.mem_info().total * 1024
# XXX: tm_mem = utils.size_to_bytes(treadmill_mem)
# XXX: if tm_mem <= 0:
# XXX: real_tm_mem = total_physical_mem - abs(tm_mem)
# XXX: else:
# XXX: real_tm_mem = tm_mem
treadmill_memory = total_physical_mem
apps_memory = treadmill_memory - core_memory
_LOGGER.info(
'Configuring memory limits: '
'total: %s, '
'treadmill core: %s, '
'treadmill apps: %s',
utils.bytes_to_readable(total_physical_mem, 'B'),
utils.bytes_to_readable(core_memory, 'B'),
utils.bytes_to_readable(apps_memory, 'B')
)
# calculate cpuset cores allocation
core_cpuset_cpus = _parse_cpuset_cpus(
treadmill_core_cpuset_cpus
)
apps_cpuset_cpus = _parse_cpuset_cpus(
treadmill_apps_cpuset_cpus
)
_LOGGER.info(
'Configuring cpuset cores: '
'treadmill core cpuset: %s, '
'treadmill app cpuset: %s',
core_cpuset_cpus,
apps_cpuset_cpus
)
cgutils.create_treadmill_cgroups(
core_cpu_shares,
apps_cpu_shares,
core_cpuset_cpus,
apps_cpuset_cpus,
core_memory,
apps_memory
)
def _cgroup_init(treadmill_core_cpu_shares,
treadmill_core_cpuset_cpus,
treadmill_apps_cpuset_cpus,
treadmill_core_memory_limit):
# TODO: Refactor this whole function:
# * It should be mostly folded into cgutils
# * There is no need to read sysinfo for CPUs, use cpuset cgroup.
# * There is no need to read bogomips for relative weight core/apps.
# * There is no need to read physical memory here, use cgroups.
# calculate CPU shares allocation
total_cores = sysinfo.cpu_count()
total_cpu_shares = sysinfo.bogomips(six.moves.range(total_cores))
if treadmill_core_cpu_shares is not None:
core_cpu_shares = int(
total_cpu_shares *
utils.cpu_units(treadmill_core_cpu_shares) / 100.0
)
apps_cpu_shares = total_cpu_shares - core_cpu_shares
else:
core_cpu_shares = apps_cpu_shares = None
_LOGGER.info(
'Configuring CPU shares: '
'total: %d, '
'treadmill core: %r, '
'treadmill apps: %r',
total_cpu_shares,
core_cpu_shares,
apps_cpu_shares
)
# calculate memory allocation
total_physical_mem = sysinfo.mem_info().total * 1024
if treadmill_core_memory_limit is not None:
core_memory = utils.size_to_bytes(treadmill_core_memory_limit)
# XXX: tm_mem = utils.size_to_bytes(treadmill_mem)
# XXX: if tm_mem <= 0:
# XXX: real_tm_mem = total_physical_mem - abs(tm_mem)
# XXX: else:
# XXX: real_tm_mem = tm_mem
treadmill_memory = total_physical_mem
apps_memory = treadmill_memory - core_memory
else:
core_memory = apps_memory = None
_LOGGER.info(
'Configuring memory limits: '
'total: %s, '
'treadmill core: %r, '
'treadmill apps: %r',
utils.bytes_to_readable(total_physical_mem, 'B'),
utils.bytes_to_readable(core_memory, 'B'),
utils.bytes_to_readable(apps_memory, 'B')
)
# calculate cpuset cores allocation
if treadmill_core_cpuset_cpus is not None:
core_cpuset_cpus = _parse_cpuset_cpus(
treadmill_core_cpuset_cpus
)
# TODO: Calculate from apps as treadmill - core
apps_cpuset_cpus = _parse_cpuset_cpus(
treadmill_apps_cpuset_cpus
)
else:
core_cpuset_cpus = apps_cpuset_cpus = None
_LOGGER.info(
'Configuring cpuset cores: '
'treadmill cpuset: %r, '
'treadmill core cpuset: %r, '
'treadmill app cpuset: %r',
'TBD',
core_cpuset_cpus,
apps_cpuset_cpus
)
cgutils.create_treadmill_cgroups(
core_cpu_shares,
apps_cpu_shares,
core_cpuset_cpus,
apps_cpuset_cpus,
core_memory,
apps_memory
)
