def _cgroup_init(treadmill_core_cpu_shares, treadmill_core_cpuset_cpus,
treadmill_apps_cpuset_cpus, treadmill_core_memory_limit,
root_cgroup):
# calculate memory limit
(core_memory,
apps_memory) = _get_cgroup_memory(treadmill_core_memory_limit,
root_cgroup)
# calculate CPU shares allocation
(core_cpu_shares,
apps_cpu_shares) = _get_cgroup_cpu_shares(treadmill_core_cpu_shares,
treadmill_apps_cpuset_cpus)
# calculate cpu cores allocation
(core_cpuset_cpus,
apps_cpuset_cpus) = _get_cgroup_cpuset_cpus(treadmill_core_cpuset_cpus,
treadmill_apps_cpuset_cpus)
cgutils.create_treadmill_cgroups(
core_cpu_shares,
apps_cpu_shares,
core_cpuset_cpus,
apps_cpuset_cpus,
core_memory,
apps_memory,
root_cgroup,
)
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 test_create_treadmill_cgroups(self):
"""Test the creation of core treadmill cgroups.
"""
treadmill_core_cpu_shares = 10
treadmill_apps_cpu_shares = 90
treadmill_core_cpuset_cpus = '0-15'
treadmill_app_cpuset_cpus = '1-15'
treadmill_core_mem = 512
treadmill_apps_mem = 256
cgutils.create_treadmill_cgroups(treadmill_core_cpu_shares,
treadmill_apps_cpu_shares,
treadmill_core_cpuset_cpus,
treadmill_app_cpuset_cpus,
treadmill_core_mem,
treadmill_apps_mem)
calls = [
mock.call('cpu', 'treadmill/core'),
mock.call('cpu', 'treadmill/apps'),
mock.call('cpuacct', 'treadmill/core'),
mock.call('cpuacct', 'treadmill/apps'),
mock.call('cpuset', 'treadmill/core'),
mock.call('cpuset', 'treadmill/apps'),
mock.call('memory', 'treadmill/core'),
mock.call('memory', 'treadmill/apps')
]
treadmill.cgroups.create.assert_has_calls(calls)
calls = [
mock.call('cpu', 'treadmill/core',
'cpu.shares', treadmill_core_cpu_shares),
mock.call('cpu', 'treadmill/apps',
'cpu.shares', treadmill_apps_cpu_shares),
mock.call('cpuset', 'treadmill/core',
'cpuset.mems', '0'),
mock.call('cpuset', 'treadmill/apps',
'cpuset.mems', '0'),
mock.call('cpuset', 'treadmill/core',
'cpuset.cpus', '0-15'),
mock.call('cpuset', 'treadmill/apps',
'cpuset.cpus', '1-15'),
mock.call('memory', 'treadmill/core',
'memory.move_charge_at_immigrate', 1),
mock.call('memory', 'treadmill/apps',
'memory.move_charge_at_immigrate', 1),
mock.call('memory', 'treadmill/core',
'memory.limit_in_bytes', treadmill_core_mem),
mock.call('memory', 'treadmill/core',
'memory.memsw.limit_in_bytes', treadmill_core_mem),
mock.call('memory', 'treadmill/core',
'memory.soft_limit_in_bytes', treadmill_core_mem),
mock.call('memory', 'treadmill/apps',
'memory.limit_in_bytes', treadmill_apps_mem),
mock.call('memory', 'treadmill/apps',
'memory.memsw.limit_in_bytes', treadmill_apps_mem),
mock.call('memory', 'treadmill/apps',
'memory.soft_limit_in_bytes', treadmill_apps_mem)
]
treadmill.cgroups.set_value.assert_has_calls(calls)
def test_create_treadmill_cgroups(self):
"""Test the creation of core treadmill cgroups"""
system_cpu_shares = 50
treadmill_cpu_shares = 50
treadmill_core_cpu_shares = 10
treadmill_apps_cpu_shares = 90
treadmill_cpu_cores = 0
treadmill_mem = 1024
treadmill_core_mem = 512
treadmill_apps_mem = treadmill_mem - treadmill_core_mem
cgutils.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)
calls = [
mock.call('cpu', 'system'),
mock.call('cpu', 'treadmill'),
mock.call('cpu', 'treadmill/core'),
mock.call('cpu', 'treadmill/apps'),
mock.call('cpuacct', 'system'),
mock.call('cpuacct', 'treadmill'),
mock.call('cpuacct', 'treadmill/core'),
mock.call('cpuacct', 'treadmill/apps'),
mock.call('cpuset', 'system'),
mock.call('cpuset', 'treadmill'),
mock.call('memory', 'system'),
mock.call('memory', 'treadmill'),
mock.call('memory', 'treadmill/core'),
mock.call('memory', 'treadmill/apps')
]
treadmill.cgroups.create.assert_has_calls(calls)
calls = [
mock.call('cpu', 'treadmill', 'cpu.shares', treadmill_cpu_shares),
mock.call('cpu', 'system', 'cpu.shares', system_cpu_shares),
mock.call('cpu', 'treadmill/core', 'cpu.shares',
treadmill_core_cpu_shares),
mock.call('cpu', 'treadmill/apps', 'cpu.shares',
treadmill_apps_cpu_shares),
mock.call('cpuset', 'system', 'cpuset.mems', 0),
mock.call('cpuset', 'treadmill', 'cpuset.mems', 0),
mock.call('cpuset', 'treadmill', 'cpuset.cpus', '0-3'),
mock.call('cpuset', 'system', 'cpuset.cpus', '0-3'),
mock.call('memory', 'system', 'memory.move_charge_at_immigrate',
1),
mock.call('memory', 'treadmill', 'memory.move_charge_at_immigrate',
1),
mock.call('memory', 'treadmill', 'memory.use_hierarchy', '1'),
mock.call('memory', 'treadmill', 'memory.limit_in_bytes',
treadmill_mem),
mock.call('memory', 'treadmill', 'memory.memsw.limit_in_bytes',
treadmill_mem),
mock.call('memory', 'treadmill', 'memory.oom_control', '0'),
mock.call('memory', 'treadmill/core',
'memory.move_charge_at_immigrate', 1),
mock.call('memory', 'treadmill/apps',
'memory.move_charge_at_immigrate', 1),
mock.call('memory', 'treadmill/core', 'memory.limit_in_bytes',
treadmill_core_mem),
mock.call('memory', 'treadmill/core',
'memory.memsw.limit_in_bytes', treadmill_core_mem),
mock.call('memory', 'treadmill/core', 'memory.soft_limit_in_bytes',
treadmill_core_mem),
mock.call('memory', 'treadmill/apps', 'memory.limit_in_bytes',
treadmill_apps_mem),
mock.call('memory', 'treadmill/apps',
'memory.memsw.limit_in_bytes', treadmill_apps_mem)
]
treadmill.cgroups.set_value.assert_has_calls(calls)
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
)
