def patrun_version(self):
'''Checks tool's version:
.. code-block::
> pat_run -V
CrayPat/X: Version 20.08.0 Revision 28ef35c9f
'''
reference_tool_version = {
'daint': '20.08.0',
'dom': '20.08.0',
'eiger': '20.11.0',
'pilatus': '20.11.0',
}
ref_version = reference_tool_version[self.current_system.name]
regex = r'^CrayPat/X:\s+Version (?P<toolversion>\S+) Revision'
res_version = sn.extractsingle(regex, self.version_rpt, 'toolversion')
def __init__(self):
super().__init__()
self.descr = ('ReFrame tutorial demonstrating the class'
'RunOnlyRegressionTest')
self.valid_systems = ['*']
self.valid_prog_environs = ['*']
self.sourcesdir = None
lower = 90
upper = 100
self.executable = 'echo "Random: $((RANDOM%({1}+1-{0})+{0}))"'.format(
lower, upper)
self.sanity_patterns = sn.assert_bounded(sn.extractsingle(
r'Random: (?P<number>\S+)', self.stdout, 'number', float),
lower, upper)
self.maintainers = ['put-your-name-here']
self.tags = {'tutorial'}
def __init__(self, scale, variant):
super().__init__()
self.descr = f'QuantumESPRESSO CPU check (version: {scale}, {variant})'
self.valid_systems = ['daint:mc']
self.modules = ['QuantumESPRESSO']
if scale == 'small':
self.valid_systems += ['dom:mc']
self.num_tasks = 216
energy_reference = -11427.09017162
else:
self.num_tasks = 576
energy_reference = -11427.09017152
self.num_tasks_per_node = 36
energy = sn.extractsingle(r'!\s+total energy\s+=\s+(?P<energy>\S+) Ry',
self.stdout, 'energy', float)
energy_diff = sn.abs(energy-energy_reference)
self.sanity_patterns = sn.all([
self.sanity_patterns,
sn.assert_lt(energy_diff, 1e-8)
])
references = {
'maint': {
'small': {
'dom:mc': {'time': (115.0, None, 0.05, 's')},
'daint:mc': {'time': (115.0, None, 0.10, 's')}
},
'large': {
'daint:mc': {'time': (115.0, None, 0.10, 's')}
}
},
'prod': {
'small': {
'dom:mc': {'time': (115.0, None, 0.05, 's')},
'daint:mc': {'time': (115.0, None, 0.10, 's')}
},
'large': {
'daint:mc': {'time': (115.0, None, 0.10, 's')}
}
}
}
self.reference = references[variant][scale]
self.tags |= {'maintenance' if variant == 'maint' else 'production'}
def setup(self, partition, environ, **job_opts):
self.num_tasks_per_node = self.system_num_tasks.get(
partition.fullname, 1)
num_nodes = self.num_tasks_assigned / self.num_tasks_per_node
self.perf_patterns = {
'gflops':
sn.extractsingle(
r'HPCG result is VALID with a GFLOP\/s rating of=\s*'
r'(?P<perf>\S+)', self.output_file, 'perf', float) / num_nodes
}
self.sanity_patterns = sn.all([
sn.assert_eq(4, sn.count(sn.findall(r'PASSED', self.output_file))),
sn.assert_eq(0, self.num_tasks_assigned % self.num_tasks_per_node)
])
super().setup(partition, environ, **job_opts)
def __init__(self, lang, extension):
super().__init__(lang, extension)
self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn']
self.num_gpus_per_node = 1
self.num_tasks_per_node = 1
self.system_modules = {
'daint': ['craype-accel-nvidia60'],
'dom': ['craype-accel-nvidia60'],
'kesch': ['craype-accel-nvidia35']
}
sysname = self.current_system.name
self.modules += self.system_modules.get(sysname, [])
# as long as cuda/9 will not be the default, we will need:
if sysname in {'daint', 'kesch'}:
self.variables = {'ALLINEA_FORCE_CUDA_VERSION': '8.0'}
self.ddt_options = [
'--offline --output=ddtreport.txt ',
'--break-at _jacobi-cuda-kernel.cu:59 --evaluate *residue_d ',
'--trace-at _jacobi-cuda-kernel.cu:111,residue'
]
self.build_system.cppflags = ['-DUSE_MPI', '-D_CSCS_ITMAX=5']
if self.current_system.name == 'kesch':
arch = 'sm_37'
self.build_system.ldflags = ['-lm', '-lcudart']
else:
arch = 'sm_60'
self.build_system.ldflags = ['-lstdc++']
self.build_system.options = ['NVCCFLAGS="-g -arch=%s"' % arch]
self.sanity_patterns = sn.all([
sn.assert_found('MPI implementation', 'ddtreport.txt'),
sn.assert_found('Evaluate', 'ddtreport.txt'),
sn.assert_found(r'\*residue_d:', 'ddtreport.txt'),
sn.assert_found(r'Debugging\s*:\s*srun\s+%s' % self.executable,
'ddtreport.txt'),
sn.assert_lt(
sn.abs(
sn.extractsingle(
r'^tracepoint\s+.*\s+residue:\s+(?P<result>\S+)',
'ddtreport.txt', 'result', float) - 0.25), 1e-5),
sn.assert_found(r'Every process in your program has terminated\.',
'ddtreport.txt')
])
def __init__(self):
super().__init__()
self.valid_systems = [
'daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu', 'arolla:cn',
'tsa:cn'
]
self.num_gpus_per_node = 1
self.executable = './p2p_osu_bw'
self.executable_opts = [
'-x', '100', '-i', '1000', '-d', 'cuda', 'D', 'D'
]
self.reference = {
'dom:gpu': {
'bw': (8897.86, -0.1, None, 'MB/s')
},
'daint:gpu': {
'bw': (8765.65, -0.1, None, 'MB/s')
},
'kesch:cn': {
'bw': (6288.98, -0.1, None, 'MB/s')
},
'*': {
'bw': (0, None, None, 'MB/s')
}
}
self.perf_patterns = {
'bw':
sn.extractsingle(r'^4194304\s+(?P<bw>\S+)', self.stdout, 'bw',
float)
}
if self.current_system.name in ['daint', 'dom', 'tiger']:
self.num_gpus_per_node = 1
self.modules = ['craype-accel-nvidia60']
self.variables = {'MPICH_RDMA_ENABLED_CUDA': '1'}
elif self.current_system.name == 'kesch':
self.modules = ['cudatoolkit/8.0.61']
self.variables = {'MV2_USE_CUDA': '1'}
elif self.current_system.name in ['arolla', 'tsa']:
self.modules = ['cuda/10.1.243']
self.build_system.ldflags = [
'-L$EBROOTCUDA/lib64', '-lcudart', '-lcuda'
]
self.build_system.cppflags = ['-D_ENABLE_CUDA_']
def __init__(self):
self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu',
'arolla:cn', 'tsa:cn']
self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-cce', 'PrgEnv-pgi']
if self.current_system.name in ['daint', 'dom', 'tiger']:
self.modules = ['craype-accel-nvidia60']
elif self.current_system.name == 'kesch':
self.exclusive_access = True
self.modules = ['cudatoolkit/8.0.61']
# FIXME: workaround -- the variable should not be needed since
# there is no GPUdirect in this check
self.variables = {
'CRAY_ACCEL_TARGET': 'nvidia35',
'MV2_USE_CUDA': '1'
}
elif self.current_system.name in ['arolla', 'tsa']:
self.exclusive_access = True
# This tets requires an MPI compiler, although it uses a single task
self.num_tasks = 1
self.num_gpus_per_node = 1
self.num_tasks_per_node = 1
self.sourcepath = 'automatic_arrays_OpenACC.F90'
self.build_system = 'SingleSource'
self.build_system.fflags = ['-O2']
self.sanity_patterns = sn.assert_found(r'Result: ', self.stdout)
self.perf_patterns = {
'time': sn.extractsingle(r'Timing:\s+(?P<time>\S+)',
self.stdout, 'time', float)
}
self.arrays_reference = {
'PrgEnv-cray': {
'daint:gpu': {'time': (5.7E-05, None, 0.15, 's')},
'dom:gpu': {'time': (5.7E-05, None, 0.15, 's')},
'kesch:cn': {'time': (2.9E-04, None, 0.15, 's')},
},
'PrgEnv-pgi': {
'daint:gpu': {'time': (7.5E-05, None, 0.15, 's')},
'dom:gpu': {'time': (7.5e-05, None, 0.15, 's')},
'kesch:cn': {'time': (1.4E-04, None, 0.15, 's')},
}
}
self.maintainers = ['AJ', 'MKr']
self.tags = {'production', 'mch', 'craype'}
def scorep_top1_name(obj):
'''Reports demangled name of top1 function name, for instance:
.. code-block::
> c++filt ...
_ZN6sphexa3sph31computeMomentumAndEnergyIADImplIdNS_13 ...
ParticlesDataIdEEEEvRKNS_4TaskERT0_
void sphexa::sph::computeMomentumAndEnergyIADImpl ...
<double, sphexa::ParticlesData<double> > ...
(sphexa::Task const&, sphexa::ParticlesData<double>&)
'''
regex = r'^\s{9}(USR|COM).*\s+(?P<pct>\S+)\s+\S+\s+(?P<fn>_\w+)'
rpt = os.path.join(obj.stagedir, obj.rpt_score)
result = cxxfilt.demangle(sn.evaluate(sn.extractsingle(regex, rpt, 'fn')))
# print("fn=", result)
return ('% (' + result.split('<')[0] + ')')
def setup(self, partition, environ, **job_opts):
super().setup(partition, environ, **job_opts)
envname = self.current_environ.name
# if generic, falls back to -g:
prgenv_flags = self.prgenv_flags.get(envname, ['-g'])
self.build_system.cflags = prgenv_flags
self.build_system.cxxflags = prgenv_flags
self.build_system.fflags = prgenv_flags
self.build_system.ldflags = ['-lm']
found_version = sn.extractsingle(r'OpenMP-\s*(\d+)', self.stdout, 1,
int)
ompversion_key = '%s:%s:version' % (envname, self.lang)
self.sanity_patterns = sn.all([
sn.assert_eq(found_version, self.openmp_versions[ompversion_key]),
sn.assert_found('SUCCESS', self.stdout),
])
if self.current_system.name in {'dom', 'daint'}:
self.reference['*:elapsed_time'] = self.reference_lang
def tool_version(obj):
'''Checks tool's version:
.. code-block::
> mustrun --help 2>&1
"mustrun" from MUST v1.6
returns: True or False
'''
reference_tool_version = {
'daint': 'v1.6',
'dom': 'v1.6',
}
regex = (r'"mustrun" from MUST (?P<tool_version>\S+)')
version = sn.extractsingle(regex, obj.version_rpt, 'tool_version')
TorF = sn.assert_eq(version,
reference_tool_version[obj.current_system.name])
return TorF
def __init__(self):
self.valid_systems = ['daint:gpu', 'dom:gpu']
self.valid_prog_environs = ['PrgEnv-pgi']
self.sourcepath = 'vecAdd_cuda.cuf'
# FIXME: PGI 20.x does not support CUDA 11, see case #275674
self.modules = [
'craype-accel-nvidia60',
'cudatoolkit/10.2.89_3.29-7.0.2.1_3.5__g67354b4'
]
self.build_system = 'SingleSource'
self.build_system.fflags = ['-ta=tesla:cc60']
self.num_gpus_per_node = 1
result = sn.extractsingle(r'final result:\s+(?P<result>\d+\.?\d*)',
self.stdout, 'result', float)
self.sanity_patterns = sn.assert_reference(result, 1., -1e-5, 1e-5)
self.maintainers = ['TM', 'AJ']
self.tags = {'production', 'craype'}
def __init__(self):
super().__init__('mnist')
train_epochs = 10
self.executable = 'python3 ./official/mnist/mnist.py'
self.executable_opts = [
'--model_dir', '.', '--export_dir', '.', ' --data_dir', '.',
'--train_epochs',
str(train_epochs)
]
self.sanity_patterns = sn.all([
sn.assert_found(r'Finished evaluation at', self.stderr),
sn.assert_gt(
sn.extractsingle(
r"Evaluation results:\s+\{.*'accuracy':\s+(?P<accuracy>\S+)"
r"(?:,|\})", self.stdout, 'accuracy', float, -1), 0.99)
])
def assert_energy_diff(self):
energy = sn.extractsingle(
r'\s+ENERGY\| Total FORCE_EVAL \( QS \) '
r'energy [\[\(]a\.u\.[\]\)]:\s+(?P<energy>\S+)',
self.stdout,
'energy',
float,
item=-1)
energy_reference = -4404.2323
energy_diff = sn.abs(energy - energy_reference)
return sn.all([
sn.assert_found(r'PROGRAM STOPPED IN', self.stdout),
sn.assert_eq(
sn.count(
sn.extractall(r'(?i)(?P<step_count>STEP NUMBER)',
self.stdout, 'step_count')), 10),
sn.assert_lt(energy_diff, 1e-4)
])
def __init__(self, fs_mount_point, ior_type, **kwargs):
super().__init__('ior_write_check', fs_mount_point, **kwargs)
self.test_file = os.path.join(self.fs_mount_point, '.ior', 'write',
'ior_write.dat')
if ior_type == 'MPIIO':
self.executable_opts = ('-w -a MPIIO -B -E -F -t 64m -b 46g '
'-D 300 -o %s' % self.test_file).split()
elif ior_type == 'POSIX':
self.executable_opts = ('-w -a POSIX -B -E -F -t 1m -b 100m -D 60 '
' -o %s' % self.test_file).split()
self.sanity_patterns = sn.assert_found(r'^Max Write: ', self.stdout)
self.perf_patterns = {
'write_bw':
sn.extractsingle(r'^Max Write:\s+(?P<write_bw>\S+) MiB/sec',
self.stdout, 'write_bw', float)
}
self.tags |= {'write'}
def nsys_version(obj):
'''Checks tool's version:
.. code-block::
> nsys --version
NVIDIA Nsight Systems version 2020.1.1.65-085319d
returns: True or False
'''
reference_tool_version = {
'daint': '2020.3.1.72',
'dom': '2020.3.1.72',
}
regex = r'^NVIDIA Nsight Systems version (?P<toolversion>\S+)-'
version = sn.extractsingle(regex, obj.version_rpt, 'toolversion')
TorF = sn.assert_eq(version,
reference_tool_version[obj.current_system.name])
return TorF
def __init__(self, exec_mode):
self.sourcepath = 'fftw_benchmark.c'
self.build_system = 'SingleSource'
self.valid_systems = ['daint:gpu', 'dom:gpu']
# Cray FFTW library is not officially supported for the PGI
self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu']
self.modules = ['cray-fftw']
self.num_tasks_per_node = 12
self.num_gpus_per_node = 0
self.sanity_patterns = sn.assert_eq(
sn.count(sn.findall(r'execution time', self.stdout)), 1)
self.build_system.cflags = ['-O2']
self.perf_patterns = {
'fftw_exec_time':
sn.extractsingle(r'execution time:\s+(?P<exec_time>\S+)',
self.stdout, 'exec_time', float),
}
if exec_mode == 'nompi':
self.num_tasks = 12
self.executable_opts = ['72 12 1000 0']
self.reference = {
'dom:gpu': {
'fftw_exec_time': (0.59, None, 0.05, 's'),
},
'daint:gpu': {
'fftw_exec_time': (0.59, None, 0.05, 's'),
},
}
else:
self.num_tasks = 72
self.executable_opts = ['144 72 200 1']
self.reference = {
'dom:gpu': {
'fftw_exec_time': (0.47, None, 0.50, 's'),
},
'daint:gpu': {
'fftw_exec_time': (0.47, None, 0.50, 's'),
},
}
self.maintainers = ['AJ']
self.tags = {'benchmark', 'scs', 'craype'}
def __init__(self):
self.modules = ['likwid']
self.valid_prog_environs = ['PrgEnv-gnu']
self.sourcesdir = None
self.executable = 'likwid-bench'
self.num_tasks = 0
self.num_tasks_per_core = 2
self.system_num_cpus = {
'daint:mc': 72,
'daint:gpu': 24,
'dom:mc': 72,
'dom:gpu': 24,
}
self.system_numa_domains = {
'daint:mc': ['S0', 'S1'],
'daint:gpu': ['S0'],
'dom:mc': ['S0', 'S1'],
'dom:gpu': ['S0'],
}
# Test each level at half capacity times nthreads per domain
self.system_cache_sizes = {
'daint:mc': {'L1': '288kB', 'L2': '2304kB', 'L3': '23MB',
'memory': '1800MB'},
'daint:gpu': {'L1': '192kB', 'L2': '1536kB', 'L3': '15MB',
'memory': '1200MB'},
'dom:mc': {'L1': '288kB', 'L2': '2304kB', 'L3': '23MB',
'memory': '1800MB'},
'dom:gpu': {'L1': '192kB', 'L2': '1536kB', 'L3': '15MB',
'memory': '1200MB'},
}
self.maintainers = ['SK']
self.tags = {'benchmark', 'diagnostic'}
bw_pattern = sn.extractsingle(r'MByte/s:\s*(?P<bw>\S+)',
self.stdout, 'bw', float)
self.sanity_patterns = sn.assert_ge(bw_pattern, 0.0)
self.perf_patterns = {
'bandwidth': bw_pattern
}
def __init__(self, variant):
super().__init__()
self.strict_check = False
self.valid_systems = ['daint:gpu', 'dom:gpu', 'tiger:gpu']
self.descr = 'Alltoall OSU microbenchmark'
self.build_system = 'Make'
self.build_system.makefile = 'Makefile_alltoall'
self.executable = './osu_alltoall'
# The -m option sets the maximum message size
# The -x option sets the number of warm-up iterations
# The -i option sets the number of iterations
self.executable_opts = ['-m', '8', '-x', '1000', '-i', '20000']
self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu',
'PrgEnv-intel']
self.maintainers = ['RS', 'AJ']
self.sanity_patterns = sn.assert_found(r'^8', self.stdout)
self.perf_patterns = {
'latency': sn.extractsingle(r'^8\s+(?P<latency>\S+)',
self.stdout, 'latency', float)
}
self.tags = {variant, 'benchmark', 'craype'}
self.reference = {
'dom:gpu': {
'latency': (8.23, None, 0.1, 'us')
},
'daint:gpu': {
'latency': (20.73, None, 2.0, 'us')
},
'*': {
'latency': (0, None, None, 'us')
},
}
self.num_tasks_per_node = 1
self.num_gpus_per_node = 1
if self.current_system.name == 'daint':
self.num_tasks = 16
else:
self.num_tasks = 6
self.extra_resources = {
'switches': {
'num_switches': 1
}
}
def __init__(self, variant):
if variant == 'nompi':
self.num_tasks = 1
else:
self.num_tasks = 2
self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu',
'arolla:cn', 'tsa:cn']
self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-pgi']
if self.num_tasks == 1:
self.sourcepath = 'vecAdd_openacc.f90'
if self.current_system.name == 'kesch':
self.valid_prog_environs = ['PrgEnv-cray-nompi',
'PrgEnv-pgi-nompi']
elif self.current_system.name == 'tsa':
self.valid_prog_environs = ['PrgEnv-pgi-nompi']
else:
self.sourcepath = 'vecAdd_openacc_mpi.f90'
if self.current_system.name in ['daint', 'dom', 'tiger']:
self.modules = ['craype-accel-nvidia60']
elif self.current_system.name == 'kesch':
self.exclusive_access = True
self.variables = {
'CRAY_ACCEL_TARGET': 'nvidia35',
'MV2_USE_CUDA': '1'
}
elif self.current_system.name in ['arolla', 'tsa']:
self.exclusive_access = True
self.variables = {
'CRAY_ACCEL_TARGET': 'nvidia70',
'MV2_USE_CUDA': '1'
}
self.executable = self.name
self.build_system = 'SingleSource'
self.num_gpus_per_node = 1
self.num_tasks_per_node = 1
result = sn.extractsingle(r'final result:\s+(?P<result>\d+\.?\d*)',
self.stdout, 'result', float)
self.sanity_patterns = sn.assert_reference(result, 1., -1e-5, 1e-5)
self.maintainers = ['TM', 'AJ']
self.tags = {'production', 'craype'}
def __init__(self, num_tasks):
super().__init__()
self.tags = {'monch_acceptance'}
self.descr = 'HPCG monch acceptance check'
self.maintainers = ['VK']
self.valid_systems = ['monch:compute']
self.valid_prog_environs = ['PrgEnv-gnu']
self.sourcesdir = os.path.join(self.current_system.resourcesdir,
'HPCG-CPU')
self.executable = './bin/xhpcg'
self.num_tasks = num_tasks
self.num_tasks_per_node = 1
self.num_cpus_per_task = 20
self.variables = {
'MV2_ENABLE_AFFINITY': '0',
'OMP_NUM_THREADS': str(self.num_cpus_per_task),
}
self.prebuild_cmd = ['. configure MPI_GCC_OMP']
output_file = sn.getitem(sn.glob('HPCG-Benchmark_*.txt'), 0)
self.sanity_patterns = sn.assert_eq(
4, sn.count(sn.findall(r'PASSED', output_file)))
reference_by_nodes = {
2: {
'perf': (2.20716, -0.10, None),
},
4: {
'perf': (4.28179, -0.10, None),
},
6: {
'perf': (6.18806, -0.10, None),
},
8: {
'perf': (8.16107, -0.10, None),
},
}
self.reference = {'monch:compute': reference_by_nodes[num_tasks]}
self.perf_patterns = {
'perf':
sn.extractsingle(
r'HPCG result is VALID with a GFLOP\/s rating of=\s*'
r'(?P<perf>\S+)', output_file, 'perf', float)
}
def __init__(self):
super().__init__()
self.valid_prog_environs = ['PrgEnv-gnu']
self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn']
self.num_gpus_per_node = 1
self.num_tasks_per_node = 1
self.sourcesdir = 'src/Cuda'
self.executable = 'cuda-gdb cuda_gdb_check'
if self.current_system.name == 'kesch':
self.exclusive_access = True
self.modules = ['cudatoolkit/8.0.61']
else:
self.modules = ['craype-accel-nvidia60']
self.build_system = 'Make'
self.build_system.makefile = 'Makefile_cuda_gdb'
self.build_system.cflags = [
'-g', '-D_CSCS_ITMAX=1', '-DUSE_MPI', '-fopenmp'
]
nvidia_sm = '37' if self.current_system.name == 'kesch' else '60'
self.build_system.cxxflags = ['-g', '-G', '-arch=sm_%s' % nvidia_sm]
self.build_system.ldflags = ['-g', '-fopenmp', '-lstdc++']
# FIXME: workaround until the kesch programming environment is fixed
if self.current_system.name == 'kesch':
self.build_system.ldflags = [
'-g', '-fopenmp', '-lcublas', '-lcudart', '-lm'
]
self.sanity_patterns = sn.all([
sn.assert_found(r'^\(cuda-gdb\) Breakpoint 1 at .*: file ',
self.stdout),
sn.assert_found(r'_jacobi-cuda-kernel.cu, line 59\.', self.stdout),
sn.assert_found(r'^\(cuda-gdb\) Starting program:', self.stdout),
sn.assert_found(r'^\(cuda-gdb\) quit', self.stdout),
sn.assert_lt(
sn.abs(
sn.extractsingle(
r'^\(cuda-gdb\)\s+\$1\s+=\s+(?P<result>\S+)',
self.stdout, 'result', float)), 1e-5)
])
self.maintainers = ['MK', 'JG']
self.tags = {'production'}
def __init__(self, variant):
super().__init__()
self.time_limit = (0, 10, 0)
self.valid_systems = ['ibex:debug']
self.valid_prog_environs = ['gnu']
self.sourcesdir = None
self.modules = [
'/ibex/scratch/shaima0d/software/modulefiles/osu-microbenchmarks/5.6.2'
]
self.executable = 'osu_latency'
self.executable_opts = ('-m 256:256').split()
if variant == "multinode":
self.num_tasks = 2
self.num_tasks_per_node = 1
else:
self.num_tasks = 2
self.num_tasks_per_node = 2
self.sanity_patterns = sn.assert_found(
r'# OSU MPI Latency Test v5.6.2', self.stdout)
self.perf_patterns = {
variant:
sn.extractsingle(r'^256\s+(?P<latency>\S+)', self.stdout,
'latency', float)
}
self.reference = {
'ibex': {
'multinode': (2.0, None, 0.05),
'onenode': (0.5, None, 0.05),
},
# 'ibex:batch' : {
# 'multinode': (2.0, None, 0.05),
# 'onenode': (0.5, None, 0.05),
# },
}
self.descr = "MPI latency test on two nodes using pre-installed OSU benchmakrs"
self.maintainer = {'*****@*****.**'}
self.tags = {'mpi', variant}
def __init__(self):
self.valid_prog_environs = ['builtin']
self.executable = 'pw.x'
self.executable_opts = ['-in', 'ausurf.in']
self.sanity_patterns = sn.all([
sn.assert_found(r'convergence has been achieved', self.stdout),
])
self.perf_patterns = {
'time':
sn.extractsingle(r'electrons.+\s(?P<wtime>\S+)s WALL', self.stdout,
'wtime', float)
}
self.maintainers = ['LM']
self.tags = {'scs'}
self.strict_check = False
self.extra_resources = {'switches': {'num_switches': 1}}
def add_sanity(self):
assert_references = []
for (perf_v, props) in sanity_config.assert_reference.items():
assert_references.append(
sn.assert_reference(
sn.extractsingle(props['pattern'],
self.output_file,
perf_v, float,
item=-1),
props['ref_value'],
props['lower_thres'],
props['upper_thres']
)
)
self.sanity_patterns = sn.all([
*[sn.assert_found(af, self.output_file) for af in sanity_config.assert_found],
*assert_references
])
def gp_perf_patterns(obj):
'''Reports top % from the tool
.. code-block::
Type: cpu
Showing nodes accounting for 3690ms, 92.48% of 3990ms total
Dropped 79 nodes (cum <= 19.95ms)
flat flat% sum% cum cum%
530ms 13.28% 13.28% 530ms 13.28% sphexa::.../lookupTables.hpp:123
^^^^^ ^^^^^^^^^^^^^^^^ ^^^
'''
regex = (r'^\s+flat\s+flat%\s+sum%\s+cum\s+cum%\n\s+\d+ms\s+(?P<pctg>\S+)'
r'%.*/(?P<filename>\S+):(?P<linen>\S+)')
result = sn.extractsingle(regex, obj.rpt_file_txt, 'pctg', float)
res_d = {
'gperftools_top_function1': result,
}
return res_d
def tool_version(obj):
'''Checks tool's version:
.. code-block::
> pat_report -V
CrayPat/X: Version 20.08.0 Revision 28ef35c9f 07/08/20 20:40:20
^^^^^^^
returns: True or False
'''
reference_tool_version = {
'daint': '20.08.0',
'dom': '20.08.0',
}
regex = r'CrayPat\/X:\s+Version\s+(?P<toolversion>\S+)\s+'
res_version = sn.extractsingle(regex, obj.version_rpt, 'toolversion')
TorF = sn.assert_eq(res_version,
reference_tool_version[obj.current_system.name])
return TorF
def __init__(self, **kwargs):
super().__init__('simpleFoam',
'OpenFOAM check of simpleFoam: motorbike tutorial',
**kwargs)
self.executable_opts = ['-parallel']
self.num_tasks = 6
self.num_tasks_per_node = 6
self.sanity_patterns = sn.all([
sn.assert_found('Finalising parallel run', self.stdout),
sn.assert_found(r'^\s*[Ee]nd', self.stdout),
sn.assert_lt(
sn.abs(
sn.extractsingle(
r'time step continuity errors : \S+\s\S+ = \S+\s'
r'global = (?P<res>-?\S+),', self.stdout, 'res',
float)), 1.e-04)
])
def eval_sanity(self):
all_tested_nodes = sn.evaluate(sn.extractall(
r'(?P<hostname>\S+):\s+Time for \d+ DGEMM operations',
self.stdout, 'hostname'))
num_tested_nodes = len(all_tested_nodes)
failure_msg = ('Requested %s node(s), but found %s node(s)' %
(self.job.num_tasks, num_tested_nodes))
sn.assert_eq(num_tested_nodes, self.job.num_tasks, msg=failure_msg)
for hostname in all_tested_nodes:
if self.sys_reference[self.current_partition.fullname]:
partition_name = self.current_partition.fullname
ref_name = '%s:%s' % (partition_name, hostname)
self.reference[ref_name] = self.sys_reference[partition_name]
self.perf_patterns[hostname] = sn.extractsingle(
r'%s:\s+Avg\. performance\s+:\s+(?P<gflops>\S+)'
r'\sGflop/s' % hostname, self.stdout, 'gflops', float)
return True
def vtune_version(obj):
'''Checks tool's version:
.. code-block::
> vtune --version
Intel(R) VTune(TM) Profiler 2020 (build 605129) Command Line Tool
returns: True or False
'''
reference_tool_version = {
'daint': '605129', # 2020
'dom': '610396', # 2020_update2
}
regex = (r'^Intel\(R\) VTune\(TM\) Profiler \d+\s+.*\(build'
r'\s(?P<toolsversion>\d+)')
version = sn.extractsingle(regex, obj.version_rpt, 'toolsversion')
TorF = sn.assert_eq(version,
reference_tool_version[obj.current_system.name])
return TorF
def __init__(self):
self.valid_prog_environs = ['PrgEnv-gnu']
self.valid_systems = ['daint:gpu', 'dom:gpu', 'arolla:cn', 'tsa:cn']
self.num_gpus_per_node = 1
self.num_tasks_per_node = 1
self.sourcesdir = 'src/Cuda'
self.executable = 'cuda-gdb'
self.executable_opts = ['-x .in.cudagdb ./cuda_gdb_check']
# unload xalt to avoid runtime error:
self.prerun_cmds = ['unset LD_PRELOAD']
if self.current_system.name in ['arolla', 'tsa']:
self.exclusive_access = True
self.modules = ['cuda/10.1.243']
nvidia_sm = '70'
else:
self.modules = ['craype-accel-nvidia60', 'cdt-cuda']
nvidia_sm = '60'
self.build_system = 'Make'
self.build_system.makefile = 'Makefile_cuda_gdb'
self.build_system.cflags = [
'-g', '-D_CSCS_ITMAX=1', '-DUSE_MPI', '-fopenmp'
]
self.build_system.cxxflags = ['-g', '-G', '-arch=sm_%s' % nvidia_sm]
self.build_system.ldflags = ['-g', '-fopenmp', '-lstdc++']
if self.current_system.name in ['arolla', 'tsa']:
self.build_system.ldflags += [
'-L$EBROOTCUDA/lib64', '-lcudart', '-lm'
]
self.sanity_patterns = sn.all([
sn.assert_found(r'^Breakpoint 1 at .*: file ', self.stdout),
sn.assert_found(r'_jacobi-cuda-kernel.cu, line 59\.', self.stdout),
sn.assert_found(r'^\(cuda-gdb\) quit', self.stdout),
sn.assert_lt(
sn.abs(
sn.extractsingle(r'\$1\s+=\s+(?P<result>\S+)', self.stdout,
'result', float)), 1e-5)
])
self.maintainers = ['MKr', 'JG']
self.tags = {'production', 'craype'}
