Add command: benchpark system init

bin/benchpark-python

@@ -0,0 +1,21 @@
+#!/bin/sh
+#
+# 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
+
+#
+# benchpark-python
+#
+# If you want to write your own executable Python script that uses Benchpark
+# modules, on Mac OS or maybe some others, you may be able to do it like
+# this:
+#
+#   #!/usr/bin/env benchpark-python
+#
+# This is compatible across platforms.
+#
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+export PYTHONPATH="${SCRIPT_DIR}/../lib":$PYTHONPATH
+exec python3 -i "$@"

lib/benchpark/directives.py

@@ -0,0 +1,203 @@
+# 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
+
+import collections.abc
+import inspect
+import os
+import re
+from typing import Any, Callable, Optional, Tuple, Union
+
+import benchpark.spec
+import benchpark.paths
+import benchpark.repo
+import benchpark.runtime
+import benchpark.variant
+
+import ramble.language.language_base
+import ramble.language.language_helpers
+import ramble.language.shared_language
+from ramble.language.language_base import DirectiveError
+
+
+# TODO remove this when it is added to ramble.lang (when ramble updates from spack
+class classproperty:
+    """Non-data descriptor to evaluate a class-level property. The function that performs
+    the evaluation is injected at creation time and take an instance (could be None) and
+    an owner (i.e. the class that originated the instance)
+    """
+
+    def __init__(self, callback):
+        self.callback = callback
+
+    def __get__(self, instance, owner):
+        return self.callback(owner)
+
+
+class DirectiveMeta(ramble.language.shared_language.SharedMeta):
+    """
+    metaclass for supporting directives (e.g., depends_on) and phases
+    """
+
+    _directive_names = set()
+    _directives_to_be_executed = []
+
+    # Hack to be able to use SharedMeta outside of Ramble
+    # will ask Ramble to implement fix on their end and then we can remove this
+    def __init__(self, *args, **kwargs):
+        with benchpark.repo.override_ramble_hardcoded_globals():
+            super(DirectiveMeta, self).__init__(*args, **kwargs)
+
+
+benchpark_directive = DirectiveMeta.directive
+
+
+@benchpark_directive("variants")
+def variant(
+    name: str,
+    default: Optional[Any] = None,
+    description: str = "",
+    values: Optional[Union[collections.abc.Sequence, Callable[[Any], bool]]] = None,
+    multi: Optional[bool] = None,
+    validator: Optional[Callable[[str, str, Tuple[Any, ...]], None]] = None,
+    when: Optional[Union[str, bool]] = None,
+    sticky: bool = False,
+):
+    """Define a variant.
+    Can specify a default value as well as a text description.
+    Args:
+        name: Name of the variant
+        default: Default value for the variant, if not specified otherwise the default will be
+            False for a boolean variant and 'nothing' for a multi-valued variant
+        description: Description of the purpose of the variant
+        values: Either a tuple of strings containing the allowed values, or a callable accepting
+            one value and returning True if it is valid
+        multi: If False only one value per spec is allowed for this variant
+        validator: Optional group validator to enforce additional logic. It receives the experiment
+            name, the variant name and a tuple of values and should raise an instance of BenchparkError
+            if the group doesn't meet the additional constraints
+        when: Optional condition on which the variant applies
+        sticky: The variant should not be changed by the concretizer to find a valid concrete spec
+    Raises:
+        DirectiveError: If arguments passed to the directive are invalid
+    """
+
+    def format_error(msg, pkg):
+        msg += " @*r{{[{0}, variant '{1}']}}"
+        return msg.format(pkg.name, name)
+
+    def _always_true(_x):
+        return True
+
+    # Ensure we have a sequence of allowed variant values, or a
+    # predicate for it.
+    if values is None:
+        if str(default).upper() in ("TRUE", "FALSE"):
+            values = (True, False)
+        else:
+            values = _always_true
+
+    # The object defining variant values might supply its own defaults for
+    # all the other arguments. Ensure we have no conflicting definitions
+    # in place.
+    for argument in ("default", "multi", "validator"):
+        # TODO: we can consider treating 'default' differently from other
+        # TODO: attributes and let a packager decide whether to use the fluent
+        # TODO: interface or the directive argument
+        if hasattr(values, argument) and locals()[argument] is not None:
+
+            def _raise_argument_error(pkg):
+                msg = (
+                    "Remove specification of {0} argument: it is handled "
+                    "by an attribute of the 'values' argument"
+                )
+                raise DirectiveError(format_error(msg.format(argument), pkg))
+
+            return _raise_argument_error
+
+    # Allow for the object defining the allowed values to supply its own
+    # default value and group validator, say if it supports multiple values.
+    default = getattr(values, "default", default)
+    validator = getattr(values, "validator", validator)
+    multi = getattr(values, "multi", bool(multi))
+
+    # Here we sanitize against a default value being either None
+    # or the empty string, as the former indicates that a default
+    # was not set while the latter will make the variant unparsable
+    # from the command line
+    if default is None or default == "":
+
+        def _raise_default_not_set(pkg):
+            if default is None:
+                msg = "either a default was not explicitly set, or 'None' was used"
+            elif default == "":
+                msg = "the default cannot be an empty string"
+            raise DirectiveError(format_error(msg, pkg))
+
+        return _raise_default_not_set
+
+    description = str(description).strip()
+
+    def _execute_variant(pkg):
+        if not re.match(benchpark.spec.IDENTIFIER, name):
+            directive = "variant"
+            msg = "Invalid variant name in {0}: '{1}'"
+            raise DirectiveError(directive, msg.format(pkg.name, name))
+
+        pkg.variants[name] = benchpark.variant.Variant(
+            name, default, description, values, multi, validator, sticky
+        )
+
+    return _execute_variant
+
+
+class SpecTemplate(metaclass=DirectiveMeta):
+    @classproperty
+    def package_dir(cls):
+        """Directory where the package.py file lives."""
+        return os.path.abspath(os.path.dirname(cls.module.__file__))
+
+    @classproperty
+    def module(cls):
+        """Module object (not just the name) that this package is defined in.
+        We use this to add variables to package modules.  This makes
+        install() methods easier to write (e.g., can call configure())
+        """
+        return __import__(cls.__module__, fromlist=[cls.__name__])
+
+    @classproperty
+    def namespace(cls):
+        """Spack namespace for the package, which identifies its repo."""
+        parts = cls.__module__.split(".")
+        return ".".join(parts[2:-1])
+
+    @classproperty
+    def fullname(cls):
+        """Name of this package, including the namespace"""
+        return f"{cls.namespace}.{cls.name}"
+
+    @classproperty
+    def fullnames(cls):
+        """Fullnames for this package and any packages from which it inherits."""
+        fullnames = []
+        for cls in inspect.getmro(cls):
+            namespace = getattr(cls, "namespace", None)
+            if namespace:
+                fullnames.append(f"{namespace}.{cls.name}")
+            if namespace == "builtin":
+                # builtin packages cannot inherit from other repos
+                break
+        return fullnames
+
+    @classproperty
+    def name(cls):
+        """The name of this package.
+        The name of a package is the name of its Python module, without
+        the containing module names.
+        """
+        if cls._name is None:
+            cls._name = cls.module.__name__
+            if "." in cls._name:
+                cls._name = cls._name[cls._name.rindex(".") + 1 :]
+        return cls._name

lib/benchpark/error.py

@@ -0,0 +1,81 @@
+# 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
+
+import inspect
+import sys
+
+#: at what level we should write stack traces or short error messages
+#: this is module-scoped because it needs to be set very early
+debug = 0
+
+
+class BenchparkError(Exception):
+    """This is the superclass for all Benchpark errors.
+    Subclasses can be found in the modules they have to do with.
+    """
+
+    def __init__(self, message, long_message=None):
+        super().__init__()
+        self.message = message
+        self._long_message = long_message
+
+        # for exceptions raised from child build processes, we save the
+        # traceback as a string and print it in the parent.
+        self.traceback = None
+
+        # we allow exceptions to print debug info via print_context()
+        # before they are caught at the top level. If they *haven't*
+        # printed context early, we do it by default when die() is
+        # called, so we need to remember whether it's been called.
+        self.printed = False
+
+    @property
+    def long_message(self):
+        return self._long_message
+
+    def print_context(self):
+        """Print extended debug information about this exception.
+
+        This is usually printed when the top-level Spack error handler
+        calls ``die()``, but it can be called separately beforehand if a
+        lower-level error handler needs to print error context and
+        continue without raising the exception to the top level.
+        """
+        if self.printed:
+            return
+
+        # basic debug message
+        if self.long_message:
+            sys.stderr.write(self.long_message)
+            sys.stderr.write("\n")
+
+        # stack trace, etc. in debug mode.
+        if debug:
+            if self.traceback:
+                # exception came from a build child, already got
+                # traceback in child, so print it.
+                sys.stderr.write(self.traceback)
+            else:
+                # run parent exception hook.
+                sys.excepthook(*sys.exc_info())
+
+        sys.stderr.flush()
+        self.printed = True
+
+    def die(self):
+        self.print_context()
+        sys.exit(1)
+
+    def __str__(self):
+        msg = self.message
+        if self._long_message:
+            msg += "\n    %s" % self._long_message
+        return msg
+
+    def __repr__(self):
+        args = [repr(self.message), repr(self.long_message)]
+        args = ",".join(args)
+        qualified_name = inspect.getmodule(self).__name__ + "." + type(self).__name__
+        return qualified_name + "(" + args + ")"