Merge branch 'master' into update-syntax/vasp

Vasileios Karakasis · web-flow · commit 4e6e0f7dd809 · 2021-12-20T21:16:43.000+01:00
diff --git a/cscs-checks/apps/cp2k/cp2k_check.py b/cscs-checks/apps/cp2k/cp2k_check.py
@@ -8,55 +8,88 @@
 
 
 class Cp2kCheck(rfm.RunOnlyRegressionTest):
-    def __init__(self):
+    modules = ['CP2K']
+    executable = 'cp2k.psmp'
+    executable_opts = ['H2O-256.inp']
+    maintainers = ['LM']
+    tags = {'scs'}
+    strict_check = False
+    extra_resources = {
+        'switches': {
+            'num_switches': 1
+        }
+    }
+
+    @run_after('init')
+    def set_prgenv(self):
         if self.current_system.name in ['eiger', 'pilatus']:
             self.valid_prog_environs = ['cpeGNU']
         else:
             self.valid_prog_environs = ['builtin']
 
-        self.modules = ['CP2K']
-        self.executable = 'cp2k.psmp'
-        self.executable_opts = ['H2O-256.inp']
-
+    @sanity_function
+    def assert_energy_diff(self):
         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([
+        return sn.all([
             sn.assert_found(r'PROGRAM STOPPED IN', self.stdout),
             sn.assert_eq(sn.count(sn.extractall(
                 r'(?i)(?P<step_count>STEP NUMBER)',
                 self.stdout, 'step_count')), 10),
             sn.assert_lt(energy_diff, 1e-4)
         ])
 
-        self.perf_patterns = {
-            'time': sn.extractsingle(r'^ CP2K(\s+[\d\.]+){4}\s+(?P<perf>\S+)',
-                                     self.stdout, 'perf', float)
-        }
-
-        self.maintainers = ['LM']
-        self.tags = {'scs'}
-        self.strict_check = False
-        self.extra_resources = {
-            'switches': {
-                'num_switches': 1
-            }
-        }
+    @performance_function('s')
+    def time(self):
+        return sn.extractsingle(r'^ CP2K(\s+[\d\.]+){4}\s+(?P<perf>\S+)',
+                                self.stdout, 'perf', float)
 
 
-@rfm.parameterized_test(*([s, v]
-                          for s in ['small', 'large']
-                          for v in ['maint', 'prod']))
+@rfm.simple_test
 class Cp2kCpuCheck(Cp2kCheck):
-    def __init__(self, scale, variant):
-        super().__init__()
-        self.descr = 'CP2K CPU check (version: %s, %s)' % (scale, variant)
-        self.valid_systems = ['daint:mc', 'eiger:mc', 'pilatus:mc']
-        if scale == 'small':
+    scale = parameter(['small', 'large'])
+    variant = parameter(['maint', 'prod'])
+    valid_systems = ['daint:mc', 'eiger:mc', 'pilatus:mc']
+    references_by_variant = {
+        'maint': {
+            'small': {
+                'dom:mc': {'time': (202.2, None, 0.05, 's')},
+                'daint:mc': {'time': (180.9, None, 0.08, 's')},
+                'eiger:mc': {'time': (70.0, None, 0.08, 's')},
+                'pilatus:mc': {'time': (70.0, None, 0.08, 's')}
+            },
+            'large': {
+                'daint:mc': {'time': (141.0, None, 0.05, 's')},
+                'eiger:mc': {'time': (46.0, None, 0.05, 's')},
+                'pilatus:mc': {'time': (46.0, None, 0.05, 's')}
+            }
+        },
+        'prod': {
+            'small': {
+                'dom:mc': {'time': (202.2, None, 0.05, 's')},
+                'daint:mc': {'time': (180.9, None, 0.08, 's')},
+                'eiger:mc': {'time': (70.0, None, 0.08, 's')},
+                'pilatus:mc': {'time': (70.0, None, 0.08, 's')}
+            },
+            'large': {
+                'daint:mc': {'time': (113.0, None, 0.05, 's')},
+                'eiger:mc': {'time': (46.0, None, 0.05, 's')},
+                'pilatus:mc': {'time': (46.0, None, 0.05, 's')}
+            }
+        }
+    }
+
+    @run_after('init')
+    def setup_by_variant_and_scale(self):
+        self.descr = f'CP2K CPU check (version: {self.scale}, {self.variant})'
+        self.tags |= {'maintenance'
+                      if self.variant == 'maint' else 'production'}
+        if self.scale == 'small':
             self.valid_systems += ['dom:mc']
             if self.current_system.name in ['daint', 'dom']:
                 self.num_tasks = 216
@@ -91,37 +124,7 @@ def __init__(self, scale, variant):
                     'OMP_PROC_BIND': 'close'
                 }
 
-        references = {
-            'maint': {
-                'small': {
-                    'dom:mc': {'time': (202.2, None, 0.05, 's')},
-                    'daint:mc': {'time': (180.9, None, 0.08, 's')},
-                    'eiger:mc': {'time': (70.0, None, 0.08, 's')},
-                    'pilatus:mc': {'time': (70.0, None, 0.08, 's')}
-                },
-                'large': {
-                    'daint:mc': {'time': (141.0, None, 0.05, 's')},
-                    'eiger:mc': {'time': (46.0, None, 0.05, 's')},
-                    'pilatus:mc': {'time': (46.0, None, 0.05, 's')}
-                }
-            },
-            'prod': {
-                'small': {
-                    'dom:mc': {'time': (202.2, None, 0.05, 's')},
-                    'daint:mc': {'time': (180.9, None, 0.08, 's')},
-                    'eiger:mc': {'time': (70.0, None, 0.08, 's')},
-                    'pilatus:mc': {'time': (70.0, None, 0.08, 's')}
-                },
-                'large': {
-                    'daint:mc': {'time': (113.0, None, 0.05, 's')},
-                    'eiger:mc': {'time': (46.0, None, 0.05, 's')},
-                    'pilatus:mc': {'time': (46.0, None, 0.05, 's')}
-                }
-            }
-        }
-
-        self.reference = references[variant][scale]
-        self.tags |= {'maintenance' if variant == 'maint' else 'production'}
+        self.reference = self.references_by_variant[self.variant][self.scale]
 
     @run_before('run')
     def set_task_distribution(self):
@@ -132,46 +135,48 @@ def set_cpu_binding(self):
         self.job.launcher.options = ['--cpu-bind=cores']
 
 
-@rfm.parameterized_test(*([s, v]
-                          for s in ['small', 'large']
-                          for v in ['maint', 'prod']))
+@rfm.simple_test
 class Cp2kGpuCheck(Cp2kCheck):
-    def __init__(self, scale, variant):
-        super().__init__()
-        self.descr = 'CP2K GPU check (version: %s, %s)' % (scale, variant)
-        self.valid_systems = ['daint:gpu']
-        self.num_gpus_per_node = 1
-        if scale == 'small':
+    scale = parameter(['small', 'large'])
+    variant = parameter(['maint', 'prod'])
+    valid_systems = ['daint:gpu']
+    num_gpus_per_node = 1
+    num_tasks_per_node = 6
+    num_cpus_per_task = 2
+    variables = {
+        'CRAY_CUDA_MPS': '1',
+        'OMP_NUM_THREADS': str(num_cpus_per_task)
+    }
+    references_by_variant = {
+        'maint': {
+            'small': {
+                'dom:gpu': {'time': (251.8, None, 0.15, 's')},
+                'daint:gpu': {'time': (241.3, None, 0.05, 's')}
+            },
+            'large': {
+                'daint:gpu': {'time': (199.6, None, 0.06, 's')}
+            }
+        },
+        'prod': {
+            'small': {
+                'dom:gpu': {'time': (240.0, None, 0.05, 's')},
+                'daint:gpu': {'time': (241.3, None, 0.05, 's')}
+            },
+            'large': {
+                'daint:gpu': {'time': (199.6, None, 0.06, 's')}
+            }
+        }
+    }
+
+    @run_after('init')
+    def setup_by_variant_and_scale(self):
+        self.descr = f'CP2K GPU check (version: {self.scale}, {self.variant})'
+        if self.scale == 'small':
             self.valid_systems += ['dom:gpu']
             self.num_tasks = 36
         else:
             self.num_tasks = 96
 
-        self.num_tasks_per_node = 6
-        self.num_cpus_per_task = 2
-        self.variables = {
-            'CRAY_CUDA_MPS': '1',
-            'OMP_NUM_THREADS': str(self.num_cpus_per_task)
-        }
-        references = {
-            'maint': {
-                'small': {
-                    'dom:gpu': {'time': (251.8, None, 0.15, 's')},
-                    'daint:gpu': {'time': (241.3, None, 0.05, 's')}
-                },
-                'large': {
-                    'daint:gpu': {'time': (199.6, None, 0.06, 's')}
-                }
-            },
-            'prod': {
-                'small': {
-                    'dom:gpu': {'time': (240.0, None, 0.05, 's')},
-                    'daint:gpu': {'time': (241.3, None, 0.05, 's')}
-                },
-                'large': {
-                    'daint:gpu': {'time': (199.6, None, 0.06, 's')}
-                }
-            }
-        }
-        self.reference = references[variant][scale]
-        self.tags |= {'maintenance' if variant == 'maint' else 'production'}
+        self.reference = self.references_by_variant[self.variant][self.scale]
+        self.tags |= {'maintenance'
+                      if self.variant == 'maint' else 'production'}
diff --git a/cscs-checks/apps/cpmd/cpmd_check.py b/cscs-checks/apps/cpmd/cpmd_check.py
@@ -3,62 +3,80 @@
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
+import contextlib
 import reframe as rfm
 import reframe.utility.sanity as sn
 
 
-@rfm.parameterized_test(['small'], ['large'])
+@rfm.simple_test
 class CPMDCheck(rfm.RunOnlyRegressionTest):
-    def __init__(self, scale):
-        self.descr = 'CPMD check (C4H6 metadynamics)'
-        self.maintainers = ['AJ', 'LM']
-        self.tags = {'production'}
+    scale = parameter(['small', 'large'])
+    descr = 'CPMD check (C4H6 metadynamics)'
+    maintainers = ['AJ', 'LM']
+    tags = {'production'}
+    valid_systems = ['daint:gpu']
+    num_tasks_per_node = 1
+    valid_prog_environs = ['builtin']
+    modules = ['CPMD']
+    executable = 'cpmd.x'
+    executable_opts = ['ana_c4h6.in > stdout.txt']
+    readonly_files = ['ana_c4h6.in', 'C_MT_BLYP', 'H_MT_BLYP']
+    use_multithreading = True
+    strict_check = False
+    extra_resources = {
+        'switches': {
+            'num_switches': 1
+        }
+    }
+    allref = {
+        '9': {
+            'p100': {
+                'time': (285.5, None, 0.20, 's')
+            },
+        },
+        '16': {
+            'p100': {
+                'time': (245.0, None, 0.59, 's')
+            }
+        }
+    }
 
-        self.valid_systems = ['daint:gpu']
-        if scale == 'small':
-            self.num_tasks = 9
+    @run_after('init')
+    def setup_by_scale(self):
+        if self.scale == 'small':
             self.valid_systems += ['dom:gpu']
+            self.num_tasks = 9
         else:
             self.num_tasks = 16
 
-        self.num_tasks_per_node = 1
-        self.valid_prog_environs = ['builtin']
-        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']
-        self.use_multithreading = True
-        self.strict_check = False
-        self.extra_resources = {
-            'switches': {
-                'num_switches': 1
+    @run_before('performance')
+    def set_perf_reference(self):
+        proc = self.current_partition.processor
+        pname = self.current_partition.fullname
+        if pname in ('daint:gpu', 'dom:gpu'):
+            arch = 'p100'
+        else:
+            arch = proc.arch
+
+        with contextlib.suppress(KeyError):
+            self.reference = {
+                pname: {
+                    'perf': self.allref[self.num_tasks][arch][self.benchmark]
+                }
             }
-        }
 
+    @sanity_function
+    def assert_energy_diff(self):
         #  OpenMP version of CPMD segfaults
         #  self.variables = { 'OMP_NUM_THREADS' : '8' }
         energy = sn.extractsingle(
             r'CLASSICAL ENERGY\s+-(?P<result>\S+)',
             'stdout.txt', 'result', float)
         energy_reference = 25.81
         energy_diff = sn.abs(energy - energy_reference)
-        self.sanity_patterns = sn.assert_lt(energy_diff, 0.26)
-        self.perf_patterns = {
-            'time': sn.extractsingle(r'^ cpmd(\s+[\d\.]+){3}\s+(?P<perf>\S+)',
-                                     'stdout.txt', 'perf', float)
-        }
-        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')
-                }
-            }
+        return sn.assert_lt(energy_diff, 0.26)
+
+    @performance_function('s')
+    def time(self):
+        return sn.extractsingle(r'^ cpmd(\s+[\d\.]+){3}\s+(?P<perf>\S+)',
+                                'stdout.txt', 'perf', float)
