Merge remote-tracking branch 'origin/bugfix/bootstrap_python_version' into bugfix/bootstrap_python_version

Author: Theofilos Manitaras

.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).

bootstrap.sh

@@ -62,8 +62,8 @@ pyver=$($python -V | sed -n 's/Python \([0-9]\+\)\.\([0-9]\+\)\..*/\1.\2/p')
 # We need to exit with a zero code if the Python version is the correct
 # one, so we invert the comparison
 
-if $python -c 'import sys;sys.exit(sys.version_info[:2] >= (3, 6))'; then
-    echo -e "ReFrame requires Python >= 3.6"
+if $python -c 'import sys; sys.exit(sys.version_info[:2] >= (3, 6))'; then
+    echo -e "ReFrame requires Python >= 3.6 (found $($python -V 2>&1))"
     exit 1
 fi
 

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/apps/quantumespresso/quantumespresso_check.py

@@ -39,17 +39,43 @@ class QuantumESPRESSOCpuCheck(QuantumESPRESSOCheck):
     def __init__(self, scale, variant):
         super().__init__()
         self.descr = f'QuantumESPRESSO CPU check (version: {scale}, {variant})'
-        self.valid_systems = ['daint:mc']
+        self.valid_systems = ['daint:mc', 'eiger:mc']
         self.modules = ['QuantumESPRESSO']
         if scale == 'small':
             self.valid_systems += ['dom:mc']
-            self.num_tasks = 216
             energy_reference = -11427.09017218
+            if self.current_system.name in ['daint', 'dom']:
+                self.num_tasks = 216
+                self.num_tasks_per_node = 36
+            elif self.current_system.name == 'eiger':
+                self.num_tasks = 96
+                self.num_tasks_per_node = 16
+                self.num_cpus_per_task = 16
+                self.num_tasks_per_core = 1
+                self.use_multithreading = False
+                self.variables = {
+                    'MPICH_OFI_STARTUP_CONNECT': '1',
+                    'OMP_NUM_THREADS': '8',
+                    'OMP_PLACES': 'cores',
+                    'OMP_PROC_BIND': 'close'
+                }
         else:
-            self.num_tasks = 576
             energy_reference = -11427.09017152
-
-        self.num_tasks_per_node = 36
+            if self.current_system.name in ['daint']:
+                self.num_tasks = 576
+                self.num_tasks_per_node = 36
+            elif self.current_system.name in ['eiger']:
+                self.num_tasks = 256
+                self.num_tasks_per_node = 16
+                self.num_cpus_per_task = 16
+                self.num_tasks_per_core = 1
+                self.use_multithreading = False
+                self.variables = {
+                    'MPICH_OFI_STARTUP_CONNECT': '1',
+                    'OMP_NUM_THREADS': '8',
+                    'OMP_PLACES': 'cores',
+                    'OMP_PROC_BIND': 'close'
+                }
 
         energy = sn.extractsingle(r'!\s+total energy\s+=\s+(?P<energy>\S+) Ry',
                                   self.stdout, 'energy', float)
@@ -65,26 +91,37 @@ def __init__(self, scale, variant):
             'maint': {
                 'small': {
                     'dom:mc': {'time': (115.0, None, 0.05, 's')},
-                    'daint:mc': {'time': (115.0, None, 0.10, 's')}
+                    'daint:mc': {'time': (115.0, None, 0.10, 's')},
+                    'eiger:mc': {'time': (66.0, None, 0.10, 's')}
                 },
                 'large': {
-                    'daint:mc': {'time': (115.0, None, 0.10, 's')}
+                    'daint:mc': {'time': (115.0, None, 0.10, 's')},
+                    'eiger:mc': {'time': (53.0, None, 0.10, 's')}
                 }
             },
             'prod': {
                 'small': {
                     'dom:mc': {'time': (115.0, None, 0.05, 's')},
-                    'daint:mc': {'time': (115.0, None, 0.10, 's')}
+                    'daint:mc': {'time': (115.0, None, 0.10, 's')},
+                    'eiger:mc': {'time': (66.0, None, 0.10, 's')}
                 },
                 'large': {
-                    'daint:mc': {'time': (115.0, None, 0.10, 's')}
+                    'daint:mc': {'time': (115.0, None, 0.10, 's')},
+                    'eiger:mc': {'time': (53.0, None, 0.10, 's')}
                 }
             }
         }
 
         self.reference = references[variant][scale]
         self.tags |= {'maintenance' if variant == 'maint' else 'production'}
 
+    @rfm.run_before('run')
+    def set_task_distribution(self):
+        self.job.options = ['--distribution=block:block']
+
+    @rfm.run_before('run')
+    def set_cpu_binding(self):
+        self.job.launcher.options = ['--cpu-bind=cores']
 
 @rfm.parameterized_test(*([s, v]
                           for s in ['small', 'large']

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