def __init__(self): self.descr = 'OSU benchmarks build test' self.valid_systems = [ 'build-node:parallel', 'beluga:cpu_parallel', 'cedar:cpu_parallel', 'graham:cpu_parallel' ] self.valid_prog_environs = ['*'] self.sourcesdir = None self.prebuild_cmd = [ 'cp /cvmfs/soft.computecanada.ca/easybuild/sources/o/OSU-Micro-Benchmarks/osu-micro-benchmarks-5.6.1.tar.gz .', 'tar xzf osu-micro-benchmarks-5.6.1.tar.gz', 'cd osu-micro-benchmarks-5.6.1' ] self.build_system = 'Autotools' self.build_system.max_concurrency = 8 self.sanity_patterns = sn.assert_not_found('error', self.stderr)
def __init__(self): super().__init__() self.descr = ('verifies merging of 3 standard netCDF files') self.executable = 'cdo' self.executable_opts = [ '-O', 'merge', 'sresa1b_ncar_ccsm3-example_pr.nc', 'sresa1b_ncar_ccsm3-example_tas.nc', 'sresa1b_ncar_ccsm3-example_area.nc', 'sresa1b_ncar_ccsm3-example_area_pr_tas_area.nc' ] self.sanity_patterns = sn.all([ sn.assert_not_found(r'(?i)unsupported|error', self.stderr), sn.assert_found( r'merge: Processed( 98304 values from)? ' r'3 variables', self.stderr) ])
def __init__(self): super().__init__() self.descr = ('verifies merging of 3 netCDF-4 files') self.executable = 'cdo' self.executable_opts = [ '-O', 'merge', 'test_echam_spectral-deflated_wind10.nc4', 'test_echam_spectral-deflated_wl.nc4', 'test_echam_spectral-deflated_ws.nc4', 'test_echam_spectral-deflated_wind10_wl_ws.nc4' ] self.sanity_patterns = sn.all([ sn.assert_not_found(r'(?i)unsupported|error', self.stderr), sn.assert_found( r'merge: Processed( 442368 values from)? ' r'3 variables', self.stderr) ])
def __init__(self): super().__init__() self.descr = ('verifies merging and compressing of 3 compressed ' 'netCDF-4 files') self.executable = 'cdo' self.executable_opts = [ '-O', '-z', 'zip', 'merge', 'test_echam_spectral-deflated_wind10.nc4c', 'test_echam_spectral-deflated_wl.nc4c', 'test_echam_spectral-deflated_ws.nc4c', 'test_echam_spectral-deflated_wind10_wl_ws.nc4c' ] self.sanity_patterns = sn.all([ sn.assert_not_found(r'(?i)unsupported|error', self.stderr), sn.assert_found( r'cdo merge: Processed 442368 values from 3 ' r'variables over (8|24) timesteps', self.stderr) ])
def __init__(self): self.descr = 'check for avx2 instructions' self.valid_systems = ['dom:login', 'daint:login'] self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu', 'PrgEnv-intel', 'PrgEnv-pgi'] self.modules = ['craype-haswell'] self.sourcesdir = 'src/haswell_fma' self.build_system = 'Make' self.build_system.cflags = ['-O3', '-S'] self.build_system.cxxflags = ['-O3', '-S'] self.build_system.fflags = ['-O3', '-S'] self.sanity_patterns = sn.all([ sn.assert_found(r'vfmadd', 'vectorize_fma_c.s'), sn.assert_found(r'vfmadd', 'vectorize_fma_cplusplus.s'), sn.assert_found(r'vfmadd', 'vectorize_fma_ftn.s'), sn.assert_not_found('warning|WARNING', self.stderr) ]) self.maintainers = ['AJ', 'CB'] self.tags = {'production', 'craype'}
def __init__(self, **kwargs): super().__init__('haswell_fma_check', os.path.dirname(__file__), **kwargs) self.descr = 'check for avx2 instructions' self.valid_systems = ['dom:login', 'daint:login', 'kesch:login'] if self.current_system.name == 'kesch': self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu'] else: self.valid_prog_environs = [ 'PrgEnv-cray', 'PrgEnv-gnu', 'PrgEnv-intel', 'PrgEnv-pgi' ] self.sourcesdir = 'src/haswell_fma' self.sanity_patterns = sn.all([ sn.assert_found(r'vfmadd', 'vectorize_fma_c.s'), sn.assert_found(r'vfmadd', 'vectorize_fma_cplusplus.s'), sn.assert_found(r'vfmadd', 'vectorize_fma_ftn.s'), sn.assert_not_found('warning|WARNING', self.stderr) ]) self.maintainers = ['AJ', 'VK'] self.tags = {'production'}
def __init__(self, variant): super().__init__() self.valid_systems = ['daint:gpu'] self.sourcesdir = os.path.join('../', variant) if variant == 'cuda': self.valid_prog_environs = ['PrgEnv-gnu'] elif variant == 'openacc': self.valid_prog_environs = ['PrgEnv-pgi'] if self.current_system.name == 'daint': self.modules = ['craype-accel-nvidia60'] self.executable = './main' self.executable_opts = ['256', '256', '100', '0.01'] self.keep_files = ['output.bin', 'output.bov'] self.time_limit = (0, 5, 0) self.sanity_patterns = sn.allx([ sn.assert_found(r'Goodbye\!', self.stdout), sn.assert_not_found(r'ERROR', self.stdout) ]) self.perf_patterns = { 'exec_time': sn.extractsingle(r'simulation took (\S+) seconds', self.stdout, 1, float), 'perf': sn.extractsingle(r'at rate of (\S+) iters/second', self.stdout, 1, float) } self.reference = { 'daint:gpu': { 'exec_time': (0, None, None, 's'), 'perf': (0, None, None, 'iters/s') }, '*': { 'exec_time': (0, None, None, 's'), 'perf': (0, None, None, 'iters/s') } } self.maintainers = ['karakasis<at>cscs.ch']
def __init__(self): # {{{ pe self.descr = 'Tool validation' self.valid_prog_environs = ['PrgEnv-gnu', 'cpeGNU'] self.valid_systems = [ 'dom:mc', 'dom:gpu', 'daint:mc', 'daint:gpu', 'eiger:mc', 'pilatus:mc' ] self.tool = 'stat-cl' self.modules = ['cray-stat', 'cray-cti'] self.maintainers = ['JG'] self.tags = {'sph', 'hpctools', 'cpu', 'craype', 'debugging'} # }}} # {{{ compile self.testname = 'sedov' self.executable = 'mpi+omp' # re_ver_1 = 'STAT_VERSION1=$' # re_ver_2 = 'STAT_VERSION2=$' version_rpt = 'version.rpt' which_rpt = 'which.rpt' cs = self.current_system.name if cs not in {'pilatus', 'eiger'}: self.prebuild_cmds += [ # --- chech tool version f'echo STAT_VERSION1=$STAT_VERSION > {version_rpt}', f'echo STAT_VERSION2=`STATbin --version` >> {version_rpt}', ] else: self.prebuild_cmds += [ # --- chech tool version f'echo STAT_VERSION1=$STAT_LEVEL > {version_rpt}', f'echo STAT_VERSION2=`STATbin --version` >> {version_rpt}', ] self.prebuild_cmds += [ f'STATbin -V >> {version_rpt}', f'which {self.tool} > {which_rpt}', ] # {{{ run self.time_limit = '10m' # }}} # {{{ sanity # TODO: regex = ( # r'function="(?P<fun>.*)", source="(?P<filename>.*)",' # r' line=":(?P<ll>\d+)"' # ) # + cuda # + largescale self.sanity_patterns = sn.all([ # check the job output: sn.assert_found(r'Starting main loop', self.stdout), # check the tool output: sn.assert_not_found('not found', which_rpt), sn.assert_not_found('ERROR', self.stdout), # <LMON FE API> (ERROR): read_lmonp_msgheader failed while # attempting to receive continue launch message from back end sn.assert_found(r'STAT started', self.stdout), sn.assert_found(r'Attaching to job launcher', self.stdout), sn.assert_found(r'launching tool daemons', self.stdout), sn.assert_found(r'Results written to', self.stdout), ])
def __init__(self): self.valid_prog_environs = ['*'] self.valid_systems = ['*'] self.prerun_cmds = ['echo hello'] self.executable = 'true' self.sanity_patterns = sn.assert_not_found(r'hello', self.stdout)
def test_assert_not_found_encoding(utf16_file): assert sn.assert_not_found(r'Iliad', utf16_file, encoding='utf-16')
def test_assert_not_found(tempfile): assert sn.assert_not_found(r'foo: \d+', tempfile) assert sn.assert_not_found(r'foo: \d+', sn.defer(tempfile)) with pytest.raises(SanityError): sn.evaluate(sn.assert_not_found(r'Step: \d+', tempfile))
def set_sanity_patterns(self): self.sanity_patterns = sn.assert_not_found(r'warning', self.stdout)
def sanity_check_build(self): return sanity.assert_not_found("error", self.stderr)
def validate(self): return sn.assert_not_found(r'(?i)error', self.stdout)
def validate_compilation(self): return sn.assert_not_found(r'warning', self.stdout)
def test_assert_not_found_encoding(self): self.assertTrue( sn.assert_not_found('Iliad', self.utf16_file, encoding='utf-16'))
def validate_build(self): return sn.assert_not_found('error', self.stderr)
def assert_config(self): patterns = [ sn.assert_found(r'Added \d+ new compilers', self.stdout), sn.assert_not_found(r'ERROR', self.stdout), ] # Compiler assertions with open(self.compilers_file_path) as f: spack_compilers = yaml.safe_load(f) all_compilers = sorted(self.all_compilers) for compiler in all_compilers: patterns += [ sn.assert_found(f'spec: {compiler}', self.compilers_file_path) ] if 'compilers' in spack_compilers: compilers = [] for compiler in spack_compilers['compilers']: if 'compiler' in compiler: spec = compiler['compiler'] if 'spec' in spec: compilers.append(spec['spec']) else: raise SanityError( f'spec entry missing in {spec} inside the compiler.yaml file' ) else: raise SanityError( f'compiler entry missing in {compiler} inside the compiler.yaml file' ) for i, a in enumerate(sorted(compilers)): # we should have a one to one mapping between the identified # compilers and the entries inside the newly generated compilers.yaml file patterns += [sn.assert_eq(a, all_compilers[i])] else: raise SanityError( 'compilers entry not found in compilers.yaml file') # package assertions with open(self.packages_file_path) as f: spack_packages = yaml.safe_load(f) if 'packages' in spack_packages: pkgs = set() for name, pkg in self.pe_independent_pkgs.items(): if 'name' in pkg: pkgs.add(pkg['name']) else: pkgs.add(name) for name, pkg in self.pe_dependent_pkgs.items(): if 'name' in pkg: pkgs.add(pkg['name']) else: pkgs.add(name) for pkg in pkgs: patterns += [ sn.assert_found(f'{pkg}:', self.packages_file_path) ] else: raise SanityError('packages entry not found in packages.yaml file') config = spackconfig.SPACK_CONFIG # config assertions with open(self.config_file_path) as f: spack_config = yaml.safe_load(f) if 'config' in spack_config: for option in [ 'build_stage', 'source_cache', 'misc_cache', 'db_lock_timeout', 'build_jobs' ]: patterns += [ sn.assert_found(f'{option}:', self.config_file_path) ] else: raise SanityError('config entry not found in config.yaml file') return sn.all(patterns)
def __init__(self): # {{{ pe self.descr = 'Tool validation' self.valid_prog_environs = [ 'PrgEnv-gnu', 'cpeGNU' # 'PrgEnv-gnu', 'PrgEnv-intel', 'PrgEnv-pgi', 'PrgEnv-cray', # 'PrgEnv-aocc', 'cpeGNU', 'cpeIntel', 'cpeCray', 'cpeAMD', ] self.valid_systems = [ 'dom:mc', 'dom:gpu', 'daint:mc', 'daint:gpu', 'eiger:mc', 'pilatus:mc' ] self.tool = 'atp' self.modules = [self.tool, 'cray-stat'] # cray-cti self.maintainers = ['JG'] self.tags = {'sph', 'hpctools', 'cpu', 'craype', 'debugging'} # }}} # {{{ compile self.testname = 'sedov' self.sourcepath = f'{self.testname}.cpp' # atp requires full path: self.executable = './mpi+omp' cs = self.current_system.name re_slm_1 = 'libAtpSigHandler.so' re_slm_2 = 'libAtpDispatch.so' re_epr_ini1 = '^slurm = True' re_epr_cfg1 = '.debug., .ps., None, False' re_epr_cfg2 = '.eproxy., .eproxy., None, True' re_hosts_1 = 'login' re_ver_1 = 'STAT_VERSION1=$' re_ver_2 = 'STAT_VERSION2=$' re_ver_3 = 'ATP_VERSION1=$' re_ver_4 = 'ATP_VERSION2=$' re_ver_5 = 'ATP_HOME=$' re_which_1 = 'not found' re_stderr_1 = 'forcing job termination|Force Terminated (job|Step)' re_stderr_2 = 'Producing core dumps for rank' re_stderr_3 = 'View application merged backtrace tree with: stat-view' re_dot_1 = 'MPI_Allreduce|MPID_Abort|PMPI_Abort' re_dot_2 = 'sphexa::sph::|cstone::' re_core_1 = 'core file x86-64' # TODO: grep sphexa::sph atpMergedBT_line.dot -> perf_patterns # 94 [pos="0,0", label="sphexa::sph::neighborsSum(... ldd_rpt = 'ldd.rpt' cfg_rpt = 'cfg.rpt' version_rpt = 'version.rpt' which_rpt = 'which.rpt' slurm_cfg_file = '/etc/opt/slurm/plugstack.conf' cfg_file_path = '/opt/cray/elogin/eproxy' eproxy_ini_cfg_file = f'{cfg_file_path}/etc/eproxy.ini' eproxy_cfg_file = f'{cfg_file_path}/default/bin/eproxy_config.py' hosts_cfg_file = '/etc/hosts' apt_dot_file = 'atpMergedBT_line.dot' # TODO: regex_rk0 = 'core.atp.*.0.0.*' # {{{ Needed when reporting a support case: if cs not in {'pilatus', 'eiger'}: self.prebuild_cmds += [ # --- check slurm_cfg # (optional /opt/cray/pe/atp/libAtpDispatch.so) f'grep "{re_slm_2}" {slurm_cfg_file} > {cfg_rpt}', # --- check ini_cfg_file (slurm = True) f'grep "{re_epr_ini1}" {eproxy_ini_cfg_file} >> {cfg_rpt}', # --- check eproxy_cfg_file (['debug', 'ps', None, False]) f'grep "{re_epr_cfg1}" {eproxy_cfg_file} >> {cfg_rpt}', # --- check eproxy_cfg_file (['eproxy', 'eproxy', None, True]) f'grep "{re_epr_cfg2}" {eproxy_cfg_file} >> {cfg_rpt}', # --- check STAT_MOM_NODE in /etc/hosts (daintgw01|domgw03) f'grep "{re_hosts_1}" {hosts_cfg_file} >> {cfg_rpt}', # --- chech stat version f'echo STAT_VERSION1=$STAT_VERSION > {version_rpt}', f'echo STAT_VERSION2=`STATbin --version` >> {version_rpt}', ] else: self.prebuild_cmds += [ # --- chech stat version f'echo STAT_VERSION1=$STAT_LEVEL > {version_rpt}', f'echo STAT_VERSION2=`STATbin --version` >> {version_rpt}', ] # }}} self.prebuild_cmds += [ # TODO: open cray case f'export PKG_CONFIG_PATH=$ATP_INSTALL_DIR/lib/pkgconfig:' f'$PKG_CONFIG_PATH', # --- check atp version and path f'echo ATP_VERSION1=$ATP_VERSION >> {version_rpt}', f'echo ATP_VERSION2=' f'`pkg-config --modversion libAtpSigHandler` >> {version_rpt}', f'echo ATP_HOME=$ATP_HOME >> {version_rpt}', f'pkg-config --variable=exec_prefix libAtpSigHandler &>{which_rpt}' ] self.postbuild_cmds += [ # --- check exe (/opt/cray/pe/atp/3.8.1/lib/libAtpSigHandler.so.1) f'ldd {self.executable}* |grep "{re_slm_1}" &> {ldd_rpt}', ] # }}} # {{{ run self.time_limit = '10m' self.variables['ATP_ENABLED'] = '1' self.postrun_cmds += [ f'ldd {self.executable}* |grep atp', 'file core*' ] # {{{ TODO: gdb_command # - gdb_command = (r'-e %s ' # - r'--eval-command="set pagination off" ' # - r'--eval-command="bt" ' # - r'--eval-command="quit"' % self.executable) # - regex_not_rk0 = r'grep -m1 -v atp' # - self.postrun_cmds = [ # - 'echo stoptime=`date +%s`', # - # --- rank 0: MPI_Allreduce # - f'gdb -c {regex_rk0} {gdb_command} &> {self.rpt_rk0}', # - # - # --- rank>2: MPI::Comm::Abort # -# f'ln -s `ls -1 core.* |{regex_not_rk0}` mycore', # -# f'gdb -c mycore {gdb_command} &> {self.rpt_rkn}', # - # can't do this because core filename is unknown at runtime: # - # 'gdb -c core.atp.*.%s.* -e %s' % (self.core, self.executable), # - # - '# stat-view atpMergedBT_line.dot' # }}} # }}} # {{{ sanity # TODO: self.sanity_patterns += ... ? if cs in {'pilatus', 'eiger'}: self.sanity_patterns = sn.all([ # check the job output: sn.assert_found(r'UpdateSmoothingLength: \S+s', self.stdout), # check the tool output: sn.assert_found(re_slm_1, ldd_rpt), # sn.assert_not_found(re_ver_1, version_rpt), sn.assert_not_found(re_ver_2, version_rpt), sn.assert_not_found(re_ver_3, version_rpt), sn.assert_not_found(re_ver_4, version_rpt), sn.assert_not_found(re_ver_5, version_rpt), sn.assert_not_found(re_which_1, which_rpt), # sn.assert_found(re_stderr_1, self.stderr), sn.assert_found(re_stderr_2, self.stderr), sn.assert_found(re_stderr_3, self.stderr), # sn.assert_found(re_dot_1, apt_dot_file), # sn.assert_found(re_dot_2, apt_dot_file), sn.assert_found(re_core_1, self.stdout), ]) else: self.sanity_patterns = sn.all([ # check the job output: sn.assert_found(r'UpdateSmoothingLength: \S+s', self.stdout), # check the tool output: sn.assert_found(re_slm_1, ldd_rpt), sn.assert_found(re_slm_2, cfg_rpt), sn.assert_found(re_epr_ini1, cfg_rpt), sn.assert_found(re_epr_cfg1, cfg_rpt), sn.assert_found(re_epr_cfg2, cfg_rpt), sn.assert_found(re_hosts_1, cfg_rpt), # sn.assert_not_found(re_ver_1, version_rpt), sn.assert_not_found(re_ver_2, version_rpt), sn.assert_not_found(re_ver_3, version_rpt), sn.assert_not_found(re_ver_4, version_rpt), sn.assert_not_found(re_ver_5, version_rpt), sn.assert_not_found(re_which_1, which_rpt), # sn.assert_found(re_stderr_1, self.stderr), sn.assert_found(re_stderr_2, self.stderr), sn.assert_found(re_stderr_3, self.stderr), # sn.assert_found(re_dot_1, apt_dot_file), # sn.assert_found(re_dot_2, apt_dot_file), sn.assert_found(re_core_1, self.stdout), ])
def __init__(self, lang): super().__init__() self.name = 'scorep_mpi_omp_%s' % lang.replace('+', 'p') self.descr = 'SCORE-P %s check' % lang self.valid_systems = ['daint:gpu', 'daint:mc', 'dom:gpu', 'dom:mc'] self.valid_prog_environs = ['PrgEnv-gnu', 'PrgEnv-intel', 'PrgEnv-pgi'] self.scorep_modules = { 'PrgEnv-gnu': ['Score-P/4.0-CrayGNU-18.08'], 'PrgEnv-intel': ['Score-P/4.0-CrayIntel-18.08'], 'PrgEnv-pgi': ['Score-P/4.0-CrayPGI-18.08'] } self.prgenv_flags = { 'PrgEnv-cray': ['-g', '-homp'], 'PrgEnv-gnu': ['-g', '-fopenmp'], 'PrgEnv-intel': ['-g', '-openmp'], 'PrgEnv-pgi': ['-g', '-mp'] } self.executable = 'jacobi' self.build_system = 'Make' self.build_system.makefile = 'Makefile_scorep_mpi_omp' # NOTE: Restrict concurrency to allow creation of Fortran modules if lang == 'F90': self.build_system.max_concurrency = 1 self.sourcesdir = os.path.join('src', lang) self.num_tasks = 3 self.num_tasks_per_node = 3 self.num_cpus_per_task = 4 self.num_iterations = 200 self.variables = { 'OMP_NUM_THREADS': str(self.num_cpus_per_task), 'ITERATIONS': str(self.num_iterations), 'SCOREP_ENABLE_PROFILING': 'false', 'SCOREP_ENABLE_TRACING': 'true', 'OMP_PROC_BIND': 'true', 'SCOREP_TIMER': 'clock_gettime' } cpu_count = self.num_cpus_per_task * self.num_tasks_per_node self.otf2_file = 'otf2.txt' self.sanity_patterns = sn.all([ sn.assert_found('SUCCESS', self.stdout), sn.assert_eq( sn.count( sn.extractall(r'(?P<line>LEAVE.*omp\s+\S+\s+\@_jacobi)', self.otf2_file, 'line')), 4 * self.num_iterations * cpu_count), sn.assert_not_found('warning|WARNING', self.stderr) ]) self.maintainers = ['MK', 'JG'] self.tags = {'production'} # additional program call in order to generate the tracing output for # the sanity check self.post_run = [ 'otf2-print scorep-*/traces.otf2 > %s' % self.otf2_file ]
def validate(self): return sn.assert_not_found(r'hello', self.stdout)
def set_sanity_patterns(self): self.sanity_patterns = sn.assert_not_found('error', self.stderr)
def validate_build(self): return sn.assert_not_found(r'warning', self.stdout)
def __init__(self): self.descr = 'GPU specs test' self.maintainers = ['JG'] self.valid_systems = [ 'daint:gpu', 'dom:gpu', 'arolla:cn', 'tsa:cn', 'ault:amdv100', 'ault:intelv100', 'ault:amda100', 'ault:amdvega' ] self.valid_prog_environs = ['PrgEnv-gnu'] self.sourcesdir = 'src' self.build_system = 'Make' self.executable = './exe' # {{{ run self.num_tasks = 1 self.num_tasks_per_node = 1 self.num_cpus_per_task = 1 self.num_tasks_per_core = 1 # self.use_multithreading = False # self.exclusive = True # self.exclusive_access = True self.time_limit = '1m' self.prerun_cmds = ['module list'] # }}} # {{{ sanity_patterns self.sanity_patterns = sn.all([ sn.assert_not_found(r'MapSMtoCores.*is undefined', self.stdout), sn.assert_found(r'Kernel Module', self.stdout), sn.assert_found(r'CUDA Driver Version / Runtime', self.stdout), sn.assert_found(r'CUDA Capability Major/Minor', self.stdout), sn.assert_found(r'Theoretical peak performance', self.stdout), sn.assert_found(r'^Device ', self.stdout), # sn.assert_found(r'', self.stdout), ]) # self.sanity_patterns = self.assert_num_tasks() # }}} # {{{ performance regex1 = r'Kernel Module\s+(\S+)\.\d+\s+' regex2 = r'\s+CUDA Driver Version / Runtime Version\s+(\S+) / (\S+)' regex3 = r'\s+CUDA Capability Major/Minor version number:\s+(\S+)' regex4 = r'Theoretical peak performance per GPU:\s+(\S+) Gflop/s' self.perf_patterns = { 'driver': sn.extractsingle(regex1, self.stdout, 1, float), 'cuda_driver_version': sn.extractsingle(regex2, self.stdout, 1, float), 'cuda_runtime_version': sn.extractsingle(regex2, self.stdout, 2, float), 'cuda_capability': sn.extractsingle(regex3, self.stdout, 1, float), 'peak_perf': sn.extractsingle(regex4, self.stdout, 1, int), } self.reference = { 'dom:gpu': { 'peak_perf': (4761, -0.10, None, 'Gflop/s'), }, 'daint:gpu': { 'peak_perf': (4761, -0.10, None, 'Gflop/s'), }, 'ault:intelv100': { 'peak_perf': (7066, -0.10, None, 'Gflop/s'), }, 'ault:amda100': { 'peak_perf': (15000, -0.10, None, 'Gflop/s'), }, 'ault:amdv100': { 'peak_perf': (5500, -0.10, None, 'Gflop/s'), }, 'ault:amdvega': { 'peak_perf': (3450, -0.10, None, 'Gflop/s'), }, 'arolla:cn': { 'peak_perf': (5861, -0.10, None, 'Gflop/s'), }, 'tsa:cn': { 'peak_perf': (5861, -0.10, None, 'Gflop/s'), }, '*': { 'driver': (0, None, None, ''), 'cuda_driver_version': (0, None, None, ''), 'cuda_runtime_version': (0, None, None, ''), 'cuda_capability': (0, None, None, '') }, }
def validate_download(self): return sn.assert_not_found('error', self.stderr)
def __init__(self, part, n_tasks, n_tasks_per_node): self.valid_systems = [part] self.valid_prog_environs = ['openfoam'] self.num_tasks_per_node = n_tasks_per_node self.num_tasks = n_tasks self.num_nodes = int(n_tasks / n_tasks_per_node) self.tags = { 'num_procs=%i' % self.num_tasks, 'num_nodes=%i' % self.num_nodes } self.sourcesdir = 'downloads' self.exclusive_access = True self.time_limit = '1h' self.prerun_cmds = [ 'tar --strip-components 2 -xf Motorbike_bench_template.tar.gz bench_template/basecase', './Allclean', # removes logs, old timehistories etc just in case # set domain decomposition: # using 'scotch' method means simpleCoeffs is ignored so it doesn't need to match num_tasks: 'sed -i -- "s/method .*/method scotch;/g" system/decomposeParDict', 'sed -i -- "s/numberOfSubdomains .*/numberOfSubdomains %i;/g" system/decomposeParDict' % self.num_tasks, # remove streamlines: 'sed -i -- \'s/ #include "streamLines"//g\' system/controlDict', 'sed -i -- \'s/ #include "wallBoundedStreamLines"//g\' system/controlDict', # fix location of mesh quality defaults (needed for v6+?) "sed -i -- 's|caseDicts|caseDicts/mesh/generation|' system/meshQualityDict", './Allmesh', # do meshing 'time \\', # want to run mpi task under time ] # could also check: #$ ompi_info -c | grep -oE "MPI_THREAD_MULTIPLE[^,]*" # MPI_THREAD_MULTIPLE: yes self.executable = 'simpleFoam' self.executable_opts = ['-parallel'] self.keep_files = [ 'log.snappyHexMesh', 'log.blockMesh', 'log.decomposePar' ] result = sn.extractall( r'time step continuity errors : ' r'\S+\s\S+ = \S+\sglobal = (?P<res>-?\S+),', self.stdout, 'res', float) # NB: `time` outputs to stderr so can't assume that should be empty self.sanity_patterns = sn.all([ # ensure meshing finished ok: sn.assert_found('End', 'log.blockMesh'), sn.assert_found('End', 'log.decomposePar'), sn.assert_found('Finished meshing without any errors', 'log.snappyHexMesh'), # ensure simpleFoam finished ok: sn.assert_found('Finalising parallel run', self.stdout), sn.assert_not_found('FOAM FATAL ERROR', self.stdout), sn.assert_not_found('FOAM FATAL ERROR', self.stderr), # ensure continuity errors small enough - copied from # https://github.com/eth-cscs/reframe/blob/0a4dc5207b35c737861db346bd483fd4ac202846/cscs-checks/apps/openfoam/check_openfoam_extend.py#L56 sn.all(sn.map(lambda x: sn.assert_lt(abs(x), 5.e-04), result)), ]) self.perf_patterns = { # from openfoam output: 'ExecutionTime': sn.extractall( r'ExecutionTime = ([\d.]+) s ClockTime = ([\d.]+) s', self.stdout, 1, float)[-1], 'ClockTime': sn.extractall( r'ExecutionTime = ([\d.]+) s ClockTime = ([\d.]+) s', self.stdout, 2, float)[-1], # from `time`: 'runtime_real': sn.extractsingle(r'^real\s+(\d+m[\d.]+s)$', self.stderr, 1, parse_time_cmd), } self.reference = { '*': { 'ExecutionTime': (0, None, None, 's'), 'ClockTime': (0, None, None, 's'), 'runtime_real': (0, None, None, 's'), } }