[test] Add support to PrgEnv-nvidia in various tests

cscs-checks/compile/libsci_resolve.py

@@ -4,52 +4,52 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import reframe as rfm
+import reframe.utility.osext as osext
 import reframe.utility.sanity as sn
 
 
 class LibSciResolveBaseTest(rfm.CompileOnlyRegressionTest):
-    def __init__(self):
-        self.sourcesdir = 'src/libsci_resolve'
-        self.sourcepath = 'libsci_resolve.f90'
-        self.valid_systems = ['daint:login', 'daint:gpu',
-                              'dom:login', 'dom:gpu']
-        self.modules = ['craype-haswell']
-        self.maintainers = ['AJ', 'LM']
-        self.tags = {'production', 'craype'}
+    sourcesdir = 'src/libsci_resolve'
+    sourcepath = 'libsci_resolve.f90'
+    valid_systems = ['daint:login', 'daint:gpu', 'dom:login', 'dom:gpu']
+    modules = ['craype-haswell']
+    maintainers = ['AJ', 'LM']
+    tags = {'production', 'craype'}
+
+    @run_after('setup')
+    def set_postbuild_cmds(self):
+        self.postbuild_cmds = [f'readelf -d {self.executable}']
 
 
-@rfm.parameterized_test(['craype-accel-nvidia35'], ['craype-accel-nvidia60'])
+@rfm.simple_test
 class NvidiaResolveTest(LibSciResolveBaseTest):
-    def __init__(self, module_name):
-        super().__init__()
-        self.descr = f'Module {module_name} resolves libsci_acc'
-        self.build_system = 'SingleSource'
+    accel_nvidia_version = parameter(['60'])
+    valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu']
+    build_system = 'SingleSource'
+    compiler_version = '81'
+
+    @run_after('init')
+    def set_description(self):
+        self.descr = (f'Module craype-accel-nvidia{self.accel_nvidia_version} '
+                      f'resolves libsci_acc')
+
+    @run_after('init')
+    def update_tags(self):
         self.tags.add('health')
 
-        self.module_name = module_name
-        self.module_version = {
-            'craype-accel-nvidia35': 'nv35',
-            'craype-accel-nvidia60': 'nv60'
-        }
-        self.compiler_version = '81'
-        self.modules = ['craype-haswell', module_name]
-        self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu']
-        self.prgenv_names = {
-            'PrgEnv-cray': 'cray',
-            'PrgEnv-gnu':  'gnu'
-        }
-        self.postbuild_cmds = [f'readelf -d {self.executable}']
+    @run_after('setup')
+    def set_modules(self):
+        self.modules += [f'craype-accel-nvidia{self.accel_nvidia_version}']
 
     @run_before('sanity')
     def set_sanity(self):
         # here lib_name is in the format: libsci_acc_gnu_48_nv35.so or
         #                                 libsci_acc_cray_nv35.so
         regex = (r'.*\(NEEDED\).*libsci_acc_(?P<prgenv>[A-Za-z]+)_'
                  r'((?P<cver>[A-Za-z0-9]+)_)?(?P<version>\S+)\.so')
-        prgenv = self.prgenv_names[self.current_environ.name]
+        prgenv = self.current_environ.name.split('-')[1]
         cver = self.compiler_version
-        mod_name = self.module_version[self.module_name]
-
+        mod_name = f'nv{self.accel_nvidia_version}'
         if self.current_environ.name == 'PrgEnv-cray':
             cver_sanity = sn.assert_found(regex, self.stdout)
         else:
@@ -67,14 +67,24 @@ def set_sanity(self):
 
 @rfm.simple_test
 class MKLResolveTest(LibSciResolveBaseTest):
-    def __init__(self):
-        super().__init__()
-        self.descr = '-mkl Resolves to MKL'
-        self.valid_prog_environs = ['PrgEnv-intel']
-        self.build_system = 'SingleSource'
+    descr = '-mkl Resolves to MKL'
+    valid_prog_environs = ['PrgEnv-intel']
+    build_system = 'SingleSource'
 
+    @run_before('compile')
+    def set_fflags(self):
         self.build_system.fflags = ['-mkl']
-        self.postbuild_cmds = [f'readelf -d {self.executable}']
+
+    @run_before('compile')
+    def cdt_2105_workaround(self):
+        # FIXME: The mkl libraries are not found in cdt 21.05, CASE #285117
+        if osext.cray_cdt_version() == '21.05':
+            self.build_system.ldflags += [
+                '-L/opt/intel/oneapi/mkl/latest/lib/intel64/'
+            ]
+
+    @run_before('sanity')
+    def set_sanity(self):
         regex = (r'.*\(NEEDED\).*libmkl_(?P<prgenv>[A-Za-z]+)_(?P<version>\S+)'
                  r'\.so')
         self.sanity_patterns = sn.all([
@@ -83,6 +93,3 @@ def __init__(self):
             sn.assert_eq(
                 sn.extractsingle(regex, self.stdout, 'version'), 'lp64')
         ])
-
-        self.maintainers = ['AJ', 'LM']
-        self.tags = {'production', 'craype'}

cscs-checks/libraries/io/hdf5_compile_run.py

@@ -4,38 +4,75 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import reframe as rfm
+import reframe.utility.osext as osext
 import reframe.utility.sanity as sn
 
 
-@rfm.parameterized_test(*([lang, linkage] for lang in ['c', 'f90']
-                          for linkage in ['static', 'dynamic']))
+@rfm.simple_test
 class HDF5Test(rfm.RegressionTest):
-    def __init__(self, lang, linkage):
+    lang = parameter(['c', 'f90'])
+    linkage = parameter(['static', 'dynamic'])
+    valid_systems = ['daint:gpu', 'daint:mc', 'dom:gpu', 'dom:mc']
+    build_system = 'SingleSource'
+    modules = ['cray-hdf5']
+    keep_files = ['h5dump_out.txt']
+    num_tasks = 1
+    num_tasks_per_node = 1
+    postrun_cmds = ['h5dump h5ex_d_chunk.h5 > h5dump_out.txt']
+    maintainers = ['SO', 'RS']
+    tags = {'production', 'craype', 'health'}
+
+    @run_after('init')
+    def set_description(self):
         lang_names = {
             'c': 'C',
             'f90': 'Fortran 90'
         }
-        self.linkage = linkage
-        self.descr = lang_names[lang] + ' HDF5 ' + linkage.capitalize()
-        self.sourcepath = f'h5ex_d_chunk.{lang}'
-        self.valid_systems = ['daint:gpu', 'daint:mc', 'dom:gpu', 'dom:mc']
-        if linkage == 'dynamic':
+        self.descr = (f'{lang_names[self.lang]} HDF5 '
+                      f'{self.linkage.capitalize()}')
+
+    @run_after('init')
+    def set_valid_systems(self):
+        if self.linkage == 'dynamic':
             self.valid_systems += ['eiger:mc', 'pilatus:mc']
 
+    @run_after('init')
+    def set_prog_environs(self):
         if self.current_system.name in ['eiger', 'pilatus']:
-            # no cray-hdf5 as of PE 21.02 with PrgEnv-intel on Eiger and
-            # Pilatus
+            # no cray-hdf5 as of PE 21.02 with PrgEnv-intel on Eiger & Pilatus
             self.valid_prog_environs = ['PrgEnv-aocc', 'PrgEnv-cray',
                                         'PrgEnv-gnu']
         else:
             self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu',
-                                        'PrgEnv-intel', 'PrgEnv-pgi']
+                                        'PrgEnv-intel', 'PrgEnv-pgi',
+                                        'PrgEnv-nvidia']
+
+    @run_after('setup')
+    def cdt_2105_skip(self):
+        # cray-hdf5 is supported only on PrgEnv-nvidia for cdt >= 21.05
+        if self.current_environ.name == 'PrgEnv-nvidia':
+            self.skip_if(
+                osext.cray_cdt_version() < '21.05',
+                "cray-hdf5 is not supported for cdt < 21.05 on PrgEnv-nvidia"
+            )
+        elif self.current_environ.name == 'PrgEnv-pgi':
+            self.skip_if(
+                osext.cray_cdt_version() >= '21.05',
+                "cray-hdf5 is not supported for cdt >= 21.05 on PrgEnv-pgi"
+            )
 
-        self.modules = ['cray-hdf5']
-        self.keep_files = ['h5dump_out.txt']
+    @run_before('compile')
+    def set_sourcepath(self):
+        self.sourcepath = f'h5ex_d_chunk.{self.lang}'
 
+    @run_before('compile')
+    def set_ldflags(self):
+        self.build_system.ldflags = [f'-{self.linkage}']
+
+    @run_before('sanity')
+    def set_sanity(self):
         # C and Fortran write transposed matrix
-        if lang == 'c':
+        if self.lang == 'c':
             self.sanity_patterns = sn.all([
                 sn.assert_found(r'Data as written to disk by hyberslabs',
                                 self.stdout),
@@ -79,12 +116,3 @@ def __init__(self, lang, linkage):
                 sn.assert_found(r'\(7,0\): 1, 1, 0, 1, 1, 0',
                                 'h5dump_out.txt'),
             ])
-
-        self.num_tasks = 1
-        self.num_tasks_per_node = 1
-        self.build_system = 'SingleSource'
-        self.build_system.ldflags = [f'-{linkage}']
-        self.postrun_cmds = ['h5dump h5ex_d_chunk.h5 > h5dump_out.txt']
-
-        self.maintainers = ['SO', 'RS']
-        self.tags = {'production', 'craype', 'health'}

cscs-checks/libraries/io/netcdf_compile_run.py

@@ -6,29 +6,41 @@
 import os
 
 import reframe as rfm
+import reframe.utility.osext as osext
 import reframe.utility.sanity as sn
 
 
-@rfm.parameterized_test(*([lang, linkage] for lang in ['cpp', 'c', 'f90']
-                          for linkage in ['dynamic', 'static']))
+@rfm.simple_test
 class NetCDFTest(rfm.RegressionTest):
-    def __init__(self, lang, linkage):
-        lang_names = {
+    lang = parameter(['cpp', 'c', 'f90'])
+    linkage = parameter(['dynamic', 'static'])
+    valid_systems = ['daint:gpu', 'daint:mc', 'dom:gpu', 'dom:mc',
+                     'arolla:cn', 'tsa:cn']
+    build_system = 'SingleSource'
+    num_tasks = 1
+    num_tasks_per_node = 1
+    maintainers = ['AJ', 'SO']
+    tags = {'production', 'craype', 'external-resources', 'health'}
+    lang_names = {
             'c': 'C',
             'cpp': 'C++',
             'f90': 'Fortran 90'
-        }
-        self.lang = lang
-        self.linkage = linkage
-        self.descr = f'{lang_names[lang]} NetCDF {linkage.capitalize()}'
-        self.valid_systems = ['daint:gpu', 'daint:mc', 'dom:gpu', 'dom:mc',
-                              'arolla:cn', 'tsa:cn']
-        if linkage == 'dynamic':
+    }
+
+    @run_after('init')
+    def set_description(self):
+        self.descr = (f'{self.lang_names[self.lang]} NetCDF '
+                      f'{self.linkage.capitalize()}')
+
+    @run_after('init')
+    def setup_prgenvs(self):
+        if self.linkage == 'dynamic':
             self.valid_systems += ['eiger:mc', 'pilatus:mc']
 
         if self.current_system.name in ['daint', 'dom']:
             self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu',
-                                        'PrgEnv-intel', 'PrgEnv-pgi']
+                                        'PrgEnv-intel', 'PrgEnv-pgi',
+                                        'PrgEnv-nvidia']
             self.modules = ['cray-netcdf']
         elif self.current_system.name in ['arolla', 'tsa']:
             self.exclusive_access = True
@@ -41,15 +53,25 @@ def __init__(self, lang, linkage):
         else:
             self.valid_prog_environs = []
 
+    @run_after('setup')
+    def cdt_2105_skip(self):
+        # cray-netcdf is supported only on PrgEnv-nvidia for cdt >= 21.05
+        if self.current_environ.name == 'PrgEnv-nvidia':
+            self.skip_if(
+                osext.cray_cdt_version() < '21.05',
+                "cray-netcdf is not supported for cdt < 21.05 on PrgEnv-nvidia"
+            )
+        elif self.current_environ.name == 'PrgEnv-pgi':
+            self.skip_if(
+                osext.cray_cdt_version() >= '21.05',
+                "cray-netcdf is not supported for cdt >= 21.05 on PrgEnv-pgi"
+            )
+
+    @run_before('compile')
+    def set_sources(self):
         self.sourcesdir = os.path.join(self.current_system.resourcesdir,
                                        'netcdf')
-        self.build_system = 'SingleSource'
-        self.sourcepath = 'netcdf_read_write.' + lang
-        self.num_tasks = 1
-        self.num_tasks_per_node = 1
-        self.sanity_patterns = sn.assert_found(r'SUCCESS', self.stdout)
-        self.maintainers = ['AJ', 'SO']
-        self.tags = {'production', 'craype', 'external-resources', 'health'}
+        self.sourcepath = f'netcdf_read_write.{self.lang}'
 
     @run_before('compile')
     def setflags(self):
@@ -71,3 +93,7 @@ def setflags(self):
             ]
         else:
             self.build_system.ldflags = [f'-{self.linkage}']
+
+    @run_before('sanity')
+    def set_sanity(self):
+        self.sanity_patterns = sn.assert_found(r'SUCCESS', self.stdout)

cscs-checks/microbenchmarks/gpu/kernel_latency/kernel_latency.py

@@ -65,8 +65,8 @@ class gpu_kernel_latency_check(GpuKernelLatency):
     def set_valid_prog_environs(self):
         cs = self.current_system.name
         if cs in {'dom', 'daint'}:
-            self.valid_prog_environs = ['PrgEnv-cray',
-                                        'PrgEnv-pgi', 'PrgEnv-gnu']
+            self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-pgi',
+                                        'PrgEnv-gnu', 'PrgEnv-nvidia']
         elif cs in {'arolla', 'tsa'}:
             self.valid_prog_environs = ['PrgEnv-pgi']
         elif cs in {'ault'}:

cscs-checks/prgenv/cpu_target_check.py

@@ -9,15 +9,17 @@
 
 @rfm.simple_test
 class CrayCPUTargetTest(rfm.RunOnlyRegressionTest):
-    def __init__(self):
-        self.descr = 'Checks whether CRAY_CPU_TARGET is set'
-        self.valid_systems = ['daint:login', 'dom:login']
-        self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu',
-                                    'PrgEnv-intel', 'PrgEnv-pgi']
-        self.sourcesdir = None
-        self.executable = 'echo CRAY_CPU_TARGET=$CRAY_CPU_TARGET'
+    descr = 'Checks whether CRAY_CPU_TARGET is set'
+    valid_systems = ['daint:login', 'dom:login', 'eiger:login',
+                     'pilatus:login']
+    valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu', 'PrgEnv-intel',
+                           'PrgEnv-pgi', 'PrgEnv-nvidia']
+    sourcesdir = None
+    executable = 'echo CRAY_CPU_TARGET=$CRAY_CPU_TARGET'
+    maintainers = ['TM', 'LM']
+    tags = {'production', 'maintenance', 'craype'}
+
+    @run_before('sanity')
+    def set_sanity(self):
         self.sanity_patterns = sn.assert_found(r'CRAY_CPU_TARGET=\S+',
                                                self.stdout)
-
-        self.maintainers = ['TM', 'LM']
-        self.tags = {'production', 'maintenance', 'craype'}