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'}