def test_evaluate(): a = sn.defer(3) assert 3 == a.evaluate() assert 3 == sn.evaluate(a) assert 3 == sn.evaluate(3)
def test_ior(self): v = V(2) dv = sn.defer(v) dv |= V(5) sn.evaluate(dv) self.assertEqual(7, v._value)
def n_cubeside(self): regex = r'Domain synchronized, nLocalParticles (\d+)' n_particles = sn.extractsingle(regex, self.stdout, 1, int) return int(pow(sn.evaluate(n_particles), 1 / 3))
def test_ilshift(self): v = V(1) dv = sn.defer(v) dv <<= V(2) sn.evaluate(dv) self.assertEqual(4, v._value)
def test_iand(self): v = V(7) dv = sn.defer(v) dv &= V(2) sn.evaluate(dv) self.assertEqual(2, v._value)
def test_itruediv(self): v = V(3) dv = sn.defer(v) dv /= V(2) sn.evaluate(dv) self.assertEqual(1.5, v._value)
def test_imod(self): v = V(3) dv = sn.defer(v) dv %= V(2) sn.evaluate(dv) self.assertEqual(1, v._value)
def test_imod(): v = V(3) dv = sn.defer(v) dv %= V(2) sn.evaluate(dv) assert 1 == v._value
def test_ipow(): v = V(3) dv = sn.defer(v) dv **= V(2) sn.evaluate(dv) assert 9 == v._value
def test_itruediv(): v = V(3) dv = sn.defer(v) dv /= V(2) sn.evaluate(dv) assert 1.5 == v._value
def test_ifloordiv(): v = V(3) dv = sn.defer(v) dv //= V(2) sn.evaluate(dv) assert 1 == v._value
def test_imul(): v = V(1) dv = sn.defer(v) dv *= V(3) sn.evaluate(dv) assert 3 == v._value
def test_isub(): v = V(1) dv = sn.defer(v) dv -= V(3) sn.evaluate(dv) assert -2 == v._value
def test_iadd(): v = V(1) dv = sn.defer(v) dv += V(3) sn.evaluate(dv) assert 4 == v._value
def test_isub(self): v = V(1) dv = sn.defer(v) dv -= V(3) sn.evaluate(dv) self.assertEqual(-2, v._value)
def test_ilshift(): v = V(1) dv = sn.defer(v) dv <<= V(2) sn.evaluate(dv) assert 4 == v._value
def test_imul(self): v = V(1) dv = sn.defer(v) dv *= V(3) sn.evaluate(dv) self.assertEqual(3, v._value)
def test_irshift(): v = V(8) dv = sn.defer(v) dv >>= V(3) sn.evaluate(dv) assert 1 == v._value
def test_ifloordiv(self): v = V(3) dv = sn.defer(v) dv //= V(2) sn.evaluate(dv) self.assertEqual(1, v._value)
def test_iand(): v = V(7) dv = sn.defer(v) dv &= V(2) sn.evaluate(dv) assert 2 == v._value
def test_ipow(self): v = V(3) dv = sn.defer(v) dv **= V(2) sn.evaluate(dv) self.assertEqual(9, v._value)
def test_ixor(): v = V(7) dv = sn.defer(v) dv ^= V(7) sn.evaluate(dv) assert 0 == v._value
def test_irshift(self): v = V(8) dv = sn.defer(v) dv >>= V(3) sn.evaluate(dv) self.assertEqual(1, v._value)
def test_ior(): v = V(2) dv = sn.defer(v) dv |= V(5) sn.evaluate(dv) assert 7 == v._value
def test_ixor(self): v = V(7) dv = sn.defer(v) dv ^= V(7) sn.evaluate(dv) self.assertEqual(0, v._value)
def test_evaluate(self): a = sn.defer(3) self.assertEqual(3, a.evaluate()) self.assertEqual(3, sn.evaluate(a)) self.assertEqual(3, sn.evaluate(3))
def eval_sanity(self): output_files = [] output_files = [ file for file in os.listdir(self.stagedir) if file.startswith('output-') ] num_greasy_tasks = len(output_files) failure_msg = (f'Requested {self.num_greasy_tasks} task(s), but ' f'executed only {num_greasy_tasks} tasks(s)') sn.evaluate( sn.assert_eq(num_greasy_tasks, self.num_greasy_tasks, msg=failure_msg)) num_tasks = sn.getattr(self, 'nranks_per_worker') num_cpus_per_task = sn.getattr(self, 'num_cpus_per_task') def tid(match): return int(match.group(1)) def num_threads(match): return int(match.group(2)) def rank(match): return int(match.group(3)) def num_ranks(match): return int(match.group(4)) for output_file in output_files: result = sn.findall( r'Hello, World from thread \s*(\d+) out ' r'of \s*(\d+) from process \s*(\d+) out of ' r'\s*(\d+)', output_file) failure_msg = (f'Found {sn.count(result)} Hello, World... ' f'pattern(s) but expected ' f'{num_tasks * num_cpus_per_task} pattern(s) ' f'inside the output file {output_file}') sn.evaluate( sn.assert_eq(sn.count(result), num_tasks * num_cpus_per_task, msg=failure_msg)) sn.evaluate( sn.all( sn.chain( sn.map( lambda x: sn.assert_lt( tid(x), num_threads(x), msg=(f'Found {tid(x)} threads rather than ' f'{num_threads(x)}')), result), sn.map( lambda x: sn.assert_lt( rank(x), num_ranks(x), msg =(f'Rank id {rank(x)} is not lower than the ' f'number of ranks {self.nranks_per_worker} ' f'in output file')), result), sn.map( lambda x: sn.assert_lt( tid(x), self.num_cpus_per_task, msg=(f'Rank id {tid(x)} is not lower than the ' f'number of cpus per task ' f'{self.num_cpus_per_task} in output ' f'file {output_file}')), result), sn.map( lambda x: sn.assert_eq( num_threads(x), num_cpus_per_task, msg =(f'Found {num_threads(x)} threads rather than ' f'{self.num_cpus_per_task} in output file ' f'{output_file}')), result), sn.map( lambda x: sn.assert_lt( rank(x), num_tasks, msg=( f'Found {rank(x)} threads rather than ' f'{self.num_cpus_per_task} in output file ' f'{output_file}')), result), sn.map( lambda x: sn.assert_eq( num_ranks(x), num_tasks, msg=(f'Number of ranks {num_ranks(x)} is not ' f'equal to {self.nranks_per_worker} in ' f'output file {output_file}')), result)))) sn.evaluate(sn.assert_found(r'Finished greasing', self.greasy_logfile)) sn.evaluate( sn.assert_found((f'INFO: Summary of {self.num_greasy_tasks} ' f'tasks: ' f'{self.num_greasy_tasks} OK, ' f'0 FAILED, ' f'0 CANCELLED, ' fr'0 INVALID\.'), self.greasy_logfile)) return True
def test_iadd(self): v = V(1) dv = sn.defer(v) dv += V(3) sn.evaluate(dv) self.assertEqual(4, v._value)
def np_per_cnode(self): regex = r'Domain synchronized, nLocalParticles (\d+)' n_particles = sn.extractsingle(regex, self.stdout, 1, int) return int(sn.evaluate(n_particles) / self.mpi_rks)
def assert_success(self): envname = self.current_environ.name # {{{ extract CCE version to manage compiler versions: cce_version = None rptf = os.path.join(self.stagedir, sn.evaluate(self.stdout)) if self.lang == 'C++' and envname == 'PrgEnv-cray': cce_version = sn.extractsingle(r'CRAY_CC_VERSION=(\d+)\.\S+', rptf, 1, int) # }}} # {{{ extract AOCC version to manage compiler versions: aocc_version = None rptf = os.path.join(self.stagedir, sn.evaluate(self.stdout)) if self.lang == 'C++' and envname == 'PrgEnv-aocc': aocc_version = sn.extractsingle( r'CRAY_AOCC_VERSION=(\d+)\.\S+', rptf, 1, int) # }}} intel_type = sn.extractsingle(r'INTEL_COMPILER_TYPE=(\S*)', rptf, 1) # {{{ print(f'intel_type={intel_type}') # intel/19.1.1.217 icpc openmp/201611 # intel/19.1.3.304 icpc openmp/201611 # intel/2021.2.0 icpc openmp/201611 # intel-classic/2021.2.0 icpc openmp/201611 # intel-oneapi/2021.2.0 icpc openmp/201611 = 4.5 # intel-oneapi/2021.2.0 icpx openmp/201811 = 5.0 # __INTEL_COMPILER # INTEL_VERSION 2021.2.0 INTEL_COMPILER_TYPE ONEAPI 201811 # INTEL_VERSION 2021.2.0 INTEL_COMPILER_TYPE RECOMMENDED # INTEL_VERSION 2021.2.0 INTEL_COMPILER_TYPE CLASSIC 201611 # }}} # OpenMP support varies between compilers: # c++ - f90 # aocc - 201511 - 201307 # cce - 201511 - 201511 # gnu - 201511 - 201511 # intel - 201811 - 201611 # pgi - 201307 - 201307 # nv - 201307 - 201307 openmp_versions = { # 'PrgEnv-aocc': {'C++': 201511, 'F90': 201307}, 'PrgEnv-aocc': { 'C++': 201511 if aocc_version == 2 else 201811, 'F90': 201307, }, 'PrgEnv-cray': { 'C++': 201511 if cce_version == 10 else 201811, 'F90': 201511, }, 'PrgEnv-gnu': {'C++': 201511, 'F90': 201511}, 'PrgEnv-intel': { 'C++': 201811 if (intel_type == 'ONEAPI' or intel_type == 'RECOMMENDED') else 201611, 'F90': 201611}, 'PrgEnv-pgi': {'C++': 201307, 'F90': 201307}, 'PrgEnv-nvidia': {'C++': 201307, 'F90': 201307} } found_version = sn.extractsingle(r'OpenMP-\s*(\d+)', self.stdout, 1, int) return sn.all([ sn.assert_found('SUCCESS', self.stdout), sn.assert_eq(found_version, openmp_versions[envname][self.lang]) ])