experiment class for laghos

.github/workflows/run.yml

@@ -219,12 +219,13 @@ jobs:
             --disable-logger \
             workspace setup --dry-run
 
-      - name: Dry run laghos/mpi-only on LLNL-Magma-Penguin-icelake-OmniPath with allocation modifier
+      - name: Dry run dynamic laghos/mpi-only on LLNL-Magma-Penguin-icelake-OmniPath with allocation modifier
         run: |
-          ./bin/benchpark setup laghos/mpi-only LLNL-Magma-Penguin-icelake-OmniPath workspace/
+          ./bin/benchpark experiment init --dest=laghos-mpi-only laghos experiment=strong
+          ./bin/benchpark setup ./laghos-mpi-only LLNL-Magma-Penguin-icelake-OmniPath workspace/
           . workspace/setup.sh
           ramble \
-            --workspace-dir workspace/laghos/mpi-only/LLNL-Magma-Penguin-icelake-OmniPath/workspace \
+            --workspace-dir workspace/laghos-mpi-only/LLNL-Magma-Penguin-icelake-OmniPath/workspace \
             --disable-progress-bar \
             --disable-logger \
             workspace setup --dry-run

experiments/laghos/experiment.py

@@ -0,0 +1,78 @@
+# Copyright 2023 Lawrence Livermore National Security, LLC and other
+# Benchpark Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from benchpark.error import BenchparkError
+from benchpark.directives import variant
+from benchpark.experiment import Experiment
+from benchpark.scaling import StrongScaling
+from benchpark.expr.builtin.caliper import Caliper
+
+
+class Laghos(
+    Experiment,
+    StrongScaling,
+    Caliper,
+):
+
+    variant(
+        "workload",
+        default="triplept",
+        description="triplept or other problem",
+    )
+
+    variant(
+        "version",
+        default="develop",
+        description="app version",
+    )
+
+    def compute_applications_section(self):
+        # TODO: Replace with conflicts clause
+        scaling_modes = {
+            "strong": self.spec.satisfies("strong=oui"),
+            "single_node": self.spec.satisfies("single_node=oui"),
+        }
+
+        scaling_mode_enabled = [key for key, value in scaling_modes.items() if value]
+        if len(scaling_mode_enabled) != 1:
+            raise BenchparkError(
+                f"Only one type of scaling per experiment is allowed for application package {self.name}"
+            )
+
+        # Number of initial nodes
+        num_nodes = {"n_nodes": 1}
+
+        if self.spec.satisfies("single_node=oui"):
+            for pk, pv in num_nodes.items():
+                self.add_experiment_variable(pk, pv, True)
+        elif self.spec.satisfies("strong=oui"):
+            scaled_variables = self.generate_strong_scaling_params(
+                {tuple(num_nodes.keys()): list(num_nodes.values())},
+                int(self.spec.variants["scaling-factor"][0]),
+                int(self.spec.variants["scaling-iterations"][0]),
+            )
+            for pk, pv in scaled_variables.items():
+                self.add_experiment_variable(pk, pv, True)
+
+        self.add_experiment_variable("n_ranks", "{sys_cores_per_node} * {n_nodes}", True)
+
+    def compute_spack_section(self):
+        # get package version
+        app_version = self.spec.variants["version"][0]
+
+        # get system config options
+        # TODO: Get compiler/mpi/package handles directly from system.py
+        system_specs = {}
+        system_specs["compiler"] = "default-compiler"
+        system_specs["mpi"] = "default-mpi"
+
+        # set package spack specs
+        # empty package_specs value implies external package
+        self.add_spack_spec(system_specs["mpi"])
+        #self.add_spack_spec(system_specs["blas"])
+
+        self.add_spack_spec(
+            self.name, [f"laghos@{app_version} +metis", system_specs["compiler"]]
+        )

repo/laghos/application.py

@@ -19,9 +19,29 @@ class Laghos(ExecutableApplication):
             'lagrangian','spatial-discretization','unstructured-grid',
             'network-latency-bound','network-collectives','unstructured-grid']
 
-    executable('p', 'laghos -p 3 -m {laghos}/data/box01_hex.mesh -rs 5 -ms 500', use_mpi=True)
-
-    workload('problem', executables=['p'])
+    executable('prob', 'laghos -p {problem} -m {mesh} -rs {rs} -rp {rp} -ms {ms}', use_mpi=True)
+
+    workload('triplept', executables=['prob'])
+
+    workload_variable('mesh', default='{laghos}/data/box01_hex.mesh',
+            description='mesh file',
+            workloads=['triplept'])
+
+    workload_variable('problem', default='3',
+            description='problem number',
+            workloads=['triplept'])
+
+    workload_variable('rs', default='5',
+            description='number of serial refinements',
+            workloads=['triplept'])
+
+    workload_variable('rp', default='0',
+            description='number of parallel refinements',
+            workloads=['triplept'])
+
+    workload_variable('ms', default='500',
+            description='max number of steps',
+            workloads=['triplept'])
 
     figure_of_merit('Major kernels total time',
                     log_file='{experiment_run_dir}/{experiment_name}.out',

repo/laghos/package.py

@@ -33,7 +33,8 @@ class Laghos(MakefilePackage):
     depends_on("caliper", when="+caliper")
     depends_on("adiak", when="+caliper")
 
-    depends_on("mfem@develop", when="@develop")
+    depends_on("[email protected]+optimize+pic+shared", when="@develop")
+    depends_on("mfem@develop^[email protected]+optimize+pic+shared", when="@develop")
     depends_on("[email protected]:", when="@3.1")
     depends_on("[email protected]:4.1", when="@3.0")
     # Recommended mfem version for laghos v2.0 is: ^[email protected]

var/exp_repo/experiments/laghos/experiment.py

@@ -0,0 +1,74 @@
+from benchpark.directives import variant
+from benchpark.experiment import Experiment
+
+
+class Laghos(Experiment):
+
+    variant(
+        "experiment",
+        default="strong",
+        values=("single-node", "strong"),
+        description="weak or strong scaling",
+    )
+
+    variant(
+        "workload",
+        default="triplept",
+        description="triplept or other problem",
+    )
+
+    def compute_applications_section(self):
+        app_name = self.spec.name
+        if self.spec.satisfies("workload=triplept"):
+            self.workload = "triplept"
+        else:
+            self.workload = "triplept"
+        variables = {}
+
+        if self.spec.satisfies("experiment=single-node"):
+            variables["n_nodes"] = ["1"]
+        elif self.spec.satisfies("experiment=strong"):
+            variables["n_nodes"] = ["1", "2", "4", "8", "16", "32", "64", "128"]
+
+        variables["n_ranks"] = "{sys_cores_per_node} * {n_nodes}"
+
+        experiment_name_template = f"laghos_{self.spec.variants['experiment'][0]}"
+        experiment_name_template += "_{n_nodes}_{n_ranks}"
+        return {
+            app_name: {  # ramble Application name
+                "workloads": {
+                    f"{self.workload}": {
+                        "experiments": {
+                            experiment_name_template: {
+                                "variants": {"package_manager": "spack"},
+                                "variables": variables,
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+    def compute_spack_section(self):
+        laghos_spack_spec = "laghos@develop +metis"
+        zlib_spack_spec = "[email protected] +optimize+pic+shared"
+        packages = [
+            "default-mpi",
+            "zlib",
+            "blas",
+            self.spec.name,
+        ]
+
+        return {
+            "packages": {
+                "zlib": {
+                    "pkg_spec": zlib_spack_spec,
+                    "compiler": "default-compiler",
+                },
+                "laghos": {
+                    "pkg_spec": laghos_spack_spec,
+                    "compiler": "default-compiler",  # TODO: this should probably move?
+                },
+            },
+            "environments": {"laghos": {"packages": packages}},
+        }