Merge branch 'master' into regresstion_test/gpu_bandwidth_build_systems

vkarak · web-flow · commit fe31d9d8c197 · 2018-09-06T13:11:57.000+02:00
diff --git a/cscs-checks/prgenv/helloworld.py b/cscs-checks/prgenv/helloworld.py
@@ -1,15 +1,12 @@
-import os
 from datetime import datetime
 
+import reframe as rfm
 import reframe.utility.sanity as sn
-from reframe.core.pipeline import RegressionTest
 
 
-class HelloWorldBaseTest(RegressionTest):
-    def __init__(self, name, lang, linkage, **kwargs):
-        super().__init__('hello_world_%s_%s_%s' % (name, linkage, lang),
-                         os.path.dirname(__file__), **kwargs)
-
+class HelloWorldBaseTest(rfm.RegressionTest):
+    def __init__(self, variant, lang, linkage):
+        super().__init__()
         if self.current_system.name in ['dom', 'daint']:
             self.modules += ['gcc/6.1.0']
 
@@ -20,10 +17,9 @@ def __init__(self, name, lang, linkage, **kwargs):
             'cpp': 'C++',
             'f90': 'Fortran 90'
         }
-
         self.descr = self.lang_names[lang] + ' Hello World'
         self.sourcepath = 'hello_world'
-
+        self.build_system = 'SingleSource'
         self.valid_systems = ['daint:gpu', 'daint:mc', 'dom:gpu', 'dom:mc',
                               'kesch:cn', 'kesch:pn', 'leone:normal',
                               'monch:compute']
@@ -49,18 +45,30 @@ def setup(self, partition, environ, **job_opts):
         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.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),
                      )
         )
 
@@ -73,46 +81,51 @@ def setup(self, partition, environ, **job_opts):
             }
         }
         super().setup(partition, environ, **job_opts)
-
-    def compile(self):
         prgenv_flags = self.prgenv_flags[self.current_environ.name]
-        self.current_environ.cflags = prgenv_flags
-        self.current_environ.cxxflags = prgenv_flags
-        self.current_environ.fflags = prgenv_flags
+        self.build_system.cflags = prgenv_flags
+        self.build_system.cxxflags = prgenv_flags
+        self.build_system.fflags = prgenv_flags
 
+    def compile(self):
         self.compilation_time_seconds = datetime.now()
         super().compile()
         self.compilation_time_seconds = (
             datetime.now() - self.compilation_time_seconds).total_seconds()
 
 
+@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)
 
         self.sourcepath += '_serial.' + lang
         self.descr += ' Serial ' + linkage.capitalize()
         self.prgenv_flags = {
-            'PrgEnv-cray': '',
-            'PrgEnv-gnu': '',
-            'PrgEnv-intel': '',
-            'PrgEnv-pgi': ''
+            'PrgEnv-cray': [],
+            'PrgEnv-gnu': [],
+            'PrgEnv-intel': [],
+            'PrgEnv-pgi': []
         }
         self.num_tasks = 1
         self.num_tasks_per_node = 1
         self.num_cpus_per_task = 1
 
 
+@rfm.parameterized_test(*([lang, linkage]
+                          for lang in ['cpp', 'c', 'f90']
+                          for linkage in ['dynamic', 'static']))
 class HelloWorldTestOpenMP(HelloWorldBaseTest):
-    def __init__(self, lang, linkage, **kwargs):
-        super().__init__('openmp', lang, linkage, **kwargs)
+    def __init__(self, lang, linkage):
+        super().__init__('openmp', lang, linkage)
         self.sourcepath += '_openmp.' + lang
         self.descr += ' OpenMP ' + str.capitalize(linkage)
         self.prgenv_flags = {
-            'PrgEnv-cray': ' -homp ',
-            'PrgEnv-gnu': ' -fopenmp ',
-            'PrgEnv-intel': ' -qopenmp ',
-            'PrgEnv-pgi': ' -mp '
+            'PrgEnv-cray': ['-homp'],
+            'PrgEnv-gnu': ['-fopenmp'],
+            'PrgEnv-intel': ['-qopenmp'],
+            'PrgEnv-pgi': ['-mp']
         }
         self.num_tasks = 1
         self.num_tasks_per_node = 1
@@ -125,16 +138,19 @@ def __init__(self, lang, linkage, **kwargs):
         }
 
 
+@rfm.parameterized_test(*([lang, linkage]
+                          for lang in ['cpp', 'c', 'f90']
+                          for linkage in ['dynamic', 'static']))
 class HelloWorldTestMPI(HelloWorldBaseTest):
-    def __init__(self, lang, linkage, **kwargs):
-        super().__init__('mpi', lang, linkage, **kwargs)
+    def __init__(self, lang, linkage):
+        super().__init__('mpi', lang, linkage)
         self.sourcepath += '_mpi.' + lang
         self.descr += ' MPI ' + linkage.capitalize()
         self.prgenv_flags = {
-            'PrgEnv-cray': '',
-            'PrgEnv-gnu': '',
-            'PrgEnv-intel': '',
-            'PrgEnv-pgi': ''
+            'PrgEnv-cray': [],
+            'PrgEnv-gnu': [],
+            'PrgEnv-intel': [],
+            'PrgEnv-pgi': []
         }
 
         # for the MPI test the self.num_tasks_per_node should always be one. If
@@ -145,16 +161,19 @@ def __init__(self, lang, linkage, **kwargs):
         self.num_cpus_per_task = 1
 
 
+@rfm.parameterized_test(*([lang, linkage]
+                          for lang in ['cpp', 'c', 'f90']
+                          for linkage in ['dynamic', 'static']))
 class HelloWorldTestMPIOpenMP(HelloWorldBaseTest):
-    def __init__(self, lang, linkage, **kwargs):
-        super().__init__('mpi_openmp', lang, linkage, **kwargs)
+    def __init__(self, lang, linkage):
+        super().__init__('mpi_openmp', lang, linkage)
         self.sourcepath += '_mpi_openmp.' + lang
         self.descr += ' MPI + OpenMP ' + linkage.capitalize()
         self.prgenv_flags = {
-            'PrgEnv-cray': ' -homp ',
-            'PrgEnv-gnu': ' -fopenmp ',
-            'PrgEnv-intel': ' -qopenmp ',
-            'PrgEnv-pgi': ' -mp '
+            'PrgEnv-cray': ['-homp'],
+            'PrgEnv-gnu': ['-fopenmp'],
+            'PrgEnv-intel': ['-qopenmp'],
+            'PrgEnv-pgi': ['-mp']
         }
         self.num_tasks = 6
         self.num_tasks_per_node = 3
@@ -165,22 +184,3 @@ def __init__(self, lang, linkage, **kwargs):
         self.variables = {
             'OMP_NUM_THREADS': str(self.num_cpus_per_task)
         }
-
-
-class HelloWorldTestFactory():
-    def create(lang, variant, linkage, **kwargs):
-        if variant == 'serial':
-            return HelloWorldTestSerial(lang, linkage, **kwargs)
-        elif variant == 'openmp':
-            return HelloWorldTestOpenMP(lang, linkage, **kwargs)
-        elif variant == 'mpi':
-            return HelloWorldTestMPI(lang, linkage, **kwargs)
-        elif variant == 'mpi_openmp':
-            return HelloWorldTestMPIOpenMP(lang, linkage, **kwargs)
-
-
-def _get_checks(**kwargs):
-    return [HelloWorldTestFactory.create(lang, variant, linkage, **kwargs)
-            for lang in ['cpp', 'c', 'f90']
-            for variant in ['serial', 'openmp', 'mpi', 'mpi_openmp']
-            for linkage in ['dynamic', 'static']]
diff --git a/cscs-checks/tools/profiling_and_debugging/perftools.py b/cscs-checks/tools/profiling_and_debugging/perftools.py
@@ -1,13 +1,13 @@
 import os
-import reframe.utility.sanity as sn
 
-from reframe.core.pipeline import RegressionTest
+import reframe as rfm
+import reframe.utility.sanity as sn
 
 
-class PerftoolsCheck(RegressionTest):
-    def __init__(self, lang, **kwargs):
-        super().__init__('perftools_check_' + lang.replace('+', 'p'),
-                         os.path.dirname(__file__), **kwargs)
+@rfm.parameterized_test(*([lang] for lang in ['C', 'Cpp', 'F90', 'Cuda']))
+class PerftoolsCheck(rfm.RegressionTest):
+    def __init__(self, lang):
+        super().__init__()
         if lang == 'Cuda':
             self.valid_systems = ['daint:gpu', 'dom:gpu']
         else:
@@ -22,48 +22,53 @@ def __init__(self, lang, **kwargs):
             # FIXME: PGI Fortran is hanging after completion
             self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu']
 
+        # 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, 1, 0)
+
         self.num_gpus_per_node = 1
         self.executable = 'perftools_check'
-
         self.prgenv_flags = {
-            'PrgEnv-cray':  ' -h nomessage=3140 -homp ',
-            'PrgEnv-gnu':   ' -fopenmp ',
-            'PrgEnv-intel': ' -openmp ',
-            'PrgEnv-pgi':   ' -mp ',
+            'PrgEnv-cray': ['-g', '-h nomessage=3140', '-homp'],
+            'PrgEnv-gnu': ['-g', '-fopenmp'],
+            'PrgEnv-intel': ['-g', '-openmp'],
+            'PrgEnv-pgi': ['-g', '-mp']
         }
-
         if self.current_system.name == 'kesch':
             # `-lcudart -lm` must be passed explicitly on kesch
-            self.prgenv_flags['PrgEnv-gnu'] = ' -fopenmp -lcudart -lm '
+            self.prgenv_flags['PrgEnv-gnu'] = ['-fopenmp', '-lcudart', '-lm']
 
         self.sanity_patterns = sn.assert_found('Table 1:  Profile by Function',
                                                self.stdout)
-        self.modules  = ['perftools-base', 'perftools-lite', 'cudatoolkit']
-        self.makefile = 'Makefile_perftools'
-        self.sourcesdir = os.path.join('src', lang)
-        self.maintainers = ['MK', 'JG']
-        self.tags = {'production'}
+
+        self.modules = ['perftools-lite', 'craype-accel-nvidia60']
+        self.build_system = 'Make'
+        self.build_system.makefile = 'Makefile_perftools'
+        self.build_system.cppflags = ['-D_CSCS_ITMAX=1', '-DUSE_MPI']
+        self.build_system.options = ['NVCCFLAGS="-arch=sm_60"']
+
+        if lang == 'Cpp':
+            self.sourcesdir = os.path.join('src', 'C++')
+        else:
+            self.sourcesdir = os.path.join('src', lang)
+
+        # NOTE: Restrict concurrency to allow creation of Fortran modules
+        if lang == 'F90':
+            self.build_system.max_concurrency = 1
 
         if lang != 'Cuda':
             self.num_tasks_per_node = 2
             self.variables = {'OMP_NUM_THREADS': '2'}
         else:
             self.num_tasks_per_node = 1
 
-    def compile(self):
-        self.flags = ' -g -D_CSCS_ITMAX=1 -DUSE_MPI '
-        prgenv_flags = self.prgenv_flags[self.current_environ.name]
-        self.current_environ.cflags    = self.flags + prgenv_flags
-        self.current_environ.cxxflags  = self.flags + prgenv_flags
-        self.current_environ.fflags    = self.flags + prgenv_flags
-        self.current_environ.ldflags   = self.flags + prgenv_flags
-        super().compile(makefile=self.makefile,
-                        options='NVCCFLAGS="-arch=sm_60"')
-
-
-def _get_checks(**kwargs):
-    ret = []
-    for lang in ['C', 'C++', 'F90', 'Cuda']:
-        ret.append(PerftoolsCheck(lang, **kwargs))
+        self.maintainers = ['MK', 'JG']
+        self.tags = {'production'}
 
-    return ret
+    def setup(self, environ, partition, **job_opts):
+        super().setup(environ, partition, **job_opts)
+        flags = self.prgenv_flags[self.current_environ.name]
+        self.build_system.cflags = flags
+        self.build_system.cxxflags = flags
+        self.build_system.fflags = flags
+        self.build_system.ldflags = flags
diff --git a/cscs-checks/tools/profiling_and_debugging/src/C++/Makefile_perftools b/cscs-checks/tools/profiling_and_debugging/src/C++/Makefile_perftools
@@ -7,7 +7,7 @@ LIB            =
 .SUFFIXES: .o .cc
 
 %.o: %.cc
-	$(CXX) $(CXXFLAGS) -c $< -o $(PE_ENV)$@
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $< -o $(PE_ENV)$@
 
 perftools_check: $(OBJ)
 	$(LD) $(LDFLAGS) $(OBJ2) $(LIB) -o $@
diff --git a/cscs-checks/tools/profiling_and_debugging/src/C/Makefile_perftools b/cscs-checks/tools/profiling_and_debugging/src/C/Makefile_perftools
@@ -7,7 +7,7 @@ LIB            =
 .SUFFIXES: .o .c
 
 %.o: %.c
-	$(CC) $(CFLAGS) -c $< -o $(PE_ENV)$@
+	$(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $(PE_ENV)$@
 
 perftools_check: $(OBJ)
 	$(LD) $(LDFLAGS) $(OBJ2) $(LIB) -o $@
diff --git a/cscs-checks/tools/profiling_and_debugging/src/Cuda/Makefile_perftools b/cscs-checks/tools/profiling_and_debugging/src/Cuda/Makefile_perftools
@@ -12,7 +12,7 @@ LIB            =
 .SUFFIXES: .o .c
 
 %.o: %.c
-	$(CC) $(CFLAGS) $(DDTFLAGS) -c $< -o $(PE_ENV)$@
+	$(CC) $(CPPFLAGS) $(CFLAGS) $(DDTFLAGS) -c $< -o $(PE_ENV)$@
 
 perftools_check: $(OBJ)
 	$(LD) $(LDFLAGS) $(OBJ2) $(LIB) -o $@
diff --git a/cscs-checks/tools/profiling_and_debugging/src/F90/Makefile_perftools b/cscs-checks/tools/profiling_and_debugging/src/F90/Makefile_perftools
@@ -7,7 +7,7 @@ LIB            =
 .SUFFIXES: .o .F90
 
 %.o: %.F90
-	$(FC) $(FFLAGS) -c $< -o $(PE_ENV)$@
+	$(FC) $(CPPFLAGS) $(FFLAGS) -c $< -o $(PE_ENV)$@
 
 perftools_check: $(OBJ)
 	$(LD) $(LDFLAGS) $(OBJ2) $(LIB) -o $@
diff --git a/reframe/core/pipeline.py b/reframe/core/pipeline.py
@@ -21,7 +21,7 @@
 import reframe.utility.os_ext as os_ext
 from reframe.core.buildsystems import BuildSystem, BuildSystemField
 from reframe.core.deferrable import deferrable, _DeferredExpression, evaluate
-from reframe.core.environments import Environment
+from reframe.core.environments import Environment, EnvironmentSnapshot
 from reframe.core.exceptions import (BuildError, PipelineError, SanityError,
                                      user_deprecation_warning)
 from reframe.core.launchers.registry import getlauncher
@@ -775,12 +775,16 @@ def _setup_environ(self, environ):
         for k, v in self.variables.items():
             self._current_environ.set_variable(k, v)
 
+        # Temporarily load the test's environment to record the actual module
+        # load/unload sequence
+        environ_save = EnvironmentSnapshot()
         # First load the local environment of the partition
         self.logger.debug('loading environment for the current partition')
         self._current_partition.local_env.load()
 
         self.logger.debug("loading test's environment")
         self._current_environ.load()
+        environ_save.load()
 
     def _setup_paths(self):
         """Setup the check's dynamic paths."""
diff --git a/reframe/frontend/cli.py b/reframe/frontend/cli.py
@@ -319,8 +319,8 @@ def main():
         for d in options.checkpath:
             d = os.path.expandvars(d)
             if not os.path.exists(d):
-                printer.info("%s: path `%s' does not exist. Skipping...\n" %
-                             (argparser.prog, d))
+                printer.warning("%s: path `%s' does not exist. Skipping..." %
+                                (argparser.prog, d))
                 continue
 
             load_path.append(d)
diff --git a/unittests/test_pipeline.py b/unittests/test_pipeline.py
