Merge pull request #449 from teojgo/regression_test/prgenv_build_systems

[test] Adapt prgenv test to build systems

Author: vkarak

cscs-checks/prgenv/environ_check.py

@@ -1,14 +1,12 @@
-import os
+import reframe as rfm
 
-from reframe.core.pipeline import RunOnlyRegressionTest
 from reframe.core.runtime import runtime
 
 
-class DefaultPrgEnvCheck(RunOnlyRegressionTest):
-    def __init__(self, **kwargs):
-        super().__init__('default_prgenv_check',
-                         os.path.dirname(__file__), **kwargs)
-
+@rfm.simple_test
+class DefaultPrgEnvCheck(rfm.RunOnlyRegressionTest):
+    def __init__(self):
+        super().__init__()
         self.descr = 'Ensure PrgEnv-cray is loaded by default'
         self.valid_prog_environs = ['PrgEnv-cray']
         self.valid_systems = ['daint:login', 'dom:login']
@@ -37,10 +35,10 @@ def cleanup(self, remove_files=False, unload_env=True):
         pass
 
 
-class EnvironmentCheck(RunOnlyRegressionTest):
-    def __init__(self, **kwargs):
-        super().__init__('environ_load_check',
-                         os.path.dirname(__file__), **kwargs)
+@rfm.simple_test
+class EnvironmentCheck(rfm.RunOnlyRegressionTest):
+    def __init__(self):
+        super().__init__()
         self.descr = 'Ensure programming environment is loaded correctly'
         self.valid_systems = ['daint:login', 'dom:login', 'kesch:login']
         self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu', 'PrgEnv-pgi']
@@ -55,7 +53,3 @@ def __init__(self, **kwargs):
     def check_sanity(self):
         return runtime().modules_system.is_module_loaded(
             self.current_environ.name)
-
-
-def _get_checks(**kwargs):
-    return [DefaultPrgEnvCheck(**kwargs), EnvironmentCheck(**kwargs)]

cscs-checks/prgenv/openacc_checks.py

@@ -1,50 +1,49 @@
-import os
-
+import reframe as rfm
 import reframe.utility.sanity as sn
-from reframe.core.pipeline import RegressionTest
 
-class OpenACCFortranCheck(RegressionTest):
-    def __init__(self, num_tasks, **kwargs):
+
+@rfm.parameterized_test([1], [2])
+class OpenACCFortranCheck(rfm.RegressionTest):
+    def __init__(self, num_tasks):
+        super().__init__()
         if num_tasks == 1:
-            check_name = 'openacc_fortran_check'
+            self.name = 'openacc_fortran_check'
+            self.descr = 'OpenACC Fortran check'
         else:
-            check_name = 'openacc_mpi_fortran_check'
-        super().__init__(check_name,
-                         os.path.dirname(__file__), **kwargs)
+            self.name = 'openacc_mpi_fortran_check'
+            self.descr = 'OpenACC+MPI Fortran check'
+
         self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn']
         self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-pgi']
-        if self.current_system.name in ['daint', 'dom']:
-            self.modules = ['craype-accel-nvidia60']
-            self._pgi_flags = '-acc -ta=tesla:cc60'
-        elif self.current_system.name in ['kesch']:
-            self.modules = ['craype-accel-nvidia35']
-            self._pgi_flags = '-acc -ta=tesla:cc35'
-
         self.num_tasks = num_tasks
         if self.num_tasks == 1:
             self.sourcepath = 'vecAdd_openacc.f90'
         else:
             self.sourcepath = 'vecAdd_openacc_mpi.f90'
+
+        if self.current_system.name in ['daint', 'dom']:
+            self.modules = ['craype-accel-nvidia60']
+        elif self.current_system.name == 'kesch':
+            self.modules = ['craype-accel-nvidia35']
+
+        self.build_system = 'SingleSource'
         self.num_gpus_per_node = 1
         self.executable = self.name
         self.num_tasks_per_node = 1
-
         result = sn.extractsingle(r'final result:\s+(?P<result>\d+\.?\d*)',
-            self.stdout, 'result', float)
+                                  self.stdout, 'result', float)
         self.sanity_patterns = sn.assert_reference(result, 1., -1e-5, 1e-5)
 
         self.maintainers = ['TM', 'VK']
         self.tags = {'production'}
 
     def setup(self, partition, environ, **job_opts):
         if environ.name == 'PrgEnv-cray':
-            environ.fflags = '-hacc -hnoomp'
+            self.build_system.fflags = ['-hacc', '-hnoomp']
         elif environ.name == 'PrgEnv-pgi':
-            environ.fflags = self._pgi_flags
+            if self.current_system.name in ['daint', 'dom']:
+                self.build_system.fflags = ['-acc', '-ta=tesla:cc60']
+            else:
+                self.build_system.fflags = ['-acc', '-ta=tesla:cc35']
 
         super().setup(partition, environ, **job_opts)
-
-
-def _get_checks(**kwargs):
-    return [OpenACCFortranCheck(1, **kwargs),
-            OpenACCFortranCheck(2, **kwargs)]

cscs-checks/prgenv/ulimit_check.py

@@ -1,29 +1,21 @@
-import os
-
+import reframe as rfm
 import reframe.utility.sanity as sn
-from reframe.core.pipeline import RegressionTest
-
 
-class UlimitCheck(RegressionTest):
 
-    def __init__(self, **kwargs):
-        super().__init__('ulimit_check', os.path.dirname(__file__), **kwargs)
+@rfm.simple_test
+class UlimitCheck(rfm.RegressionTest):
+    def __init__(self):
+        super().__init__()
         self.descr = 'Checking the output of ulimit -s in node.'
-
         self.valid_systems = ['daint:gpu', 'daint:mc',
                               'dom:gpu',   'dom:mc']
         self.valid_prog_environs = ['PrgEnv-cray',  'PrgEnv-gnu',
                                     'PrgEnv-intel', 'PrgEnv-pgi']
         self.sourcepath = 'ulimit.c'
-        self.tags = {'production', 'scs'}
-
         self.sanity_patterns = sn.all([
             sn.assert_found(r'The soft limit is unlimited', self.stdout),
             sn.assert_found(r'The hard limit is unlimited', self.stdout),
         ])
 
         self.maintainers = ['RS', 'VK']
-
-
-def _get_checks(**kwargs):
-    return [UlimitCheck(**kwargs)]
+        self.tags = {'production', 'scs'}