def show(self):
if not self.have_device:
return
for cpu in self.system.cpus:
if not self.read_cpu(cpu):
break
enabled = set()
disabled = set()
for cpu, state in self.cpu_states.items():
if state:
enabled.add(cpu)
else:
disabled.add(cpu)
text = []
if enabled:
text.append('CPU %s: enabled' % format_cpu_list(enabled))
if disabled:
text.append('CPU %s: disabled' % format_cpu_list(disabled))
if text:
self.log_state(', '.join(text))
self.tuned_for_benchmarks = (not enabled)
if enabled:
self.advice('Disable Turbo Boost on CPU %s to get more reliable '
'CPU frequency' % format_cpu_list(enabled))
def test_format_cpu_list(self):
self.assertEqual(cpu_utils.format_cpu_list([0]),
'0')
self.assertEqual(cpu_utils.format_cpu_list([0, 1, 5, 6]),
'0-1,5-6')
self.assertEqual(cpu_utils.format_cpu_list([1, 3, 7]),
'1,3,7')
def _cpu_affinity(self):
cpus = self.args.affinity
if not cpus:
# --affinity option is not set: detect isolated CPUs
isolated = True
cpus = get_isolated_cpus()
if not cpus:
# no isolated CPUs or unable to get the isolated CPUs
return
else:
isolated = False
cpus = parse_cpu_list(cpus)
if set_cpu_affinity(cpus):
if self.args.verbose:
if isolated:
text = ("Pin process to isolated CPUs: %s"
% format_cpu_list(cpus))
else:
text = ("Pin process to CPUs: %s"
% format_cpu_list(cpus))
print(text)
if isolated:
self.args.affinity = format_cpu_list(cpus)
else:
if not isolated:
print("ERROR: CPU affinity not available.", file=sys.stderr)
print("Use Python 3.3 or newer, or install psutil dependency")
sys.exit(1)
elif not self.args.quiet:
print("WARNING: unable to pin worker processes to "
"isolated CPUs, CPU affinity not available")
print("Use Python 3.3 or newer, or install psutil dependency")
def show(self):
if not self.have_device:
return
for cpu in self.system.cpus:
if not self.read_cpu(cpu):
break
enabled = set()
disabled = set()
for cpu, state in self.cpu_states.items():
if state:
enabled.add(cpu)
else:
disabled.add(cpu)
text = []
if enabled:
text.append('CPU %s: enabled' % format_cpu_list(enabled))
if disabled:
text.append('CPU %s: disabled' % format_cpu_list(disabled))
if text:
self.log_state(', '.join(text))
self.tuned_for_benchmarks = (not enabled)
if enabled:
self.advice('Disable Turbo Boost on CPU %s to get more reliable '
'CPU frequency' % format_cpu_list(enabled))
def write_irqs(self, new_cpus):
affinity = self.read_irqs_affinity()
modified = []
for irq in self.get_irqs():
if self.permission_error:
break
cpus = affinity.get(irq)
if new_cpus == cpus:
continue
if self.write_irq(irq, new_cpus):
modified.append(irq)
if modified:
self.log_action("Set affinity of IRQ %s to CPU %s"
% (format_cpu_list(modified), format_cpu_list(new_cpus)))
def show(self):
irqbalance_active = self.read_irqbalance_state()
if irqbalance_active is not None:
state = 'active' if irqbalance_active else 'inactive'
self.log_state("irqbalance service: %s" % state)
default_smp_affinity = self.read_default_affinity()
if default_smp_affinity:
self.log_state("Default IRQ affinity: CPU %s"
% format_cpu_list(default_smp_affinity))
irq_affinity = self.read_irqs_affinity()
if irq_affinity:
infos = {irq: 'CPU %s' % format_cpu_list(cpus)
for irq, cpus in irq_affinity.items()}
infos = format_cpu_infos(infos)
infos = ['IRQ %s' % info for info in infos]
self.log_state('IRQ affinity: %s' % '; '.join(infos))
def show(self):
irqbalance_active = self.read_irqbalance_state()
if irqbalance_active is not None:
state = 'active' if irqbalance_active else 'inactive'
self.log_state("irqbalance service: %s" % state)
default_smp_affinity = self.read_default_affinity()
if default_smp_affinity:
self.log_state("Default IRQ affinity: CPU %s"
% format_cpu_list(default_smp_affinity))
irq_affinity = self.read_irqs_affinity()
if irq_affinity:
infos = {irq: 'CPU %s' % format_cpu_list(cpus)
for irq, cpus in irq_affinity.items()}
infos = format_cpu_infos(infos)
infos = ['IRQ %s' % info for info in infos]
self.log_state('IRQ affinity: %s' % '; '.join(infos))
def check_isolcpus(self):
isolated = get_isolated_cpus()
if isolated:
self.log_state('Isolated CPUs (%s/%s): %s'
% (len(isolated), self.ncpu,
format_cpu_list(isolated)))
elif self.ncpu > 1:
self.log_state('No CPU is isolated')
self.advice('Use isolcpus=<cpu list> kernel parameter '
'to isolate CPUs')
def check_rcu_nocbs(self):
rcu_nocbs = self.read_rcu_nocbs()
if rcu_nocbs:
self.log_state('RCU disabled on CPUs (%s/%s): %s'
% (len(rcu_nocbs), self.ncpu,
format_cpu_list(rcu_nocbs)))
elif self.ncpu > 1:
self.advice('Use rcu_nocbs=<cpu list> kernel parameter '
'(with isolcpus) to not schedule RCU '
'on isolated CPUs')
def check_rcu_nocbs(self):
rcu_nocbs = self.read_rcu_nocbs()
if rcu_nocbs:
self.log_state('RCU disabled on CPUs (%s/%s): %s'
% (len(rcu_nocbs), self.ncpu,
format_cpu_list(rcu_nocbs)))
elif self.ncpu > 1:
self.advice('Use rcu_nocbs=<cpu list> kernel parameter '
'(with isolcpus) to not schedule RCU '
'on isolated CPUs')
def check_isolcpus(self):
isolated = get_isolated_cpus()
if isolated:
self.log_state('Isolated CPUs (%s/%s): %s'
% (len(isolated), self.ncpu,
format_cpu_list(isolated)))
elif self.ncpu > 1:
self.log_state('No CPU is isolated')
self.advice('Use isolcpus=<cpu list> kernel parameter '
'to isolate CPUs')
def collect_cpu_affinity(metadata, cpu_affinity, cpu_count):
if not cpu_affinity:
return
if not cpu_count:
return
# CPU affinity
if set(cpu_affinity) == set(range(cpu_count)):
return
metadata['cpu_affinity'] = format_cpu_list(cpu_affinity)
def write(self, tune):
modified = []
for cpu in self.system.cpus:
if self.write_cpu(cpu, tune):
modified.append(cpu)
if self.permission_error:
break
if modified:
cpus = format_cpu_list(modified)
if tune:
action = "set to the maximum frequency"
else:
action = "reset to the minimum frequency"
self.log_action("Minimum frequency of CPU %s %s" % (cpus, action))
def write_default(self, new_affinity):
default_smp_affinity = self.read_default_affinity()
if new_affinity == default_smp_affinity:
return
mask = format_cpus_as_mask(new_affinity)
try:
write_text(self.default_affinity_path, mask)
except IOError as exc:
self.check_permission_error(exc)
self.error("Failed to write %r into %s: %s"
% (mask, self.default_affinity_path, exc))
else:
self.log_action("Set default affinity to CPU %s"
% format_cpu_list(new_affinity))
def write(self, tune):
modified = []
for cpu in self.system.cpus:
if self.write_cpu(cpu, tune):
modified.append(cpu)
if self.permission_error:
break
if modified:
cpus = format_cpu_list(modified)
if tune:
action = "set to the maximum frequency"
else:
action = "reset to the minimum frequency"
self.log_action("Minimum frequency of CPU %s %s" % (cpus, action))
def write_default(self, new_affinity):
default_smp_affinity = self.read_default_affinity()
if new_affinity == default_smp_affinity:
return
mask = format_cpus_as_mask(new_affinity)
try:
write_text(self.default_affinity_path, mask)
except IOError as exc:
self.check_permission_error(exc)
self.error("Failed to write %r into %s: %s"
% (mask, self.default_affinity_path, exc))
else:
self.log_action("Set default affinity to CPU %s"
% format_cpu_list(new_affinity))
def show(self):
nohz_full = self.read_first_line(sysfs_path('devices/system/cpu/nohz_full'))
if not nohz_full:
return
nohz_full = parse_cpu_list(nohz_full)
if not nohz_full:
return
used = set(self.system.cpus) | set(nohz_full)
if not used:
return
self.advice("WARNING: nohz_full is enabled on CPUs %s which use the "
"intel_pstate driver, whereas intel_pstate is incompatible "
"with nohz_full"
% format_cpu_list(used))
self.advice("See https://bugzilla.redhat.com/show_bug.cgi?id=1378529")
self.tuned_for_benchmarks = False
def init(self, args):
if not self.operations:
print("WARNING: no operation available for your platform")
sys.exit()
self.logical_cpu_count = get_logical_cpu_count()
if not self.logical_cpu_count:
print("ERROR: failed to get the number of logical CPUs")
sys.exit(1)
isolated = get_isolated_cpus()
if isolated:
self.cpus = tuple(isolated)
elif args.affinity:
self.cpus = tuple(args.affinity)
else:
self.cpus = tuple(range(self.logical_cpu_count))
# The list of cpus must be sorted to avoid useless write in operations
assert sorted(self.cpus) == list(self.cpus)
self.log_state("CPU: use %s logical CPUs: %s"
% (len(self.cpus), format_cpu_list(self.cpus)))
def init(self, args):
if not self.operations:
print("WARNING: no operation available for your platform")
sys.exit()
self.logical_cpu_count = get_logical_cpu_count()
if not self.logical_cpu_count:
print("ERROR: failed to get the number of logical CPUs")
sys.exit(1)
isolated = get_isolated_cpus()
if isolated:
self.cpus = tuple(isolated)
elif args.affinity:
self.cpus = tuple(args.affinity)
else:
self.cpus = tuple(range(self.logical_cpu_count))
# The list of cpus must be sorted to avoid useless write in operations
assert sorted(self.cpus) == list(self.cpus)
self.log_state("CPU: use %s logical CPUs: %s"
% (len(self.cpus), format_cpu_list(self.cpus)))
def test_format_cpu_list(self):
self.assertEqual(cpu_utils.format_cpu_list([0]), '0')
self.assertEqual(cpu_utils.format_cpu_list([0, 1, 5, 6]), '0-1,5-6')
self.assertEqual(cpu_utils.format_cpu_list([1, 3, 7]), '1,3,7')
