Merge branch 'master' into checks/namd-perf

Author: vkarak

README.md

@@ -19,6 +19,9 @@ Users can create their own test hierarchies, create test factories for generatin
 The official documentation is maintained [here](https://eth-cscs.github.io/reframe/index.html).
 It corresponds to the [latest](https://github.com/eth-cscs/reframe/releases/latest) stable release and not to the current status of the `master`.
 
+* SC18 presentation [[pdf](https://drive.google.com/file/d/1sIecW59E-AvhD-vl6c6QGXM14UKNzgo_/view?usp=sharing)]
+* SC18 Demo [[link](https://asciinema.org/a/6SQJTaRe2zrMInV92X0yb2gTh)]
+
 ### Building the documentation from master
 
 You may build the documentation of the master either with Python 2 or Python 3 (<= 3.5).

cscs-checks/apps/cp2k/cp2k_check.py

@@ -1,12 +1,11 @@
 import os
-
+import reframe as rfm
 import reframe.utility.sanity as sn
-from reframe.core.pipeline import RunOnlyRegressionTest
 
 
-class Cp2kCheck(RunOnlyRegressionTest):
-    def __init__(self, check_name, check_descr, **kwargs):
-        super().__init__(check_name, os.path.dirname(__file__), **kwargs)
+class Cp2kCheck(rfm.RunOnlyRegressionTest):
+    def __init__(self, check_name, check_descr):
+        super().__init__(check_name, os.path.dirname(__file__))
         self.descr = check_descr
         self.valid_prog_environs = ['PrgEnv-gnu']
 
@@ -42,9 +41,11 @@ def __init__(self, check_name, check_descr, **kwargs):
         }
 
 
+@rfm.parameterized_test(['prod'], ['maint'])
 class Cp2kCpuCheck(Cp2kCheck):
-    def __init__(self, **kwargs):
-        super().__init__('cp2k_cpu_check', 'CP2K check CPU', **kwargs)
+    def __init__(self, variant):
+        super().__init__('cp2k_cpu_%s_check' % variant,
+                         'CP2K check CPU')
         self.valid_systems = ['daint:mc', 'dom:mc']
         self.num_gpus_per_node = 0
         if self.current_system.name == 'dom':
@@ -53,21 +54,34 @@ def __init__(self, **kwargs):
             self.num_tasks = 576
 
         self.num_tasks_per_node = 36
-        self.reference = {
-            'dom:mc': {
-                'perf': (174.5, None, 0.05)
-            },
-            'daint:mc': {
-                'perf': (113.0, None, 0.25)
-            },
-        }
-        self.tags |= {'maintenance', 'production'}
+
+        if variant == 'maint':
+            self.tags |= {'maintenance'}
+            self.reference = {
+                'dom:mc': {
+                    'perf': (182.6, None, 0.05)
+                },
+                'daint:mc': {
+                    'perf': (106.8, None, 0.10)
+                },
+            }
+        else:
+            self.tags |= {'production'}
+            self.reference = {
+                'dom:mc': {
+                    'perf': (174.5, None, 0.05)
+                },
+                'daint:mc': {
+                    'perf': (113.0, None, 0.25)
+                },
+            }
 
 
+@rfm.parameterized_test(['prod'], ['maint'])
 class Cp2kGpuCheck(Cp2kCheck):
-    def __init__(self, variant, **kwargs):
+    def __init__(self, variant):
         super().__init__('cp2k_gpu_%s_check' % variant,
-                         'CP2K check GPU', **kwargs)
+                         'CP2K check GPU')
         self.valid_systems = ['daint:gpu', 'dom:gpu']
         self.variables = {'CRAY_CUDA_MPS': '1'}
         self.modules = ['CP2K']
@@ -79,36 +93,23 @@ def __init__(self, variant, **kwargs):
 
         self.num_tasks_per_node = 12
 
-
-class Cp2kGpuMaintCheck(Cp2kGpuCheck):
-    def __init__(self, **kwargs):
-        super().__init__('maint', **kwargs)
-        self.tags |= {'maintenance'}
-        self.reference = {
-            'dom:gpu': {
-                'perf': (258.0, None, 0.15)
-            },
-            'daint:gpu': {
-                'perf': (139.0, None, 0.10)
-            },
-        }
-
-
-class Cp2kGpuProdCheck(Cp2kGpuCheck):
-    def __init__(self, **kwargs):
-        super().__init__('prod', **kwargs)
-        self.tags |= {'production'}
-        self.reference = {
-            'dom:gpu': {
-                'perf': (240.0, None, 0.05)
-            },
-            'daint:gpu': {
-                'perf': (195.0, None, 0.10)
-            },
-        }
-
-
-def _get_checks(**kwargs):
-    return [Cp2kCpuCheck(**kwargs),
-            Cp2kGpuMaintCheck(**kwargs),
-            Cp2kGpuProdCheck(**kwargs)]
+        if variant == 'maint':
+            self.tags |= {'maintenance'}
+            self.reference = {
+                'dom:gpu': {
+                    'perf': (251.8, None, 0.15)
+                },
+                'daint:gpu': {
+                    'perf': (182.3, None, 0.10)
+                },
+            }
+        else:
+            self.tags |= {'production'}
+            self.reference = {
+                'dom:gpu': {
+                    'perf': (240.0, None, 0.05)
+                },
+                'daint:gpu': {
+                    'perf': (195.0, None, 0.10)
+                },
+            }

cscs-checks/apps/gromacs/gromacs_check.py

@@ -88,7 +88,7 @@ def __init__(self):
         self.tags |= {'production'}
         self.reference = {
             'dom:gpu': {
-                'perf': (37.5, -0.05, None)
+                'perf': (29.3, -0.05, None)
             },
             'daint:gpu': {
                 'perf': (42.0, -0.20, None)

cscs-checks/compile/libsci_acc_symlink.py

@@ -1,36 +1,27 @@
 import os
 
+import reframe as rfm
 import reframe.utility.sanity as sn
-from reframe.core.pipeline import RunOnlyRegressionTest
 
 
-class LibSciAccSymLinkTest(RunOnlyRegressionTest):
-    def __init__(self, lib_name, **kwargs):
-        super().__init__(lib_name.replace('.so', '_symlink_check'),
-                         os.path.dirname(__file__), **kwargs)
-
+@rfm.parameterized_test(['libsci_acc_gnu_49_nv20'],
+                        ['libsci_acc_gnu_49_nv35'],
+                        ['libsci_acc_gnu_49_nv60'],
+                        ['libsci_acc_cray_nv20_openacc'],
+                        ['libsci_acc_cray_nv35_openacc'],
+                        ['libsci_acc_cray_nv60_openacc'])
+class LibSciAccSymLinkTest(rfm.RunOnlyRegressionTest):
+    def __init__(self, lib_name):
+        super().__init__()
         self.descr = 'LibSciAcc symlink check of %s' % lib_name
-        self.valid_systems = ['daint:login', 'dom:login']
+        self.valid_systems = ['daint:login', 'daint:gpu',
+                              'dom:login', 'dom:gpu']
 
         # The prgenv is irrelevant for this case, so just chose one
         self.valid_prog_environs = ['PrgEnv-cray']
-
         self.executable = 'ls'
-        self.executable_opts = '-al /opt/cray/pe/lib64/libsci_a*'.split()
-        self.sanity_patterns = sn.assert_found(lib_name, self.stdout)
+        self.executable_opts = ['-al', '/opt/cray/pe/lib64/libsci_a*']
+        self.sanity_patterns = sn.assert_found(lib_name + '.so', self.stdout)
+
         self.maintainers = ['AJ']
         self.tags = {'production'}
-
-
-def _get_checks(**kwargs):
-
-    ret = []
-    for lib_name in [r'libsci_acc_gnu_49_nv20.so',
-                     r'libsci_acc_gnu_49_nv35.so',
-                     r'libsci_acc_gnu_49_nv60.so',
-                     r'libsci_acc_cray_nv20_openacc.so',
-                     r'libsci_acc_cray_nv35_openacc.so',
-                     r'libsci_acc_cray_nv60_openacc.so']:
-        ret.append(LibSciAccSymLinkTest(lib_name, **kwargs))
-
-    return ret

cscs-checks/compile/libsci_resolve.py

@@ -7,7 +7,8 @@ def __init__(self):
         super().__init__()
         self.sourcesdir = 'src/libsci_resolve'
         self.sourcepath = 'libsci_resolve.f90'
-        self.valid_systems = ['daint:login', 'dom:login']
+        self.valid_systems = ['daint:login', 'daint:gpu',
+                              'dom:login', 'dom:gpu']
         self.modules = ['craype-haswell']
         self.maintainers = ['AJ']
         self.tags = {'production'}

cscs-checks/libraries/magma/magma_checks.py

@@ -76,27 +76,27 @@ def __init__(self, name, libversion, variant):
             if variant == 'prod':
                 self.reference = {
                     'daint:gpu': {
-                        'magma':  (2151.0, None, 0.2),
-                        'cublas': (2411.0, None, 0.45),
-                        'cpu':    (44.1, None, 0.1),
+                        'magma':  (3357.0, None, 0.2),
+                        'cublas': (3775.0, None, 0.45),
+                        'cpu':    (47.01, None, 0.1),
                     },
                     'dom:gpu': {
-                        'magma':  (2532.0, None, 0.1),
-                        'cublas': (3391.0, None, 0.05),
-                        'cpu':    (43.9, None, 0.05),
+                        'magma':  (3330.0, None, 0.1),
+                        'cublas': (3774.0, None, 0.05),
+                        'cpu':    (47.32, None, 0.05),
                     },
                 }
             elif variant == 'maint':
                 self.reference = {
                     'daint:gpu': {
-                        'magma':  (2151.0, None, 0.2),
-                        'cublas': (2411.0, None, 0.45),
-                        'cpu':    (44.1, None, 0.1),
+                        'magma':  (3357.0, None, 0.2),
+                        'cublas': (3775.0, None, 0.45),
+                        'cpu':    (47.01, None, 0.1),
                     },
                     'dom:gpu': {
-                        'magma':  (2532.0, None, 0.1),
-                        'cublas': (3391.0, None, 0.05),
-                        'cpu':    (43.9, None, 0.05),
+                        'magma':  (3330.0, None, 0.1),
+                        'cublas': (3774.0, None, 0.05),
+                        'cpu':    (47.32, None, 0.05),
                     },
                 }
         elif name == 'zsymmetrize':

cscs-checks/mch/check_ruby.py

@@ -0,0 +1,19 @@
+import reframe as rfm
+import reframe.utility.sanity as sn
+
+
+@rfm.simple_test
+class RubyNArray(rfm.RunOnlyRegressionTest):
+    def __init__(self):
+        super().__init__()
+        self.descr = ('Check NArray for Ruby version 2.2.2')
+        self.valid_systems = ['kesch:cn']
+        self.valid_prog_environs = ['PrgEnv-gnu-nompi']
+        self.modules = ['ruby/2.2.2-gmvolf-17.02']
+        self.executable = 'ruby'
+        self.executable_opts = ['NArray.rb']
+        self.sanity_patterns = sn.assert_found(r'NArray\.float\(4\):\s*'
+                                               r'\[ 1.0, 2.0, 3.0, 4.0 \]',
+                                               self.stdout)
+        self.maintainers = ['MKr']
+        self.tags = {'production'}

cscs-checks/mch/src/NArray.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require 'gsl'
+
+g1 = GSL::Vector.alloc(1,2,3,4)
+a1 = g1.to_na
+
+p a1

cscs-checks/prgenv/cpu_target_check.py

@@ -0,0 +1,18 @@
+import reframe as rfm
+import reframe.utility.sanity as sn
+
+
+@rfm.simple_test
+class CrayCPUTargetTest(rfm.RunOnlyRegressionTest):
+    def __init__(self):
+        super().__init__()
+        self.descr = 'Checks whether CRAY_CPU_TARGET is set'
+        self.valid_systems = ['daint:login', 'dom:login']
+        self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu',
+                                    'PrgEnv-intel', 'PrgEnv-pgi']
+        self.executable = 'echo CRAY_CPU_TARGET=$CRAY_CPU_TARGET'
+        self.sanity_patterns = sn.assert_found(r'CRAY_CPU_TARGET=\S+',
+                                               self.stdout)
+
+        self.maintainers = ['TM']
+        self.tags = {'production', 'maintenance'}