def _get_cgroup_memory(treadmill_core_memory_limit):
"""get cgroup memory parameter for treadmill core/apps group
"""
total_physical_mem = sysinfo.mem_info().total * 1024
total_treadmill_mem = cgutils.get_memory_limit('treadmill')
if total_treadmill_mem > total_physical_mem:
_LOGGER.warning(
'memory limit for treadmill group > physical, use physical %s',
utils.bytes_to_readable(total_treadmill_mem, 'B'),
)
total_treadmill_mem = total_physical_mem
# calculate memory allocation
if treadmill_core_memory_limit is not None:
core_memory = utils.size_to_bytes(treadmill_core_memory_limit)
treadmill_memory = total_treadmill_mem
apps_memory = treadmill_memory - core_memory
else:
core_memory = apps_memory = None
_LOGGER.info(
'Configuring memory limits: '
'phycial total: %s, '
'treadmill total: %s, '
'treadmill core: %s, '
'treadmill apps: %s', utils.bytes_to_readable(total_physical_mem, 'B'),
utils.bytes_to_readable(total_treadmill_mem, 'B'),
utils.bytes_to_readable(core_memory, 'B'),
utils.bytes_to_readable(apps_memory, 'B'))
return (core_memory, apps_memory)
def test_humanreadable(self):
"""Tests conversion of values into human readable format."""
self.assertEqual('1.0M', utils.bytes_to_readable(1024, 'K'))
self.assertEqual('1.0G', utils.bytes_to_readable(1024, 'M'))
self.assertEqual('2.5T',
utils.bytes_to_readable(1024 * 1024 * 2.5, 'M'))
self.assertEqual('1.0K', utils.bytes_to_readable(1024, 'B'))
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 psmem_cmd(fast, cgroup):
"""Reports memory utilization details for given container."""
if cgroup:
pids = cgutils.pids_in_cgroup('memory', cgroup)
else:
pids = [int(pid) for pid in os.listdir('/proc') if pid.isdigit()]
use_pss = not fast
memusage = psmem.get_memory_usage(pids, use_pss=use_pss)
columns = (['name', 'count', 'private', 'shared', 'total'])
table = prettytable.PrettyTable(columns)
for column in columns:
table.align[column] = 'l'
table.set_style(prettytable.PLAIN_COLUMNS)
table.left_padding_width = 0
table.right_padding_width = 2
readable = lambda value: utils.bytes_to_readable(value, power='B')
for proc, info in sorted(memusage.iteritems()):
table.add_row([proc, info['count']] + [
readable(info[col]) for col in ['private', 'shared', 'total']
])
total = sum([info['total'] for info in memusage.values()])
table.add_row(['', '', '', '', ''])
table.add_row(['Total:', '', '', '', readable(total)])
print table
memusage, softmem, hardmem = cgutils.cgrp_meminfo(cgroup)
print ''
print 'memory.usage : ', readable(memusage)
print 'memory.softlimit : ', readable(softmem)
print 'memory.hardlimit : ', readable(hardmem)
def psmem_cmd(fast, app, verbose, percent):
"""Reports memory utilization details for given container."""
if app.find('#') == -1:
raise click.BadParameter('Specify full instance name: xxx#nnn')
app = app.replace('#', '-')
cgroup = None
apps = os.listdir('/sys/fs/cgroup/memory/treadmill/apps')
for entry in apps:
if app in entry:
cgroup = os.path.join('/treadmill/apps', entry)
if not cgroup:
raise click.BadParameter('Could not find corresponding cgroup')
pids = cgutils.pids_in_cgroup('memory', cgroup)
use_pss = not fast
memusage = psmem.get_memory_usage(pids, verbose, use_pss=use_pss)
proc_columns = ([
'ppid', 'name', 'threads', 'private', 'shared', 'total'
])
proc_table = prettytable.PrettyTable(proc_columns)
proc_table.align = 'l'
proc_table.set_style(prettytable.PLAIN_COLUMNS)
proc_table.left_padding_width = 0
proc_table.right_padding_width = 2
total = sum([info['total'] for info in memusage.values()])
readable = lambda value: utils.bytes_to_readable(value, power='B')
percentage = lambda value, total: "{:.1%}".format(value / total)
cols = proc_columns[3:]
for proc, info in sorted(memusage.items()):
row_base = [proc, info['name'], info['threads']]
row_values = None
if percent:
row_values = [percentage(info[col], total) for col in cols]
else:
row_values = [readable(info[col]) for col in cols]
proc_table.add_row(row_base + row_values)
proc_table.add_row(['', '', '', '', '', ''])
proc_table.add_row(['Total:', '', '', '', '', readable(total)])
print(proc_table)
metric = metrics.read_memory_stats(cgroup)
total_table = prettytable.PrettyTable(['memory', 'value'])
total_table.align['memory'] = 'l'
total_table.align['value'] = 'r'
total_table.set_style(prettytable.PLAIN_COLUMNS)
total_table.header = False
# Actual memory usage is without the disk cache
memory_usage = readable(metric['memory.usage_in_bytes'] -
metric['memory.stats']['cache'])
total_table.add_row(['usage', memory_usage])
total_table.add_row([
'',
percentage(metric['memory.usage_in_bytes'],
metric['memory.limit_in_bytes'])
])
total_table.add_row(
['diskcache',
readable(metric['memory.stats']['cache'])])
total_table.add_row(
['softlimit',
readable(metric['memory.soft_limit_in_bytes'])])
total_table.add_row(
['hardlimit',
readable(metric['memory.limit_in_bytes'])])
print('')
print(total_table)
def _readable(value):
return utils.bytes_to_readable(value, power='B')
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
)
