Test uniform

apps/benchmarks/NonUniformGridGPU/simulation_setup/benchmark_configs.py

@@ -4,6 +4,11 @@ import sqlite3
 import os
 import sys
 
+try:
+    import machinestate as ms
+except ImportError:
+    ms = None
+
 DB_FILE = os.environ.get('DB_FILE', "cpu_benchmark.sqlite3")
 
 
@@ -15,6 +20,7 @@ class Scenario:
                  refinement_depth=0,
                  cells_per_block=(32, 32, 32),
                  timesteps=101,
+                 gpu_enabled_mpi=False,
                  vtk_write_frequency=0,
                  logger_frequency=0,
                  blockforest_filestem="blockforest",
@@ -31,6 +37,7 @@ class Scenario:
         self.write_setup_vtk = write_setup_vtk
 
         self.timesteps = timesteps
+        self.gpu_enabled_mpi = gpu_enabled_mpi
         self.vtk_write_frequency = vtk_write_frequency
         self.logger_frequency = logger_frequency
 
@@ -61,7 +68,7 @@ class Scenario:
                 'vtkWriteFrequency': self.vtk_write_frequency,
                 'useVTKAMRWriter': True,
                 'oneFilePerProcess': False,
-                'gpuEnabledMPI': False,
+                'gpuEnabledMPI': self.gpu_enabled_mpi,
             },
             'Logging': {
                 'logLevel': "info",
@@ -84,8 +91,16 @@ class Scenario:
         data['compile_flags'] = wlb.build_info.compiler_flags
         data['walberla_version'] = wlb.build_info.version
         data['build_machine'] = wlb.build_info.build_machine
-        sequenceValuesToScalars(data)
 
+        if ms:
+            state = ms.MachineState(extended=False, anonymous=True)
+            state.generate()                        # generate subclasses
+            state.update()                          # read information
+            data["MachineState"] = str(state.get())
+        else:
+            print("MachineState module is not available. MachineState was not saved")
+
+        sequenceValuesToScalars(data)
         result = data
         sequenceValuesToScalars(result)
         num_tries = 4
@@ -114,29 +129,33 @@ def validation_run():
     scenario = Scenario(domain_size=domain_size,
                         root_blocks=root_blocks,
                         cells_per_block=cells_per_block,
-                        refinement_depth=1)
+                        refinement_depth=1,
+                        gpu_enabled_mpi=False)
     scenarios.add(scenario)
 
 
-def scaling():
+def scaling(num_proc, gpu_enabled_mpi=False):
     wlb.log_info_on_root("Running scaling benchmark...")
 
-    # numProc = wlb.mpi.numProcesses()
+    if wlb.mpi.numProcesses() > 1:
+        num_proc = wlb.mpi.numProcesses()
 
-    cells_per_block = (200, 200, 200)
-    domain_size = (cells_per_block[0] * 3, cells_per_block[1] * 3, cells_per_block[2] * 1)
+    cells_per_block = (192, 192, 192)
+    domain_size = (cells_per_block[0] * 3, cells_per_block[1] * 3, cells_per_block[2] * 3 * num_proc)
 
     root_blocks = tuple([d // c for d, c in zip(domain_size, cells_per_block)])
 
     scenarios = wlb.ScenarioManager()
-    scenario = Scenario(domain_size=domain_size,
+    scenario = Scenario(blockforest_filestem=f"blockforest_{num_proc}",
+                        domain_size=domain_size,
                         root_blocks=root_blocks,
                         num_processes=4,
                         cells_per_block=cells_per_block,
-                        refinement_depth=3,
-                        timesteps=10)
+                        refinement_depth=0,
+                        timesteps=10,
+                        gpu_enabled_mpi=gpu_enabled_mpi)
     scenarios.add(scenario)
 
 
 # validation_run()
-scaling()
+scaling(4, True)