[test] Enable small scale application tests also on Daint

cscs-checks/apps/amber/amber_check.py

@@ -41,49 +41,54 @@ def __init__(self, input_file, output_file):
         self.tags = {'scs'}
 
 
-@rfm.parameterized_test(*([variant, arch]
-                          for variant in ['prod', 'maint']
-                          for arch in ['CPU', 'GPU']))
+@rfm.required_version('>=2.16')
+@rfm.parameterized_test(*(
+    [variant, arch, scale]
+    for variant in ['prod', 'maint']
+    for arch in ['CPU', 'GPU']
+    for scale in ['small', 'large']
+    if (not (scale, arch) == ('large', 'GPU') and
+        not (variant, arch) == ('maint', 'CPU'))
+))
 class AmberCheck(AmberBaseCheck):
-    def __init__(self, variant, arch):
+    def __init__(self, variant, arch, scale):
         super().__init__('mdin.%s' % arch, 'amber.out')
+        self.descr = 'Amber parallel %s %s check (%s)' % (scale, arch, variant)
+        self.tags |= {'maintenance' if variant == 'maint' else 'production'}
         if arch == 'GPU':
             self.valid_systems = ['daint:gpu', 'dom:gpu']
             self.executable = 'pmemd.cuda.MPI'
             self.reference = {
                 'dom:gpu': {
-                    'perf': (30.0, -0.05, None)
+                    'perf': (30.0, -0.05, None, 'ns/day')
                 },
                 'daint:gpu': {
-                    'perf': (30.0, -0.05, None)
+                    'perf': (30.0, -0.05, None, 'ns/day')
                 },
             }
-            if variant == 'prod':
-                self.descr = 'Amber parallel GPU production check'
-                self.tags |= {'production'}
-            elif variant == 'maint':
-                self.descr = 'Amber parallel GPU maintenance check'
-                self.tags |= {'maintenance'}
         elif arch == 'CPU':
-            self.valid_systems = ['daint:mc', 'dom:mc']
-            if variant == 'prod':
-                self.descr = 'Amber parallel CPU production check'
-                self.tags |= {'production'}
-                self.executable = 'pmemd.MPI'
-                self.strict_check = False
-                if self.current_system.name == 'dom':
-                    self.num_tasks = 216
-                    self.num_tasks_per_node = 36
-                else:
-                    self.num_tasks = 576
-                    self.num_tasks_per_node = 36
+            self.valid_systems = ['daint:mc']
+            if scale == 'small':
+                self.valid_systems += ['dom:mc']
 
+            self.executable = 'pmemd.MPI'
+            self.strict_check = False
+            if scale == 'small':
+                self.num_tasks = 216
+                self.num_tasks_per_node = 36
                 self.reference = {
                     'dom:mc': {
-                        'perf': (8.0, -0.05, None)
+                        'perf': (8.0, -0.05, None, 'ns/day')
                     },
                     'daint:mc': {
-                        'perf': (10.7, -0.25, None)
-                    },
+                        'perf': (7.6, -0.05, None, 'ns/day')
+                    }
+                }
+            else:
+                self.num_tasks = 576
+                self.num_tasks_per_node = 36
+                self.reference = {
+                    'daint:mc': {
+                        'perf': (10.7, -0.25, None, 'ns/day')
+                    }
                 }
-

cscs-checks/apps/cp2k/cp2k_check.py

@@ -4,11 +4,9 @@
 
 
 class Cp2kCheck(rfm.RunOnlyRegressionTest):
-    def __init__(self, check_name, check_descr):
-        super().__init__(check_name, os.path.dirname(__file__))
-        self.descr = check_descr
+    def __init__(self):
+        super().__init__()
         self.valid_prog_environs = ['PrgEnv-gnu']
-
         self.executable = 'cp2k.psmp'
         self.executable_opts = ['H2O-256.inp']
 
@@ -26,7 +24,7 @@ def __init__(self, check_name, check_descr):
         ])
 
         self.perf_patterns = {
-            'perf': sn.extractsingle(r'^ CP2K(\s+[\d\.]+){4}\s+(?P<perf>\S+)',
+            'time': sn.extractsingle(r'^ CP2K(\s+[\d\.]+){4}\s+(?P<perf>\S+)',
                                      self.stdout, 'perf', float)
         }
 
@@ -41,75 +39,83 @@ def __init__(self, check_name, check_descr):
         }
 
 
-@rfm.parameterized_test(['prod'], ['maint'])
+@rfm.parameterized_test(*([s, v]
+                          for s in ['small', 'large']
+                          for v in ['maint', 'prod']))
 class Cp2kCpuCheck(Cp2kCheck):
-    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':
+    def __init__(self, scale, variant):
+        super().__init__()
+        self.descr = 'CP2K CPU check (version: %s, %s)' % (scale, variant)
+        self.valid_systems = ['daint:mc']
+        if scale == 'small':
+            self.valid_systems += ['dom:mc']
             self.num_tasks = 216
         else:
             self.num_tasks = 576
 
         self.num_tasks_per_node = 36
-
-        if variant == 'maint':
-            self.tags |= {'maintenance'}
-            self.reference = {
-                'dom:mc': {
-                    'perf': (182.6, None, 0.05)
+        references = {
+            'maint': {
+                'small': {
+                    'dom:mc': {'time': (182.6, None, 0.05, 's')},
+                    'daint:mc': {'time': (214.5, None, 0.15, 's')}
                 },
-                'daint:mc': {
-                    'perf': (141.0, None, 0.05)
-                },
-            }
-        else:
-            self.tags |= {'production'}
-            self.reference = {
-                'dom:mc': {
-                    'perf': (174.5, None, 0.05)
-                },
-                'daint:mc': {
-                    'perf': (113.0, None, 0.25)
+                'large': {
+                    'daint:mc': {'time': (141.0, None, 0.05, 's')}
+                }
+            },
+            'prod': {
+                'small': {
+                    'dom:mc': {'time': (174.5, None, 0.05, 's')},
+                    'daint:mc': {'time': (214.5, None, 0.15, 's')}
                 },
+                'large': {
+                    'daint:mc': {'time': (113.0, None, 0.05, 's')}
+                }
             }
+        }
 
+        self.reference = references[variant][scale]
+        self.tags |= {'maintenance' if variant == 'maint' else 'production'}
 
-@rfm.parameterized_test(['prod'], ['maint'])
+
+@rfm.parameterized_test(*([s, v]
+                          for s in ['small', 'large']
+                          for v in ['maint', 'prod']))
 class Cp2kGpuCheck(Cp2kCheck):
-    def __init__(self, variant):
-        super().__init__('cp2k_gpu_%s_check' % variant,
-                         'CP2K check GPU')
-        self.valid_systems = ['daint:gpu', 'dom:gpu']
+    def __init__(self, scale, variant):
+        super().__init__()
+        self.descr = 'CP2K GPU check (version: %s, %s)' % (scale, variant)
+        self.valid_systems = ['daint:gpu']
         self.variables = {'CRAY_CUDA_MPS': '1'}
         self.modules = ['CP2K']
         self.num_gpus_per_node = 1
-        if self.current_system.name == 'dom':
+        if scale == 'small':
+            self.valid_systems += ['dom:gpu']
             self.num_tasks = 72
         else:
             self.num_tasks = 192
 
         self.num_tasks_per_node = 12
-
-        if variant == 'maint':
-            self.tags |= {'maintenance'}
-            self.reference = {
-                'dom:gpu': {
-                    'perf': (251.8, None, 0.15)
+        references = {
+            'maint': {
+                'small': {
+                    'dom:gpu': {'time': (251.8, None, 0.15, 's')},
+                    'daint:gpu': {'time': (262.6, None, 0.10, 's')}
                 },
-                'daint:gpu': {
-                    'perf': (222.6, None, 0.05)
-                },
-            }
-        else:
-            self.tags |= {'production'}
-            self.reference = {
-                'dom:gpu': {
-                    'perf': (240.0, None, 0.05)
-                },
-                'daint:gpu': {
-                    'perf': (222.6, None, 0.05)
+                'large': {
+                    'daint:gpu': {'time': (222.6, None, 0.05, 's')}
+                }
+            },
+            'prod': {
+                'small': {
+                    'dom:gpu': {'time': (240.0, None, 0.05, 's')},
+                    'daint:gpu': {'time': (262.6, None, 0.10, 's')}
                 },
+                'large': {
+                    'daint:gpu': {'time': (222.6, None, 0.05, 's')}
+                }
             }
+        }
+        self.reference = references[variant][scale]
+        self.tags |= {'maintenance' if variant == 'maint' else 'production'}

cscs-checks/apps/cpmd/cpmd_check.py

@@ -1,35 +1,38 @@
-import os
-
 import reframe as rfm
 import reframe.utility.sanity as sn
 
 
-@rfm.simple_test
+@rfm.required_version('>=2.16')
+@rfm.parameterized_test(['small'], ['large'])
 class CPMDCheck(rfm.RunOnlyRegressionTest):
-    def __init__(self):
+    def __init__(self, scale):
         super().__init__()
         self.descr = 'CPMD check (C4H6 metadynamics)'
         self.maintainers = ['AJ', 'LM']
         self.tags = {'production'}
 
-        self.valid_systems = ['daint:gpu', 'dom:gpu']
+        self.valid_systems = ['daint:gpu']
+        if scale == 'small':
+            self.num_tasks = 9
+            self.valid_systems += ['dom:gpu']
+        else:
+            self.num_tasks = 16
+            self.time_limit = (0, 20, 0)
+
+        self.num_tasks_per_node = 1
         self.valid_prog_environs = ['PrgEnv-intel']
         self.modules = ['CPMD']
         self.executable = 'cpmd.x'
         self.executable_opts = ['ana_c4h6.in > stdout.txt']
         self.readonly_files = ['ana_c4h6.in', 'C_MT_BLYP', 'H_MT_BLYP']
-        if self.current_system.name == 'dom':
-            self.num_tasks = 9
-        else:
-            self.num_tasks = 16
-        self.num_tasks_per_node = 1
         self.use_multithreading = True
         self.strict_check = False
         self.extra_resources = {
             'switches': {
                 'num_switches': 1
             }
         }
+
         #  OpenMP version of CPMD segfaults
         #  self.variables = { 'OMP_NUM_THREADS' : '8' }
         energy = sn.extractsingle(
@@ -39,16 +42,21 @@ def __init__(self):
         energy_diff = sn.abs(energy - energy_reference)
         self.sanity_patterns = sn.assert_lt(energy_diff, 0.26)
         self.perf_patterns = {
-            'perf': sn.extractsingle(r'^ cpmd(\s+[\d\.]+){3}\s+(?P<perf>\S+)',
+            'time': sn.extractsingle(r'^ cpmd(\s+[\d\.]+){3}\s+(?P<perf>\S+)',
                                      'stdout.txt', 'perf', float)
         }
-
-        self.reference = {
-            'daint:gpu': {
-                'perf': (245.0, None, 0.59)   # (225.0, None, 0.15)
-            },
-            'dom:gpu': {
-                'perf': (332.0, None, 0.15)
-            },
-        }
-
+        if scale == 'small':
+            self.reference = {
+                'daint:gpu': {
+                    'time': (285.5, None, 0.20, 's')
+                },
+                'dom:gpu': {
+                    'time': (332.0, None, 0.15, 's')
+                }
+            }
+        else:
+            self.reference = {
+                'daint:gpu': {
+                    'time': (245.0, None, 0.59, 's')
+                }
+            }

cscs-checks/apps/espresso/espresso_check.py

@@ -4,27 +4,42 @@
 import reframe.utility.sanity as sn
 
 
-@rfm.simple_test
+@rfm.required_version('>=2.16')
+@rfm.parameterized_test(['small'], ['large'])
 class QECheck(rfm.RunOnlyRegressionTest):
-    def __init__(self):
+    def __init__(self, scale):
         super().__init__()
         self.descr = 'Quantum Espresso CPU check'
         self.maintainers = ['AK', 'LM']
         self.tags = {'scs', 'production'}
         self.sourcesdir = os.path.join(self.current_system.resourcesdir,
                                        'Espresso')
 
-        self.valid_systems = ['daint:mc', 'dom:mc']
+        self.valid_systems = ['daint:mc']
         self.valid_prog_environs = ['PrgEnv-intel']
         self.modules = ['QuantumESPRESSO']
         self.executable = 'pw.x'
         self.executable_opts = ['-in', 'ausurf.in']
-        if self.current_system.name == 'dom':
+        if scale == 'small':
+            self.valid_systems += ['dom:mc']
             self.num_tasks = 216
             self.num_tasks_per_node = 36
+            self.reference = {
+                'dom:mc': {
+                    'time': (159.0, None, 0.05, 's'),
+                },
+                'daint:mc': {
+                    'time': (151.6, None, 0.05, 's')
+                },
+            }
         else:
             self.num_tasks = 576
             self.num_tasks_per_node = 36
+            self.reference = {
+                'daint:mc': {
+                    'time': (157.0, None, 0.40, 's')
+                },
+            }
 
         self.use_multithreading = True
         self.extra_resources = {
@@ -41,15 +56,6 @@ def __init__(self):
             sn.assert_reference(energy, -11427.09017162, -1e-10, 1e-10)
         ])
         self.perf_patterns = {
-            'sec': sn.extractsingle(r'electrons    :\s+(?P<sec>\S+)s CPU ',
-                                    self.stdout, 'sec', float)
+            'time': sn.extractsingle(r'electrons    :\s+(?P<sec>\S+)s CPU ',
+                                     self.stdout, 'sec', float)
         }
-        self.reference = {
-            'dom:mc': {
-                'sec': (159.0, None, 0.05),
-            },
-            'daint:mc': {
-                'sec': (157.0, None, 0.40)
-            },
-        }
-