features/branson

experiments/branson/experiment.py

@@ -0,0 +1,101 @@
+# 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.scaling import WeakScaling
+from benchpark.expr.builtin.caliper import Caliper
+
+
+class Branson(
+    Experiment,
+    StrongScaling,
+    WeakScaling,
+    Caliper,
+):
+    variant(
+        "workload",
+        default="branson",
+        description="workload name",
+    )
+
+    variant(
+        "version",
+        default="develop",
+        description="app version",
+    )
+
+    def compute_applications_section(self):
+        # TODO: Replace with conflicts clause
+        scaling_modes = {
+            "strong": self.spec.satisfies("+strong"),
+            "weak": self.spec.satisfies("+weak"),
+            "single_node": self.spec.satisfies("+single_node"),
+        }
+
+        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 processes in each dimension
+        num_nodes = {"n_nodes": 1}
+
+        # Per-process size (in zones) in each dimension
+        num_particles = {"num_particles": 850000000}
+
+        if self.spec.satisfies("+single_node"):
+            for pk, pv in num_nodes.items():
+                self.add_experiment_variable(pk, pv, True)
+            for nk, nv in num_particles.items():
+                self.add_experiment_variable(nk, nv, True)
+        elif self.spec.satisfies("+strong"):
+            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)
+            for nk, nv in num_particles.items():
+                self.add_experiment_variable(nk, nv, True)
+        elif self.spec.satisfies("+weak"):
+            scaled_variables = self.generate_weak_scaling_params(
+                {tuple(num_nodes.keys()): list(num_nodes.values())},
+                {tuple(num_particles.keys()): list(num_particles.values())},
+                int(self.spec.variants["scaling-factor"][0]),
+                int(self.spec.variants["scaling-iterations"][0]),
+            )
+            for k, v in scaled_variables.items():
+                self.add_experiment_variable(k, v, True)
+
+        self.add_experiment_variable("n_ranks", "{n_nodes}*{sys_cores_per_node}", 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"
+        # if self.spec.satisfies("+cuda"):
+        #     system_specs["cuda_version"] = "{default_cuda_version}"
+        #     system_specs["cuda_arch"] = "{cuda_arch}"
+        #     system_specs["blas"] = "cublas-cuda"
+        # if self.spec.satisfies("+rocm"):
+        #     system_specs["rocm_arch"] = "{rocm_arch}"
+        #     system_specs["blas"] = "blas-rocm"
+
+        # set package spack specs
+        self.add_spack_spec(system_specs["mpi"])
+
+        self.add_spack_spec(
+            self.name, [f"branson@{app_version}", system_specs["compiler"]]
+        )

legacy/experiments/branson/mpi-only/ramble.yaml

@@ -0,0 +1,51 @@
+ramble:
+  applications:
+    branson:
+      workloads:
+        branson:
+          experiments:
+            branson_branson_weak_scaling_caliper_time_mpi_{n_nodes}_{num_particles}_{n_ranks}:
+              exclude: {}
+              matrix: []
+              variables:
+                n_nodes:
+                - 1
+                - 2
+                - 4
+                - 8
+                n_ranks: '{n_nodes}*{sys_cores_per_node}'
+                num_particles:
+                - 850000000
+                - 1700000000
+                - 3400000000
+                - 6800000000
+              variants:
+                package_manager: spack
+              zips: {}
+  config:
+    deprecated: true
+    spack_flags:
+      concretize: -U -f
+      install: --add --keep-stage
+  include:
+  - ./configs
+  modifiers:
+  - name: allocation
+  - mode: mpi
+    name: caliper
+  - mode: time
+    name: caliper
+  software:
+    environments:
+      branson:
+        packages:
+        - caliper
+        - default-mpi
+        - branson
+    packages:
+      branson:
+        compiler: default-compiler
+        pkg_spec: branson@develop+caliper
+      caliper:
+        compiler: default-compiler
+        pkg_spec: caliper@master+adiak+mpi~libunwind~libdw~papi

repo/branson/package.py

@@ -6,6 +6,8 @@
 from spack.package import *
 from spack.pkg.builtin.boost import Boost
 
+import os
+
 
 class Branson(CMakePackage):
     """Branson's purpose is to study different algorithms for parallel Monte
@@ -30,6 +32,9 @@ class Branson(CMakePackage):
     )
     version("0.81", sha256="493f720904791f06b49ff48c17a681532c6a4d9fa59636522cf3f9700e77efe4")
     version("0.8", sha256="85ffee110f89be00c37798700508b66b0d15de1d98c54328b6d02a9eb2cf1cb8")
+
+    variant("caliper", default=False, description="Enable Caliper monitoring")
+
     #depends_on("mpi")
     depends_on("mpi@2:")
 
@@ -39,16 +44,39 @@ class Branson(CMakePackage):
     depends_on(Boost.with_default_variants, when="@:0.81")
     depends_on("metis")
     depends_on("parmetis", when="@:0.81")
+    depends_on("caliper", when="+caliper")
+    depends_on("adiak", when="+caliper")
 
     root_cmakelists_dir = "src"
 
+    def patch(self):
+        ppu_intrinsics_file = os.path.join(self.stage.source_path, "src", "random123", "features", "ppu_intrinsics.h")
+        with open(ppu_intrinsics_file , "w") as f:
+            pass
+
+    def setup_build_environment(self, env):
+        if not self.spec.satisfies("+cuda"):
+            env.unset("CUDA_HOME")
+            env.unset("CUDADIR")
+            env.unset("CUDACXX")
+
     def cmake_args(self):
         spec = self.spec
         args = []
         #args.append("--enable-mpi")
         args.append(f"-DCMAKE_C_COMPILER={spec['mpi'].mpicc}")
         args.append(f"-DCMAKE_CXX_COMPILER={spec['mpi'].mpicxx}")
         args.append(f"-DCMAKE_Fortran_COMPILER={spec['mpi'].mpifc}")
+
+        cflags = " ".join(self.compiler.flags['cflags']) if 'cflags' in self.compiler.flags else ""
+        cxxflags = " ".join(self.compiler.flags['cxxflags']) if 'cxxflags' in self.compiler.flags else ""
+
+        args.append("-DCMAKE_C_FLAGS={} -I{}/src/random123/features".format(cflags, self.stage.source_path))
+        args.append("-DCMAKE_CXX_FLAGS={} -I{}/src/random123/features".format(cxxflags, self.stage.source_path))
+        args.append(f"-DBUILD_TESTING=OFF")
+        if self.spec.satisfies("+caliper"):
+            args.append(f"-DCALIPER_ROOT_DIR={self.spec['caliper'].prefix}")
+
         return args
 
     def install(self, spec, prefix):