Resolve conflicts

Author: Theofilos Manitaras

cscs-checks/libraries/io/hdf5_compile_run.py

@@ -20,6 +20,7 @@ def __init__(self, lang, linkage):
                                     'PrgEnv-intel', 'PrgEnv-pgi']
         self.modules = ['cray-hdf5']
         self.keep_files = ['h5dump_out.txt']
+
         # C and Fortran write transposed matrix
         if lang == 'c':
             self.sanity_patterns = sn.all([

cscs-checks/libraries/io/netcdf_compile_run.py

@@ -41,8 +41,8 @@ def __init__(self, lang, linkage):
         self.maintainers = ['AJ', 'SO']
         self.tags = {'production', 'craype', 'external-resources'}
 
-    @rfm.run_after('setup')
-    def set_flags(self):
+    @rfm.run_before('compile')
+    def setflags(self):
         # FIXME: static compilation yields a link error in case of
         # PrgEnv-cray(Cray Bug #255707)
         if (self.linkage == 'static' and

cscs-checks/libraries/math/scalapack_compile_run.py

@@ -16,7 +16,6 @@ def __init__(self, linkage):
         self.num_tasks = 16
         self.num_tasks_per_node = 8
         self.variables = {'CRAYPE_LINK_TYPE': linkage}
-
         if self.current_system.name == 'kesch':
             self.exclusive_access = True
             self.valid_prog_environs = ['PrgEnv-cray']
@@ -29,7 +28,7 @@ def __init__(self, linkage):
         self.maintainers = ['CB', 'LM']
         self.tags = {'production', 'external-resources'}
 
-    @rfm.run_after('setup')
+    @rfm.run_before('compile')
     def set_linker_variables(self):
         # FIXME: static compilation yields a link error in case of
         # PrgEnv-cray(Cray Bug #255707)

cscs-checks/libraries/math/trilinos_compile_run.py

@@ -6,7 +6,6 @@
 @rfm.parameterized_test(['static'], ['dynamic'])
 class TrilinosTest(rfm.RegressionTest):
     def __init__(self, linkage):
-        super().__init__()
         self.valid_systems = ['daint:gpu', 'daint:mc', 'dom:gpu', 'dom:mc',
                               'tiger:gpu']
         # NOTE: PrgEnv-cray in dynamic does not work because of CrayBug/809265
@@ -38,7 +37,7 @@ def __init__(self, linkage):
         self.maintainers = ['AJ', 'CB']
         self.tags = {'production', 'craype'}
 
-    def setup(self, partition, environ, **job_opts):
-        prgenv_flags = self.prgenv_flags[environ.name]
-        self.build_system.cxxflags = prgenv_flags
-        super().setup(partition, environ, **job_opts)
+    @rfm.run_before('compile')
+    def set_cxxflags(self):
+        flags = self.prgenv_flags[self.current_environ.name]
+        self.build_system.cxxflags = flags

cscs-checks/libraries/petsc/petsc_helloworld.py

@@ -5,28 +5,28 @@
 @rfm.required_version('>=2.14')
 @rfm.parameterized_test(['dynamic'], ['static'])
 class PetscPoisson2DCheck(rfm.RegressionTest):
-    def __init__(self, variant):
-        super().__init__()
+    def __init__(self, linkage):
         self.descr = ('Compile/run PETSc 2D Poisson example with cray-petsc '
-                      '(%s linking)') % variant
+                      '(%s linking)') % linkage
         self.valid_systems = ['daint:gpu', 'daint:mc',
                               'dom:gpu', 'dom:mc', 'tiger:gpu']
-        self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu',
-                                    'PrgEnv-intel']
+        self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu']
+        if linkage == 'dynamic':
+            # FIXME: static compilation yields a link error in case of
+            # PrgEnv-intel (Cray Bug #255701)
+            self.valid_prog_environs += ['PrgEnv-intel']
+
         self.sourcepath = 'poisson2d.c'
         self.modules = ['cray-petsc']
         self.num_tasks = 16
         self.num_tasks_per_node = 8
         self.build_system = 'SingleSource'
-        if variant == 'dynamic':
-            self.build_system.cflags = ['-dynamic']
-
+        self.variables = {'CRAYPE_LINK_TYPE': linkage}
         self.executable_opts = ['-da_grid_x 4', '-da_grid_y 4', '-ksp_monitor']
 
         # Check the final residual norm for convergence
         norm = sn.extractsingle(r'\s+\d+\s+KSP Residual norm\s+(?P<norm>\S+)',
                                 self.stdout, 'norm', float, -1)
         self.sanity_patterns = sn.assert_lt(norm, 1.0e-5)
-
         self.tags = {'production', 'craype'}
         self.maintainers = ['AJ', 'CB']

cscs-checks/mch/g2g_meteoswiss_check.py

@@ -5,13 +5,9 @@
 @rfm.parameterized_test([1], [2])
 class G2GMeteoswissTest(rfm.RegressionTest):
     def __init__(self, g2g):
-        super().__init__()
         self.descr = 'G2G Meteoswiss check with G2G=%s' % g2g
         self.strict_check = False
         self.valid_systems = ['kesch:cn']
-
-        # FIXME: temporary workaround until the mvapich module is fixed;
-        #        'PrgEnv-gnu-c2sm-gpu' will be added later
         self.valid_prog_environs = ['PrgEnv-gnu']
         self.exclusive_access = True
         self.modules = ['cmake']

cscs-checks/mch/gpu_direct_cuda.py

@@ -6,11 +6,8 @@
 @rfm.simple_test
 class GpuDirectCudaCheck(rfm.RegressionTest):
     def __init__(self):
-        super().__init__()
         self.descr = 'tests gpu-direct for CUDA'
         self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu']
-        # FIXME: temporary workaround until the mvapich module is fixed
-        #        'PrgEnv-gnu-c2sm-gpu' will be added later
         self.valid_prog_environs = ['PrgEnv-gnu']
         self.sourcepath = 'gpu_direct_cuda.cu'
         self.build_system = 'SingleSource'

cscs-checks/prgenv/helloworld.py

@@ -32,82 +32,89 @@ def __init__(self, variant, lang, linkage):
             self.valid_prog_environs = []
 
         self.compilation_time_seconds = None
-        self.maintainers = ['VH', 'EK']
-        self.tags = {'production', 'craype'}
-
-    def compile(self):
-        self.compilation_time_seconds = datetime.now()
-        super().compile()
-        self.compilation_time_seconds = (
-            datetime.now() - self.compilation_time_seconds).total_seconds()
-
-    @rfm.run_after('setup')
-    def set_flags(self):
-        # FIXME: static compilation yields a link error in case of
-        # PrgEnv-cray(Cray Bug #255707)
-        if (self.linkage == 'static' and
-            self.current_system.name == 'dom' and
-            self.current_environ.name.startswith('PrgEnv-cray')):
-            self.variables = {'LINKER_X86_64': '/usr/bin/ld',
-                              'LINKER_AARCH64': '=/usr/bin/ld'}
 
         result = sn.findall(r'Hello World from thread \s*(\d+) out '
                             r'of \s*(\d+) from process \s*(\d+) out of '
                             r'\s*(\d+)', self.stdout)
 
+        num_tasks = sn.getattr(self, 'num_tasks')
+        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))
+
         self.sanity_patterns = sn.all(
-            sn.chain([sn.assert_eq(sn.count(result), self.num_tasks *
-                                   self.num_cpus_per_task)],
-                     sn.map(
-                         lambda x: sn.assert_lt(int(x.group(1)),
-                                                int(x.group(2))),
-                         result),
-                     sn.map(
-                         lambda x: sn.assert_lt(int(x.group(3)),
-                                                int(x.group(4))),
-                         result),
-                     sn.map(
-                         lambda x: sn.assert_lt(int(x.group(1)),
-                                                self.num_cpus_per_task),
-                         result),
-                     sn.map(
-                         lambda x: sn.assert_eq(int(x.group(2)),
-                                                self.num_cpus_per_task),
-                         result),
-                     sn.map(
-                         lambda x: sn.assert_lt(int(x.group(3)),
-                                                self.num_tasks),
-                         result),
-                     sn.map(
-                         lambda x: sn.assert_eq(int(x.group(4)),
-                                                self.num_tasks),
-                         result),
-                     )
+            sn.chain(
+                [sn.assert_eq(sn.count(result), num_tasks*num_cpus_per_task)],
+                sn.map(lambda x: sn.assert_lt(tid(x), num_threads(x)), result),
+                sn.map(lambda x: sn.assert_lt(rank(x), num_ranks(x)), result),
+                sn.map(
+                    lambda x: sn.assert_lt(tid(x), num_cpus_per_task), result
+                ),
+                sn.map(
+                    lambda x: sn.assert_eq(num_threads(x), num_cpus_per_task),
+                    result
+                ),
+                sn.map(lambda x: sn.assert_lt(rank(x), num_tasks), result),
+                sn.map(
+                    lambda x: sn.assert_eq(num_ranks(x), num_tasks), result
+                ),
+            )
         )
-
         self.perf_patterns = {
             'compilation_time': sn.getattr(self, 'compilation_time_seconds')
         }
         self.reference = {
             '*': {
-                'compilation_time': (60, None, 0.1)
+                'compilation_time': (60, None, 0.1, 's')
             }
         }
 
+        self.maintainers = ['VH', 'EK']
+        self.tags = {'production', 'craype'}
+
+    @rfm.run_before('compile')
+    def setflags(self):
+        # FIXME: static compilation yields a link error in case of
+        # PrgEnv-cray(Cray Bug #255707)
+        if (self.linkage == 'static' and
+            self.current_system.name == 'dom' and
+            self.current_environ.name.startswith('PrgEnv-cray')):
+            self.variables = {'LINKER_X86_64': '/usr/bin/ld',
+                              'LINKER_AARCH64': '=/usr/bin/ld'}
+
         envname = self.current_environ.name.replace('-nompi', '')
         prgenv_flags = self.prgenv_flags[envname]
         self.build_system.cflags = prgenv_flags
         self.build_system.cxxflags = prgenv_flags
         self.build_system.fflags = prgenv_flags
 
+    @rfm.run_before('compile')
+    def compile_timer_start(self):
+        self.compilation_time_seconds = datetime.now()
+
+    @rfm.run_after('compile')
+    def compile_timer_end(self):
+        elapsed = datetime.now() - self.compilation_time_seconds
+        self.compilation_time_seconds = elapsed.total_seconds()
+
 
 @rfm.required_version('>=2.14')
 @rfm.parameterized_test(*([lang, linkage]
                           for lang in ['cpp', 'c', 'f90']
                           for linkage in ['dynamic', 'static']))
 class HelloWorldTestSerial(HelloWorldBaseTest):
-    def __init__(self, lang, linkage, **kwargs):
-        super().__init__('serial', lang, linkage, **kwargs)
+    def __init__(self, lang, linkage):
+        super().__init__('serial', lang, linkage)
         self.valid_systems += ['kesch:pn']
         self.sourcepath += '_serial.' + lang
         self.descr += ' Serial ' + linkage.capitalize()

cscs-checks/tools/profiling_and_debugging/perftools.py

@@ -29,8 +29,8 @@ def __init__(self, lang):
             self.modules += ['craype-accel-nvidia60']
 
         self.build_system = 'Make'
-        # NOTE: Restrict concurrency to allow creation of Fortran modules
         if lang == 'F90':
+            # NOTE: Restrict concurrency to allow creation of Fortran modules
             self.build_system.max_concurrency = 1
 
         self.prgenv_flags = {
@@ -50,10 +50,6 @@ def __init__(self, lang):
                 'LIB=-lstdc++']
 
         self.executable = 'jacobi'
-        # NOTE: Reduce time limit because for PrgEnv-pgi even if the output
-        # is correct, the batch job uses all the time.
-        self.time_limit = (0, 5, 0)
-
         self.num_tasks = 3
         self.num_tasks_per_node = 3
         self.num_cpus_per_task = 4
@@ -94,8 +90,8 @@ def __init__(self, lang):
         self.maintainers = ['JG', 'MKr']
         self.tags = {'production', 'craype'}
 
-    def setup(self, environ, partition, **job_opts):
-        super().setup(environ, partition, **job_opts)
+    @rfm.run_before('compile')
+    def setflags(self):
         flags = self.prgenv_flags[self.current_environ.name]
         self.build_system.cflags = flags
         self.build_system.cxxflags = flags

docs/index.rst

@@ -31,6 +31,7 @@ You can always find the latest release `here <https://github.com/eth-cscs/refram
 Publications
 ============
 
+* Slides [`pdf <https://drive.google.com/open?id=1W7R5lfRkXvBpVDSZ7dVBadk_d3K4dFrS>`__] @ `5th EasyBuild User Meeting 2020 <https://github.com/easybuilders/easybuild/wiki/5th-EasyBuild-User-Meeting>`__.
 * Slides [`pdf <https://drive.google.com/open?id=1Z3faPh9OSSXvlLHL07co3MRRn443dYsY>`__] @ `HPC System Testing BoF <https://sc19.supercomputing.org/session/?sess=sess324>`__, SC'19.
 * Slides [`pdf <https://drive.google.com/open?id=1JOFqY3ejbR1X5kTn_IZyp1GlCd2ZZS58>`__] @ `HUST 2019 <https://sc19.supercomputing.org/session/?sess=sess116>`__, SC'19.
 * Slides [`pdf <https://drive.google.com/open?id=1iwg1I48LVaWhhZCZIYPJSi3hdFLRcuhi>`__] @ `HPC Knowledge Meeting '19 <https://hpckp.org/>`__.