Moose::internal::Capabilities Class Reference

Holds the public (to MooseApp) facing CapabilityRegistry for storing and checking capabilities. More...

#include <Capabilities.h>

Inheritance diagram for Moose::internal::Capabilities:

Classes
class	AugmentPassKey
	Passkey for augment() More...
class	GetCapabilitiesPassKey
	Passkey for get() More...

Public Types
enum	CheckState {   CERTAIN_FAIL = 0, POSSIBLE_FAIL = 1, UNKNOWN = 2, POSSIBLE_PASS = 3,   CERTAIN_PASS = 4, IGNORE = 5 }
	Return state for check. More...
using	RegistryType = std::map< std::string, Capability, std::less<> >
	Type for the registry. More...

Public Member Functions
std::string	dump () const
	create a JSON dump of the capabilities registry More...
void	augment (const nlohmann::json &input, const AugmentPassKey)
	Augment the capabilities with the given input capabilities. More...
bool	isRelocated () const
bool	isInTree () const
Capability &	add (const std::string_view name, const Moose::Capability::Value &value, const std::string_view doc)
	Add a capability. More...
std::size_t	size () const
CheckResult	check (std::string requirements, const CapabilityRegistry::CheckOptions &options=CapabilityRegistry::CheckOptions()) const
	Checks if a set of requirements is satisified by the capabilities. More...
	Capabilities (Capabilities const &)=delete
	Don't allow creation through copy/move construction or assignment. More...
Capabilities &	operator= (Capabilities const &)=delete
	Capabilities (Capabilities &&)=delete
Capabilities &	operator= (Capabilities &&)=delete
const Capability *	query (std::string capability) const
	Query a capability, if it exists, otherwise nullptr. More...
Capability *	query (std::string capability)
const Capability &	get (const std::string &capability) const
	Get a capability. More...
Capability &	get (const std::string &capability)

Static Public Member Functions
static Capabilities &	getCapabilities (const GetCapabilitiesPassKey)
	Get the singleton Capabilities. More...

Static Public Attributes
static const std::set< std::string, std::less<> >	augmented_capability_names
	Capabilities that are reserved and can only be augmented. More...

Protected Attributes
RegistryType	_registry
	Registry storage. More...

Private Member Functions
	FRIEND_TEST (::CapabilitiesTest, isInstallationType)
	FRIEND_TEST (::CapabilitiesTest, mooseAppIsRelocated)
	FRIEND_TEST (::CapabilitiesTest, mooseAppisInTree)
bool	isInstallationType (const std::string &installation_type) const
	Helper for isRelocated() and isInTree() More...
void	registerMooseCapabilities ()
	Register the MOOSE capabilities. More...
	Capabilities ()

Friends
class	::CapabilitiesTest
class	::DataFileUtilsTest
class	::RegistryTest

Detailed Description

Holds the public (to MooseApp) facing CapabilityRegistry for storing and checking capabilities.

A capability can refer to an optional library or optional functionality. Capabilities can either be registered as boolean values (present or not), an integer quantity (like the AD backing store size), a string (like the compiler used to build the executable), or a version number (numbers separated by dots, e.g. the petsc version).

Definition at line 50 of file Capabilities.h.

Member Typedef Documentation

RegistryType

using Moose::internal::CapabilityRegistry::RegistryType = std::map<std::string, Capability, std::less<> >

inherited

Type for the registry.

Definition at line 43 of file CapabilityRegistry.h.

Member Enumeration Documentation

CheckState

enum Moose::internal::CapabilityRegistry::CheckState

inherited

Return state for check.

We use a plain enum because we rely on implicit conversion to int. Capability checks are run in the test harness using the JSON dump exported from the executable using --show-capabilities. This static check does not take dynamic loading into account, as capabilities that would be registered after initializing the dynamically loaded application will not exist with --show-capabilities.

A requested capability that is not registered at all is considered in a "possible" state, as we cannot guarantee that it does or not exist with a dynamic application. If no dynamic application loading is used, the possible states can be considered certain states.

When the test harness Tester specification "dynamic_capabilities" is set to True, it will run the test unless the result of the check is CERTAIN_FAIL. In this case, the runtime check in the executable will terminate if the result is either CERTAIN_FAIL or POSSIBLE_FAIL.

Enumerator
CERTAIN_FAIL
POSSIBLE_FAIL
UNKNOWN
POSSIBLE_PASS
CERTAIN_PASS
IGNORE

Definition at line 61 of file CapabilityRegistry.h.

  {
    CERTAIN_FAIL = 0,
    POSSIBLE_FAIL = 1,
    UNKNOWN = 2,
    POSSIBLE_PASS = 3,
    CERTAIN_PASS = 4,
    IGNORE = 5
  };

Constructor & Destructor Documentation

Capabilities() [1/3]

Moose::internal::Capabilities::Capabilities ( Capabilities const &  )

delete

Don't allow creation through copy/move construction or assignment.

Capabilities() [2/3]

Moose::internal::Capabilities::Capabilities ( Capabilities &&  )

delete

Capabilities() [3/3]

Moose::internal::Capabilities::Capabilities ( )

private

Definition at line 45 of file Capabilities.C.

Referenced by getCapabilities().

                           : CapabilityRegistry()
{
  // Register the moose capabilities, just once
  registerMooseCapabilities();
}

Member Function Documentation

add()

Capability & Moose::internal::CapabilityRegistry::add ( const std::string_view  name, const Moose::Capability::Value &  value, const std::string_view  doc  )

inherited

Add a capability.

Parameters

registry	The registry
capability	The name of the capability
value	The value of the capability
doc	The documentation string

Returns

The capability

Definition at line 34 of file CapabilityRegistry.C.

Referenced by Registry::addDataFilePathCapability(), augment(), AppFactory::registerAppCapability(), and registerMooseCapabilities().

{
  auto it_pair = _registry.lower_bound(name);
  if (it_pair != _registry.end() && it_pair->first == name)
  {
    auto & capability = it_pair->second;
    if (capability.getValue() != value || capability.getDoc() != doc)
      throw CapabilityException("Capability '" + std::string(name) +
                                "' already exists and is not equal");
    return capability;
  }

  return _registry
      .emplace_hint(it_pair,
                    std::piecewise_construct,
                    std::forward_as_tuple(name),
                    std::forward_as_tuple(name, value, doc))
      ->second;
}

augment()

void Moose::internal::Capabilities::augment	(	const nlohmann::json &	input,
		const AugmentPassKey
	)

Augment the capabilities with the given input capabilities.

This is used when loading additional capabilities at run time from the TestHarness and thus is only allowed to be used by the MooseApp.

Definition at line 80 of file Capabilities.C.

{
  for (const auto & [name_json, entry] : input.items())
  {
    const std::string name = name_json;

    const auto error = [&name](const std::string & message)
    { throw CapabilityException("Capabilities::augment: Capability '" + name + "' " + message); };

    std::string doc;
    if (const auto it = entry.find("doc"); it != entry.end())
      doc = *it;
    else
      error("missing 'doc' entry");

    Moose::Capability::Value value;
    if (const auto it = entry.find("value"); it != entry.end())
    {
      if (it->is_boolean())
        value = it->get<bool>();
      else if (it->is_number_integer())
        value = it->get<int>();
      else
        value = it->get<std::string>();
    }
    else
      error("missing 'value' entry");

    auto & capability = add(name, value, doc);

    if (const auto it = entry.find("explicit"); it != entry.end() && it->get<bool>())
      capability.setExplicit();

    if (const auto it = entry.find("enumeration"); it != entry.end())
      capability.setEnumeration(it->get<std::set<std::string>>());
  }
}

check()

CapabilityRegistry::CheckResult Moose::internal::CapabilityRegistry::check ( std::string  requirements, const CapabilityRegistry::CheckOptions &  options = CapabilityRegistry::CheckOptions()  ) const

inherited

Checks if a set of requirements is satisified by the capabilities.

Parameters

requirements	The requirement string
options	Options to apply to the check

This method is exposed to Python within pycapabilities.Capabilities.check in python/pycapabilities/_pycapabilities.C. This external method is used significantly by the TestHarness to check capabilities for individual test specs.

Additionally, this method is used by the MooseApp command line option "--required-capabilities ...".

Requirements can use comparison operators (>,<,>=,<=,=!,=), where the name of the capability must always be on the left hand side. Comparisons can be performed on strings "compiler!=GCC" (which are case insensitive), integer numbers "ad_size>=50", and version numbers "petsc>3.8.0". The state of a boolean valued capability can be tested by just specifying the capability name "chaco". This check can be inverted using the ! operator as "!chaco".

The logic operators & and | can be used to chain multiple checks as "thermochimica & thermochimica>1.0". Parenthesis can be used to build complex logic expressions.

Definition at line 86 of file CapabilityRegistry.C.

{
  using namespace peg;

  // unquote
  while (true)
  {
    const auto len = requirements.length();
    if (len >= 2 && ((requirements[0] == '\'' && requirements[len - 1] == '\'') ||
                     (requirements[0] == '"' && requirements[len - 1] == '"')))
      requirements = requirements.substr(1, len - 2);
    else
      break;
  }

  CheckResult result;
  result.state = CheckState::CERTAIN_FAIL;

  if (requirements.length() == 0)
  {
    result.state = CheckState::CERTAIN_PASS;
    return result;
  }

  static parser parser(R"(
    Expression    <-  _ Bool _ LogicOperator _ Expression / Bool _
    Bool          <-  Comparison / '!' Bool / '!' Identifier / Identifier / '(' _ Expression _ ')'
    Comparison    <-  Identifier _ Operator _ Version / Identifier _ Operator _ String
    String        <-  [a-zA-Z0-9_-]+
    Identifier    <-  [a-zA-Z][a-zA-Z0-9_]*
    Operator      <-  [<>=!]+
    LogicOperator <-  [&|]
    Version       <-  Number '.' Version  / Number
    Number        <-  [0-9]+
    ~_            <-  [ \t]*
  )");

  if (!static_cast<bool>(parser))
    throw CapabilityException("Capabilities parser build failure.");

  // Keep track of unknown capabilities in the event that
  // the check must be certain
  std::set<std::string> unknown_capabilities;
  const auto add_unknown_capability = [&unknown_capabilities](const auto & name)
  { unknown_capabilities.insert(MooseUtils::toLower(name)); };

  // Make sure that the capabilities to ignore are valid capabilities
  for (const auto & name : options.ignore_capabilities)
    if (!_registry.count(name))
      throw CapabilityException("Capability to ignore '" + name + "' is not known");

  parser["Number"] = [](const SemanticValues & vs) { return vs.token_to_number<int>(); };

  parser["Version"] = [](const SemanticValues & vs)
  {
    switch (vs.choice())
    {
      case 0: // Number '.' Version
      {
        std::vector<int> ret{std::any_cast<int>(vs[0])};
        const auto & vs1 = std::any_cast<std::vector<int>>(vs[1]);
        ret.insert(ret.end(), vs1.begin(), vs1.end());
        return ret;
      }

      case 1: // Number
        return std::vector<int>{std::any_cast<int>(vs[0])};
    }

    checkException(vs, "unknown number match.");
  };

  enum LogicOperator
  {
    OP_AND,
    OP_OR
  };

  parser["LogicOperator"] = [](const SemanticValues & vs)
  {
    const auto op = vs.token();
    if (op == "&")
      return OP_AND;
    if (op == "|")
      return OP_OR;
    checkException(vs, "unknown logic operator.");
  };

  enum Operator
  {
    OP_LESS_EQ,
    OP_GREATER_EQ,
    OP_LESS,
    OP_GREATER,
    OP_NOT_EQ,
    OP_EQ
  };

  parser["Operator"] = [](const SemanticValues & vs)
  {
    const auto op = vs.token();
    if (op == "<=")
      return OP_LESS_EQ;
    if (op == ">=")
      return OP_GREATER_EQ;
    if (op == "<")
      return OP_LESS;
    if (op == ">")
      return OP_GREATER;
    if (op == "!=")
      return OP_NOT_EQ;
    if (op == "=" || op == "==")
      return OP_EQ;
    checkException(vs, "unknown operator.");
  };

  parser["String"] = [](const SemanticValues & vs) { return vs.token_to_string(); };
  parser["Identifier"] = [](const SemanticValues & vs) { return vs.token_to_string(); };

  parser["Comparison"] =
      [this, &add_unknown_capability, &options, &result](const SemanticValues & vs)
  {
    const auto left = std::any_cast<std::string>(vs[0]);
    const auto op = std::any_cast<Operator>(vs[1]);

    // check existence
    const auto capability_ptr = query(left);
    if (!capability_ptr)
    {
      // return an unknown if the capability does not exist, this is important as it
      // stays unknown upon negation
      add_unknown_capability(left);
      return CheckState::UNKNOWN;
    }

    // capability is registered by the app
    const auto & capability = *capability_ptr;
    const auto & name = capability.getName();

    // register capability as seen
    result.capability_names.insert(name);

    // whether or not the capability is ignored
    const auto is_ignored = [&name, &options]() { return options.ignore_capabilities.count(name); };

    // explicitly false causes any comparison to fail unless ignored
    if (const auto bool_ptr = capability.queryBoolValue(); (bool_ptr && !(*bool_ptr)))
      return is_ignored() ? CheckState::IGNORE : CheckState::CERTAIN_FAIL;

    // comparator
    auto comp = [&is_ignored](const int i, const auto & a, const auto & b)
    {
      // early exit for ignored capabilities
      if (is_ignored())
        return CheckState::IGNORE;

      // do the comparison
      const auto do_comp = [&i, &a, &b]()
      {
        switch (i)
        {
          case OP_LESS_EQ:
            return a <= b;
          case OP_GREATER_EQ:
            return a >= b;
          case OP_LESS:
            return a < b;
          case OP_GREATER:
            return a > b;
          case OP_NOT_EQ:
            return a != b;
          case OP_EQ:
            return a == b;
        }
        return false;
      };
      return do_comp() ? CheckState::CERTAIN_PASS : CheckState::CERTAIN_FAIL;
    };

    // version comparison
    std::vector<int> app_value_version;

    switch (vs.choice())
    {
      case 0: // Identifier _ Operator _ Version
      {
        // int comparison
        const auto right = std::any_cast<std::vector<int>>(vs[2]);
        if (const auto int_ptr = capability.queryIntValue())
        {
          if (right.size() != 1)
            checkException(vs, "cannot be compared to a version.", capability);

          return comp(op, *int_ptr, right[0]);
        }

        const auto string_ptr = capability.queryStringValue();
        if (!string_ptr)
          checkException(vs,
                         "cannot be compared to a " +
                             std::string(right.size() == 1 ? "number" : "version number") + ".",
                         capability);

        if (!MooseUtils::tokenizeAndConvert(*string_ptr, app_value_version, "."))
          checkException(vs, "cannot be compared to a version.", capability);

        // compare versions
        return comp(op, app_value_version, right);
      }

      case 1: // Identifier _ Operator _ String
      {
        // here we would check for valid options and throw if not valid
        const auto right = MooseUtils::toLower(std::any_cast<std::string>(vs[2]));
        // the capability value has to be a string
        const auto string_ptr = capability.queryStringValue();
        if (!string_ptr)
          checkException(vs, "cannot be compared to a string.", capability);

        // If this capability has an enumeration, make sure a valid
        // choice is used
        if (!capability.hasEnumeration(right))
          checkException(vs,
                         "'" + right + "' invalid for capability '" + left +
                             "'; valid values: " + capability.enumerationToString());

        // Capability is a version
        if (MooseUtils::tokenizeAndConvert(*string_ptr, app_value_version, "."))
          checkException(vs, "cannot be compared to a string.", capability);

        return comp(op, *string_ptr, right);
      }
    }

    checkException(vs, "failed comparison.", capability);
  };

  parser["Bool"] = [this, &add_unknown_capability, &options, &result](const SemanticValues & vs)
  {
    switch (vs.choice())
    {
      case 0: // Comparison
      case 4: // '(' _ Expression _ ')'
        return std::any_cast<CheckState>(vs[0]);

      case 1: // '!' Bool
        switch (std::any_cast<CheckState>(vs[0]))
        {
          case CheckState::CERTAIN_FAIL:
            return CheckState::CERTAIN_PASS;
          case CheckState::CERTAIN_PASS:
            return CheckState::CERTAIN_FAIL;
          case CheckState::POSSIBLE_FAIL:
            return CheckState::POSSIBLE_PASS;
          case CheckState::POSSIBLE_PASS:
            return CheckState::POSSIBLE_FAIL;
          case CheckState::IGNORE:
            return CheckState::IGNORE;
          default:
            return CheckState::UNKNOWN;
        }

      case 2: // '!' Identifier
      case 3: // Identifier
      {
        const bool negated = vs.choice() == 2;
        const auto identifier = std::any_cast<std::string>(vs[0]);
        if (const auto capability_ptr = query(identifier))
        {
          const auto & capability = *capability_ptr;
          const auto & name = capability.getName();

          // explicit; cannot be a bool expression
          if (capability.getExplicit())
          {
            std::string message = "capability '" + name +
                                  "' requires a value and cannot be used in a boolean expression";
            if (capability.queryEnumeration())
              message += "; valid values: " + capability.enumerationToString();
            checkException(vs, message);
          }

          // mark as used
          result.capability_names.insert(name);
          // is ignored
          if (options.ignore_capabilities.count(name))
            return CheckState::IGNORE;

          // helper for negating a passing value if needed
          const auto bool_to_pass = [&negated](const bool val)
          { return (val ^ negated) ? CheckState::CERTAIN_FAIL : CheckState::CERTAIN_PASS; };
          // has a boolean value, so use it
          if (const auto bool_ptr = capability.queryBoolValue())
            return bool_to_pass(!*bool_ptr);
          // not ignored and doesn't have a boolean value
          return bool_to_pass(false);
        }

        add_unknown_capability(identifier);
        return negated ? CheckState::POSSIBLE_PASS : CheckState::POSSIBLE_FAIL;
      }

      default:
        throw CapabilityException("Unknown choice in Bool non-terminal");
    }
  };

  parser["Expression"] = [](const SemanticValues & vs)
  {
    switch (vs.choice())
    {
      case 0: // Bool _ LogicOperator _ Expression
      {
        const auto left = std::any_cast<CheckState>(vs[0]);
        const auto right = std::any_cast<CheckState>(vs[2]);
        const auto op = std::any_cast<LogicOperator>(vs[1]);

        switch (op)
        {
          case OP_AND:
            if (left == CheckState::IGNORE)
              return right;
            if (right == CheckState::IGNORE)
              return left;
            for (const auto state : {CheckState::CERTAIN_FAIL,
                                     CheckState::POSSIBLE_FAIL,
                                     CheckState::UNKNOWN,
                                     CheckState::POSSIBLE_PASS,
                                     CheckState::CERTAIN_PASS})
              if (left == state || right == state)
                return state;
            throw CapabilityException("Conjunction failure");

          case OP_OR:
            if (left == CheckState::IGNORE || right == CheckState::IGNORE)
              return CheckState::IGNORE;
            for (const auto state : {CheckState::CERTAIN_PASS,
                                     CheckState::POSSIBLE_PASS,
                                     CheckState::UNKNOWN,
                                     CheckState::POSSIBLE_FAIL,
                                     CheckState::CERTAIN_FAIL})
              if (left == state || right == state)
                return state;
            throw CapabilityException("Conjunction failure");

          default:
            throw CapabilityException("Unknown logic operator");
        }
      }

      case 1: // Bool
        return std::any_cast<CheckState>(vs[0]);

      default:
        throw CapabilityException("Unknown choice in Expression non-terminal");
    }
  };

  // (4) Parse
  parser.enable_packrat_parsing(); // Enable packrat parsing.

  if (!parser.parse(requirements, result.state))
    throw CapabilityException("Unable to parse requested capabilities '", requirements, "'.");

  // If certain and unknown capabilities were found, throw accordingly
  if (options.certain && unknown_capabilities.size())
    throw UnknownCapabilitiesException({unknown_capabilities.begin(), unknown_capabilities.end()});

  // Consider an ignored state to be a pass
  if (result.state == CheckState::IGNORE)
    result.state = CheckState::CERTAIN_PASS;

  return result;
}

dump()

std::string Moose::internal::Capabilities::dump

(

)

const

create a JSON dump of the capabilities registry

Definition at line 63 of file Capabilities.C.

{
  nlohmann::json root;
  for (const auto & [name, capability] : _registry)
  {
    auto & entry = root[name];
    std::visit([&entry](const auto & v) { entry["value"] = v; }, capability.getValue());
    entry["doc"] = capability.getDoc();
    if (const auto enumeration_ptr = capability.queryEnumeration())
      entry["enumeration"] = *enumeration_ptr;
    if (!capability.hasBoolValue())
      entry["explicit"] = capability.getExplicit();
  }
  return root.dump(2);
}

FRIEND_TEST() [1/3]

Moose::internal::Capabilities::FRIEND_TEST ( ::CapabilitiesTest  , isInstallationType    )

private

FRIEND_TEST() [2/3]

Moose::internal::Capabilities::FRIEND_TEST ( ::CapabilitiesTest  , mooseAppIsRelocated    )

private

FRIEND_TEST() [3/3]

Moose::internal::Capabilities::FRIEND_TEST ( ::CapabilitiesTest  , mooseAppisInTree    )

private

get() [1/2]

const Capability & Moose::internal::CapabilityRegistry::get ( const std::string &  capability ) const

inherited

Get a capability.

Will convert the capability name to lowercase.

Definition at line 66 of file CapabilityRegistry.C.

Referenced by MooseApp::setupOptions().

{
  if (const auto capability_ptr = query(capability))
    return *capability_ptr;
  throw CapabilityException("Capability '" + capability + "' not registered");
}

get() [2/2]

Capability & Moose::internal::CapabilityRegistry::get ( const std::string &  capability )

inlineinherited

Definition at line 184 of file CapabilityRegistry.h.

{
  return const_cast<Capability &>(std::as_const(*this).get(capability));
}

getCapabilities()

Capabilities & Moose::internal::Capabilities::getCapabilities ( const GetCapabilitiesPassKey  )

static

Get the singleton Capabilities.

Only accessible through MooseApp and AppFactory. Addition of capabilities should be done through the MooseApp::add[Bool,Int,String]capability() method.

Definition at line 52 of file Capabilities.C.

Referenced by MooseApp::addCapability(), MooseApp::addCapabilityInternal(), Registry::addDataFilePathCapability(), MooseApp::isInTree(), MooseApp::isRelocated(), AppFactory::registerAppCapability(), and MooseApp::setupOptions().

{
  // We need a naked new here (_not_ a smart pointer or object instance) due to what seems like a
  // bug in clang's static object destruction when using dynamic library loading.
  static Capabilities * capability_registry = nullptr;
  if (!capability_registry)
    capability_registry = new Capabilities();
  return *capability_registry;
}

isInstallationType()

bool Moose::internal::Capabilities::isInstallationType ( const std::string &  installation_type ) const

private

Helper for isRelocated() and isInTree()

Definition at line 119 of file Capabilities.C.

Referenced by isInTree(), isRelocated(), and registerMooseCapabilities().

{
  const auto & capability = get("installation_type");
  mooseAssert(capability.getEnumeration().count(installation_type), "Not a valid enumeration");
  return capability.getStringValue() == installation_type;
}

isInTree()

bool Moose::internal::Capabilities::isInTree ( ) const

inline

Returns

Whether or not the application is in-tree

Definition at line 126 of file Capabilities.h.

{ return isInstallationType("in_tree"); }

isRelocated()

bool Moose::internal::Capabilities::isRelocated ( ) const

inline

Returns

Whether or not the application is relocated

Definition at line 121 of file Capabilities.h.

{ return isInstallationType("relocated"); }

operator=() [1/2]

Capabilities& Moose::internal::Capabilities::operator= ( Capabilities const &  )

delete

operator=() [2/2]

Capabilities& Moose::internal::Capabilities::operator= ( Capabilities &&  )

delete

query() [1/2]

const Capability * Moose::internal::CapabilityRegistry::query ( std::string  capability ) const

inherited

Query a capability, if it exists, otherwise nullptr.

Will convert the capability name to lowercase.

Definition at line 57 of file CapabilityRegistry.C.

Referenced by Moose::internal::CapabilityRegistry::check(), and Moose::internal::CapabilityRegistry::get().

{
  capability = MooseUtils::toLower(capability);
  if (const auto it = _registry.find(capability); it != _registry.end())
    return &it->second;
  return nullptr;
}

query() [2/2]

Capability * Moose::internal::CapabilityRegistry::query ( std::string  capability )

inlineinherited

Definition at line 176 of file CapabilityRegistry.h.

{
  return const_cast<Capability *>(std::as_const(*this).query(capability));
}

registerMooseCapabilities()

void Moose::internal::Capabilities::registerMooseCapabilities ( )

private

Register the MOOSE capabilities.

Called during the construction of the registry.

Putting this here enforces that only capabilities that represent context before the app is constructed can be added.

Definition at line 127 of file Capabilities.C.

Referenced by Capabilities().

{
  // helper lambdas for explicitly adding typed capabilities
  const auto add_bool = [&](const std::string_view capability,
                            const bool value,
                            const std::string_view doc) -> Capability &
  { return add(capability, value, doc); };
  const auto add_int = [&](const std::string_view capability,
                           const int value,
                           const std::string_view doc) -> Capability &
  { return add(capability, value, doc); };
  const auto add_string = [&](const std::string_view capability,
                              const std::string_view value,
                              const std::string_view doc) -> Capability &
  { return add(capability, std::string(value), doc); };

  // helper lambdas for adding capabilities
  const auto have = [&](const std::string & capability, const std::string & doc) -> Capability &
  { return add_bool(capability, true, doc + " is available."); };
  const auto missing = [&](const std::string & capability,
                           const std::string & doc,
                           const std::string & help = "") -> Capability &
  { return add_bool(capability, false, doc + " is not available. " + help); };

  const auto have_version = [&](const std::string & capability,
                                const std::string & doc,
                                const std::string & version) -> Capability &
  { return add_string(capability, version, doc + " version " + version + " is available."); };
  const auto petsc_missing = [&](const std::string & capability,
                                 const std::string & doc) -> Capability &
  {
    return add_bool(
        capability, false, doc + " is not available. Check your PETSc configure options.");
  };
  const auto libmesh_missing = [&](const std::string & capability,
                                   const std::string & doc,
                                   const std::string & config_option) -> Capability &
  {
    return add_bool(capability,
                    false,
                    doc + " is not available. It is controlled by the `" + config_option +
                        "` libMesh configure option.");
  };

  {
    const auto doc = "LibTorch machine learning and parallel tensor algebra library";
#ifdef MOOSE_LIBTORCH_ENABLED
    add_string("libtorch", TORCH_VERSION, doc);
#else
    missing("libtorch",
            doc,
            "Check "
            "https://mooseframework.inl.gov/moose/getting_started/installation/"
            "install_libtorch.html for "
            "instructions on how to configure and build moose with libTorch.");
#endif
  }

  {
    const auto doc = "MFEM finite element library";
#ifdef MOOSE_MFEM_ENABLED
    add_string("mfem", MFEM_VERSION_STRING, doc);
#else
    missing("mfem",
            doc,
            "Install mfem using the scripts/update_and_rebuild_mfem.sh script after "
            "first running scripts/update_and_rebuild_conduit.sh. Finally, configure "
            "moose with ./configure --with-mfem");
#endif
  }

  {
    const auto doc = "New Engineering Material model Library, version 2";
#ifdef NEML2_ENABLED
    have("neml2", doc);
#else
    missing("neml2",
            doc,
            "Install neml2 using the scripts/update_and_rebuild_neml2.sh script, then "
            "configure moose with ./configure --with-neml2 --with-libtorch");
#endif
  }

  {
    const auto doc = "gperftools code performance analysis and profiling library";
#ifdef HAVE_GPERFTOOLS
    have("gperftools", doc);
#else
    missing("gperftools",
            doc,
            "Check https://mooseframework.inl.gov/application_development/profiling.html "
            "for instructions on profiling MOOSE based applications.");
#endif
  }

  {
    const auto doc = "libPNG portable network graphics format library";
#ifdef MOOSE_HAVE_LIBPNG
    have("libpng", doc);
#else
    missing("libpng",
            doc,
            "Install libpng through conda or your distribution and check that it gets "
            "detected through pkg-config, then reconfigure and rebuild MOOSE.");
#endif
  }

  {
    const auto doc = "NVIDIA GPU parallel computing platform";
#ifdef PETSC_HAVE_CUDA
    const std::string version = QUOTE(PETSC_PKG_CUDA_VERSION_MAJOR) "." QUOTE(
        PETSC_PKG_CUDA_VERSION_MINOR) "." QUOTE(PETSC_PKG_CUDA_VERSION_SUBMINOR);
    add_string("cuda", version, doc);
#else
    missing("cuda", doc, "Add the CUDA bin directory to your path and rebuild PETSc.");
#endif
  }

  {
    const auto doc = "Kokkos performance portability programming ecosystem";
#ifdef MOOSE_KOKKOS_ENABLED
    const std::string version = QUOTE(PETSC_PKG_KOKKOS_VERSION_MAJOR) "." QUOTE(
        PETSC_PKG_KOKKOS_VERSION_MINOR) "." QUOTE(PETSC_PKG_KOKKOS_VERSION_SUBMINOR);
    add_string("kokkos", version, doc);
#else
    missing("kokkos",
            doc,
            "Rebuild PETSc with Kokkos support and libMesh. Then, reconfigure MOOSE with "
            "--with-kokkos.");
#endif
  }

  {
    const auto doc = "Kokkos support for PETSc";
#ifdef PETSC_HAVE_KOKKOS
    const std::string version = QUOTE(PETSC_PKG_KOKKOS_VERSION_MAJOR) "." QUOTE(
        PETSC_PKG_KOKKOS_VERSION_MINOR) "." QUOTE(PETSC_PKG_KOKKOS_VERSION_SUBMINOR);
    add_string("petsc_kokkos", version, doc);
#else
    missing(
        "petsc_kokkos", doc, "Rebuild PETSc with Kokkos support, then rebuild libMesh and MOOSE.");
#endif
  }

  {
    const auto doc = "Intel OneAPI XPU accelerator support";
#ifdef MOOSE_HAVE_XPU
    if (torch::xpu::is_available())
      have("xpu", doc);
    else
      missing("xpu", doc, "No usable XPU devices have been found.");
#else
    missing("xpu", doc, "The torch version used to build this app has no XPU support.");
#endif
  }

  add_int(
      "ad_size",
      MOOSE_AD_MAX_DOFS_PER_ELEM,
      "MOOSE was configured and built with a dual number backing store size of " +
          Moose::stringify(MOOSE_AD_MAX_DOFS_PER_ELEM) +
          ". Complex simulations with many variables or contact problems may require larger "
          "values. Reconfigure MOOSE with the --with-derivative-size=<n> option in the root of the "
          "repository.")
      .setExplicit();

  {
    const std::string method = QUOTE(METHOD);
    add_string("method", method, "The executable was built with METHOD=\"" + method + "\"")
        .setExplicit()
        .setEnumeration({"dbg", "devel", "oprof", "opt"});
  }

  {
    const std::string version = QUOTE(LIBMESH_DETECTED_PETSC_VERSION_MAJOR) "." QUOTE(
        LIBMESH_DETECTED_PETSC_VERSION_MINOR) "." QUOTE(LIBMESH_DETECTED_PETSC_VERSION_SUBMINOR);
    add_string("petsc", version, "Using PETSc version " + version + ".");
  }

#ifdef LIBMESH_PETSC_USE_DEBUG
  add_bool("petsc_debug", true, "PETSc was built with debugging options.");
#else
  add_bool("petsc_debug", false, "PETSc was built without debugging options.");
#endif

  {
    const auto doc = "SuperLU direct solver";
#ifdef LIBMESH_PETSC_HAVE_SUPERLU_DIST
    const std::string version = QUOTE(PETSC_PKG_SUPERLU_DIST_VERSION_MAJOR) "." QUOTE(
        PETSC_PKG_SUPERLU_DIST_VERSION_MINOR) "." QUOTE(PETSC_PKG_SUPERLU_DIST_VERSION_SUBMINOR);
    add_string("superlu", version, doc);
#else
    petsc_missing("superlu", doc);
#endif
  }

  {
    const auto doc = "MUltifrontal Massively Parallel sparse direct Solver (MUMPS)";
#ifdef LIBMESH_PETSC_HAVE_MUMPS
    const std::string version = QUOTE(PETSC_PKG_MUMPS_VERSION_MAJOR) "." QUOTE(
        PETSC_PKG_MUMPS_VERSION_MINOR) "." QUOTE(PETSC_PKG_MUMPS_VERSION_SUBMINOR);
    add_string("mumps", version, doc);
#else
    petsc_missing("mumps", doc);
#endif
  }

  {
    const auto doc = "STRUMPACK - STRUctured Matrix PACKage solver library";
#ifdef LIBMESH_PETSC_HAVE_STRUMPACK
    const std::string version = QUOTE(PETSC_PKG_STRUMPACK_VERSION_MAJOR) "." QUOTE(
        PETSC_PKG_STRUMPACK_VERSION_MINOR) "." QUOTE(PETSC_PKG_STRUMPACK_VERSION_SUBMINOR);
    add_string("strumpack", version, doc);
#else
    petsc_missing("strumpack", doc);
#endif
  }

  {
    const auto doc = "Parmetis partitioning library";
#if defined(LIBMESH_PETSC_HAVE_PARMETIS)
    const std::string version = QUOTE(PETSC_PKG_PARMETIS_VERSION_MAJOR) "." QUOTE(
        PETSC_PKG_PARMETIS_VERSION_MINOR) "." QUOTE(PETSC_PKG_PARMETIS_VERSION_SUBMINOR);
    add_string("parmetis", version, doc);
#elif defined(LIBMESH_HAVE_PARMETIS)
    have("parmetis", doc);
#else
    petsc_missing("parmetis", doc);
#endif
  }

  {
    const auto doc = "Chaco graph partitioning library";
#ifdef LIBMESH_PETSC_HAVE_CHACO
    have("chaco", doc);
#else
    petsc_missing("chaco", doc);
#endif
  }

  {
    const auto doc = "Party matrix or graph partitioning library";
#ifdef LIBMESH_PETSC_HAVE_PARTY
    have("party", doc);
#else
    petsc_missing("party", doc);
#endif
  }

  {
    const auto doc = "PT-Scotch graph partitioning library";
#ifdef LIBMESH_PETSC_HAVE_PTSCOTCH
    const std::string version = QUOTE(PETSC_PKG_PTSCOTCH_VERSION_MAJOR) "." QUOTE(
        PETSC_PKG_PTSCOTCH_VERSION_MINOR) "." QUOTE(PETSC_PKG_PTSCOTCH_VERSION_SUBMINOR);
    add_string("ptscotch", version, doc);
#else
    petsc_missing("ptscotch", doc);
#endif
  }

  {
    const auto doc = "Optimized BLAS library";
#ifdef PETSC_HAVE_OPENBLAS
    const std::string version = QUOTE(PETSC_PKG_OPENBLAS_VERSION_MAJOR) "." QUOTE(
        PETSC_PKG_OPENBLAS_VERSION_MINOR) "." QUOTE(PETSC_PKG_OPENBLAS_VERSION_SUBMINOR);
    add_string("openblas", version, doc);
#else
    petsc_missing("openblas", doc);
#endif
  }

  {
    const auto doc = "Umpire resource management library";
#ifdef PETSC_HAVE_UMPIRE
    have("umpire", doc);
#else
    petsc_missing("umpire", doc);
#endif
  }

  {
    const auto doc = "Scalable Library for Eigenvalue Problem Computations (SLEPc)";
#ifdef LIBMESH_HAVE_SLEPC
    const auto version = QUOTE(LIBMESH_DETECTED_SLEPC_VERSION_MAJOR) "." QUOTE(
        LIBMESH_DETECTED_SLEPC_VERSION_MINOR) "." QUOTE(LIBMESH_DETECTED_SLEPC_VERSION_SUBMINOR);
    have_version("slepc", doc, version);
#else
    petsc_missing("slepc", doc);
#endif
  }

  {
    const auto doc = "Exodus mesh file format library";
#ifdef LIBMESH_HAVE_EXODUS_API
    const std::string version = QUOTE(LIBMESH_DETECTED_EXODUS_VERSION_MAJOR) "." QUOTE(
        LIBMESH_DETECTED_EXODUS_VERSION_MINOR);
    have_version("exodus", doc, version);
#else
    libmesh_missing("exodus", doc, "--enable-exodus");
#endif
  }

  {
    const auto doc = "Netgen meshing library";
#ifdef LIBMESH_HAVE_NETGEN
    const std::string version =
        QUOTE(NETGEN_VERSION_MAJOR) "." QUOTE(NETGEN_VERSION_MINOR) "." QUOTE(NETGEN_VERSION_PATCH);
    add_string("netgen", version, doc);
#else
    libmesh_missing("netgen", doc, "--enable-netgen");
#endif
  }

  {
    const auto doc = "Visualization Toolkit (VTK)";
#ifdef LIBMESH_HAVE_VTK
    const std::string version = QUOTE(LIBMESH_DETECTED_VTK_VERSION_MAJOR) "." QUOTE(
        LIBMESH_DETECTED_VTK_VERSION_MINOR) "." QUOTE(LIBMESH_DETECTED_VTK_VERSION_SUBMINOR);
    have_version("vtk", doc, version);
#else
    libmesh_missing("vtk", doc, "--disable-vtk and --enable-vtk-required");
#endif
  }

  {
    const auto doc = "libcurl - the multiprotocol file transfer library";
#ifdef LIBMESH_HAVE_CURL
    have("curl", doc);
#else
    libmesh_missing("curl", doc, "--enable-curl");
#endif
  }

  {
    const auto doc = "Tecplot post-processing tools API";
#ifdef LIBMESH_HAVE_TECPLOT_API
    have("tecplot", doc);
#else
    libmesh_missing("tecplot", doc, "--enable-tecplot");
#endif
  }

  {
    const auto doc = "NVIDIA Tools Extension Library API";
#ifdef LIBMESH_HAVE_NVTX_API
    have("nvtx_api", doc);
#else
    libmesh_missing("nvtx_api", doc, "--with-nvtx");
#endif
  }

  {
    const auto doc = "libMesh performance logging";
#ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING
    have("libmesh_perflog", doc);
#else
    libmesh_missing("libmesh_perflog", doc, "--enable-perflog");
#endif
  }

  {
    const auto doc = "Boost C++ library";
#ifdef LIBMESH_HAVE_EXTERNAL_BOOST
    have("boost", doc);
#else
    libmesh_missing("boost", doc, "--with-boost");
#endif
  }

  // libmesh stuff
  {
    const auto doc = "Adaptive mesh refinement";
#ifdef LIBMESH_ENABLE_AMR
    have("amr", doc);
#else
    libmesh_missing("amr", doc, "--disable-amr");
#endif
  }

  {
    const auto doc = "nanoflann library for Nearest Neighbor (NN) search with KD-trees";
#ifdef LIBMESH_HAVE_NANOFLANN
    have("nanoflann", doc);
#else
    libmesh_missing("nanoflann", doc, "--disable-nanoflann");
#endif
  }

  {
    const auto doc = "sfcurves library for space filling curves (required by geometric "
                     "partitioners such as SFCurves, Hilbert and Morton -  not LGPL compatible)";
#ifdef LIBMESH_HAVE_SFCURVES
    have("sfcurves", doc);
#else
    libmesh_missing("sfcurves", doc, "--disable-sfc");
#endif
  }

  {
#ifdef LIBMESH_HAVE_FPARSER
#ifdef LIBMESH_HAVE_FPARSER_JIT
    const auto value = "jit";
    const auto doc = "FParser enabled with just in time compilation support.";
#else
    const auto value = "byte_code";
    const auto doc = "FParser enabled.";
#endif
    add_string("fparser", value, doc);
#else
    add_bool("fparser",
             false,
             "FParser is disabled, libMesh was likely configured with --disable-fparser.");
#endif
  }

#ifdef LIBMESH_HAVE_DLOPEN
  add_bool("dlopen", true, "The dlopen() system call is available to dynamically load libraries.");
#else
  add_bool("dlopen",
           false,
           "The dlopen() system call is not available. Dynamic library loading is "
           "not supported on this system.");
#endif

  {
    const auto doc = "LibMesh support for threaded execution";
#ifdef LIBMESH_USING_THREADS
    have("threads", doc);
#else
    libmesh_missing("threads", doc, "--with-thread-model=tbb,pthread,openmp,auto,none");
#endif
  }

  {
    const auto doc = "OpenMP multi-platform shared-memory parallel programming API";
#ifdef LIBMESH_HAVE_OPENMP
    have("openmp", doc);
#else
    libmesh_missing("openmp", doc, "--with-thread-model=tbb,pthread,openmp,auto,none");
#endif
  }
  {
    const auto doc = "POSIX Threads API";
#ifdef LIBMESH_HAVE_PTHREAD
    have("pthread", doc);
#else
    libmesh_missing("pthread", doc, "--with-thread-model=tbb,pthread,openmp,auto,none");
#endif
  }
  {
    const auto doc = "oneAPI Threading Building Blocks (TBB) API";
#ifdef LIBMESH_HAVE_TBB_API
    have("tbb", doc);
#else
    libmesh_missing("tbb", doc, "--with-thread-model=tbb,pthread,openmp,auto,none");
#endif
  }

  {
    const auto doc = "libMesh unique ID support";
#ifdef LIBMESH_ENABLE_UNIQUE_ID
    have("unique_id", doc);
#else
    libmesh_missing("unique_id", doc, "--enable-unique-id");
#endif
  }

  {
#ifdef LIBMESH_ENABLE_PARMESH
    const auto value = "distributed";
#else
    const auto value = "replicated";
#endif
    add_string("mesh_mode", value, "libMesh default mesh mode")
        .setExplicit()
        .setEnumeration({"distributed", "replicated"});
  }

  add_int("dof_id_bytes",
          static_cast<int>(sizeof(dof_id_type)),
          "Degree of freedom (DOF) identifiers use " + Moose::stringify(sizeof(dof_id_type)) +
              " bytes for storage. This is controlled by the "
              "--with-dof-id-bytes=<1|2|4|8> libMesh configure option.")
      .setExplicit();

  {
#ifdef LIBMESH_HAVE_STATIC_LIBS
    const auto value = "static";
#else
    const auto value = "dynamic";
#endif
    add_string("library_mode",
               value,
               "The libMesh library mode. This is controlled by the --enable-static libMesh "
               "configure option.")
        .setExplicit()
        .setEnumeration({"dynamic", "static"});
  }

  // compiler
  {
    const auto doc = "Compiler used to build the MOOSE framework.";
#if defined(__INTEL_LLVM_COMPILER)
    const auto value = "intel";
#elif defined(__clang__)
    const auto value = "clang";
#elif defined(__GNUC__) || defined(__GNUG__)
    const auto value = "gcc";
#elif defined(_MSC_VER)
    const auto value = "msvc";
#else
    mooseDoOnce(mooseWarning("Failed to determine compiler; setting capability compiler=unknown"));
    const auto value = "unknown";
#endif
    add_string("compiler", value, doc)
        .setExplicit()
        .setEnumeration({"clang", "gcc", "intel", "msvc", "unknown"});
  }

  // OS related
  {
#ifdef __APPLE__
    const auto value = "darwin";
#elif __WIN32__
    const auto value = "win32";
#elif __linux__
    const auto value = "linux";
#elif __unix__
    const auto value = "unix";
#else
    mooseDoOnce(mooseWarning("Failed to determine platform; setting capability platform=unknown"));
    const auto value = "unknown";
#endif
    add_string("platform", value, "Operating system this executable is running on.")
        .setExplicit()
        .setEnumeration({"darwin", "linux", "unix", "unknown", "win32"});
  }

  // Installation type (in tree or installed)
  {
    // Try to find the path to the running executable
    std::optional<std::string> executable_path;
    {
      Moose::ScopedThrowOnError scoped_throw_on_error;
      try
      {
        executable_path = Moose::getExec();
      }
      catch (const MooseException &)
      {
      }
    }

    std::string value = "unknown";

    if (executable_path)
    {
      // Try to follow all symlinks to get the real path
      std::error_code ec;
      const auto resolved_path =
          std::filesystem::weakly_canonical(std::filesystem::path(*executable_path), ec);
      if (ec)
        mooseDoOnce(mooseWarning("Failed to resolve executable path '",
                                 *executable_path,
                                 "':\n",
                                 ec.message(),
                                 "\n\nSetting capability installation_type=unknown"));
      else
      {
        // If the binary is in a folder "bin", we'll consider it installed.
        // This isn't the best check, but it works with how we currently
        // install applications in app.mk
        value = resolved_path.parent_path().filename() == "bin" ? "relocated" : "in_tree";
      }
    }
    else
      mooseDoOnce(mooseWarning(
          "Failed to determine executable path; setting capability installation_type=unknown"));

    add_string("installation_type", value, "The installation type of the application.")
        .setExplicit()
        .setEnumeration({"in_tree", "relocated", "unknown"});

    mooseAssert(isInstallationType(value), "Value mismatch");
  }
}

size()

std::size_t Moose::internal::CapabilityRegistry::size ( ) const

inlineinherited

Returns

The size of the registry (number of capabilities registered).

Definition at line 135 of file CapabilityRegistry.h.

{ return _registry.size(); }

Friends And Related Function Documentation

::CapabilitiesTest

friend class ::CapabilitiesTest

friend

Definition at line 130 of file Capabilities.h.

::DataFileUtilsTest

friend class ::DataFileUtilsTest

friend

Definition at line 131 of file Capabilities.h.

::RegistryTest

friend class ::RegistryTest

friend

Definition at line 132 of file Capabilities.h.

Member Data Documentation

_registry

RegistryType Moose::internal::CapabilityRegistry::_registry

protectedinherited

Registry storage.

Definition at line 171 of file CapabilityRegistry.h.

Referenced by Moose::internal::CapabilityRegistry::add(), Moose::internal::CapabilityRegistry::check(), dump(), Moose::internal::CapabilityRegistry::query(), and Moose::internal::CapabilityRegistry::size().

augmented_capability_names

const std::set< std::string, std::less<> > Moose::internal::CapabilityRegistry::augmented_capability_names

staticinherited

Initial value:

{
    
    "hpc",
    "machine",
    "library_mode",
    
    "mpi_procs",
    "num_threads"}

Capabilities that are reserved and can only be augmented.

Definition at line 38 of file CapabilityRegistry.h.

---

The documentation for this class was generated from the following files:

• include/base/Capabilities.h
• src/base/Capabilities.C