def main():
target = Target()
test_results = Results(target)
test_results.log(
target.execute('cat /sys/kernel/debug/sched_features | grep _WA_ ',
as_root=True))
tests_to_run = []
# tests_to_run = ['SysBenchCpu', 'SysBenchMemory']
# tests_to_run = ['PerfBenchFutexWake']
time = 60
events = [
'sched:sched_migrate_task', 'sched:sched_stick_numa',
'sched:sched_move_numa', 'sched:sched_swap_numa'
]
events.extend(['migrate:mm_migrate_pages'])
for test in test_registry.test_registry:
if not tests_to_run or test(target).__class__.__name__ in tests_to_run:
t = test(target, time=time)
t.run_event(target, events, test_results)
res_files = []
res_files.append(test_results.store('Res1'))
res_files.append(test_results.store('Res2'))
create_report(res_files, 'Report', 'Test Run')
def __init__(self, target: Target):
self.start_time = datetime.now()
self.raw_data = []
self.log_data = []
self.test_results = {}
self.test_results['platform'] = target.platform
self.test_results['tests'] = {}
target.execute('mkdir tmp', as_root=False)
def start(self, btn):
weights = {}
for key in ATTRIBUTES:
weights[key + 'W'] = self.app.getScale(key + 'W')
self.target_shishen.target = Target(weights)
if self.app.getOptionBox('types') != '- - 无 - -':
self.target_shishen.type_name = self.app.getOptionBox('types')
best_n_list = helper.find_best_solution_for(self.target_shishen)
if not best_n_list:
self.app.setLabel('result', '无可用方案')
return
i = 1
for yh_list in best_n_list.values():
self.target_shishen.clear_yuhun_list()
self.target_shishen.set_yuhun_list(yh_list)
self.set_attributes('方案' + str(i),
self.target_shishen.final_attributes)
for yh in yh_list:
the_dict = yh.get_dict()
name = the_dict.pop('Name')
k = the_dict.pop('Position') - 1
self.app.setToggleFrameText('方案' + str(i) + '-' + str(k),
str(k + 1) + '号位：' + name)
j = 0
for key, value in the_dict.items():
self.app.setLabel(
'方案' + str(i) + str(k) + 'yuhun_key_' + str(j),
YUHUN_ATTRIBUTES[key])
self.app.setLabel(
'方案' + str(i) + str(k) + 'yuhun_value_' + str(j),
value)
j += 1
i += 1
self.app.setLabel('result', '生成完毕！')
def main():
target = Target()
test_results = Results(target)
for test in test_registry.test_registry:
t = test(target, time=60)
print(t.command)
def __init__(self, target: Target, command, events=None, output=None):
self.target = target
cmd = "bash -c 'echo event-fork > /sys/kernel/debug/tracing/trace_options'"
target.execute(cmd)
cmd = "bash -c 'echo 0 > /sys/kernel/debug/tracing/tracing_on'"
print(cmd)
target.execute(cmd)
self.enable_events(events)
if output is None:
output = "trace_pipe.txt"
cmd = "cat /sys/kernel/debug/tracing/trace_pipe > {}".format(output)
proc = subprocess.Popen("sudo bash -c '{}'".format(cmd), shell=True)
cmd = "sh -c 'echo $$ > /sys/kernel/debug/tracing/set_event_pid; echo 1 > /sys/kernel/debug/tracing/tracing_on; {}'".format(
command)
print(cmd)
self.results = target.execute(cmd)
cmd = "bash -c 'echo 0 > /sys/kernel/debug/tracing/tracing_on'"
print(cmd)
target.execute(cmd)
proc.kill()
proc.wait()
self.disable_events(events)
def main():
target = Target()
res_files = []
# tests_to_run = ['SysBenchMutex', 'SysBenchThreads', 'SysBenchMemory', 'SysBenchCpu']
tests_to_run = ['SysBenchThreads', 'HackbenchForkSockets', 'SysBenchMutex', 'PerfBenchFutexWake']
iter = 3
for batch in range(0,1):
target.execute('sysctl kernel.sched_check_group_util=0', as_root=True)
time.sleep(5)
for i in range(iter):
res_files.append(run_tests(test_name='BASELINE_{}'.format(batch), target=target, tests_to_run=tests_to_run, iter=i))
target.execute('sysctl kernel.sched_check_group_util=1', as_root=True)
time.sleep(5)
for i in range(iter):
res_files.append(run_tests(test_name='PATCH_{}'.format(batch), target=target, tests_to_run=tests_to_run, iter=i))
title = "Usage of group_util in update_pick_idlest() impact on common benchmarks"
description = "In update_pick_idlest() function \
When both groups have 'group_has_spare' type \
and the same number of idle CPU's. \
We suggest evaluating group_util to find idlest group. "
#create_report(res_files, 'results/group_util', title=title, description= description)
create_patch(res_files, 'results/group_util', title=title, description= description)
def main():
target = Target()
res_files = []
# tests_to_run = ['SysBenchMutex', 'SysBenchThreads', 'SysBenchMemory', 'SysBenchCpu']
tests_to_run = [
'SysBenchThreads', 'HackbenchForkSockets', 'SysBenchMutex',
'PerfBenchFutexWake'
]
#tests_to_run = ['SysBenchThreads']
iter = 3
target.execute('sysctl kernel.sched_check_group_util=0', as_root=True)
time.sleep(5)
result_name = 'BASELINE'
for test in test_registry.test_registry:
test_name = test(target).__class__.__name__
if not tests_to_run or test_name in tests_to_run:
run_single_test(result_name, test_name, target, res_files, iter)
target.execute('sysctl kernel.sched_check_group_util=1', as_root=True)
time.sleep(5)
result_name = 'PATCH'
for test in test_registry.test_registry:
test_name = test(target).__class__.__name__
if not tests_to_run or test_name in tests_to_run:
run_single_test(result_name, test_name, target, res_files, iter)
title = "Usage of group_util in update_pick_idlest() impact on common benchmarks"
description = "In update_pick_idlest() function \
When both groups have 'group_has_spare' type \
and the same number of idle CPU's. \
We suggest evaluating group_util to find idlest group. "
#create_report(res_files, 'results/group_util', title=title, description= description)
#create_patch(res_files, 'results/group_util', title=title, description= description)
create_patch_loop(res_files,
'results/group_util',
title=title,
description=description)
def main():
target = Target()
res_files = []
tests_to_run = []
iter = 3
target.execute('sysctl kernel.numa_balancing=1', as_root=True)
target.execute(
"bash -c 'echo WA_WEIGHT > /sys/kernel/debug/sched_features'",
as_root=True)
target.execute("bash -c 'echo WA_IDLE > /sys/kernel/debug/sched_features'",
as_root=True)
for i in range(iter):
time.sleep(10)
res_files.append(
run_tests(test_name='Default-{}'.format(i),
target=target,
tests_to_run=tests_to_run))
target.execute('sysctl kernel.numa_balancing=0', as_root=True)
for i in range(iter):
time.sleep(10)
res_files.append(
run_tests(test_name='NB-OFF-{}'.format(i),
target=target,
tests_to_run=tests_to_run))
target.execute('sysctl kernel.numa_balancing=0', as_root=True)
target.execute(
"bash -c 'echo NO_WA_WEIGHT > /sys/kernel/debug/sched_features'",
as_root=True)
target.execute(
"bash -c 'echo NO_WA_IDLE > /sys/kernel/debug/sched_features'",
as_root=True)
for i in range(iter):
time.sleep(10)
res_files.append(
run_tests(test_name='NB-OFF_NO_WA_IDLE-{}'.format(i),
target=target,
tests_to_run=tests_to_run))
title = "NUMA balancing impact on common benchmarks"
description = "NUMA balancing can lead to performance degradation on \
NUMA-based arm64 systems when tasks migrate, \n \
and their memory accesses now suffer additional latency. \
NO_WA_IDLE prevents idle CPUs aggressively pull tasks. "
create_report(res_files,
'results/wa_idle',
title=title,
description=description)
def __init__(self, target: Target, **kwargs):
threads = int(target.n_cpus() / 2)
command = 'hackbench --pipe --threads --loops 20000 --datasize 4096'
super().__init__(command)
import time
from src.trace_event import TraceEvent
from src.target import Target
target = Target()
# events = ['sched_wakeup_new', 'sched_wakeup', 'sched_migrate_task', 'sched_move_numa']
# events = ['sched_move_numa', 'sched_preferred_nid', 'sched_numa_faults', 'sched_numa_stats']
events = ['sched_wakeup_new']
# cmd = "perf bench mem memset -s 1536MB -l 10 -f default"
# cmd = "perf bench -f simple futex wake -s -t 32 -w 1"
cmd = "sysbench threads --threads=8 run"
target.execute('sysctl kernel.sched_check_group_util=0', as_root=True)
te = TraceEvent(target,
cmd,
events=events,
output="sched_check_group_util_0.txt")
print(te.results)
time.sleep(5)
target.execute('sysctl kernel.sched_check_group_util=1', as_root=True)
te = TraceEvent(target,
cmd,
events=events,
output="sched_check_group_util_1.txt")
print(te.results)
def run1():
target = Target()
return target.method1(1, 2, 3)
def __init__(self, target: Target, **kwargs):
threads = int(target.n_cpus() / target.n_nodes())
command = 'sysbench cpu --threads={} --cpu-max-prime=10000 run'.format(
threads)
super().__init__(command)
def main():
target = Target()
res_files = []
tests_to_run = [
'SysBenchMutex', 'SysBenchThreads', 'SysBenchMemory', 'SysBenchCpu',
'PerfBenchMemMemset'
]
iter = 5
test_delay = 2
target.execute('sysctl kernel.sched_enable_task_numa_init=0', as_root=True)
for i in range(iter):
gc.collect()
time.sleep(test_delay)
res_files.append(
run_tests(test_name='Default',
target=target,
tests_to_run=tests_to_run,
iter=i))
target.execute('sysctl kernel.sched_enable_task_numa_init=0', as_root=True)
for i in range(iter):
gc.collect()
time.sleep(test_delay)
res_files.append(
run_tests(test_name='numa_init',
target=target,
tests_to_run=tests_to_run,
iter=i))
target.execute('sysctl kernel.sched_enable_task_numa_init=0', as_root=True)
for i in range(iter):
gc.collect()
time.sleep(test_delay)
res_files.append(
run_tests(test_name='Default_1',
target=target,
tests_to_run=tests_to_run,
iter=i))
target.execute('sysctl kernel.sched_enable_task_numa_init=0', as_root=True)
for i in range(iter):
gc.collect()
time.sleep(test_delay)
res_files.append(
run_tests(test_name='numa_init_1',
target=target,
tests_to_run=tests_to_run,
iter=i))
title = "Impact of setting numa_preferred_nid during wakeup_new phase on common benchmarks"
description = "In update_pick_idlest() function \
When both groups have 'group_has_spare' type \
and the same number of idle CPU's. \
We suggest evaluating group_util to find idlest group. "
create_report(res_files,
'results/numa_init',
title=title,
description=description)
def __init__(self, target: Target, **kwargs):
threads = min(int(target.n_cpus() / target.n_nodes()), 16)
command = 'sysbench threads --threads={} run'.format(threads)
#command = 'sysbench threads --max-time=1 --max-requests=-1 --threads={} run'.format(threads)
super().__init__(command)
def __init__(self, target: Target, **kwargs):
threads = min(int(target.n_cpus() / target.n_nodes()), 16)
command = 'sysbench mutex --mutex-num=1 --threads={} run'.format(
threads)
super().__init__(command)
def __init__(self, target: Target, **kwargs):
threads = int(target.n_cpus() / target.n_nodes())
command = 'sysbench memory --memory-access-mode=rnd --threads={} run'.format(
threads)
super().__init__(command)
def __init__(self, target: Target, **kwargs):
threads = int(target.n_cpus() / 2)
command = 'hackbench --loops 20000'
super().__init__(command)
def main(config_file, console=False, debug=False):
"""
数据清洗
"""
with open(config_file, encoding='utf-8') as f:
config_data = yaml.load(f)
if 'joinSource' in config_data:
reader = JoinSourceReader(config_data['source'],config_data['joinSource'])
else:
reader = Reader(config_data['source'])
target = None
if not console:
target = Target(config_data['target'])
else:
target = Target({'type': 'console'})
rowsLimit = None # 从源数据中读取的行数
if 'rowsLimit' in config_data['target']:
rowsLimit = config_data['target']['rowsLimit']
transform = None
if 'transform' in config_data:
transform = Transform(config_data['transform'])
count = 0
finish_run = False
for row in reader.next():
count += 1
if transform is not None:
for row_new in transform.do(row):
target.write(row_new)
else:
target.write(row)
if rowsLimit is not None and count >= rowsLimit:
finish_run = True
target.finish() # 通知已经完成了
break
if not finish_run and rowsLimit is not None:
target.finish() # 至少应该被运行一次
def test_get_cost(self):
target = Target({'A': (10000, 1), 'CR': (100, 3)})
cost = target.get_cost({'A': 9999, 'H': 10000, 'CR': 95})
self.assertEqual(cost, 1 + 75)
def test_init_target(self):
target = Target({'A': (10000, 1), 'CR': (100, 3)})
self.assertEqual(target.values_and_weights, {'A': 10000, 'AW': 1, 'H': 0, 'HW': 0, 'D': 0, 'DW': 0,
'CR': 100, 'CRW': 3, 'CA': 0, 'CAW': 0, 'HR': 0, 'HRW': 0,
'DR': 0, 'DRW': 0, 'S': 0, 'SW': 0})
