Merge pull request #2454 from lucamar/vasp_update

[test] Update VASP checks and reference values

Author: Vasileios Karakasis

cscs-checks/apps/vasp/vasp_check.py

@@ -7,105 +7,119 @@
 import reframe.utility.sanity as sn
 
 
+@rfm.simple_test
 class VASPCheck(rfm.RunOnlyRegressionTest):
-    keep_files = ['OUTCAR']
-    maintainers = ['LM']
-    tags = {'scs'}
-    strict_check = False
     modules = ['VASP']
+    executable = 'vasp_std'
     extra_resources = {
         'switches': {
             'num_switches': 1
         }
     }
+    keep_files = ['OUTCAR']
+    strict_check = False
+    use_multithreading = False
+    tags = {'maintenance', 'production'}
+    maintainers = ['LM']
 
-    @run_after('init')
-    def setup_by_system(self):
-        if self.current_system.name in ['eiger', 'pilatus']:
-            self.valid_prog_environs = ['cpeIntel']
-        else:
-            self.valid_prog_environs = ['builtin']
+    num_nodes = parameter([6, 16], loggable=True)
+    references = {
+        6: {
+            'sm_60': {
+                'dom:gpu': {'time': (56.0, None, 0.10, 's')},
+                'daint:gpu': {'time': (65.0, None, 0.15, 's')},
+            },
+            'broadwell': {
+                'dom:mc': {'time': (58.0, None, 0.10, 's')},
+                'daint:mc': {'time': (65.0, None, 0.15, 's')},
+            },
+            'zen2': {
+                'eiger:mc': {'time': (100.0, None, 0.10, 's')},
+                'pilatus:mc': {'time': (100.0, None, 0.10, 's')},
+            },
+        },
+        16: {
+            'sm_60': {
+                'daint:gpu': {'time': (55.0, None, 0.15, 's')},
+            },
+            'broadwell': {
+                'daint:mc': {'time': (55.0, None, 0.15, 's')},
+            },
+            'zen2': {
+                'eiger:mc': {'time': (100.0, None, 0.10, 's')},
+                'pilatus:mc': {'time': (100.0, None, 0.10, 's')}
+            }
+        }
+    }
+
+    @performance_function('s')
+    def elapsed_time(self):
+        return sn.extractsingle(r'Elapsed time \(sec\):'
+                                r'\s+(?P<time>\S+)', 'OUTCAR',
+                                'time', float)
 
     @sanity_function
     def assert_reference(self):
         force = sn.extractsingle(r'1 F=\s+(?P<result>\S+)',
                                  self.stdout, 'result', float)
         return sn.assert_reference(force, -.85026214E+03, -1e-5, 1e-5)
 
-    @performance_function('s')
-    def time(self):
-        return sn.extractsingle(r'Elapsed time \(sec\):'
-                                r'\s+(?P<time>\S+)', 'OUTCAR',
-                                'time', float)
-
+    @run_after('init')
+    def setup_system_filtering(self):
+        self.descr = f'VASP check ({self.num_nodes} node(s))'
+
+        # setup system filter
+        valid_systems = {
+            6: ['daint:gpu', 'daint:mc', 'dom:gpu', 'dom:mc',
+                'eiger:mc', 'pilatus:mc'],
+            16: ['daint:gpu', 'daint:mc', 'eiger:mc']
+        }
 
-@rfm.simple_test
-class VASPCpuCheck(VASPCheck):
-    valid_systems = ['daint:mc', 'dom:mc', 'eiger:mc', 'pilatus:mc']
-    executable = 'vasp_std'
-    reference = {
-        'dom:mc': {'time': (138.0, None, 0.15, 's')},
-        'daint:mc': {'time': (138.0, None, 0.15, 's')},
-        'eiger:mc': {'time': (100.0, None, 0.10, 's')},
-        'pilatus:mc': {'time': (100.0, None, 0.10, 's')}
-    }
+        self.skip_if(self.num_nodes not in valid_systems,
+                     f'No valid systems found for {self.num_nodes}(s)')
+        self.valid_systems = valid_systems[self.num_nodes]
 
-    @run_after('init')
-    def setup_by_scale(self):
-        self.descr = f'VASP CPU check'
-        if self.current_system.name == 'dom':
-            self.num_tasks = 72
-            self.num_tasks_per_node = 12
-            self.use_multithreading = True
-        elif self.current_system.name in ['eiger', 'pilatus']:
-            self.num_tasks = 64
-            self.num_tasks_per_node = 4
-            self.num_cpus_per_task = 8
-            self.num_tasks_per_core = 1
-            self.use_multithreading = False
-            self.variables = {
-                'MPICH_OFI_STARTUP_CONNECT': '1',
-                'OMP_NUM_THREADS': str(self.num_cpus_per_task),
-                'OMP_PLACES': 'cores',
-                'OMP_PROC_BIND': 'close'
-            }
+        # setup programming environment filter
+        if self.current_system.name in ['eiger', 'pilatus']:
+            self.valid_prog_environs = ['cpeIntel']
         else:
-            self.num_tasks = 32
-            self.num_tasks_per_node = 2
-            self.use_multithreading = True
-
-        self.reference = self.references_by_variant[self.variant]
-        self.tags |= {'maintenance', 'production'}
+            self.valid_prog_environs = ['builtin']
 
-    @run_before('run')
-    def set_task_distribution(self):
-        self.job.options = ['--distribution=block:block']
 
     @run_before('run')
-    def set_cpu_binding(self):
+    def setup_run(self):
+        # set auto-detected architecture
+        self.skip_if_no_procinfo()
+        proc = self.current_partition.processor
+        arch = proc.arch
+
+        # set architecture for GPU partition (no auto-detection)
+        if self.current_partition.fullname in ['daint:gpu', 'dom:gpu']:
+            arch = 'sm_60'
+
+        try:
+            found = self.references[self.num_nodes][arch]
+        except KeyError:
+            self.skip(f'Configuration with {self.num_nodes} node(s) '
+                      f'is not supported on {arch!r}')
+
+        # common setup for every architecture
         self.job.launcher.options = ['--cpu-bind=cores']
+        self.job.options = ['--distribution=block:block']
+        self.num_tasks_per_node = proc.num_sockets
+        self.num_cpus_per_task = proc.num_cores // self.num_tasks_per_node
+        self.num_tasks = self.num_nodes * self.num_tasks_per_node
+        self.variables = {
+            'OMP_NUM_THREADS': str(self.num_cpus_per_task),
+            'OMP_PLACES': 'cores',
+            'OMP_PROC_BIND': 'close'
+        }
 
+        # custom settings for selected architectures
+        if arch == 'zen2':
+            self.variables.update({
+                'MPICH_OFI_STARTUP_CONNECT': '1'
+            })
 
-@rfm.simple_test
-class VASPGpuCheck(VASPCheck):
-    variant = parameter(['maint', 'prod'])
-    valid_systems = ['daint:gpu', 'dom:gpu']
-    executable = 'vasp_std'
-    num_gpus_per_node = 1
-    reference = {
-        'dom:gpu': {'time': (45.0, None, 0.15, 's')},
-        'daint:gpu': {'time': (45.0, None, 0.15, 's')},
-    }
-
-    @run_after('init')
-    def setup_by_variant(self):
-        self.descr = f'VASP GPU check (variant: {self.variant})'
-        if self.current_system.name == 'dom':
-            self.num_tasks = 6
-            self.num_tasks_per_node = 1
-            self.num_cpus_per_task = 12
-        else:
-            self.num_tasks = 16
-            self.num_tasks_per_node = 1
-
-        self.tags |= {'maintenance', 'production'}
+        # setup performance references
+        self.reference = self.references[self.num_nodes][arch]