def __init__(self, mpi_task):
# {{{ pe
self.descr = 'Tool validation'
self.valid_prog_environs = ['PrgEnv-gnu', 'PrgEnv-intel', 'PrgEnv-pgi',
'PrgEnv-cray']
# self.valid_systems = ['daint:gpu', 'dom:gpu']
self.valid_systems = ['*']
self.maintainers = ['JG']
self.tags = {'sph', 'hpctools', 'cpu'}
# }}}
# {{{ compile
self.testname = 'sqpatch'
self.tool = 'scalasca'
self.prebuild_cmds = ['module rm xalt', 'module list -t']
tool_ver = '2.5'
tc_ver = '20.08'
self.tool_modules = {
'PrgEnv-gnu': [f'Scalasca/{tool_ver}-CrayGNU-{tc_ver}'],
'PrgEnv-intel': [f'Scalasca/{tool_ver}-CrayIntel-{tc_ver}'],
'PrgEnv-cray': [f'Scalasca/{tool_ver}-CrayCCE-{tc_ver}'],
'PrgEnv-pgi': [f'Scalasca/{tool_ver}-CrayPGI-{tc_ver}'],
}
self.prgenv_flags = {
'PrgEnv-gnu': ['-I.', '-I./include', '-std=c++14', '-g', '-O3',
'-DUSE_MPI', '-DNDEBUG'],
'PrgEnv-intel': ['-I.', '-I./include', '-std=c++14', '-g', '-O3',
'-DUSE_MPI', '-DNDEBUG'],
'PrgEnv-cray': ['-I.', '-I./include', '-std=c++17', '-g', '-Ofast',
'-DUSE_MPI', '-DNDEBUG'],
'PrgEnv-pgi': ['-I.', '-I./include', '-std=c++14', '-g', '-O3',
'-DUSE_MPI', '-DNDEBUG'],
}
self.build_system = 'SingleSource'
self.build_system.cxx = 'scorep --mpp=mpi --nocompiler CC'
self.sourcepath = f'{self.testname}.cpp'
self.executable = f'./{self.testname}.exe'
# }}}
# {{{ run
ompthread = 1
self.num_tasks = mpi_task
self.cubeside = cubeside_dict[mpi_task]
self.steps = steps_dict[mpi_task]
cycles = cycles_dict[mpi_task]
self.name = \
'sphexa_scalascaS+T_{}_{:03d}mpi_{:03d}omp_{}n_{}steps_{}cycles'. \
format(self.testname, mpi_task, ompthread, self.cubeside,
self.steps, cycles)
self.num_tasks_per_node = 24
# {{{ ht:
# self.num_tasks_per_node = mpitask if mpitask < 36 else 36 # noht
# self.use_multithreading = False # noht
# self.num_tasks_per_core = 1 # noht
# self.num_tasks_per_node = mpitask if mpitask < 72 else 72
# self.use_multithreading = True # ht
# self.num_tasks_per_core = 2 # ht
# }}}
self.num_cpus_per_task = ompthread
self.num_tasks_per_core = 2
self.use_multithreading = True
self.exclusive = True
self.time_limit = '10m'
self.variables = {
'CRAYPE_LINK_TYPE': 'dynamic',
'OMP_NUM_THREADS': str(self.num_cpus_per_task),
'SCOREP_ENABLE_PROFILING': 'false',
'SCOREP_ENABLE_TRACING': 'true',
'SCOREP_ENABLE_UNWINDING': 'true',
'SCOREP_SAMPLING_EVENTS': 'perf_cycles@%s' % cycles,
# 'SCOREP_SAMPLING_EVENTS': 'PAPI_TOT_CYC@1000000',
# 'SCOREP_SAMPLING_EVENTS': 'PAPI_TOT_CYC@%s' % cycles,
# export SCOREP_SAMPLING_EVENTS=PAPI_TOT_CYC@1000000
# empty SCOREP_SAMPLING_EVENTS will profile mpi calls only:
# ok: 'SCOREP_SAMPLING_EVENTS': '',
# 'SCOREP_METRIC_PAPI': 'PAPI_TOT_INS,PAPI_TOT_CYC',
# 'SCOREP_METRIC_RUSAGE': 'ru_maxrss',
# 'SCOREP_TIMER': 'clock_gettime',
# 'SCOREP_PROFILING_MAX_CALLPATH_DEPTH': '1',
# 'SCOREP_VERBOSE': 'true',
# To avoid "No free memory page available":
'SCOREP_TOTAL_MEMORY': '1G',
# Advanced performance metrics:
'SCOREP_METRIC_RUSAGE': 'ru_maxrss',
'SCOREP_METRIC_PAPI': 'PAPI_TOT_INS,PAPI_TOT_CYC',
}
self.version_rpt = 'version.rpt'
self.which_rpt = 'which.rpt'
self.info_rpt = 'info.rpt'
self.rpt = 'rpt'
# must use scorep.score:
self.score_rpt = '%s.postproc' % self.rpt
self.stat_rpt = 'scorep_%s_%s_trace/trace.stat' % \
(self.testname, self.num_tasks)
# self.rpt_inclusive = '%s.inclusive' % self.rpt
# self.rpt_exclusive = '%s.exclusive' % self.rpt
# self.cubetool = 'cube_calltree'
self.executable_opts = [
f'-n {self.cubeside}', f'-s {self.steps}', '2>&1']
self.prerun_cmds = [
'module rm xalt',
f'{self.tool} -V &> {self.version_rpt}',
f'scorep --version >> {self.version_rpt}',
f'which {self.tool} &> {self.which_rpt}',
f'which scorep >> {self.which_rpt}',
# f'which {self.cubetool} >> {self.which_rpt}',
f'scorep-info config-summary &> {self.info_rpt}',
]
cubetree = 'cube_calltree -m time -p -t 1'
# -m metricname -- print out values for the metric <metricname>
# -i -- calculate inclusive values instead of exclusive
# -t treshold -- print out only call path with a value larger
# than <treshold>%
# -p -- diplay percent value
self.postrun_cmds = [
# can't test directly from vampir gui, dumping tracefile content:
'otf2-print scorep_*_trace/traces.otf2 > %s' % self.rpt
# 'otf2-print scorep-*/traces.otf2 > %s' % self.rpt
]
# }}}
# {{{ sanity
self.sanity_patterns = sn.all([
# check the job output:
sn.assert_found(r'Total time for iteration\(0\)', self.stdout),
# check the tool's version and configuration:
sn.assert_true(sphsscorep.scorep_version(self)),
sn.assert_true(sphsscorep.scorep_info_papi_support(self)),
sn.assert_true(sphsscorep.scorep_info_perf_support(self)),
sn.assert_true(sphsscorep.scorep_info_unwinding_support(self)),
# check the report:
sn.assert_eq(sphsscorep.program_begin_count(self), self.num_tasks),
sn.assert_eq(sphsscorep.program_end_count(self), self.num_tasks),
# check the summary report:
# sn.assert_found(r'^S=C=A=N: \S+ complete\.', self.stderr)
])
# }}}
# {{{ performance
# {{{ internal timers
self.prerun_cmds += ['echo starttime=`date +%s`']
self.postrun_cmds += ['echo stoptime=`date +%s`']
# }}}
# {{{ perf_patterns:
basic_perf_patterns = sn.evaluate(sphs.basic_perf_patterns(self))
# tool: scalasca
tool_perf_patterns = sn.evaluate(sphssca.rpt_trace_stats_d(self))
self.perf_patterns = {**basic_perf_patterns, **tool_perf_patterns}
# tool: scorep
self.perf_patterns.update({
'max_ipc_rk0': sphsscorep.ipc_rk0(self),
'max_rumaxrss_rk0': sphsscorep.ru_maxrss_rk0(self),
})
# }}}
# {{{ reference:
self.reference = sn.evaluate(sphs.basic_reference_scoped_d(self))
# tool
myzero_n = (0, None, None, 'count')
myzero_ipc = (0, None, None, 'ins/cyc')
myzero_kb = (0, None, None, 'kilobytes')
# tool
self.reference['*:mpi_latesender'] = myzero_n
self.reference['*:mpi_latesender_wo'] = myzero_n
self.reference['*:mpi_latereceiver'] = myzero_n
self.reference['*:mpi_wait_nxn'] = myzero_n
self.reference['*:max_ipc_rk0'] = myzero_ipc
self.reference['*:max_rumaxrss_rk0'] = myzero_kb
def set_basic_reference(self):
self.reference = sn.evaluate(sphs.basic_reference_scoped_d(self))
def __init__(self, mpi_task):
# {{{ pe
self.descr = 'Tool validation'
self.valid_prog_environs = [
'PrgEnv-gnu', 'PrgEnv-intel', 'PrgEnv-pgi', 'PrgEnv-cray'
]
# self.valid_systems = ['daint:gpu', 'dom:gpu']
self.valid_systems = ['*']
self.maintainers = ['JG']
self.tags = {'sph', 'hpctools', 'cpu'}
# }}}
# {{{ compile
self.testname = 'sqpatch'
self.tool = 'inspxe-cl'
self.modules = ['inspector']
self.prebuild_cmds = ['module rm xalt', 'module list -t']
self.tool_v = '2020_update2'
tc_ver = '20.08'
self.tool_modules = {
'PrgEnv-gnu':
[f'CrayGNU/.{tc_ver}', f'{self.modules[0]}/{self.tool_v}'],
'PrgEnv-intel':
[f'CrayIntel/.{tc_ver}', f'{self.modules[0]}/{self.tool_v}'],
'PrgEnv-cray':
[f'CrayCCE/.{tc_ver}', f'{self.modules[0]}/{self.tool_v}'],
'PrgEnv-pgi':
[f'CrayPGI/.{tc_ver}', f'{self.modules[0]}/{self.tool_v}'],
}
self.prgenv_flags = {
'PrgEnv-gnu': [
'-I.', '-I./include', '-std=c++14', '-g', '-O3', '-DUSE_MPI',
'-DNDEBUG'
],
'PrgEnv-intel': [
'-I.', '-I./include', '-std=c++14', '-g', '-O3', '-DUSE_MPI',
'-DNDEBUG'
],
'PrgEnv-cray': [
'-I.', '-I./include', '-std=c++17', '-g', '-Ofast',
'-DUSE_MPI', '-DNDEBUG'
],
'PrgEnv-pgi': [
'-I.', '-I./include', '-std=c++14', '-g', '-O3', '-DUSE_MPI',
'-DNDEBUG'
],
}
self.build_system = 'SingleSource'
# self.build_system.cxx = 'CC'
self.sourcepath = f'{self.testname}.cpp'
self.executable = self.tool
self.target_executable = f'./{self.testname}.exe'
self.postbuild_cmds = [f'mv {self.tool} {self.target_executable}']
# }}}
# {{{ run
ompthread = 1
self.num_tasks = mpi_task
self.cubeside = cubeside_dict[mpi_task]
self.steps = steps_dict[mpi_task]
self.name = 'sphexa_inspector_{}_{:03d}mpi_{:03d}omp_{}n_{}steps'. \
format(self.testname, mpi_task, ompthread, self.cubeside,
self.steps)
self.num_tasks_per_node = 24
# {{{ ht:
# self.num_tasks_per_node = mpitask if mpitask < 36 else 36 # noht
# self.use_multithreading = False # noht
# self.num_tasks_per_core = 1 # noht
# self.num_tasks_per_node = mpitask if mpitask < 72 else 72
# self.use_multithreading = True # ht
# self.num_tasks_per_core = 2 # ht
# }}}
self.num_cpus_per_task = ompthread
self.num_tasks_per_core = 2
self.use_multithreading = True
self.exclusive = True
self.time_limit = '10m'
self.variables = {
'CRAYPE_LINK_TYPE': 'dynamic',
'OMP_NUM_THREADS': str(self.num_cpus_per_task),
}
self.dir_rpt = 'rpt'
self.tool_opts = '-collect mi1 -trace-mpi -no-auto-finalize -r %s' \
% self.dir_rpt
self.executable_opts = [
self.tool_opts, self.target_executable, f'-n {self.cubeside}',
f'-s {self.steps}', '2>&1'
]
self.version_rpt = 'version.rpt'
self.which_rpt = 'which.rpt'
self.summary_rpt = 'summary.rpt'
self.prerun_cmds = [
'module rm xalt',
f'{self.tool} --version >> {self.version_rpt}',
f'which {self.tool} &> {self.which_rpt}',
]
self.postrun_cmds = [
f'{self.tool} -r {self.dir_rpt}.* -report=summary '
f'&> {self.summary_rpt}',
# '%s -report=problems &> %s' % (self.tool, self.problems_rpt),
# '%s -report=observations &> %s' %
# (self.tool, self.observations_rpt),
]
# }}}
# {{{ sanity
self.sanity_patterns = sn.all([
# check the job output:
sn.assert_found(r'Total time for iteration\(0\)', self.stdout),
# check the tool's version:
sn.assert_true(sphsintel.inspector_version(self)),
# check the summary report:
sn.assert_found(r'\d new problem\(s\) found', self.summary_rpt),
])
# }}}
# {{{ performance
# {{{ internal timers
self.prerun_cmds += ['echo starttime=`date +%s`']
self.postrun_cmds += ['echo stoptime=`date +%s`']
# }}}
# {{{ perf_patterns:
self.perf_patterns = sn.evaluate(sphs.basic_perf_patterns(self))
# tool
self.perf_patterns.update({
'Memory not deallocated':
sphsintel.inspector_not_deallocated(self),
# 'Memory leak': sphsintel.inspector_leak(self),
})
# }}}
# {{{ reference:
self.reference = sn.evaluate(sphs.basic_reference_scoped_d(self))
# tool
self.reference['*:Memory not deallocated'] = (0, None, None, '')
def __init__(self, mpitask, steps, cycles, rumetric):
# {{{ pe
self.descr = 'Tool validation'
self.valid_prog_environs = ['PrgEnv-pgi']
# self.valid_systems = ['daint:gpu', 'dom:gpu']
self.valid_systems = ['*']
self.maintainers = ['JG']
self.tags = {'sph', 'hpctools', 'gpu', 'openacc'}
# }}}
# {{{ compile
self.testname = 'sqpatch'
self.prebuild_cmds = ['module rm xalt']
self.prgenv_flags = {
'PrgEnv-pgi': [
'-I.', '-I./include', '-std=c++14', '-g', '-O3', '-DNDEBUG',
'-DUSE_MPI', '-DUSE_ACC', '-DUSE_STD_MATH_IN_KERNELS', '-acc',
'-ta=tesla:managed,cc60'
], # -mp
}
# ---------------------------------------------------------------- tool
self.modules = ['craype-accel-nvidia60']
tc_ver = '19.10'
tool_ver = '6.0'
postproc_tool_ver = '4ef9d3f'
postproc_tool_serial = 'otf-profiler'
self.postproc_tool = 'otf-profiler-mpi'
self.tool_modules = {
'PrgEnv-pgi': ['Score-P/%s-CrayPGI-%s' % (tool_ver, tc_ver)]
}
# ---------------------------------------------------------------- tool
self.build_system = 'SingleSource'
self.build_system.cxx = 'scorep-CC'
self.sourcepath = '%s.cpp' % self.testname
self.executable = '%s.exe' % self.testname
# {{{ openmp:
# 'PrgEnv-intel': ['-qopenmp'],
# 'PrgEnv-gnu': ['-fopenmp'],
# 'PrgEnv-pgi': ['-mp'],
# 'PrgEnv-cray_classic': ['-homp'],
# 'PrgEnv-cray': ['-fopenmp'],
# # '-homp' if lang == 'F90' else '-fopenmp',
# }}}
# }}}
# {{{ run
ompthread = 1
# weak scaling = 10^6 p/cn:
size_dict = {
1: 100,
2: 126,
4: 159,
8: 200,
16: 252,
32: 318,
64: 400,
128: 504,
256: 635
}
cubesize = size_dict[mpitask]
self.name = \
'openacc_scorepT_{}_{:03d}mpi_{:03d}omp_{}n_{}steps_{}cycles_{}'. \
format(self.testname, mpitask, ompthread, cubesize, steps, cycles,
rumetric)
self.num_tasks = mpitask
self.num_tasks_per_node = 1
# {{{ ht:
# self.num_tasks_per_node = mpitask if mpitask < 36 else 36 # noht
# self.use_multithreading = False # noht
# self.num_tasks_per_core = 1 # noht
# self.num_tasks_per_node = mpitask if mpitask < 72 else 72
# self.use_multithreading = True # ht
# self.num_tasks_per_core = 2 # ht
# }}}
self.num_cpus_per_task = ompthread
self.num_tasks_per_core = 1
self.use_multithreading = False
self.exclusive = True
self.time_limit = '10m'
self.variables = {
'CRAYPE_LINK_TYPE': 'dynamic',
'SCOREP_OPENACC_ENABLE': 'yes',
'OMP_NUM_THREADS': str(self.num_cpus_per_task),
'SCOREP_WRAPPER_INSTRUMENTER_FLAGS': '"--mpp=mpi --openacc"',
'SCOREP_ENABLE_PROFILING': 'false',
'SCOREP_ENABLE_TRACING': 'true',
'SCOREP_FILTERING_FILE': 'myfilt',
'SCOREP_VERBOSE': 'true',
# Needed to avoid "No free memory page available"
'SCOREP_TOTAL_MEMORY': '1G',
# Adding some performance metrics:
# http://scorepci.pages.jsc.fz-juelich.de/scorep-pipelines/docs/
# => scorep-6.0/html/measurement.html#rusage_counters
# => https://vampir.eu/public/files/pdf/spcheatsheet_letter.pdf
# 'SCOREP_METRIC_RUSAGE': 'ru_maxrss',
# 'SCOREP_METRIC_RUSAGE': 'ru_maxrss,ru_utime',
# 'SCOREP_METRIC_RUSAGE': 'ru_maxrss',
# 'SCOREP_METRIC_RUSAGE': '',
'SCOREP_METRIC_RUSAGE': rumetric,
'SCOREP_METRIC_PAPI': 'PAPI_TOT_INS,PAPI_TOT_CYC',
}
self.rusage_name = sn.evaluate(sphsscacc.otf2cli_metric_name(self))
if cycles > 0:
self.variables['SCOREP_SAMPLING_EVENTS'] \
= 'perf_cycles@%s' % cycles
self.version_rpt = 'version.rpt'
self.which_rpt = 'which.rpt'
self.info_rpt = 'scorep-info.rpt'
self.rpt = 'rpt'
self.rpt_jsn = 'result.json'
self.rpt_inclusive = '%s.inclusive' % self.rpt
self.rpt_exclusive = '%s.exclusive' % self.rpt
self.tool = 'scorep'
self.executable_opts = ['-n %s' % cubesize, '-s %s' % steps]
self.prerun_cmds = [
'module rm xalt',
'%s --version &> %s' % (self.tool, self.version_rpt),
'which %s &> %s' % (self.tool, self.which_rpt),
'scorep-info config-summary &> %s' % self.info_rpt,
]
self.postrun_cmds = [
# otf-profiler is needed for postprocessing but i managed to
# compile only gnu version => removing CubeLib to avoid conflict
# with CrayPGI:
'module rm CubeLib',
'module load otf2_cli_profile/%s-CrayGNU-%s' %
(postproc_tool_ver, tc_ver),
# report post-processing tools version
'%s --version' % postproc_tool_serial,
# OTF-Profiler version 2.0.0
'which %s %s' % (postproc_tool_serial, self.postproc_tool),
# create result.json performance report from tracefile
# see otf_profiler method (@run_after)
]
# }}}
# {{{ sanity
# sanity
self.sanity_patterns = sn.all([
# check the job output:
sn.assert_found(r'Total time for iteration\(0\)', self.stdout),
# check the tool's version and configuration:
sn.assert_true(sphsscorep.scorep_version(self)),
# Needed when using papi counters:
# sn.assert_true(sphsscorep.scorep_info_papi_support(self)),
sn.assert_true(sphsscorep.scorep_info_perf_support(self)),
sn.assert_true(sphsscorep.scorep_info_unwinding_support(self)),
])
# }}}
# {{{ performance
# {{{ internal timers
# use linux date as timer:
self.prerun_cmds += ['echo starttime=`date +%s`']
# }}}
# {{{ perf_patterns:
basic_perf_patterns = sn.evaluate(sphs.basic_perf_patterns(self))
tool_perf_patterns = sn.evaluate(sphsscacc.otf2cli_perf_patterns(self))
self.perf_patterns = {**basic_perf_patterns, **tool_perf_patterns}
# }}}
# {{{ reference:
self.reference = sn.evaluate(sphs.basic_reference_scoped_d(self))
self.reference = sn.evaluate(sphsscacc.otf2cli_tool_reference(self))
def __init__(self, mpi_task):
# {{{ pe
self.descr = 'Tool validation'
self.valid_prog_environs = ['PrgEnv-gnu']
# self.valid_systems = ['daint:gpu', 'dom:gpu']
self.valid_systems = ['*']
self.maintainers = ['JG']
self.tags = {'sph', 'hpctools', 'cpu'}
# }}}
# {{{ compile
self.testname = 'sqpatch'
self.sourcesdir = 'src_cpu'
self.prgenv_flags = {
'PrgEnv-gnu': [
'-I.', '-I./include', '-std=c++14', '-g', '-O3', '-DUSE_MPI',
'-DNDEBUG', '-fopenmp'
]
}
tool_ver = '2.8'
tc_ver = '20.08'
self.prebuild_cmds = ['module rm xalt', 'module list -t']
self.tool_modules = {
'PrgEnv-gnu': [f'CrayGNU/.{tc_ver}', f'gperftools/{tool_ver}'],
}
self.build_system = 'SingleSource'
self.sourcepath = f'{self.testname}.cpp'
self.executable = './gperftools.sh'
self.tool_executable = f'gperftools_script.sh'
self.target_executable = f'./{self.testname}.exe'
self.prebuild_cmds = [
'module rm xalt',
'module list -t',
]
# }}}
# {{{ run
ompthread = 1
self.num_tasks = mpi_task
self.cubeside = cubeside_dict[mpi_task]
self.steps = steps_dict[mpi_task]
self.name = 'sphexa_gperf_{}_{:03d}mpi_{:03d}omp_{}n_{}steps'.format(
self.testname, mpi_task, ompthread, self.cubeside, self.steps)
self.num_tasks_per_node = 12
self.num_cpus_per_task = ompthread
self.num_tasks_per_core = 1
self.use_multithreading = False
self.exclusive = True
self.time_limit = '10m'
self.variables = {
'CRAYPE_LINK_TYPE': 'dynamic',
'OMP_NUM_THREADS': str(self.num_cpus_per_task),
'OMP_PROC_BIND': 'true',
}
self.executable_opts = [
self.target_executable, f"-n {self.cubeside}", f"-s {self.steps}"
]
self.prerun_cmds += [
'module rm xalt', 'module list -t',
f'mv {self.executable} {self.target_executable}',
f'mv {self.tool_executable} {self.executable}'
]
self.rpt_file = 'gperftools.rpt'
self.rpt_file_txt = f'{self.rpt_file}.txt'
self.rpt_file_pdf = f'{self.rpt_file}.pdf'
self.rpt_file_doc = f'{self.rpt_file}.doc'
self.postrun_tool = '$EBROOTPPROF/bin/pprof'
self.postrun_cmds += [
# txt rpt (quotation mark will make it fail):
f'{self.postrun_tool} --unit=ms --text --lines '
f'{self.target_executable} *.0 &> {self.rpt_file_txt}',
# pdf rpt:
f'{self.postrun_tool} --pdf {self.target_executable} *.0 '
f'&> {self.rpt_file_pdf}',
# pdf rpt type:
f'file {self.rpt_file_pdf} &> {self.rpt_file_doc}',
# '$EBROOTPPROF/bin/pprof --unit=ms --text --lines %s %s &> %s' %
# (self.exe, '*.0', self.rpt_file_txt),
# '$EBROOTPPROF/bin/pprof --pdf %s %s &> %s' %
# (self.exe, '*.0', self.rpt_file_pdf),
# 'file %s &> %s' % (self.rpt_file_pdf, self.rpt_file_doc)
]
# }}}
# {{{ sanity
self.sanity_patterns = sn.all([
# check the job output:
sn.assert_found(r'Total time for iteration\(0\)', self.stdout),
sn.assert_found('PDF document', self.rpt_file_doc),
])
# }}}
# {{{ performance
# {{{ internal timers
self.prerun_cmds += ['echo starttime=`date +%s`']
self.postrun_cmds += ['echo stoptime=`date +%s`']
# }}}
# {{{ perf_patterns:
basic_perf_patterns = sn.evaluate(sphs.basic_perf_patterns(self))
tool_perf_patterns = sn.evaluate(sphsgperf.gp_perf_patterns(self))
self.perf_patterns = {**basic_perf_patterns, **tool_perf_patterns}
# }}}
# {{{ reference:
self.reference = sn.evaluate(sphs.basic_reference_scoped_d(self))
self.reference = sn.evaluate(sphsgperf.gp_tool_reference(self))
def __init__(self, mpi_task):
# super().__init__()
# {{{ pe
self.descr = 'Tool validation'
self.valid_prog_environs = [
'PrgEnv-gnu', 'PrgEnv-intel', 'PrgEnv-pgi', 'PrgEnv-cray'
]
# self.valid_systems = ['daint:gpu', 'dom:gpu']
self.valid_systems = ['*']
self.maintainers = ['JG']
self.tags = {'sph', 'hpctools', 'cpu'}
# }}}
# {{{ compile
self.testname = 'sqpatch'
self.tool = 'valgrind4hpc'
self.prgenv_flags = {
'PrgEnv-gnu': [
'-I.', '-I./include', '-std=c++14', '-g', '-O0', '-DUSE_MPI',
'-DNDEBUG'
],
'PrgEnv-intel': [
'-I.', '-I./include', '-std=c++14', '-g', '-O0', '-DUSE_MPI',
'-DNDEBUG'
],
'PrgEnv-cray': [
'-I.', '-I./include', '-std=c++17', '-g', '-O0', '-DUSE_MPI',
'-DNDEBUG'
],
'PrgEnv-pgi': [
'-I.', '-I./include', '-std=c++14', '-g', '-O0', '-DUSE_MPI',
'-DNDEBUG'
],
}
tc_ver = '20.08'
self.prebuild_cmds = ['module rm xalt', 'module list -t']
self.tool_modules = {
'PrgEnv-gnu': [f'CrayGNU/.{tc_ver}', self.tool],
'PrgEnv-intel': [f'CrayIntel/.{tc_ver}', self.tool],
'PrgEnv-cray': [f'CrayCCE/.{tc_ver}', self.tool],
'PrgEnv-pgi': [f'CrayPGI/.{tc_ver}', self.tool],
}
self.build_system = 'SingleSource'
self.sourcepath = f'{self.testname}.cpp'
self.executable = self.tool
self.target_executable = f'./{self.testname}.exe'
self.postbuild_cmds = [
f'mv {self.executable} {self.target_executable}',
]
# }}}
# {{{ run
ompthread = 1
self.num_tasks = mpi_task
self.cubeside = cubeside_dict[mpi_task]
self.steps = steps_dict[mpi_task]
self.name = 'sphexa_valgrind4hpc_{}_{:03d}mpi_{:03d}omp_{}n_{}steps'. \
format(self.testname, mpi_task, ompthread, self.cubeside,
self.steps)
self.num_tasks_per_node = 12
self.num_cpus_per_task = ompthread
self.num_tasks_per_core = 1
self.use_multithreading = False
self.exclusive = True
self.time_limit = '10m'
self.variables = {
'CRAYPE_LINK_TYPE':
'dynamic',
'OMP_NUM_THREADS':
str(self.num_cpus_per_task),
'PKG_CONFIG_PATH':
'$VALGRIND4HPC_INSTALL_DIR/lib/pkgconfig:$PKG_CONFIG_PATH',
}
self.tool_opts = (
f' -n{self.num_tasks}'
# f' --launcher-args=""'
f' --valgrind-args="--track-origins=yes --leak-check=full"')
# valgrind4hpc -n32 --launcher-args="-N16 -j2"
# --valgrind-args="--track-origins=yes --leak-check=full" ./a.out
# -- arg1 arg2
self.executable_opts = [
self.tool_opts, self.target_executable, f'-- -n {self.cubeside}',
f'-s {self.steps}', '2>&1'
]
self.version_rpt = 'version.rpt'
self.which_rpt = 'which.rpt'
self.prerun_cmds = [
'module rm xalt',
f'echo $VALGRIND4HPC_VERSION > {self.version_rpt}',
f'grep PACKAGE_VERSION $VALGRIND4HPC_INSTALL_DIR/include/'
f'valgrind/config.h >> {self.version_rpt}',
f'which {self.tool} &> {self.which_rpt}',
]
# }}}
# {{{ sanity
sanity_1 = r'Conditional jump or move depends on uninitialised value'
sanity_2 = r'Uninitialised value was created by a heap allocation'
sanity_3 = r'All heap blocks were freed -- no leaks are possible'
self.sanity_patterns = sn.all([
# check the job output:
sn.assert_found(r'Total time for iteration\(0\)', self.stdout),
sn.assert_found(sanity_1, self.stdout),
sn.assert_found(sanity_2, self.stdout),
sn.assert_found(sanity_3, self.stdout),
])
# }}}
# {{{ performance
# {{{ internal timers
self.time_rpt = 'time.rpt'
# the tool flushes stdout hence we need this trick:
self.prerun_cmds += [f'echo starttime=`date +%s` > {self.time_rpt}']
self.postrun_cmds += [
f'echo stoptime=`date +%s` >> {self.time_rpt}',
f'cat {self.time_rpt}'
]
# }}}
# {{{ perf_patterns:
basic_perf_patterns = sn.evaluate(sphs.basic_perf_patterns(self))
tool_perf_patterns = sn.evaluate(sphsvalgrind.vhpc_perf_patterns(self))
self.perf_patterns = {**basic_perf_patterns, **tool_perf_patterns}
# }}}
# {{{ reference:
self.reference = sn.evaluate(sphs.basic_reference_scoped_d(self))
self.reference = sn.evaluate(sphsvalgrind.vhpc_tool_reference(self))
def __init__(self, mpi_task):
# {{{ pe
self.descr = 'Tool validation'
self.valid_prog_environs = ['PrgEnv-gnu']
# self.valid_systems = ['daint:gpu', 'dom:gpu']
self.valid_systems = ['*']
self.maintainers = ['JG']
self.tags = {'sph', 'hpctools', 'gpu'}
# }}}
# {{{ compile
self.testname = 'sqpatch'
self.tool = 'scorep'
self.prebuild_cmds = ['module rm xalt', 'module list -t']
tool_ver = '6.0'
tc_ver = '20.08'
self.tool_modules = {
'PrgEnv-gnu': [f'Score-P/{tool_ver}-CrayGNU-{tc_ver}-cuda'],
}
self.build_system = 'Make'
self.build_system.makefile = 'Makefile'
self.build_system.nvcc = 'nvcc'
self.build_system.cxx = 'CC'
self.build_system.max_concurrency = 2
self.sourcepath = f'{self.testname}.cpp'
self.executable = f'./{self.testname}.exe'
self.target_executable = 'mpi+omp+cuda'
self.build_system.cxx = 'scorep --mpp=mpi --cuda --nocompiler CC'
self.build_system.nvcc = 'scorep --cuda --nocompiler nvcc'
self.build_system.options = [
self.target_executable,
f'MPICXX="{self.build_system.cxx}"',
'SRCDIR=.',
'BUILDDIR=.',
'BINDIR=.',
'CXXFLAGS=-std=c++14',
'CUDA_PATH=$CUDATOOLKIT_HOME',
# The makefile adds -DUSE_MPI
]
self.postbuild_cmds = [
f'mv {self.target_executable}.app '
f'{self.executable}'
]
# }}}
# {{{ run
ompthread = 1
self.num_tasks = mpi_task
self.cubeside = cubeside_dict[mpi_task]
self.steps = steps_dict[mpi_task]
# cycles = cycles_dict[mpi_task]
self.name = \
'sphexa_scorep+cuda_{}_{:03d}mpi_{:03d}omp_{}n_{}steps'. \
format(self.testname, mpi_task, ompthread, self.cubeside,
self.steps)
self.num_tasks_per_node = 1
self.num_cpus_per_task = ompthread
self.num_tasks_per_core = 1
self.use_multithreading = False
self.exclusive = True
self.time_limit = '10m'
self.variables = {
'CRAYPE_LINK_TYPE': 'dynamic',
'OMP_NUM_THREADS': str(self.num_cpus_per_task),
'SCOREP_ENABLE_PROFILING': 'false',
'SCOREP_ENABLE_TRACING': 'true',
'SCOREP_CUDA_ENABLE': 'yes',
'SCOREP_ENABLE_UNWINDING': 'true',
# 'SCOREP_SAMPLING_EVENTS': 'perf_cycles@%s' % cycles,
# 'SCOREP_SAMPLING_EVENTS': 'PAPI_TOT_CYC@1000000',
# 'SCOREP_SAMPLING_EVENTS': 'PAPI_TOT_CYC@%s' % cycles,
# export SCOREP_SAMPLING_EVENTS=PAPI_TOT_CYC@1000000
# empty SCOREP_SAMPLING_EVENTS will profile mpi calls only:
# ok: 'SCOREP_SAMPLING_EVENTS': '',
# 'SCOREP_METRIC_PAPI': 'PAPI_TOT_INS,PAPI_TOT_CYC',
# 'SCOREP_METRIC_RUSAGE': 'ru_maxrss',
# 'SCOREP_TIMER': 'clock_gettime',
# 'SCOREP_PROFILING_MAX_CALLPATH_DEPTH': '1',
# 'SCOREP_VERBOSE': 'true',
# 'SCOREP_TOTAL_MEMORY': '1G',
}
self.version_rpt = 'version.rpt'
self.which_rpt = 'which.rpt'
self.info_rpt = 'info.rpt'
self.executable_opts = [
f'-n {self.cubeside}', f'-s {self.steps}', '2>&1'
]
self.prerun_cmds = [
'module rm xalt',
f'{self.tool} --version &> {self.version_rpt}',
f'which {self.tool} &> {self.which_rpt}',
'scorep-info config-summary &> %s' % self.info_rpt,
]
# }}}
# {{{ sanity
self.sanity_patterns = sn.all([
# check the job output:
sn.assert_found(r'Total time for iteration\(0\)', self.stdout),
# check the tool's version and configuration:
sn.assert_true(sphsscorep.scorep_version(self)),
sn.assert_true(sphsscorep.scorep_info_papi_support(self)),
sn.assert_true(sphsscorep.scorep_info_perf_support(self)),
sn.assert_true(sphsscorep.scorep_info_unwinding_support(self)),
sn.assert_true(sphsscorep.scorep_info_cuda_support(self)),
])
# }}}
# {{{ performance
# {{{ internal timers
self.prerun_cmds += ['echo starttime=`date +%s`']
self.postrun_cmds += ['echo stoptime=`date +%s`']
# }}}
# {{{ perf_patterns:
basic_perf_patterns = sn.evaluate(sphs.basic_perf_patterns(self))
self.perf_patterns = {**basic_perf_patterns}
# }}}
# {{{ reference:
self.reference = sn.evaluate(sphs.basic_reference_scoped_d(self))
def __init__(self, mpi_task, cubeside):
# {{{ pe
self.descr = 'Tool validation'
self.valid_prog_environs = ['PrgEnv-gnu']
# self.valid_systems = ['daint:gpu', 'dom:gpu']
self.valid_systems = ['*']
self.maintainers = ['JG']
self.tags = {'sph', 'hpctools'}
# }}}
# {{{ compile
self.testname = 'sqpatch'
self.prebuild_cmds = ['module rm xalt', 'module list -t']
tc_ver = '20.08'
self.modules = ['craype-accel-nvidia60', 'perftools-base']
self.tool = 'pat_report'
self.tool_modules = {
'PrgEnv-gnu': [f'CrayGNU/.{tc_ver}', 'perftools-lite-gpu'],
}
self.build_system = 'Make'
self.build_system.makefile = 'Makefile'
self.build_system.nvcc = 'nvcc'
self.build_system.cxx = 'CC'
self.build_system.max_concurrency = 2
self.sourcepath = f'{self.testname}.cpp'
self.executable = f'./{self.testname}.exe'
self.target_executable = 'mpi+omp+cuda'
self.build_system.options = [
self.target_executable,
f'MPICXX="{self.build_system.cxx}"',
'SRCDIR=.',
'BUILDDIR=.',
'BINDIR=.',
'CXXFLAGS=-std=c++14',
'CUDA_PATH=$CUDATOOLKIT_HOME',
# The makefile adds -DUSE_MPI
]
self.version_rpt = 'version.rpt'
self.which_rpt = 'which.rpt'
self.rpt = 'RUNTIME.rpt'
self.postbuild_cmds = [
f'mv {self.target_executable}.app '
f'{self.executable}',
f'{self.tool} -V &> {self.version_rpt}',
f'which {self.tool} &> {self.which_rpt}',
]
# }}}
# {{{ run
ompthread = 1
self.num_tasks = mpi_task
self.cubeside = cubeside
self.steps = steps_dict[mpi_task]
self.name = \
'sphexa_perftools-gpu-cuda_{}_{:03d}mpi_{:03d}omp_{}n_{}steps'. \
format(self.testname, mpi_task, ompthread, self.cubeside,
self.steps)
self.num_tasks_per_node = 1
self.num_cpus_per_task = ompthread
self.num_tasks_per_core = 1
self.use_multithreading = False
self.exclusive = True
self.time_limit = '10m'
self.variables = {
'CRAYPE_LINK_TYPE': 'dynamic',
'OMP_NUM_THREADS': str(self.num_cpus_per_task),
}
self.executable_opts = [
f'-n {self.cubeside}', f'-s {self.steps}', '2>&1'
]
self.prerun_cmds = ['module rm xalt']
self.postrun_cmds = [
f'cp {self.executable}+*/rpt-files/RUNTIME.rpt {self.rpt}'
]
# }}}
# {{{ sanity
self.sanity_patterns = sn.all([
# check the job output:
sn.assert_found(r'Total time for iteration\(0\)', self.stdout),
sn.assert_true(sphsptlgpu.tool_version(self)),
])
# }}}
# {{{ performance
# {{{ internal timers
self.prerun_cmds += ['echo starttime=`date +%s`']
self.postrun_cmds += ['echo stoptime=`date +%s`']
# }}}
# {{{ perf_patterns:
basic_perf_patterns = sn.evaluate(sphs.basic_perf_patterns(self))
tool_perf_patterns = sn.evaluate(sphsptlgpu.tool_perf_patterns(self))
self.perf_patterns = {**basic_perf_patterns, **tool_perf_patterns}
# }}}
# {{{ reference:
self.reference = sn.evaluate(sphs.basic_reference_scoped_d(self))
# tool's reference
myzero_p = (0, None, None, '%')
myzero_mb = (0, None, None, 'MiBytes')
self.reference['*:host_time%'] = myzero_p
self.reference['*:device_time%'] = myzero_p
self.reference['*:acc_copyin'] = myzero_mb
self.reference['*:acc_copyout'] = myzero_mb
def __init__(self, mpi_task):
# {{{ pe
self.descr = 'Tool validation'
self.valid_prog_environs = ['PrgEnv-gnu']
# self.valid_systems = ['daint:gpu', 'dom:gpu']
self.valid_systems = ['*']
self.maintainers = ['JG']
self.tags = {'sph', 'hpctools', 'gpu'}
# }}}
# {{{ compile
self.testname = 'sqpatch'
self.tool = 'nvprof'
self.tool_mf = 'nvhpc'
tc_ver = '20.08'
self.prebuild_cmds = ['module rm xalt', 'module list -t']
self.tool_modules = {
'PrgEnv-gnu': [f'CrayGNU/.{tc_ver}', 'craype-accel-nvidia60',
self.tool_mf],
}
self.build_system = 'Make'
self.build_system.makefile = 'Makefile'
self.build_system.nvcc = 'nvcc'
self.build_system.cxx = 'CC'
self.build_system.max_concurrency = 2
self.executable = self.tool
self.target_executable = 'mpi+omp+cuda'
self.build_system.options = [
self.target_executable, 'MPICXX=CC', 'SRCDIR=.', 'BUILDDIR=.',
'BINDIR=.', 'CUDA_PATH=$CUDATOOLKIT_HOME',
# The makefile adds -DUSE_MPI
# 'CXXFLAGS=',
]
self.postbuild_cmds = [f'mv {self.target_executable}.app '
f'{self.target_executable}']
# }}}
# {{{ run
ompthread = 1
self.num_tasks = mpi_task
self.cubeside = cubeside_dict[mpi_task]
self.steps = steps_dict[mpi_task]
self.name = 'sphexa_nvprofcuda_{}_{:03d}mpi_{:03d}omp_{}n_{}steps'. \
format(self.testname, mpi_task, ompthread, self.cubeside,
self.steps)
self.num_tasks_per_node = 1
self.num_cpus_per_task = ompthread
self.num_tasks_per_core = 1
self.use_multithreading = False
self.exclusive = True
self.time_limit = '15m'
self.variables = {
'CRAYPE_LINK_TYPE': 'dynamic',
'OMP_NUM_THREADS': str(self.num_cpus_per_task),
# 'COMPUTE_PROFILE': '',
# 'PMI_NO_FORK': '1',
}
self.tool_opts = ''
# self.tool_opts = r'-o nvprof.output.%h.%p'
self.executable_opts = [
self.tool_opts, f'./{self.target_executable}',
f'-n {self.cubeside}', f'-s {self.steps}', '2>&1']
self.version_rpt = 'version.rpt'
self.which_rpt = 'which.rpt'
self.summary_rpt = 'summary.rpt'
# Reminder: NVreg_RestrictProfilingToAdminUsers=0 (RFC-16) needed since
# cuda/10.1
self.postrun_cmds = ['cat /etc/modprobe.d/nvidia.conf']
self.prerun_cmds = [
'module rm xalt',
f'{self.tool} --version &> {self.version_rpt}',
f'which {self.tool} &> {self.which_rpt}',
]
# }}}
# {{{ sanity
self.sanity_patterns = sn.all([
# check the job output:
sn.assert_found(r'Total time for iteration\(0\)', self.stdout),
# check the tool's version:
sn.assert_true(sphsnv.nvprof_version(self)),
# check the summary report:
sn.assert_found('NVPROF is profiling process', self.stdout),
])
# }}}
# {{{ performance
# {{{ internal timers
self.prerun_cmds += ['echo starttime=`date +%s`']
self.postrun_cmds += ['echo stoptime=`date +%s`']
# }}}
# {{{ perf_patterns:
basic_perf_patterns = sn.evaluate(sphs.basic_perf_patterns(self))
tool_perf_patterns = sn.evaluate(sphsnv.nvprof_perf_patterns(self))
self.perf_patterns = {**basic_perf_patterns, **tool_perf_patterns}
# }}}
# {{{ reference:
self.reference = sn.evaluate(sphs.basic_reference_scoped_d(self))
# tool's reference
myzero_k = (0, None, None, 'KiB')
myzero_p = (0, None, None, '%')
self.reference['*:%cudaMemcpy'] = myzero_p
self.reference['*:%CUDA_memcpy_HtoD_time'] = myzero_p
self.reference['*:%CUDA_memcpy_DtoH_time'] = myzero_p
self.reference['*:CUDA_memcpy_HtoD_KiB'] = myzero_k
self.reference['*:CUDA_memcpy_DtoH_KiB'] = myzero_k
self.reference['*:%computeMomentumAndEnergyIAD'] = myzero_p
self.reference['*:%computeIAD'] = myzero_p
def __init__(self, mpi_task):
# {{{ pe
self.descr = 'Tool validation'
self.valid_prog_environs = ['PrgEnv-gnu']
# self.valid_systems = ['daint:gpu', 'dom:gpu']
self.valid_systems = ['*']
self.maintainers = ['JG']
self.tags = {'sph', 'hpctools', 'cpu'}
# }}}
# {{{ compile
self.testname = 'sqpatch'
self.prebuild_cmds = ['module rm xalt']
self.prgenv_flags = {
'PrgEnv-gnu': [
'-I.', '-I./include', '-std=c++14', '-g', '-O3', '-DUSE_MPI',
'-DNDEBUG'
],
}
# ---------------------------------------------------------------- tool
self.tool = 'tool.sh'
tool_ver = '3.8.1'
tc_ver = '20.08'
self.tool_modules = {
'PrgEnv-gnu': [f'Extrae/{tool_ver}-CrayGNU-{tc_ver}'],
}
# ---------------------------------------------------------------- tool
self.build_system = 'SingleSource'
self.build_system.cxx = 'CC'
self.sourcepath = '%s.cpp' % self.testname
self.executable = self.tool
self.target_executable = './%s.exe' % self.testname
# {{{ openmp:
# 'PrgEnv-intel': ['-qopenmp'],
# 'PrgEnv-gnu': ['-fopenmp'],
# 'PrgEnv-pgi': ['-mp'],
# 'PrgEnv-cray_classic': ['-homp'],
# 'PrgEnv-cray': ['-fopenmp'],
# # '-homp' if lang == 'F90' else '-fopenmp',
# }}}
# }}}
# {{{ run
ompthread = 1
self.cubeside = cubeside_dict[mpi_task]
self.steps = steps_dict[mpi_task]
self.name = \
'sphexa_extrae_{}_{:03d}mpi_{:03d}omp_{}n_{}steps'. \
format(self.testname, mpi_task, ompthread, self.cubeside,
self.steps)
self.num_tasks = mpi_task
self.num_tasks_per_node = 24 # 72
# {{{ ht:
# self.num_tasks_per_node = mpitask if mpitask < 36 else 36 # noht
# self.use_multithreading = False # noht
# self.num_tasks_per_core = 1 # noht
# self.num_tasks_per_node = mpitask if mpitask < 72 else 72
# self.use_multithreading = True # ht
# self.num_tasks_per_core = 2 # ht
# }}}
self.num_cpus_per_task = ompthread
self.num_tasks_per_core = 2
self.use_multithreading = True
self.exclusive = True
self.time_limit = '10m'
self.variables = {
'CRAYPE_LINK_TYPE': 'dynamic',
'OMP_NUM_THREADS': str(self.num_cpus_per_task),
}
self.version_rpt = 'version.rpt'
self.which_rpt = 'which.rpt'
self.rpt = 'rpt'
self.tool = './tool.sh'
self.executable = self.tool
self.executable_opts = [
f'-- -n {self.cubeside}', f'-s {self.steps}', '2>&1'
]
self.xml1 = '$EBROOTEXTRAE/share/example/MPI/extrae.xml'
self.xml2 = 'extrae.xml'
self.patch = 'extrae.xml.patch'
self.version_file = 'extrae_version.h'
self.prerun_cmds = [
'module rm xalt',
# tool version
'cp $EBROOTEXTRAE/include/extrae_version.h %s' % self.version_file,
# will launch ./tool.sh myexe myexe_args:
'mv %s %s' % (self.executable, self.target_executable),
# .xml
'echo %s &> %s' % (self.xml1, self.which_rpt),
'patch -i %s %s -o %s' % (self.patch, self.xml1, self.xml2),
# .sh
'echo -e \'%s\' >> %s' % (sphsextrae.create_sh(self), self.tool),
'chmod u+x %s' % (self.tool),
]
self.prv = '%s.prv' % self.target_executable[2:] # stripping './'
self.postrun_cmds = [
'stats-wrapper.sh %s -comms_histo' % self.prv,
]
self.rpt_mpistats = '%s.comms.dat' % self.target_executable
# }}}
# {{{ sanity
self.sanity_patterns = sn.all([
# check the job output:
sn.assert_found(r'Total time for iteration\(0\)', self.stdout),
# check the tool version:
sn.assert_true(sphsextrae.extrae_version(self)),
# check the summary report:
sn.assert_found(
r'Congratulations! %s has been generated.' % self.prv,
self.stdout),
])
# }}}
# {{{ performance
# {{{ internal timers
# use linux date as timer:
self.prerun_cmds += ['echo starttime=`date +%s`']
self.postrun_cmds += ['echo stoptime=`date +%s`']
# }}}
# {{{ perf_patterns:
basic_perf_patterns = sn.evaluate(sphs.basic_perf_patterns(self))
tool_perf_patterns = sn.evaluate(sphsextrae.rpt_mpistats(self))
self.perf_patterns = {**basic_perf_patterns, **tool_perf_patterns}
# }}}
# {{{ reference:
basic_reference = sn.evaluate(sphs.basic_reference_scoped_d(self))
self.reference = basic_reference
# tool's reference
myzero = (0, None, None, '')
myzero_p = (0, None, None, '%')
self.reference['*:num_comms_0-10B'] = myzero
self.reference['*:num_comms_10B-100B'] = myzero
self.reference['*:num_comms_100B-1KB'] = myzero
self.reference['*:num_comms_1KB-10KB'] = myzero
self.reference['*:num_comms_10KB-100KB'] = myzero
self.reference['*:num_comms_100KB-1MB'] = myzero
self.reference['*:num_comms_1MB-10MB'] = myzero
self.reference['*:num_comms_10MB'] = myzero
#
self.reference['*:%_of_bytes_sent_0-10B'] = myzero_p
self.reference['*:%_of_bytes_sent_10B-100B'] = myzero_p
self.reference['*:%_of_bytes_sent_100B-1KB'] = myzero_p
self.reference['*:%_of_bytes_sent_1KB-10KB'] = myzero_p
self.reference['*:%_of_bytes_sent_10KB-100KB'] = myzero_p
self.reference['*:%_of_bytes_sent_100KB-1MB'] = myzero_p
self.reference['*:%_of_bytes_sent_1MB-10MB'] = myzero_p
self.reference['*:%_of_bytes_sent_10MB'] = myzero_p
def __init__(self, mpi_task, group):
# {{{ pe
self.descr = 'Tool validation'
self.valid_prog_environs = [
'PrgEnv-gnu', 'PrgEnv-intel', 'PrgEnv-cray', 'PrgEnv-pgi'
]
# self.valid_systems = ['daint:gpu', 'dom:gpu']
self.valid_systems = ['*']
self.maintainers = ['JG']
self.tags = {'sph', 'hpctools', 'cpu'}
# }}}
# {{{ compile
self.testname = 'sqpatch'
self.modules = ['likwid']
self.prebuild_cmds = ['module rm xalt', 'module list -t']
self.tool = 'likwid-perfctr'
self.tool_v = '1d6636c'
tc_ver = '20.08'
self.tool_modules = {
'PrgEnv-gnu':
[f'CrayGNU/.{tc_ver}', f'{self.modules[0]}/{self.tool_v}'],
'PrgEnv-intel':
[f'CrayIntel/.{tc_ver}', f'{self.modules[0]}/{self.tool_v}'],
'PrgEnv-cray':
[f'CrayCCE/.{tc_ver}', f'{self.modules[0]}/{self.tool_v}'],
'PrgEnv-pgi':
[f'CrayPGI/.{tc_ver}', f'{self.modules[0]}/{self.tool_v}'],
}
self.prgenv_flags = {
'PrgEnv-gnu': [
'-I.', '-I./include', '-std=c++14', '-g', '-O3', '-DUSE_MPI',
'-DNDEBUG'
],
'PrgEnv-intel': [
'-I.', '-I./include', '-std=c++14', '-g', '-O3', '-DUSE_MPI',
'-DNDEBUG'
],
'PrgEnv-cray': [
'-I.', '-I./include', '-std=c++17', '-g', '-Ofast',
'-DUSE_MPI', '-DNDEBUG'
],
'PrgEnv-pgi': [
'-I.', '-I./include', '-std=c++14', '-g', '-O3', '-DUSE_MPI',
'-DNDEBUG'
],
}
self.build_system = 'SingleSource'
self.build_system.cxx = 'CC'
self.sourcepath = '%s.cpp' % self.testname
self.executable = self.tool
self.target_executable = './%s.exe' % self.testname
# {{{ openmp:
# 'PrgEnv-intel': ['-qopenmp'],
# 'PrgEnv-gnu': ['-fopenmp'],
# 'PrgEnv-pgi': ['-mp'],
# 'PrgEnv-cray_classic': ['-homp'],
# 'PrgEnv-cray': ['-fopenmp'],
# # '-homp' if lang == 'F90' else '-fopenmp',
# }}}
# }}}
# {{{ run
ompthread = 1
self.num_tasks = mpi_task
self.cubeside = cubeside_dict[mpi_task]
self.steps = steps_dict[mpi_task]
self.group = group
self.name = 'sphexa_likwid_{}_{:03d}mpi_{:03d}omp_{}n_{}steps_{}'. \
format(self.testname, mpi_task, ompthread, self.cubeside,
self.steps, group)
self.num_tasks_per_node = 1
self.num_tasks_per_core = 1
self.use_multithreading = False
# {{{ ht:
# self.num_tasks_per_node = mpitask if mpitask < 36 else 36 # noht
# self.use_multithreading = False # noht
# self.num_tasks_per_core = 1 # noht
# self.num_tasks_per_node = mpitask if mpitask < 72 else 72
# self.use_multithreading = True # ht
# self.num_tasks_per_core = 2 # ht
# }}}
self.num_cpus_per_task = ompthread
self.exclusive = True
self.time_limit = '10m'
self.variables = {
'CRAYPE_LINK_TYPE': 'dynamic',
'OMP_NUM_THREADS': str(self.num_cpus_per_task),
}
# -Cgpu,perf -n1 -t1 likwid-perfctr -C 0 -g MEM (-m) ./streamGCC
# -r: generate a report upon successful execution
# TODO: use rpt-files/RUNTIME.rpt
# self.executable_opts = ['-C 0', '-g MEM', '-g CLOCK', '-g TMA',
self.executable_opts = [
'-C 0',
'-g %s' % group, self.target_executable, f'-n {self.cubeside}',
f'-s {self.steps}', '2>&1'
]
self.version_rpt = 'version.rpt'
self.which_rpt = 'which.rpt'
# TODO: likwid-perfctr -g $g -H
self.prerun_cmds = [
'module rm xalt',
f'mv {self.executable} {self.target_executable}',
f'{self.tool} --version &> {self.version_rpt}',
f'which {self.tool} &> {self.which_rpt}',
]
# }}}
# {{{ sanity
# sanity_patterns is set externally (in sanity_likwid.py)
# }}}
# {{{ performance
# {{{ internal timers
self.prerun_cmds += ['echo starttime=`date +%s`']
self.postrun_cmds += ['echo stoptime=`date +%s`']
# }}}
# {{{ perf_patterns:
self.perf_patterns = sn.evaluate(sphs.basic_perf_patterns(self))
# tool perf_patterns is set externally (in sanity_likwid.py)
# }}}
# {{{ reference:
self.reference = sn.evaluate(sphs.basic_reference_scoped_d(self))
def __init__(self, mpi_task):
# {{{ pe
self.descr = 'Tool validation'
self.valid_prog_environs = [
'PrgEnv-gnu', 'PrgEnv-intel', 'PrgEnv-pgi', 'PrgEnv-cray'
]
# self.valid_systems = ['daint:gpu', 'dom:gpu']
self.valid_systems = ['*']
self.maintainers = ['JG']
self.tags = {'sph', 'hpctools', 'cpu'}
# }}}
# {{{ compile
self.testname = 'sqpatch'
self.tool = 'advixe-cl'
self.modules = ['advisor']
self.prebuild_cmds = ['module rm xalt', 'module list -t']
self.tool_v = '2020_update2'
tc_ver = '20.08'
self.tool_modules = {
'PrgEnv-gnu':
[f'CrayGNU/.{tc_ver}', f'{self.modules[0]}/{self.tool_v}'],
'PrgEnv-intel':
[f'CrayIntel/.{tc_ver}', f'{self.modules[0]}/{self.tool_v}'],
'PrgEnv-cray':
[f'CrayCCE/.{tc_ver}', f'{self.modules[0]}/{self.tool_v}'],
'PrgEnv-pgi':
[f'CrayPGI/.{tc_ver}', f'{self.modules[0]}/{self.tool_v}'],
}
self.prgenv_flags = {
'PrgEnv-gnu': [
'-I.', '-I./include', '-std=c++14', '-g', '-O3', '-DUSE_MPI',
'-DNDEBUG'
],
'PrgEnv-intel': [
'-I.', '-I./include', '-std=c++14', '-g', '-O3', '-DUSE_MPI',
'-DNDEBUG'
],
'PrgEnv-cray': [
'-I.', '-I./include', '-std=c++17', '-g', '-Ofast',
'-DUSE_MPI', '-DNDEBUG'
],
'PrgEnv-pgi': [
'-I.', '-I./include', '-std=c++14', '-g', '-O3', '-DUSE_MPI',
'-DNDEBUG'
],
}
self.build_system = 'SingleSource'
# self.build_system.cxx = 'CC'
self.sourcepath = f'{self.testname}.cpp'
self.executable = self.tool
self.target_executable = f'./{self.testname}.exe'
self.postbuild_cmds = [f'mv {self.tool} {self.target_executable}']
# }}}
# {{{ run
ompthread = 1
self.num_tasks = mpi_task
self.cubeside = cubeside_dict[mpi_task]
self.steps = steps_dict[mpi_task]
self.name = 'sphexa_advisor_{}_{:03d}mpi_{:03d}omp_{}n_{}steps'.format(
self.testname, mpi_task, ompthread, self.cubeside, self.steps)
self.num_tasks_per_node = 24
# {{{ ht:
# self.num_tasks_per_node = mpitask if mpitask < 36 else 36 # noht
# self.use_multithreading = False # noht
# self.num_tasks_per_core = 1 # noht
# self.num_tasks_per_node = mpitask if mpitask < 72 else 72
# self.use_multithreading = True # ht
# self.num_tasks_per_core = 2 # ht
# }}}
self.num_cpus_per_task = ompthread
self.num_tasks_per_core = 2
self.use_multithreading = True
self.exclusive = True
self.time_limit = '10m'
self.variables = {
'CRAYPE_LINK_TYPE': 'dynamic',
'OMP_NUM_THREADS': str(self.num_cpus_per_task),
# to avoid core when reporting (venv/jenkins):
'LANG': 'C',
'LC_ALL': 'C',
}
self.dir_rpt = 'rpt'
self.tool_opts = '--collect=survey --search-dir src:rp=. ' \
'--data-limit=0 --no-auto-finalize --trace-mpi ' \
'--project-dir=%s -- ' % self.dir_rpt
self.executable_opts = [
self.tool_opts, self.target_executable, f'-n {self.cubeside}',
f'-s {self.steps}', '2>&1'
]
self.version_rpt = 'version.rpt'
self.which_rpt = 'which.rpt'
self.summary_rpt = 'summary.rpt'
self.prerun_cmds = [
'module rm xalt',
f'{self.tool} --version >> {self.version_rpt}',
f'which {self.tool} &> {self.which_rpt}',
]
self.postrun_cmds = [
f'cd {self.dir_rpt} ;ln -s nid?????.000 e000 ;cd -',
f'{self.tool} --report=survey --project-dir={self.dir_rpt} '
f'&> {self.summary_rpt}',
]
# }}}
# {{{ sanity
self.sanity_patterns = sn.all([
# check the job output:
sn.assert_found(r'Total time for iteration\(0\)', self.stdout),
# check the tool's version:
sn.assert_true(sphsintel.advisor_version(self)),
# check the summary report:
sn.assert_found(r'advixe: This data has been saved',
self.summary_rpt),
])
# }}}
# {{{ performance
# {{{ internal timers
self.prerun_cmds += ['echo starttime=`date +%s`']
self.postrun_cmds += ['echo stoptime=`date +%s`']
# }}}
# {{{ perf_patterns:
self.perf_patterns = sn.evaluate(sphs.basic_perf_patterns(self))
# tool
self.perf_patterns.update({
'advisor_elapsed':
sphsintel.advisor_elapsed(self),
'advisor_loop1_line':
sphsintel.advisor_loop1_line(self),
})
# }}}
# {{{ reference:
self.reference = sn.evaluate(sphs.basic_reference_scoped_d(self))
# tool:
self.reference['*:advisor_elapsed'] = (0, None, None, 's')
# TODO: fix loop1_fname to avoid error with --report-file:
# "Object of type '_DeferredExpression' is not JSON serializable"
# loop1_fname = sphsintel.advisor_loop1_filename(self)
loop1_fname = ''
self.reference['*:advisor_loop1_line'] = (0, None, None, loop1_fname)
def __init__(self, mpi_task):
# {{{ pe
self.descr = 'Tool validation'
self.valid_prog_environs = ['PrgEnv-gnu', 'PrgEnv-intel', 'PrgEnv-pgi',
'PrgEnv-cray']
# self.valid_systems = ['daint:gpu', 'dom:gpu']
self.valid_systems = ['*']
self.maintainers = ['JG']
self.tags = {'sph', 'hpctools', 'cpu'}
# }}}
# {{{ compile
self.testname = 'sqpatch'
self.tool = 'scorep'
self.prebuild_cmds = ['module rm xalt', 'module list -t']
tool_ver = '6.0'
tc_ver = '20.08'
self.tool_modules = {
'PrgEnv-gnu': [f'Score-P/{tool_ver}-CrayGNU-{tc_ver}'],
'PrgEnv-intel': [f'Score-P/{tool_ver}-CrayIntel-{tc_ver}'],
'PrgEnv-cray': [f'Score-P/{tool_ver}-CrayCCE-{tc_ver}'],
'PrgEnv-pgi': [f'Score-P/{tool_ver}-CrayPGI-{tc_ver}'],
}
self.prgenv_flags = {
'PrgEnv-gnu': ['-I.', '-I./include', '-std=c++14', '-g', '-O3',
'-DUSE_MPI', '-DNDEBUG'],
'PrgEnv-intel': ['-I.', '-I./include', '-std=c++14', '-g', '-O3',
'-DUSE_MPI', '-DNDEBUG'],
'PrgEnv-cray': ['-I.', '-I./include', '-std=c++17', '-g', '-Ofast',
'-DUSE_MPI', '-DNDEBUG'],
'PrgEnv-pgi': ['-I.', '-I./include', '-std=c++14', '-g', '-O3',
'-DUSE_MPI', '-DNDEBUG'],
}
self.build_system = 'SingleSource'
self.build_system.cxx = 'scorep --mpp=mpi --nocompiler CC'
self.sourcepath = f'{self.testname}.cpp'
self.executable = f'./{self.testname}.exe'
# }}}
# {{{ run
ompthread = 1
self.num_tasks = mpi_task
self.cubeside = cubeside_dict[mpi_task]
self.steps = steps_dict[mpi_task]
cycles = cycles_dict[mpi_task]
self.name = \
'sphexa_scorepS+P_{}_{:03d}mpi_{:03d}omp_{}n_{}steps_{}cycles'. \
format(self.testname, mpi_task, ompthread, self.cubeside,
self.steps, cycles)
self.num_tasks_per_node = 24
# {{{ ht:
# self.num_tasks_per_node = mpitask if mpitask < 36 else 36 # noht
# self.use_multithreading = False # noht
# self.num_tasks_per_core = 1 # noht
# self.num_tasks_per_node = mpitask if mpitask < 72 else 72
# self.use_multithreading = True # ht
# self.num_tasks_per_core = 2 # ht
# }}}
self.num_cpus_per_task = ompthread
self.num_tasks_per_core = 2
self.use_multithreading = True
self.exclusive = True
self.time_limit = '10m'
self.variables = {
'CRAYPE_LINK_TYPE': 'dynamic',
'OMP_NUM_THREADS': str(self.num_cpus_per_task),
'SCOREP_ENABLE_PROFILING': 'true',
'SCOREP_ENABLE_TRACING': 'false',
'SCOREP_ENABLE_UNWINDING': 'true',
'SCOREP_SAMPLING_EVENTS': 'perf_cycles@%s' % cycles,
# 'SCOREP_SAMPLING_EVENTS': 'PAPI_TOT_CYC@1000000',
# 'SCOREP_SAMPLING_EVENTS': 'PAPI_TOT_CYC@%s' % cycles,
# export SCOREP_SAMPLING_EVENTS=PAPI_TOT_CYC@1000000
# empty SCOREP_SAMPLING_EVENTS will profile mpi calls only:
# ok: 'SCOREP_SAMPLING_EVENTS': '',
# 'SCOREP_METRIC_PAPI': 'PAPI_TOT_INS,PAPI_TOT_CYC',
# 'SCOREP_METRIC_RUSAGE': 'ru_maxrss',
# 'SCOREP_TIMER': 'clock_gettime',
# 'SCOREP_PROFILING_MAX_CALLPATH_DEPTH': '1',
# 'SCOREP_VERBOSE': 'true',
# 'SCOREP_TOTAL_MEMORY': '1G',
}
self.version_rpt = 'version.rpt'
self.which_rpt = 'which.rpt'
self.info_rpt = 'info.rpt'
self.rpt = 'rpt'
self.rpt_inclusive = '%s.inclusive' % self.rpt
self.rpt_exclusive = '%s.exclusive' % self.rpt
self.executable_opts = [
f'-n {self.cubeside}', f'-s {self.steps}', '2>&1']
self.prerun_cmds = [
'module rm xalt',
f'{self.tool} --version &> {self.version_rpt}',
f'which {self.tool} &> {self.which_rpt}',
'scorep-info config-summary &> %s' % self.info_rpt,
]
cubetree = 'cube_calltree -m time -p -t 1'
# -m metricname -- print out values for the metric <metricname>
# -i -- calculate inclusive values instead of exclusive
# -t treshold -- print out only call path with a value larger
# than <treshold>%
# -p -- diplay percent value
self.postrun_cmds = [
# working around memory crash in scorep-score:
'(scorep-score -r scorep-*/profile.cubex ;rm -f core*) > %s' \
% self.rpt,
'(%s scorep-*/profile.cubex ;rm -f core*) >> %s' \
% (cubetree, self.rpt_exclusive),
'(%s -i scorep-*/profile.cubex ;rm -f core*) >> %s' \
% (cubetree, self.rpt_inclusive),
]
# }}}
# {{{ sanity
self.sanity_patterns = sn.all([
# check the job output:
sn.assert_found(r'Total time for iteration\(0\)', self.stdout),
# check the tool's version and configuration:
sn.assert_true(sphsscorep.scorep_version(self)),
sn.assert_true(sphsscorep.scorep_info_papi_support(self)),
sn.assert_true(sphsscorep.scorep_info_perf_support(self)),
sn.assert_true(sphsscorep.scorep_info_unwinding_support(self)),
# check the summary report:
sn.assert_found(r'Estimated aggregate size of event trace',
self.rpt)
])
# }}}
# {{{ performance
# {{{ internal timers
self.prerun_cmds += ['echo starttime=`date +%s`']
self.postrun_cmds += ['echo stoptime=`date +%s`']
# }}}
# {{{ perf_patterns:
self.perf_patterns = sn.evaluate(sphs.basic_perf_patterns(self))
# tool
self.perf_patterns.update({
'scorep_elapsed': sphsscorep.scorep_elapsed(self),
'%scorep_USR': sphsscorep.scorep_usr_pct(self),
'%scorep_MPI': sphsscorep.scorep_mpi_pct(self),
'scorep_top1': sphsscorep.scorep_top1_pct(self),
'%scorep_Energy_exclusive':
sphsscorep.scorep_exclusivepct_energy(self),
'%scorep_Energy_inclusive':
sphsscorep.scorep_inclusivepct_energy(self),
})
# }}}
# {{{ reference:
self.reference = sn.evaluate(sphs.basic_reference_scoped_d(self))
# tool:
self.reference['*:scorep_elapsed'] = (0, None, None, 's')
self.reference['*:%scorep_USR'] = (0, None, None, '%')
self.reference['*:%scorep_MPI'] = (0, None, None, '%')
top1_name = sphsscorep.scorep_top1_name(self)
# TODO: self.reference['*:scorep_top1'] = (0, None, None, top1_name)
self.reference['*:scorep_top1'] = (0, None, None, '')
self.reference['*:%scorep_Energy_exclusive'] = (0, None, None, '%')
self.reference['*:%scorep_Energy_inclusive'] = (0, None, None, '%')
def __init__(self, mpi_task):
# {{{ pe
self.descr = 'Tool validation'
self.valid_prog_environs = [
'PrgEnv-gnu', 'PrgEnv-intel', 'PrgEnv-pgi', 'PrgEnv-cray'
]
# self.valid_systems = ['daint:gpu', 'dom:gpu']
self.valid_systems = ['*']
self.maintainers = ['JG']
self.tags = {'sph', 'hpctools', 'cpu'}
# }}}
# {{{ compile
self.testname = 'sqpatch'
self.tool = 'scorep'
self.prebuild_cmds = ['module rm xalt', 'module list -t']
tool_ver = '6.0'
tc_ver = '20.08'
self.tool_modules = {
'PrgEnv-gnu': [f'Score-P/{tool_ver}-CrayGNU-{tc_ver}'],
'PrgEnv-intel': [f'Score-P/{tool_ver}-CrayIntel-{tc_ver}'],
'PrgEnv-cray': [f'Score-P/{tool_ver}-CrayCCE-{tc_ver}'],
'PrgEnv-pgi': [f'Score-P/{tool_ver}-CrayPGI-{tc_ver}'],
}
self.prgenv_flags = {
'PrgEnv-gnu': [
'-I.', '-I./include', '-std=c++14', '-g', '-O3', '-DUSE_MPI',
'-DNDEBUG'
],
'PrgEnv-intel': [
'-I.', '-I./include', '-std=c++14', '-g', '-O3', '-DUSE_MPI',
'-DNDEBUG'
],
'PrgEnv-cray': [
'-I.', '-I./include', '-std=c++17', '-g', '-Ofast',
'-DUSE_MPI', '-DNDEBUG'
],
'PrgEnv-pgi': [
'-I.', '-I./include', '-std=c++14', '-g', '-O3', '-DUSE_MPI',
'-DNDEBUG'
],
}
self.build_system = 'SingleSource'
self.build_system.cxx = 'scorep --mpp=mpi --nocompiler CC'
self.sourcepath = f'{self.testname}.cpp'
self.executable = f'./{self.testname}.exe'
# }}}
# {{{ run
ompthread = 1
self.num_tasks = mpi_task
self.cubeside = cubeside_dict[mpi_task]
self.steps = steps_dict[mpi_task]
cycles = cycles_dict[mpi_task]
self.name = \
'sphexa_scorepS+T_{}_{:03d}mpi_{:03d}omp_{}n_{}steps_{}cycles'. \
format(self.testname, mpi_task, ompthread, self.cubeside,
self.steps, cycles)
self.num_tasks_per_node = 24
# {{{ ht:
# self.num_tasks_per_node = mpitask if mpitask < 36 else 36 # noht
# self.use_multithreading = False # noht
# self.num_tasks_per_core = 1 # noht
# self.num_tasks_per_node = mpitask if mpitask < 72 else 72
# self.use_multithreading = True # ht
# self.num_tasks_per_core = 2 # ht
# }}}
self.num_cpus_per_task = ompthread
self.num_tasks_per_core = 2
self.use_multithreading = True
self.exclusive = True
self.time_limit = '10m'
self.variables = {
'CRAYPE_LINK_TYPE': 'dynamic',
'OMP_NUM_THREADS': str(self.num_cpus_per_task),
'SCOREP_ENABLE_PROFILING': 'false',
'SCOREP_ENABLE_TRACING': 'true',
'SCOREP_ENABLE_UNWINDING': 'true',
'SCOREP_SAMPLING_EVENTS': 'perf_cycles@%s' % cycles,
# 'SCOREP_SAMPLING_EVENTS': 'PAPI_TOT_CYC@1000000',
# 'SCOREP_SAMPLING_EVENTS': 'PAPI_TOT_CYC@%s' % cycles,
# export SCOREP_SAMPLING_EVENTS=PAPI_TOT_CYC@1000000
# empty SCOREP_SAMPLING_EVENTS will profile mpi calls only:
# ok: 'SCOREP_SAMPLING_EVENTS': '',
# 'SCOREP_METRIC_PAPI': 'PAPI_TOT_INS,PAPI_TOT_CYC',
# 'SCOREP_METRIC_RUSAGE': 'ru_maxrss',
# 'SCOREP_TIMER': 'clock_gettime',
# 'SCOREP_PROFILING_MAX_CALLPATH_DEPTH': '1',
# 'SCOREP_VERBOSE': 'true',
# ---
# Needed to avoid "No free memory page available"
# (SCOREP_TOTAL_MEMORY=16384000 bytes)
'SCOREP_TOTAL_MEMORY': '1G',
# ---
# adding some metrics to test my sanity_functions:
'SCOREP_METRIC_RUSAGE': 'ru_maxrss',
'SCOREP_METRIC_PAPI': 'PAPI_TOT_INS,PAPI_TOT_CYC',
}
self.version_rpt = 'version.rpt'
self.which_rpt = 'which.rpt'
self.info_rpt = 'scorep-info.rpt'
self.rpt = 'rpt'
self.rpt_inclusive = '%s.inclusive' % self.rpt
self.rpt_exclusive = '%s.exclusive' % self.rpt
self.executable_opts = [
f'-n {self.cubeside}', f'-s {self.steps}', '2>&1'
]
self.prerun_cmds = [
'module rm xalt',
f'{self.tool} --version &> {self.version_rpt}',
f'which {self.tool} &> {self.which_rpt}',
'scorep-info config-summary &> %s' % self.info_rpt,
]
self.postrun_cmds = [
# can't test directly from vampir gui:
'otf2-print scorep-*/traces.otf2 > %s' % self.rpt
]
# }}}
# {{{ sanity
self.sanity_patterns = sn.all([
# check the job output:
sn.assert_found(r'Total time for iteration\(0\)', self.stdout),
# check the tool's version and configuration:
sn.assert_true(sphsscorep.scorep_version(self)),
sn.assert_true(sphsscorep.scorep_info_papi_support(self)),
sn.assert_true(sphsscorep.scorep_info_perf_support(self)),
sn.assert_true(sphsscorep.scorep_info_unwinding_support(self)),
# check the report:
sn.assert_eq(sphsscorep.program_begin_count(self), self.num_tasks),
sn.assert_eq(sphsscorep.program_end_count(self), self.num_tasks),
# TODO: create derived metric (ipc) in cube
])
# }}}
# {{{ performance
# {{{ internal timers
self.prerun_cmds += ['echo starttime=`date +%s`']
self.postrun_cmds += ['echo stoptime=`date +%s`']
# }}}
# {{{ perf_patterns:
self.perf_patterns = sn.evaluate(sphs.basic_perf_patterns(self))
# tool
self.perf_patterns.update({
'max_ipc_rk0':
sphsscorep.ipc_rk0(self),
'max_rumaxrss_rk0':
sphsscorep.ru_maxrss_rk0(self),
})
# }}}
# {{{ reference:
self.reference = sn.evaluate(sphs.basic_reference_scoped_d(self))
# tool:
self.reference['*:max_ipc_rk0'] = (0, None, None, 'ins/cyc')
self.reference['*:max_rumaxrss_rk0'] = (0, None, None, 'kilobytes')
