Merge branch 'master' into qe-eiger

Author: Vasileios Karakasis

.github/workflows/main.yml

@@ -59,3 +59,25 @@ jobs:
         VALIDATE_ALL_CODEBASE: false
         VALIDATE_PYTHON_FLAKE8: true
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  wheelvalidation:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup up Python 3.8
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.8
+      - name: Bootstrap ReFrame
+        run: |
+          ./bootstrap.sh
+      - name: Generate Wheel
+        run: |
+          python -m pip install --upgrade pip setuptools wheel twine
+          PYTHONPATH=$PWD/external:$PYTHONPATH python setup.py sdist bdist_wheel
+      - name: Install Wheel
+        run: |
+          python -m pip install dist/ReFrame_HPC*.whl
+      - name: Test Installation
+        run: |
+          reframe -V

README.md

@@ -27,10 +27,12 @@ The stages of this pipeline take care of all the system interaction details, suc
 Writing system regression tests in a high-level modern programming language, like Python, poses a great advantage in organizing and maintaining the tests.
 Users can create their own test hierarchies, create test factories for generating multiple tests at the same time and also customize them in a simple and expressive way.
 
+Please visit the project's documentation [page](https://reframe-hpc.readthedocs.io/) for all the details!
 
-## Getting ReFrame
 
-ReFrame is almost ready to run just after you clone it from Github.
+## Installation
+
+ReFrame is fairly easy to install.
 All you need is Python 3.6 or above and to run its bootstrap script:
 
 ```bash
@@ -40,37 +42,19 @@ cd reframe
 ./bin/reframe -V
 ```
 
-### Other installation ways
-
-You can also install ReFrame through the following channels:
-
-- Through [PyPI](https://pypi.org/project/ReFrame-HPC/):
-
-  ```
-  pip install reframe-hpc
-  ```
-
-- Through [Spack](https://spack.io/):
-
-  ```
-  spack install reframe
-  ```
-
-- Through [EasyBuild](https://easybuild.readthedocs.io/):
-
-  ```
-  eb easybuild/easyconfigs/r/ReFrame/ReFrame-VERSION.eb -r
-  ```
+If you want a specific release, please refer to the documentation [page](https://reframe-hpc.readthedocs.io/en/stable/started.html).
 
-Finally, you may access all previous versions of ReFrame [here](https://github.com/eth-cscs/reframe/releases).
 
+### Running the unit tests
 
-## Documentation
+You can optionally run the framework's unit tests with the following command:
 
-You may find the official documentation of the latest release and the current master in the following links:
+```bash
+./test_reframe.py -v
+```
 
-- [Latest release](https://reframe-hpc.readthedocs.io/en/stable)
-- [Current master](https://reframe-hpc.readthedocs.io/en/latest)
+NOTE: Unit tests require a functional C compiler, available through the `cc` command, that is also able to recognize the ``-O2`` option.
+The [GNU Make](https://www.gnu.org/software/make/) build tool is also needed.
 
 
 ### Building the documentation locally
@@ -102,21 +86,18 @@ However, they can serve as a very good starting point for implementing your syst
 
 You can get in contact with the ReFrame community in the following ways:
 
-### Mailing list
-
-For keeping up with the latest news about ReFrame, posting questions and, generally getting in touch with other users and the developers, you may follow the mailing list: [[email protected]](mailto:[email protected]).
-
-Only subscribers may send messages to the list.
-To subscribe, please send an empty message to [[email protected]](mailto:[email protected]).
+### Slack
 
-For unsubscribing, you may send an empty message to [[email protected]](mailto:reframe-[email protected]).
+Please join the community's [Slack channel](https://reframe-slack.herokuapp.com) for keeping up with the latest news about ReFrame, posting questions and, generally getting in touch with other users and the developers.
 
-### Slack
+### Mailing list
 
-You may also reach the community through Slack [here](https://reframe-slack.herokuapp.com).
+You may also [subscribe](mailto:[email protected]) to the [mailing list](mailto:[email protected]).
+Only subscribers can send messages to the list.
+For unsubscribing, you may send an empty message [here](mailto:[email protected]).
 
 
 ## Contributing back
 
-ReFrame is an open-source project and we welcome third-party contributions.
+ReFrame is an open-source project and we welcome and encourage contributions!
 Check out our Contribution Guide [here](https://github.com/eth-cscs/reframe/wiki/contributing-to-reframe).

bin/reframe

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# PYTHON_ARGCOMPLETE_OK
 #
 # Copyright 2016-2021 Swiss National Supercomputing Centre (CSCS/ETH Zurich)
 # ReFrame Project Developers. See the top-level LICENSE file for details.

cscs-checks/apps/cp2k/cp2k_check.py

@@ -14,15 +14,17 @@ def __init__(self):
         self.executable = 'cp2k.psmp'
         self.executable_opts = ['H2O-256.inp']
 
-        energy = sn.extractsingle(r'\s+ENERGY\| Total FORCE_EVAL \( QS \) '
-                                  r'energy \(a\.u\.\):\s+(?P<energy>\S+)',
-                                  self.stdout, 'energy', float, item=-1)
+        energy = sn.extractsingle(
+            r'\s+ENERGY\| Total FORCE_EVAL \( QS \) '
+            r'energy [\[\(]a\.u\.[\]\)]:\s+(?P<energy>\S+)',
+            self.stdout, 'energy', float, item=-1
+        )
         energy_reference = -4404.2323
         energy_diff = sn.abs(energy-energy_reference)
         self.sanity_patterns = sn.all([
             sn.assert_found(r'PROGRAM STOPPED IN', self.stdout),
             sn.assert_eq(sn.count(sn.extractall(
-                r'(?P<step_count>STEP NUM)',
+                r'(?i)(?P<step_count>STEP NUMBER)',
                 self.stdout, 'step_count')), 10),
             sn.assert_lt(energy_diff, 1e-4)
         ])

cscs-checks/apps/gromacs/gromacs_check.py

@@ -73,7 +73,7 @@ def __init__(self, scale, variant):
         references = {
             'maint': {
                 'large': {
-                    'daint:gpu': {'perf': (73.4, -0.10, None, 'ns/day')}
+                    'daint:gpu': {'perf': (63.0, -0.10, None, 'ns/day')}
                 }
             },
             'prod': {

cscs-checks/libraries/io/netcdf_compile_run.py

@@ -22,15 +22,23 @@ def __init__(self, lang, linkage):
         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']
+        self.valid_systems = ['daint:gpu', 'daint:mc',
+                              'dom:gpu', 'dom:mc',
+                              'arolla:cn', 'tsa:cn',
+                              'eiger:mc']
+        if linkage == 'static':
+            self.valid_systems.remove('eiger:mc')
+
         if self.current_system.name in ['daint', 'dom']:
             self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu',
                                         'PrgEnv-intel', 'PrgEnv-pgi']
             self.modules = ['cray-netcdf']
         elif self.current_system.name in ['arolla', 'tsa']:
             self.exclusive_access = True
             self.valid_prog_environs = ['PrgEnv-gnu-nompi', 'PrgEnv-pgi-nompi']
+        elif self.current_system.name in ['eiger']:
+            self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu']
+            self.modules = ['cray-hdf5', 'cray-netcdf']
 
         self.sourcesdir = os.path.join(self.current_system.resourcesdir,
                                        'netcdf')

cscs-checks/microbenchmarks/cpu/fft/fftw_benchmark.py

@@ -14,16 +14,15 @@ def __init__(self, exec_mode):
         self.sourcepath = 'fftw_benchmark.c'
         self.build_system = 'SingleSource'
         self.valid_systems = ['daint:gpu', 'dom:gpu']
+
+        # Cray FFTW library is not officially supported for the PGI
+        self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu']
         self.modules = ['cray-fftw']
         self.num_tasks_per_node = 12
         self.num_gpus_per_node = 0
         self.sanity_patterns = sn.assert_eq(
             sn.count(sn.findall(r'execution time', self.stdout)), 1)
         self.build_system.cflags = ['-O2']
-        if self.current_system.name in {'daint', 'dom'}:
-            # Cray FFTW library is not officially supported for the PGI
-            self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu']
-
         self.perf_patterns = {
             'fftw_exec_time': sn.extractsingle(
                 r'execution time:\s+(?P<exec_time>\S+)', self.stdout,

cscs-checks/microbenchmarks/cpu/simd/benches/benches.hpp

@@ -0,0 +1,72 @@
+#ifndef BENCHES_HPP
+#define BENCHES_HPP
+
+#include <limits>
+#include <cmath>
+#include <climits>
+
+namespace nsimd {
+namespace benches {
+
+template <typename T>
+double rand_sign() {
+  if (std::is_unsigned<T>::value) {
+    return 1.;
+  } else {
+    return (::rand() % 2) ? 1. : -1.;
+  }
+}
+
+template <typename T>
+T rand_bits(T min, T max = std::numeric_limits<T>::max()) {
+  T r;
+  do {
+    int nbits = sizeof(T) * CHAR_BIT;
+    uint64_t x = 0;
+    for (int i = 0; i < nbits; ++i) {
+      x |= uint64_t(::rand() % 2) << i;
+    }
+    r = *((T*)&x);
+  } while (r < min || r > max);
+  return r;
+}
+
+template <typename T>
+T rand_from(T min, T max = std::numeric_limits<T>::max()) {
+  // From: http://c-faq.com/lib/randrange.html
+  return T(double(min)
+      + (double(::rand()) / (double(RAND_MAX) / (double(max) - double(min) + 1))));
+}
+
+template <typename T>
+T rand_fp(T min, T max) {
+  T r;
+  if (std::isinf(min) && std::isinf(max)) {
+    // For now, we're not using this method for random number
+    //r = rand_bits<T>(min, max);
+    r = rand_from<T>(-1000000, 1000000);
+  } else {
+    r = rand_from<T>(min, max);
+  }
+  return r;
+}
+
+template <typename T>
+T rand(T min, T max = std::numeric_limits<T>::max()) {
+  return rand_from<T>(min, max);
+}
+
+template <>
+float rand<float>(float min, float max) {
+  return rand_fp<float>(min, max);
+}
+
+template <>
+double rand<double>(double min, double max) {
+  return rand_fp<double>(min, max);
+}
+
+}
+}
+
+#endif