Merge branch 'master' into bugfix/unittest_module_cleanup

Author: Vasileios Karakasis

.github/workflows/main.yml

@@ -37,7 +37,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        modules-version: [Lmod, Tmod32, Tmod4]
+        modules-version: [Lmod, Lmod77, Tmod32, Tmod4]
     steps:
     - uses: actions/checkout@v2
     - name: Build Image for ${{ matrix.modules-version }}

ci-scripts/ci-runner.bash

@@ -126,7 +126,7 @@ if [ "X${MODULEUSE}" != "X" ]; then
 fi
 
 parallel_opts="--workers=auto --forked"
-if [[ $(hostname) =~ tsa ]]; then
+if [[ $(hostname) =~ tsa|uan ]]; then
     parallel_opts=""
 fi
 

ci-scripts/dockerfiles/Lmod77.dockerfile

@@ -0,0 +1,52 @@
+#
+# Execute this from the top-level ReFrame source directory
+#
+
+#
+# LMod versions prior to 8.2 emitted Python commands differently, so we use this
+# Dockerfile to test the bindings of older versions
+#
+
+
+FROM ubuntu:20.04
+
+ENV TZ=Europe/Zurich
+ENV DEBIAN_FRONTEND=noninteractive
+ENV _LMOD_VER=7.7
+
+# ReFrame user
+RUN useradd -ms /bin/bash rfmuser
+
+# ReFrame requirements
+RUN \
+  apt-get -y update && \
+  apt-get -y install ca-certificates && \
+  update-ca-certificates && \
+  apt-get -y install gcc && \
+  apt-get -y install make && \
+  apt-get -y install git && \
+  apt-get -y install python3 python3-pip
+
+# Required utilities
+RUN apt-get -y install wget
+
+# Install Lmod
+RUN \
+  apt-get -y install lua5.3 lua-bit32:amd64 lua-posix:amd64 lua-posix-dev liblua5.3-0:amd64 liblua5.3-dev:amd64 tcl tcl-dev tcl8.6 tcl8.6-dev:amd64 libtcl8.6:amd64 lua-filesystem:amd64 lua-filesystem-dev:amd64 && \
+  wget -q https://github.com/TACC/Lmod/archive/${_LMOD_VER}.tar.gz -O lmod.tar.gz && \
+  tar xzf lmod.tar.gz && \
+  cd Lmod-${_LMOD_VER} && \
+  ./configure && make install
+
+ENV BASH_ENV=/usr/local/lmod/lmod/init/profile
+
+USER rfmuser
+
+# Install ReFrame from the current directory
+COPY --chown=rfmuser . /home/rfmuser/reframe/
+
+WORKDIR /home/rfmuser/reframe
+
+RUN ./bootstrap.sh
+
+CMD ["/bin/bash", "-c", "./test_reframe.py --rfm-user-config=ci-scripts/configs/lmod.py -v"]

cscs-checks/apps/gromacs/gromacs_check.py

@@ -4,7 +4,6 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import contextlib
-import itertools
 import os
 
 import reframe as rfm
@@ -100,27 +99,37 @@ def __init__(self, scale, variant):
 class GromacsCPUCheck(GromacsBaseCheck):
     def __init__(self, scale, variant):
         super().__init__('md.log')
-        self.valid_systems = ['daint:mc']
+        self.valid_systems = ['daint:mc', 'eiger:mc']
         self.descr = 'GROMACS CPU check'
         self.executable_opts = ['mdrun', '-dlb yes', '-ntomp 1', '-npme -1',
                                 '-nb cpu', '-s herflat.tpr']
 
         if scale == 'small':
             self.valid_systems += ['dom:mc']
-            self.num_tasks = 216
-            self.num_tasks_per_node = 36
+            if (self.current_system.name in ['daint', 'dom']):
+                self.num_tasks = 216
+                self.num_tasks_per_node = 36
+            elif (self.current_system.name in ['eiger']):
+                self.num_tasks = 768
+                self.num_tasks_per_node = 128
         else:
-            self.num_tasks = 576
-            self.num_tasks_per_node = 36
+            if (self.current_system.name in ['daint', 'dom']):
+                self.num_tasks = 576
+                self.num_tasks_per_node = 36
+            elif (self.current_system.name in ['eiger']):
+                self.num_tasks = 2048
+                self.num_tasks_per_node = 128
 
         references = {
             'prod': {
                 'small': {
                     'dom:mc': {'perf': (40.0, -0.05, None, 'ns/day')},
-                    'daint:mc': {'perf': (38.8, -0.10, None, 'ns/day')}
+                    'daint:mc': {'perf': (38.8, -0.10, None, 'ns/day')},
+                    'eiger:mc': {'perf': (103.00, -0.10, None, 'ns/day')}
                 },
                 'large': {
-                    'daint:mc': {'perf': (68.0, -0.20, None, 'ns/day')}
+                    'daint:mc': {'perf': (68.0, -0.20, None, 'ns/day')},
+                    'eiger:mc': {'perf': (146.00, -0.20, None, 'ns/day')}
                 }
             },
         }

reframe/core/logging.py

@@ -247,8 +247,10 @@ def _create_file_handler(site_config, config_prefix):
 
 
 def _create_filelog_handler(site_config, config_prefix):
-    basedir = os.path.abspath(site_config.get(f'{config_prefix}/basedir'))
-    prefix  = site_config.get(f'{config_prefix}/prefix')
+    basedir = os.path.abspath(
+        osext.expandvars(site_config.get(f'{config_prefix}/basedir'))
+    )
+    prefix  = osext.expandvars(site_config.get(f'{config_prefix}/prefix'))
     filename_patt = os.path.join(basedir, prefix)
     append = site_config.get(f'{config_prefix}/append')
     return MultiFileHandler(filename_patt, mode='a+' if append else 'w+')

reframe/core/modules.py

@@ -492,6 +492,21 @@ def emit_load_instr(self, module):
     def emit_unload_instr(self, module):
         '''Emit the instruction that unloads module.'''
 
+    def process(self, source):
+        '''Process the Python source emitted by the Python bindings of the
+        different backends.
+
+        Backends should call this before executing any Python commands.
+
+        :arg source: The Python source code to be executed.
+        :returns: The modified Python source code to be executed. By default
+            ``source`` is returned unchanged.
+
+        .. versionadded:: 3.4
+
+        '''
+        return source
+
     def __repr__(self):
         return type(self).__name__ + '()'
 
@@ -562,7 +577,7 @@ def _execute(self, cmd, *args):
                                       completed.stderr,
                                       completed.returncode)
 
-        exec(completed.stdout)
+        exec(self.process(completed.stdout))
         return completed.stderr
 
     def available_modules(self, substr):
@@ -692,7 +707,7 @@ def _execute(self, cmd, *args):
         with open(exec_match.group(1), 'r') as content_file:
             cmd = content_file.read()
 
-        exec(cmd)
+        exec(self.process(cmd))
         return completed.stderr
 
 
@@ -729,6 +744,7 @@ def __init__(self):
                 (version, self.MIN_VERSION))
 
         self._version = version
+        self._extra_module_paths = []
 
     def name(self):
         return 'tmod4'
@@ -740,7 +756,7 @@ def _execute(self, cmd, *args):
         modulecmd = self.modulecmd(cmd, *args)
         completed = osext.run_command(modulecmd, check=False)
         namespace = {}
-        exec(completed.stdout, {}, namespace)
+        exec(self.process(completed.stdout), {}, namespace)
 
         # _mlstatus is set by the TMod4 only if the command was unsuccessful,
         # but Lmod sets it always
@@ -755,6 +771,15 @@ def _execute(self, cmd, *args):
     def load_module(self, module):
         if module.collection:
             self.execute('restore', str(module))
+
+            # Here the module search path removal/addition is repeated since
+            # 'restore' discards previous module path manipulations
+            for op, mp in self._extra_module_paths:
+                if op == '+':
+                    super().searchpath_add(mp)
+                else:
+                    super().searchpath_remove(mp)
+
             return []
         else:
             return super().load_module(module)
@@ -777,7 +802,15 @@ def conflicted_modules(self, module):
 
     def emit_load_instr(self, module):
         if module.collection:
-            return f'module restore {module}'
+            cmds = [f'module restore {module}']
+
+            # Here we append module searchpath removal/addition commands
+            # since 'restore' discards previous module path manipulations
+            for op, mp in self._extra_module_paths:
+                operation = 'use' if op == '+' else 'unuse'
+                cmds += [f'module {operation} {mp}']
+
+            return '\n'.join(cmds)
 
         return super().emit_load_instr(module)
 
@@ -787,6 +820,18 @@ def emit_unload_instr(self, module):
 
         return super().emit_unload_instr(module)
 
+    def searchpath_add(self, *dirs):
+        if dirs:
+            self._extra_module_paths += [('+', mp) for mp in dirs]
+
+        super().searchpath_add(*dirs)
+
+    def searchpath_remove(self, *dirs):
+        if dirs:
+            self._extra_module_paths += [('-', mp) for mp in dirs]
+
+        super().searchpath_remove(*dirs)
+
 
 class LModImpl(TMod4Impl):
     '''Module system for Lmod (Tcl/Lua).'''
@@ -821,9 +866,22 @@ def __init__(self):
             raise ConfigError('Python is not supported by '
                               'this Lmod installation')
 
+        self._extra_module_paths = []
+
     def name(self):
         return 'lmod'
 
+    def process(self, source):
+        major, minor, *_ = self.version().split('.')
+        major, minor = int(major), int(minor)
+        if (major, minor) < (8, 2):
+            # Older Lmod versions do not emit an `import os` and emit an
+            # invalid `false` statement in case of errors; we fix these here
+            return 'import os\n\n' + source.replace('false',
+                                                    '_mlstatus = False')
+
+        return source
+
     def modulecmd(self, *args):
         return ' '.join([self._lmod_cmd, 'python', *args])
 
@@ -865,20 +923,6 @@ def conflicted_modules(self, module):
 
         return ret
 
-    def load_module(self, module):
-        if module.collection:
-            self.execute('restore', str(module))
-            return []
-        else:
-            return super().load_module(module)
-
-    def unload_module(self, module):
-        if module.collection:
-            # Module collection are not unloaded
-            return
-
-        super().unload_module(module)
-
     def unload_all(self):
         # Currently, we don't take any provision for sticky modules in Lmod, so
         # we forcefully unload everything.

unittests/test_cli.py

@@ -364,8 +364,22 @@ def test_performance_check_failure(run_reframe, tmp_path, perflogdir):
                           'default' / 'PerformanceFailureCheck.log')
 
 
-def test_performance_report(run_reframe):
+def test_perflogdir_from_env(run_reframe, tmp_path, monkeypatch):
+    monkeypatch.setenv('FOODIR', str(tmp_path / 'perflogs'))
     returncode, stdout, stderr = run_reframe(
+        checkpath=['unittests/resources/checks/frontend_checks.py'],
+        more_options=['-t', 'PerformanceFailureCheck'],
+        perflogdir='$FOODIR'
+    )
+    assert returncode == 1
+    assert 'Traceback' not in stdout
+    assert 'Traceback' not in stderr
+    assert os.path.exists(tmp_path / 'perflogs' / 'generic' /
+                          'default' / 'PerformanceFailureCheck.log')
+
+
+def test_performance_report(run_reframe):
+    returncode, stdout, _ = run_reframe(
         checkpath=['unittests/resources/checks/frontend_checks.py'],
         more_options=['-t', 'PerformanceFailureCheck', '--performance-report']
     )

unittests/test_modules.py

@@ -3,17 +3,13 @@
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
-import abc
 import os
 import pytest
 
 import reframe.core.environments as env
 import reframe.core.modules as modules
-import reframe.utility as util
-import reframe.utility.osext as osext
 import unittests.fixtures as fixtures
-from reframe.core.exceptions import (ConfigError, EnvironError)
-from reframe.core.runtime import runtime
+from reframe.core.exceptions import ConfigError, EnvironError
 
 
 @pytest.fixture(params=['tmod', 'tmod4', 'lmod', 'nomod'])
@@ -130,6 +126,18 @@ def test_module_load_force_collection(modules_system, module_collection):
     assert modules_system.is_module_loaded('testmod_foo')
 
 
+def test_module_load_collection_searchpath(modules_system, tmpdir,
+                                           module_collection):
+    p1 = str(tmpdir.mkdir('path1'))
+    p2 = str(tmpdir.mkdir('path2'))
+    modules_system.searchpath_add(p1)
+    modules_system.searchpath_add(p2)
+    modules_system.searchpath_remove(p1)
+    modules_system.load_module(module_collection, collection=True)
+    assert p1 not in modules_system.searchpath
+    assert p2 in modules_system.searchpath
+
+
 def test_module_unload_all(modules_system):
     if modules_system.name == 'nomod':
         modules_system.unload_all()