summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--lib/spack/spack/solver/asp.py152
-rw-r--r--lib/spack/spack/solver/concretize.lp1018
-rw-r--r--lib/spack/spack/spec.py8
3 files changed, 635 insertions, 543 deletions
diff --git a/lib/spack/spack/solver/asp.py b/lib/spack/spack/solver/asp.py
index fe01be1bcf..91c0b1680a 100644
--- a/lib/spack/spack/solver/asp.py
+++ b/lib/spack/spack/solver/asp.py
@@ -515,15 +515,17 @@ class Result:
best = min(self.answers)
opt, _, answer = best
for input_spec in self.abstract_specs:
- key = input_spec.name
+ node = SpecBuilder.root_node(pkg=input_spec.name)
if input_spec.virtual:
- providers = [spec.name for spec in answer.values() if spec.package.provides(key)]
- key = providers[0]
- candidate = answer.get(key)
+ providers = [
+ spec.name for spec in answer.values() if spec.package.provides(input_spec.name)
+ ]
+ node = SpecBuilder.root_node(pkg=providers[0])
+ candidate = answer.get(node)
if candidate and candidate.satisfies(input_spec):
- self._concrete_specs.append(answer[key])
- self._concrete_specs_by_input[input_spec] = answer[key]
+ self._concrete_specs.append(answer[node])
+ self._concrete_specs_by_input[input_spec] = answer[node]
else:
self._unsolved_specs.append(input_spec)
@@ -2426,6 +2428,18 @@ class SpecBuilder:
)
)
+ node_regex = re.compile(r"node\(\d,\"(.*)\"\)")
+
+ @staticmethod
+ def root_node(*, pkg: str) -> str:
+ """Given a package name, returns the string representation of the root node in
+ the ASP encoding.
+
+ Args:
+ pkg: name of a package
+ """
+ return f'node(0,"{pkg}")'
+
def __init__(self, specs, hash_lookup=None):
self._specs = {}
self._result = None
@@ -2438,100 +2452,121 @@ class SpecBuilder:
# from this dictionary during reconstruction
self._hash_lookup = hash_lookup or {}
- def hash(self, pkg, h):
- if pkg not in self._specs:
- self._specs[pkg] = self._hash_lookup[h]
- self._hash_specs.append(pkg)
+ @staticmethod
+ def extract_pkg(node: str) -> str:
+ """Extracts the package name from a node fact, and returns it.
+
+ Args:
+ node: node from which the package name is to be extracted
+ """
+ m = SpecBuilder.node_regex.match(node)
+ if m is None:
+ raise spack.error.SpackError(f"cannot extract package information from '{node}'")
+
+ return m.group(1)
+
+ def hash(self, node, h):
+ if node not in self._specs:
+ self._specs[node] = self._hash_lookup[h]
+ self._hash_specs.append(node)
- def node(self, pkg):
- if pkg not in self._specs:
- self._specs[pkg] = spack.spec.Spec(pkg)
+ def node(self, node):
+ pkg = self.extract_pkg(node)
+ if node not in self._specs:
+ self._specs[node] = spack.spec.Spec(pkg)
- def _arch(self, pkg):
- arch = self._specs[pkg].architecture
+ def _arch(self, node):
+ arch = self._specs[node].architecture
if not arch:
arch = spack.spec.ArchSpec()
- self._specs[pkg].architecture = arch
+ self._specs[node].architecture = arch
return arch
- def node_platform(self, pkg, platform):
- self._arch(pkg).platform = platform
+ def node_platform(self, node, platform):
+ self._arch(node).platform = platform
- def node_os(self, pkg, os):
- self._arch(pkg).os = os
+ def node_os(self, node, os):
+ self._arch(node).os = os
- def node_target(self, pkg, target):
- self._arch(pkg).target = target
+ def node_target(self, node, target):
+ self._arch(node).target = target
- def variant_value(self, pkg, name, value):
+ def variant_value(self, node, name, value):
# FIXME: is there a way not to special case 'dev_path' everywhere?
if name == "dev_path":
- self._specs[pkg].variants.setdefault(
+ self._specs[node].variants.setdefault(
name, spack.variant.SingleValuedVariant(name, value)
)
return
if name == "patches":
- self._specs[pkg].variants.setdefault(
+ self._specs[node].variants.setdefault(
name, spack.variant.MultiValuedVariant(name, value)
)
return
- self._specs[pkg].update_variant_validate(name, value)
+ self._specs[node].update_variant_validate(name, value)
- def version(self, pkg, version):
- self._specs[pkg].versions = vn.VersionList([vn.Version(version)])
+ def version(self, node, version):
+ self._specs[node].versions = vn.VersionList([vn.Version(version)])
- def node_compiler_version(self, pkg, compiler, version):
- self._specs[pkg].compiler = spack.spec.CompilerSpec(compiler)
- self._specs[pkg].compiler.versions = vn.VersionList([vn.Version(version)])
+ def node_compiler_version(self, node, compiler, version):
+ self._specs[node].compiler = spack.spec.CompilerSpec(compiler)
+ self._specs[node].compiler.versions = vn.VersionList([vn.Version(version)])
- def node_flag_compiler_default(self, pkg):
- self._flag_compiler_defaults.add(pkg)
+ def node_flag_compiler_default(self, node):
+ self._flag_compiler_defaults.add(node)
- def node_flag(self, pkg, flag_type, flag):
- self._specs[pkg].compiler_flags.add_flag(flag_type, flag, False)
+ def node_flag(self, node, flag_type, flag):
+ self._specs[node].compiler_flags.add_flag(flag_type, flag, False)
- def node_flag_source(self, pkg, flag_type, source):
- self._flag_sources[(pkg, flag_type)].add(source)
+ def node_flag_source(self, node, flag_type, source):
+ self._flag_sources[(node, flag_type)].add(source)
- def no_flags(self, pkg, flag_type):
- self._specs[pkg].compiler_flags[flag_type] = []
+ def no_flags(self, node, flag_type):
+ self._specs[node].compiler_flags[flag_type] = []
- def external_spec_selected(self, pkg, idx):
+ def external_spec_selected(self, node, idx):
"""This means that the external spec and index idx
has been selected for this package.
"""
+
packages_yaml = spack.config.get("packages")
packages_yaml = _normalize_packages_yaml(packages_yaml)
+ pkg = self.extract_pkg(node)
spec_info = packages_yaml[pkg]["externals"][int(idx)]
- self._specs[pkg].external_path = spec_info.get("prefix", None)
- self._specs[pkg].external_modules = spack.spec.Spec._format_module_list(
+ self._specs[node].external_path = spec_info.get("prefix", None)
+ self._specs[node].external_modules = spack.spec.Spec._format_module_list(
spec_info.get("modules", None)
)
- self._specs[pkg].extra_attributes = spec_info.get("extra_attributes", {})
+ self._specs[node].extra_attributes = spec_info.get("extra_attributes", {})
# If this is an extension, update the dependencies to include the extendee
- package = self._specs[pkg].package_class(self._specs[pkg])
+ package = self._specs[node].package_class(self._specs[node])
extendee_spec = package.extendee_spec
+
if extendee_spec:
- package.update_external_dependencies(self._specs.get(extendee_spec.name, None))
+ extendee_node = SpecBuilder.root_node(pkg=extendee_spec.name)
+ package.update_external_dependencies(self._specs.get(extendee_node, None))
- def depends_on(self, pkg, dep, type):
- dependencies = self._specs[pkg].edges_to_dependencies(name=dep)
+ def depends_on(self, parent_node, dependency_node, type):
+ dependencies = self._specs[parent_node].edges_to_dependencies(name=dependency_node)
# TODO: assertion to be removed when cross-compilation is handled correctly
msg = "Current solver does not handle multiple dependency edges of the same name"
assert len(dependencies) < 2, msg
if not dependencies:
- self._specs[pkg].add_dependency_edge(self._specs[dep], deptypes=(type,), virtuals=())
+ self._specs[parent_node].add_dependency_edge(
+ self._specs[dependency_node], deptypes=(type,), virtuals=()
+ )
else:
# TODO: This assumes that each solve unifies dependencies
dependencies[0].update_deptypes(deptypes=(type,))
- def virtual_on_edge(self, pkg, provider, virtual):
- dependencies = self._specs[pkg].edges_to_dependencies(name=provider)
+ def virtual_on_edge(self, parent_node, provider_node, virtual):
+ provider = self.extract_pkg(provider_node)
+ dependencies = self._specs[parent_node].edges_to_dependencies(name=provider)
assert len(dependencies) == 1
dependencies[0].update_virtuals((virtual,))
@@ -2562,17 +2597,22 @@ class SpecBuilder:
# order is determined by the DAG. A spec's flags come after any of its ancestors
# on the compile line
- source_key = (spec.name, flag_type)
+ node = SpecBuilder.root_node(pkg=spec.name)
+ source_key = (node, flag_type)
if source_key in self._flag_sources:
- order = [s.name for s in spec.traverse(order="post", direction="parents")]
+ order = [
+ SpecBuilder.root_node(pkg=s.name)
+ for s in spec.traverse(order="post", direction="parents")
+ ]
sorted_sources = sorted(
self._flag_sources[source_key], key=lambda s: order.index(s)
)
# add flags from each source, lowest to highest precedence
- for name in sorted_sources:
+ for node in sorted_sources:
all_src_flags = list()
- per_pkg_sources = [self._specs[name]]
+ per_pkg_sources = [self._specs[node]]
+ name = self.extract_pkg(node)
if name in cmd_specs:
per_pkg_sources.append(cmd_specs[name])
for source in per_pkg_sources:
@@ -2645,14 +2685,14 @@ class SpecBuilder:
# solving but don't construct anything. Do not ignore error
# predicates on virtual packages.
if name != "error":
- pkg = args[0]
+ pkg = self.extract_pkg(args[0])
if spack.repo.PATH.is_virtual(pkg):
continue
# if we've already gotten a concrete spec for this pkg,
# do not bother calling actions on it except for node_flag_source,
# since node_flag_source is tracking information not in the spec itself
- spec = self._specs.get(pkg)
+ spec = self._specs.get(args[0])
if spec and spec.concrete:
if name != "node_flag_source":
continue
diff --git a/lib/spack/spack/solver/concretize.lp b/lib/spack/spack/solver/concretize.lp
index fee377f209..aa2dbecdb4 100644
--- a/lib/spack/spack/solver/concretize.lp
+++ b/lib/spack/spack/solver/concretize.lp
@@ -11,6 +11,8 @@
% Map literal input specs to facts that drive the solve
%-----------------------------------------------------------------------------
+#const root_node_id = 0.
+
% Give clingo the choice to solve an input spec or not
{ literal_solved(ID) } :- literal(ID).
literal_not_solved(ID) :- not literal_solved(ID), literal(ID).
@@ -27,11 +29,17 @@ opt_criterion(300, "number of input specs not concretized").
#minimize{ 0@300: #true }.
#minimize { 1@300,ID : literal_not_solved(ID) }.
-% Map constraint on the literal ID to the correct PSID
-attr(Name, A1) :- literal(LiteralID, Name, A1), literal_solved(LiteralID).
-attr(Name, A1, A2) :- literal(LiteralID, Name, A1, A2), literal_solved(LiteralID).
-attr(Name, A1, A2, A3) :- literal(LiteralID, Name, A1, A2, A3), literal_solved(LiteralID).
-attr(Name, A1, A2, A3, A4) :- literal(LiteralID, Name, A1, A2, A3, A4), literal_solved(LiteralID).
+% Map constraint on the literal ID to facts on the node
+attr(Name, node(root_node_id, A1)) :- literal(LiteralID, Name, A1), literal_solved(LiteralID).
+attr(Name, node(root_node_id, A1), A2) :- literal(LiteralID, Name, A1, A2), literal_solved(LiteralID).
+attr(Name, node(root_node_id, A1), A2, A3) :- literal(LiteralID, Name, A1, A2, A3), literal_solved(LiteralID), not literal_special_case(LiteralID, Name, A1, A2, A3).
+attr(Name, node(root_node_id, A1), A2, A3, A4) :- literal(LiteralID, Name, A1, A2, A3, A4), literal_solved(LiteralID).
+
+% Special cases where nodes occur in arguments other than A1
+literal_special_case(LiteralID, Name, A1, A2, A3) :- literal(LiteralID, Name, A1, A2, A3), Name == "node_flag_source".
+literal_special_case(LiteralID, Name, A1, A2, A3) :- literal(LiteralID, Name, A1, A2, A3), Name == "depends_on".
+attr("node_flag_source", node(root_node_id, A1), A2, node(root_node_id, A3)) :- literal(LiteralID, "node_flag_source", A1, A2, A3), literal_solved(LiteralID).
+attr("depends_on", node(root_node_id, A1), node(root_node_id, A2), A3) :- literal(LiteralID, "depends_on", A1, A2, A3), literal_solved(LiteralID).
#defined concretize_everything/0.
#defined literal/1.
@@ -48,15 +56,15 @@ attr_single_value("node_target").
% Error when no attribute is selected
error(100, no_value_error, Attribute, Package)
- :- attr("node", Package),
+ :- attr("node", node(ID, Package)),
attr_single_value(Attribute),
- not attr(Attribute, Package, _).
+ not attr(Attribute, node(ID, Package), _).
% Error when multiple attr need to be selected
error(100, multiple_values_error, Attribute, Package)
- :- attr("node", Package),
+ :- attr("node", node(ID, Package)),
attr_single_value(Attribute),
- 2 { attr(Attribute, Package, Version) }.
+ 2 { attr(Attribute, node(ID, Package), Value) }.
%-----------------------------------------------------------------------------
% Version semantics
@@ -74,9 +82,9 @@ facts(Package, version_declared(Version, Weight)) :- facts(Package, version_decl
% We cannot use a version declared for an installed package if we end up building it
:- facts(Package, version_declared(Version, Weight, "installed")),
- attr("version", Package, Version),
- version_weight(Package, Weight),
- not attr("hash", Package, _),
+ attr("version", node(ID, Package), Version),
+ version_weight(node(ID, Package), Weight),
+ not attr("hash", node(ID, Package), _),
internal_error("Reuse version weight used for built package").
% versions are declared w/priority -- declared with priority implies declared
@@ -88,72 +96,73 @@ facts(Package, version_declared(Version)) :- facts(Package, version_declared(Ver
% is not precisely one version chosen. Error facts are heavily optimized
% against to ensure they cannot be inferred when a non-error solution is
% possible
-{ attr("version", Package, Version) : facts(Package, version_declared(Version)) }
- :- attr("node", Package).
+{ attr("version", node(ID, Package), Version) : facts(Package, version_declared(Version)) }
+ :- attr("node", node(ID, Package)).
% A virtual package may or may not have a version, but never has more than one
error(100, "Cannot select a single version for virtual '{0}'", Virtual)
- :- attr("virtual_node", Virtual),
- 2 { attr("version", Virtual, Version) }.
+ :- attr("virtual_node", node(ID, Virtual)),
+ 2 { attr("version", node(ID, Virtual), Version) }.
% If we select a deprecated version, mark the package as deprecated
-attr("deprecated", Package, Version) :-
- attr("version", Package, Version),
+attr("deprecated", node(ID, Package), Version) :-
+ attr("version", node(ID, Package), Version),
facts(Package, deprecated_version(Version)).
-possible_version_weight(Package, Weight)
- :- attr("version", Package, Version),
+possible_version_weight(node(ID, Package), Weight)
+ :- attr("version", node(ID, Package), Version),
facts(Package, version_declared(Version, Weight)).
% we can't use the weight for an external version if we don't use the
% corresponding external spec.
-:- attr("version", Package, Version),
- version_weight(Package, Weight),
+:- attr("version", node(ID, Package), Version),
+ version_weight(node(ID, Package), Weight),
facts(Package, version_declared(Version, Weight, "external")),
- not external(Package),
+ not external(node(ID, Package)),
internal_error("External weight used for built package").
% we can't use a weight from an installed spec if we are building it
% and vice-versa
-:- attr("version", Package, Version),
- version_weight(Package, Weight),
+:- attr("version", node(ID, Package), Version),
+ version_weight(node(ID, Package), Weight),
facts(Package, version_declared(Version, Weight, "installed")),
- build(Package),
+ build(node(ID, Package)),
internal_error("Reuse version weight used for build package").
-:- attr("version", Package, Version),
- version_weight(Package, Weight),
+:- attr("version", node(ID, Package), Version),
+ version_weight(node(ID, Package), Weight),
not facts(Package, version_declared(Version, Weight, "installed")),
- not build(Package),
+ not build(node(ID, Package)),
internal_error("Build version weight used for reused package").
-1 { version_weight(Package, Weight) : facts(Package, version_declared(Version, Weight)) } 1
- :- attr("version", Package, Version),
- attr("node", Package).
+1 { version_weight(node(ID, Package), Weight) : facts(Package, version_declared(Version, Weight)) } 1
+ :- attr("version", node(ID, Package), Version),
+ attr("node", node(ID, Package)).
% node_version_satisfies implies that exactly one of the satisfying versions
% is the package's version, and vice versa.
% While this choice rule appears redundant with the initial choice rule for
% versions, virtual nodes with version constraints require this rule to be
% able to choose versions
-{ attr("version", Package, Version) : facts(Package, version_satisfies(Constraint, Version)) }
- :- attr("node_version_satisfies", Package, Constraint).
+{ attr("version", node(ID, Package), Version) : facts(Package, version_satisfies(Constraint, Version)) }
+ :- attr("node_version_satisfies", node(ID, Package), Constraint).
% If there is at least a version that satisfy the constraint, impose a lower
% bound on the choice rule to avoid false positives with the error below
-1 { attr("version", Package, Version) : facts(Package, version_satisfies(Constraint, Version)) }
- :- attr("node_version_satisfies", Package, Constraint),
+1 { attr("version", node(ID, Package), Version) : facts(Package, version_satisfies(Constraint, Version)) }
+ :- attr("node_version_satisfies", node(ID, Package), Constraint),
facts(Package, version_satisfies(Constraint, _)).
% More specific error message if the version cannot satisfy some constraint
% Otherwise covered by `no_version_error` and `versions_conflict_error`.
error(10, "Cannot satisfy '{0}@{1}'", Package, Constraint)
- :- attr("node_version_satisfies", Package, Constraint),
- attr("version", Package, Version),
+ :- attr("node_version_satisfies", node(ID, Package), Constraint),
+ attr("version", node(ID, Package), Version),
not facts(Package, version_satisfies(Constraint, Version)).
-attr("node_version_satisfies", Package, Constraint)
- :- attr("version", Package, Version), facts(Package, version_satisfies(Constraint, Version)).
+attr("node_version_satisfies", node(ID, Package), Constraint)
+ :- attr("version", node(ID, Package), Version),
+ facts(Package, version_satisfies(Constraint, Version)).
#defined version_satisfies/3.
#defined deprecated_version/2.
@@ -170,32 +179,46 @@ attr("node_version_satisfies", Package, Constraint)
%-----------------------------------------------------------------------------
% conditions are specified with `condition_requirement` and hold when
% corresponding spec attributes hold.
-condition_holds(ID, Package) :-
+condition_holds(ID, node(root_node_id, Package)) :-
facts(Package, condition(ID));
- attr(Name, A1) : condition_requirement(ID, Name, A1);
- attr(Name, A1, A2) : condition_requirement(ID, Name, A1, A2);
- attr(Name, A1, A2, A3) : condition_requirement(ID, Name, A1, A2, A3);
- attr(Name, A1, A2, A3, A4) : condition_requirement(ID, Name, A1, A2, A3, A4).
-
-% condition_holds(ID, Package) implies all imposed_constraints, unless do_not_impose(ID, Package)
+ attr(Name, node(root_node_id, A1)) : condition_requirement(ID, Name, A1);
+ attr(Name, node(root_node_id, A1), A2) : condition_requirement(ID, Name, A1, A2);
+ attr(Name, node(root_node_id, A1), A2, A3) : condition_requirement(ID, Name, A1, A2, A3), Name != "node_flag_source";
+ attr(Name, node(root_node_id, A1), A2, A3, A4) : condition_requirement(ID, Name, A1, A2, A3, A4);
+ % Special cases
+ % FIXME (node transformation): is node_flag_source needed?
+ attr("node_flag_source", node(NodeID, Package), A2, node(ID, A3)) : condition_requirement(ID, "node_flag_source", Package, A2, A3).
+
+% condition_holds(ID, node(ID, Package)) implies all imposed_constraints, unless do_not_impose(ID, node(ID, Package))
% is derived. This allows imposed constraints to be canceled in special cases.
-impose(ID, Package) :- condition_holds(ID, Package), not do_not_impose(ID, Package).
+impose(ID, PackageNode) :- condition_holds(ID, PackageNode), not do_not_impose(ID, PackageNode).
+
+% Conditions that hold impose may impose constraints on other specs
+attr(Name, node(root_node_id, A1)) :- impose(ID, node(NodeID, Package)), imposed_constraint(ID, Name, A1).
+attr(Name, node(root_node_id, A1), A2) :- impose(ID, node(NodeID, Package)), imposed_constraint(ID, Name, A1, A2).
+attr(Name, node(root_node_id, A1), A2, A3) :- impose(ID, node(NodeID, Package)), imposed_constraint(ID, Name, A1, A2, A3), not special_case(ID, Name, A1, A2, A3).
+attr(Name, node(root_node_id, A1), A2, A3, A4) :- impose(ID, node(NodeID, Package)), imposed_constraint(ID, Name, A1, A2, A3, A4).
+
-% conditions that hold impose constraints on other specs
-attr(Name, A1) :- impose(ID, Package), imposed_constraint(ID, Name, A1).
-attr(Name, A1, A2) :- impose(ID, Package), imposed_constraint(ID, Name, A1, A2).
-attr(Name, A1, A2, A3) :- impose(ID, Package), imposed_constraint(ID, Name, A1, A2, A3).
-attr(Name, A1, A2, A3, A4) :- impose(ID, Package), imposed_constraint(ID, Name, A1, A2, A3, A4).
+% Special cases
+special_case(ID, Name, A1, A2, A3) :- imposed_constraint(ID, Name, A1, A2, A3), Name == "node_flag_source".
+special_case(ID, Name, A1, A2, A3) :- imposed_constraint(ID, Name, A1, A2, A3), Name == "depends_on".
+
+% FIXME (node transformation): is node_flag_source needed?
+attr("node_flag_source", node(0, Package), A2, node(0, A3)) :- impose(ID, node(NodeID, Package)), imposed_constraint(ID, "node_flag_source", Package, A2, A3).
+attr("depends_on", node(0, Package), node(0, A2), A3) :- impose(ID, node(NodeID, Package)), imposed_constraint(ID, "depends_on", Package, A2, A3).
% we cannot have additional variant values when we are working with concrete specs
-:- attr("node", Package), attr("hash", Package, Hash),
- attr("variant_value", Package, Variant, Value),
+:- attr("node", node(ID, Package)),
+ attr("hash", node(ID, Package), Hash),
+ attr("variant_value", node(ID, Package), Variant, Value),
not imposed_constraint(Hash, "variant_value", Package, Variant, Value),
internal_error("imposed hash without imposing all variant values").
% we cannot have additional flag values when we are working with concrete specs
-:- attr("node", Package), attr("hash", Package, Hash),
- attr("node_flag", Package, FlagType, Flag),
+:- attr("node", node(ID, Package)),
+ attr("hash", node(ID, Package), Hash),
+ attr("node_flag", node(ID, Package), FlagType, Flag),
not imposed_constraint(Hash, "node_flag", Package, FlagType, Flag),
internal_error("imposed hash without imposing all flag values").
@@ -213,52 +236,55 @@ attr(Name, A1, A2, A3, A4) :- impose(ID, Package), imposed_constraint(ID, Name,
% Concrete specs
%-----------------------------------------------------------------------------
% if a package is assigned a hash, it's concrete.
-concrete(Package) :- attr("hash", Package, _), attr("node", Package).
+concrete(PackageNode) :- attr("hash", PackageNode, _), attr("node", PackageNode).
%-----------------------------------------------------------------------------
% Dependency semantics
%-----------------------------------------------------------------------------
% Dependencies of any type imply that one package "depends on" another
-depends_on(Package, Dependency) :- attr("depends_on", Package, Dependency, _).
+depends_on(PackageNode, DependencyNode) :- attr("depends_on", PackageNode, DependencyNode, _).
% a dependency holds if its condition holds and if it is not external or
% concrete. We chop off dependencies for externals, and dependencies of
% concrete specs don't need to be resolved -- they arise from the concrete
% specs themselves.
-dependency_holds(Package, Dependency, Type) :-
+dependency_holds(node(NodeID, Package), Dependency, Type) :-
facts(Package, dependency_condition(ID, Dependency)),
dependency_type(ID, Type),
- build(Package),
- not external(Package),
- condition_holds(ID, Package).
+ build(node(NodeID, Package)),
+ not external(node(NodeID, Package)),
+ condition_holds(ID, node(NodeID, Package)).
% We cut off dependencies of externals (as we don't really know them).
% Don't impose constraints on dependencies that don't exist.
-do_not_impose(ID, Package) :-
- not dependency_holds(Package, Dependency, _),
+do_not_impose(ID, node(NodeID, Package)) :-
+ not dependency_holds(node(NodeID, Package), Dependency, _),
+ attr("node", node(NodeID, Package)),
facts(Package, dependency_condition(ID, Dependency)).
% declared dependencies are real if they're not virtual AND
% the package is not an external.
% They're only triggered if the associated dependnecy condition holds.
-attr("depends_on", Package, Dependency, Type)
- :- dependency_holds(Package, Dependency, Type),
+
+% TODO (node transformation): here we infer node id 0
+attr("depends_on", node(NodeID, Package), node(0, Dependency), Type)
+ :- dependency_holds(node(NodeID, Package), Dependency, Type),
not virtual(Dependency).
% every root must be a node
-attr("node", Package) :- attr("root", Package).
+attr("node", PackageNode) :- attr("root", PackageNode).
% dependencies imply new nodes
-attr("node", Dependency) :- attr("node", Package), depends_on(Package, Dependency).
+attr("node", DependencyNode) :- attr("node", PackageNode), depends_on(PackageNode, DependencyNode).
% all nodes in the graph must be reachable from some root
% this ensures a user can't say `zlib ^libiconv` (neither of which have any
% dependencies) and get a two-node unconnected graph
-needed(Package) :- attr("root", Package).
-needed(Dependency) :- needed(Package), depends_on(Package, Dependency).
+needed(PackageNode) :- attr("root", PackageNode).
+needed(DependencyNode) :- needed(PackageNode), depends_on(PackageNode, DependencyNode).
error(10, "'{0}' is not a valid dependency for any package in the DAG", Package)
- :- attr("node", Package),
- not needed(Package).
+ :- attr("node", node(ID, Package)),
+ not needed(node(ID, Package)).
% Avoid cycles in the DAG
% some combinations of conditional dependencies can result in cycles;
@@ -274,12 +300,13 @@ error(100, "Cyclic dependency detected between '{0}' and '{1}' (consider changin
%-----------------------------------------------------------------------------
% Conflicts
%-----------------------------------------------------------------------------
-error(1, Msg) :- attr("node", Package),
- facts(Package, conflict(TriggerID, ConstraintID, Msg)),
- condition_holds(TriggerID, Package),
- condition_holds(ConstraintID, Package),
- not external(Package), % ignore conflicts for externals
- not attr("hash", Package, _). % ignore conflicts for installed packages
+error(1, Msg)
+ :- attr("node", node(ID, Package)),
+ facts(Package, conflict(TriggerID, ConstraintID, Msg)),
+ condition_holds(TriggerID, node(ID, Package)),
+ condition_holds(ConstraintID, node(ID, Package)),
+ not external(node(ID, Package)), % ignore conflicts for externals
+ not attr("hash", node(ID, Package), _). % ignore conflicts for installed packages
%-----------------------------------------------------------------------------
% Virtual dependencies
@@ -287,57 +314,62 @@ error(1, Msg) :- attr("node", Package),
% if a package depends on a virtual, it's not external and we have a
% provider for that virtual then it depends on the provider
-attr("depends_on", Package, Provider, Type)
- :- dependency_holds(Package, Virtual, Type),
- provider(Provider, Virtual),
- not external(Package).
+attr("depends_on", PackageNode, ProviderNode, Type)
+ :- dependency_holds(PackageNode, Virtual, Type),
+ provider(ProviderNode, node(0, Virtual)),
+ not external(PackageNode).
-attr("virtual_on_edge", Package, Provider, Virtual)
- :- dependency_holds(Package, Virtual, Type),
- provider(Provider, Virtual),
- not external(Package).
+attr("virtual_on_edge", PackageNode, ProviderNode, Virtual)
+ :- dependency_holds(PackageNode, Virtual, Type),
+ provider(ProviderNode, node(0, Virtual)),
+ not external(PackageNode).
% dependencies on virtuals also imply that the virtual is a virtual node
-attr("virtual_node", Virtual)
- :- dependency_holds(Package, Virtual, Type),
- virtual(Virtual), not external(Package).
+attr("virtual_node", node(0, Virtual))
+ :- dependency_holds(PackageNode, Virtual, Type),
+ virtual(Virtual), not external(PackageNode).
% If there's a virtual node, we must select one and only one provider.
% The provider must be selected among the possible providers.
-{ provider(Package, Virtual) : facts(Package, possible_provider(Virtual)) }
- :- attr("virtual_node", Virtual).
-error(100, "Cannot find valid provider for virtual {0}", Virtual)
- :- attr("virtual_node", Virtual),
- not provider(_, Virtual).
+% FIXME (node transformation): here we use root_node_id
+{ provider(node(0, Package), node(VirtualID, Virtual))
+ : facts(Package, possible_provider(Virtual)) }
+ :- attr("virtual_node", node(VirtualID, Virtual)).
+
+error(100, "Cannot find valid provider for virtual {0}", VirtualNode)
+ :- attr("virtual_node", VirtualNode),
+ not provider(_, VirtualNode).
-error(100, "Cannot select a single provider for virtual '{0}'", Virtual)
- :- attr("virtual_node", Virtual),
- 2 { provider(P, Virtual) }.
+error(100, "Cannot select a single provider for virtual '{0}'", VirtualNode)
+ :- attr("virtual_node", VirtualNode),
+ 2 { provider(P, VirtualNode) }.
% virtual roots imply virtual nodes, and that one provider is a root
-attr("virtual_node", Virtual) :- attr("virtual_root", Virtual).
+attr("virtual_node", VirtualNode) :- attr("virtual_root", VirtualNode).
% If we asked for a virtual root and we have a provider for that,
% then the provider is the root package.
-attr("root", Package) :- attr("virtual_root", Virtual), provider(Package, Virtual).
+attr("root", PackageNode) :- attr("virtual_root", VirtualNode), provider(PackageNode, VirtualNode).
% If we asked for a root package and that root provides a virtual,
% the root is a provider for that virtual. This rule is mostly relevant
% for environments that are concretized together (e.g. where we
% asks to install "mpich" and "hdf5+mpi" and we want "mpich" to
% be the mpi provider)
-provider(Package, Virtual) :- attr("node", Package), virtual_condition_holds(Package, Virtual).
+provider(PackageNode, node(0, Virtual)) :- attr("node", PackageNode), virtual_condition_holds(PackageNode, Virtual).
% The provider provides the virtual if some provider condition holds.
-virtual_condition_holds(Provider, Virtual) :-
+virtual_condition_holds(node(ProviderID, Provider), Virtual) :-virtual_condition_holds(ID, node(ProviderID, Provider), Virtual).
+virtual_condition_holds(ID, node(ProviderID, Provider), Virtual) :-
facts(Provider, provider_condition(ID, Virtual)),
- condition_holds(ID, Provider),
+ condition_holds(ID, node(ProviderID, Provider)),
virtual(Virtual).
% A package cannot be the actual provider for a virtual if it does not
% fulfill the conditions to provide that virtual
-:- provider(Package, Virtual), not virtual_condition_holds(Package, Virtual),
+:- provider(PackageNode, node(0, Virtual)),
+ not virtual_condition_holds(PackageNode, Virtual),
internal_error("Virtual when provides not respected").
%-----------------------------------------------------------------------------
@@ -347,33 +379,33 @@ virtual_condition_holds(Provider, Virtual) :-
% A provider may have different possible weights depending on whether it's an external
% or not, or on preferences expressed in packages.yaml etc. This rule ensures that
% we select the weight, among the possible ones, that minimizes the overall objective function.
-1 { provider_weight(Dependency, Virtual, Weight, Reason) :
- possible_provider_weight(Dependency, Virtual, Weight, Reason) } 1
- :- provider(Dependency, Virtual), internal_error("Package provider weights must be unique").
+1 { provider_weight(DependencyNode, VirtualNode, Weight, Reason) :
+ possible_provider_weight(DependencyNode, VirtualNode, Weight, Reason) } 1
+ :- provider(DependencyNode, VirtualNode), internal_error("Package provider weights must be unique").
% Get rid or the reason for enabling the possible weight (useful for debugging)
-provider_weight(Dependency, Virtual, Weight) :- provider_weight(Dependency, Virtual, Weight, _).
+provider_weight(DependencyNode, VirtualNode, Weight) :- provider_weight(DependencyNode, VirtualNode, Weight, _).
% A provider that is an external can use a weight of 0
-possible_provider_weight(Dependency, Virtual, 0, "external")
- :- provider(Dependency, Virtual),
- external(Dependency).
+possible_provider_weight(DependencyNode, VirtualNode, 0, "external")
+ :- provider(DependencyNode, VirtualNode),
+ external(DependencyNode).
% A provider mentioned in packages.yaml can use a weight
% according to its priority in the list of providers
-possible_provider_weight(Dependency, Virtual, Weight, "packages_yaml")
- :- provider(Dependency, Virtual),
- depends_on(Package, Dependency),
+possible_provider_weight(node(DependencyID, Dependency), node(0, Virtual), Weight, "packages_yaml")
+ :- provider(node(DependencyID, Dependency), node(0, Virtual)),
+ depends_on(node(ID, Package), node(DependencyID, Dependency)),
facts(Package, provider_preference(Virtual, Dependency, Weight)).
% A provider mentioned in the default configuration can use a weight
% according to its priority in the list of providers
-possible_provider_weight(Dependency, Virtual, Weight, "default")
- :- provider(Dependency, Virtual),
+possible_provider_weight(node(DependencyID, Dependency), node(0, Virtual), Weight, "default")
+ :- provider(node(DependencyID, Dependency), node(0, Virtual)),
default_provider_preference(Virtual, Dependency, Weight).
% Any provider can use 100 as a weight, which is very high and discourage its use
-possible_provider_weight(Dependency, Virtual, 100, "fallback") :- provider(Dependency, Virtual).
+possible_provider_weight(node(DependencyID, Dependency), VirtualNode, 100, "fallback") :- provider(node(DependencyID, Dependency), VirtualNode).
% do not warn if generated program contains none of these.
#defined virtual/1.
@@ -387,127 +419,131 @@ possible_provider_weight(Dependency, Virtual, 100, "fallback") :- provider(Depen
%-----------------------------------------------------------------------------
% if a package is external its version must be one of the external versions
-{ external_version(Package, Version, Weight):
+{ external_version(node(ID, Package), Version, Weight):
facts(Package, version_declared(Version, Weight, "external")) }
- :- external(Package).
+ :- external(node(ID, Package)).
+
error(100, "Attempted to use external for '{0}' which does not satisfy any configured external spec", Package)
- :- external(Package),
- not external_version(Package, _, _).
+ :- external(node(ID, Package)),
+ not external_version(node(ID, Package), _, _).
error(100, "Attempted to use external for '{0}' which does not satisfy any configured external spec", Package)
- :- external(Package),
- 2 { external_version(Package, Version, Weight) }.
+ :- external(node(ID, Package)),
+ 2 { external_version(node(ID, Package), Version, Weight) }.
-version_weight(Package, Weight) :- external_version(Package, Version, Weight).
-attr("version", Package, Version) :- external_version(Package, Version, Weight).
+version_weight(PackageNode, Weight) :- external_version(PackageNode, Version, Weight).
+attr("version", PackageNode, Version) :- external_version(PackageNode, Version, Weight).
% if a package is not buildable, only externals or hashed specs are allowed
-external(Package) :- buildable_false(Package),
- attr("node", Package),
- not attr("hash", Package, _).
+external(node(ID, Package))
+ :- buildable_false(Package),
+ attr("node", node(ID, Package)),
+ not attr("hash", node(ID, Package), _).
% a package is a real_node if it is not external
-real_node(Package) :- attr("node", Package), not external(Package).
+real_node(PackageNode) :- attr("node", PackageNode), not external(PackageNode).
% a package is external if we are using an external spec for it
-external(Package) :- attr("external_spec_selected", Package, _).
+external(PackageNode) :- attr("external_spec_selected", PackageNode, _).
% we can't use the weight for an external version if we don't use the
% corresponding external spec.
-:- attr("version", Package, Version),
- version_weight(Package, Weight),
+:- attr("version", node(ID, Package), Version),
+ version_weight(node(ID, Package), Weight),
facts(Package, version_declared(Version, Weight, "external")),
- not external(Package),
+ not external(node(ID, Package)),
internal_error("External weight used for internal spec").
% determine if an external spec has been selected
-attr("external_spec_selected", Package, LocalIndex) :-
- external_conditions_hold(Package, LocalIndex),
- attr("node", Package),
- not attr("hash", Package, _).
+attr("external_spec_selected", node(ID, Package), LocalIndex) :-
+ external_conditions_hold(node(ID, Package), LocalIndex),
+ attr("node", node(ID, Package)),
+ not attr("hash", node(ID, Package), _).
-external_conditions_hold(Package, LocalIndex) :-
- facts(Package, possible_external(ID, LocalIndex)), condition_holds(ID, Package).
+external_conditions_hold(node(PackageID, Package), LocalIndex) :-
+ facts(Package, possible_external(ID, LocalIndex)), condition_holds(ID, node(PackageID, Package)).
% it cannot happen that a spec is external, but none of the external specs
% conditions hold.
error(100, "Attempted to use external for '{0}' which does not satisfy any configured external spec", Package)
- :- external(Package),
- not external_conditions_hold(Package, _).
+ :- external(node(ID, Package)),
+ not external_conditions_hold(node(ID, Package), _).
%-----------------------------------------------------------------------------
% Config required semantics
%-----------------------------------------------------------------------------
-package_in_dag(Package) :- attr("node", Package).
-package_in_dag(Package) :- attr("virtual_node", Package).
+package_in_dag(Node) :- attr("node", Node).
+package_in_dag(Node) :- attr("virtual_node", Node).
-activate_requirement(Package, X) :-
- package_in_dag(Package),
+activate_requirement(node(ID, Package), X) :-
+ package_in_dag(node(ID, Package)),
requirement_group(Package, X),
not requirement_conditional(Package, X, _).
-activate_requirement(Package, X) :-
- package_in_dag(Package),
+activate_requirement(node(ID, Package), X) :-
+ package_in_dag(node(ID, Package)),
requirement_group(Package, X),
- condition_holds(Y, Package),
+ condition_holds(Y, node(ID, Package)),
requirement_conditional(Package, X, Y).
-requirement_group_satisfied(Package, X) :-
- 1 { condition_holds(Y, Package) : requirement_group_member(Y, Package, X) } 1,
+requirement_group_satisfied(node(ID, Package), X) :-
+ 1 { condition_holds(Y, node(ID, Package)) : requirement_group_member(Y, Package, X) } 1,
requirement_policy(Package, X, "one_of"),
- activate_requirement(Package, X),
+ activate_requirement(node(ID, Package), X),
requirement_group(Package, X).
-requirement_weight(Package, Group, W) :-
- condition_holds(Y, Package),
+requirement_weight(node(ID, Package), Group, W) :-
+ condition_holds(Y, node(ID, Package)),
requirement_has_weight(Y, W),
requirement_group_member(Y, Package, Group),
requirement_policy(Package, Group, "one_of"),
- requirement_group_satisfied(Package, Group).
+ requirement_group_satisfied(node(ID, Package), Group).
-requirement_group_satisfied(Package, X) :-
- 1 { condition_holds(Y, Package) : requirement_group_member(Y, Package, X) } ,
+requirement_group_satisfied(node(ID, Package), X) :-
+ 1 { condition_holds(Y, node(ID, Package)) : requirement_group_member(Y, Package, X) } ,
requirement_policy(Package, X, "any_of"),
- activate_requirement(Package, X),
+ activate_requirement(node(ID, Package), X),
requirement_group(Package, X).
% TODO: the following two choice rules allow the solver to add compiler
% flags if their only source is from a requirement. This is overly-specific
% and should use a more-generic approach like in https://github.com/spack/spack/pull/37180
-{ attr("node_flag", A1, A2, A3) } :-
+
+% FIXME (node transformation): check the following two rules for node(ID, A1)
+{ attr("node_flag", node(ID, A1), A2, A3) } :-
requirement_group_member(Y, Package, X),
- activate_requirement(Package, X),
+ activate_requirement(node(ID, Package), X),
imposed_constraint(Y,"node_flag_set", A1, A2, A3).
-{ attr("node_flag_source", A1, A2, A3) } :-
+{ attr("node_flag_source", node(ID, A1), A2, node(ID, A3)) } :-
requirement_group_member(Y, Package, X),
- activate_requirement(Package, X),
+ activate_requirement(node(ID, Package), X),
imposed_constraint(Y,"node_flag_source", A1, A2, A3).
-requirement_weight(Package, Group, W) :-
+requirement_weight(node(ID, Package), Group, W) :-
W = #min {
- Z : requirement_has_weight(Y, Z), condition_holds(Y, Package), requirement_group_member(Y, Package, Group);
+ Z : requirement_has_weight(Y, Z), condition_holds(Y, node(ID, Package)), requirement_group_member(Y, Package, Group);
% We need this to avoid an annoying warning during the solve
% concretize.lp:1151:5-11: info: tuple ignored:
% #sup@73
10000
},
requirement_policy(Package, Group, "any_of"),
- requirement_group_satisfied(Package, Group).
+ requirement_group_satisfied(node(ID, Package), Group).
error(100, "cannot satisfy a requirement for package '{0}'.", Package) :-
- activate_requirement(Package, X),
+ activate_requirement(node(ID, Package), X),
requirement_group(Package, X),
not requirement_message(Package, X, _),
- not requirement_group_satisfied(Package, X).
+ not requirement_group_satisfied(node(ID, Package), X).
error(10, Message) :-
- activate_requirement(Package, X),
+ activate_requirement(node(ID, Package), X),
requirement_group(Package, X),
requirement_message(Package, X, Message),
- not requirement_group_satisfied(Package, X).
+ not requirement_group_satisfied(node(ID, Package), X).
#defined requirement_group/2.
@@ -522,135 +558,137 @@ error(10, Message) :-
%-----------------------------------------------------------------------------
% a variant is a variant of a package if it is a variant under some condition
% and that condition holds
-node_has_variant(Package, variant(Variant)) :-
+node_has_variant(node(NodeID, Package), variant(Variant)) :-
facts(Package, conditional_variant(ID, Variant)),
- condition_holds(ID, Package).
-
-node_has_variant(Package, variant(Variant)) :- facts(Package, variant(Variant)).
-
-
-attr("variant_propagate", Package, Variant, Value, Source) :-
- attr("node", Package),
- depends_on(Parent, Package),
- attr("variant_propagate", Parent, Variant, Value, Source),
- not attr("variant_set", Package, Variant).
-
-attr("variant_value", Package, Variant, Value) :-
- attr("node", Package),
- node_has_variant(Package, variant(Variant)),
- attr("variant_propagate", Package, Variant, Value, _),
+ condition_holds(ID, node(NodeID, Package)).
+
+node_has_variant(node(ID, Package), variant(Variant)) :-
+ facts(Package, variant(Variant)),
+ attr("node", node(ID, Package)).
+
+attr("variant_propagate", PackageNode, Variant, Value, Source) :-
+ attr("node", PackageNode),
+ depends_on(ParentNode, PackageNode),
+ attr("variant_propagate", ParentNode, Variant, Value, Source),
+ not attr("variant_set", PackageNode, Variant).
+
+attr("variant_value", node(ID, Package), Variant, Value) :-
+ attr("node", node(ID, Package)),
+ node_has_variant(node(ID, Package), variant(Variant)),
+ attr("variant_propagate", node(ID, Package), Variant, Value, _),
facts(Package, variant_possible_value(Variant, Value)).
-error(100, "{0} and {1} cannot both propagate variant '{2}' to package {3} with values '{4}' and '{5}'", Source1, Source2, Variant, Package, Value1, Value2) :-
- attr("variant_propagate", Package, Variant, Value1, Source1),
- attr("variant_propagate", Package, Variant, Value2, Source2),
- node_has_variant(Package, variant(Variant)),
+error(100, "{0} and {1} cannot both propagate variant '{2}' to package {3} with values '{4}' and '{5}'", Source1, Source2, Variant, PackageNode, Value1, Value2) :-
+ attr("variant_propagate", PackageNode, Variant, Value1, Source1),
+ attr("variant_propagate", PackageNode, Variant, Value2, Source2),
+ node_has_variant(PackageNode, variant(Variant)),
Value1 < Value2.
% a variant cannot be set if it is not a variant on the package
-error(100, "Cannot set variant '{0}' for package '{1}' because the variant condition cannot be satisfied for the given spec", Variant, Package)
- :- attr("variant_set", Package, Variant),
- not node_has_variant(Package, variant(Variant)),
- build(Package).
+error(100, "Cannot set variant '{0}' for package '{1}' because the variant condition cannot be satisfied for the given spec", Variant, PackageNode)
+ :- attr("variant_set", PackageNode, Variant),
+ not node_has_variant(PackageNode, variant(Variant)),
+ build(PackageNode).
% a variant cannot take on a value if it is not a variant of the package
-error(100, "Cannot set variant '{0}' for package '{1}' because the variant condition cannot be satisfied for the given spec", Variant, Package)
- :- attr("variant_value", Package, Variant, _),
- not node_has_variant(Package, variant(Variant)),
- build(Package).
+error(100, "Cannot set variant '{0}' for package '{1}' because the variant condition cannot be satisfied for the given spec", Variant, PackageNode)
+ :- attr("variant_value", PackageNode, Variant, _),
+ not node_has_variant(PackageNode, variant(Variant)),
+ build(PackageNode).
% if a variant is sticky and not set its value is the default value
-attr("variant_value", Package, Variant, Value) :-
- node_has_variant(Package, variant(Variant)),
- not attr("variant_set", Package, Variant),
+attr("variant_value", node(ID, Package), Variant, Value) :-
+ node_has_variant(node(ID, Package), variant(Variant)),
+ not attr("variant_set", node(ID, Package), Variant),
facts(Package, variant_sticky(Variant)),
variant_default_value(Package, Variant, Value),
- build(Package).
+ build(node(ID, Package)).
% at most one variant value for single-valued variants.
{
- attr("variant_value", Package, Variant, Value)
+ attr("variant_value", node(ID, Package), Variant, Value)
: facts(Package, variant_possible_value(Variant, Value))
}
- :- attr("node", Package),
- node_has_variant(Package, variant(Variant)),
- build(Package).
+ :- attr("node", node(ID, Package)),
+ node_has_variant(node(ID, Package), variant(Variant)),
+ build(node(ID, Package)).
error(100, "'{0}' required multiple values for single-valued variant '{1}'", Package, Variant)
- :- attr("node", Package),
- node_has_variant(Package, variant(Variant)),
+ :- attr("node", node(ID, Package)),
+ node_has_variant(node(ID, Package), variant(Variant)),
facts(Package, variant_single_value(Variant)),
- build(Package),
- 2 { attr("variant_value", Package, Variant, Value) }.
+ build(node(ID, Package)),
+ 2 { attr("variant_value", node(ID, Package), Variant, Value) }.
-error(100, "No valid value for variant '{1}' of package '{0}'", Package, Variant)
- :- attr("node", Package),
- node_has_variant(Package, variant(Variant)),
- build(Package),
- not attr("variant_value", Package, Variant, _).
+error(100, "No valid value for variant '{1}' of package '{0}'", PackageNode, Variant)
+ :- attr("node", PackageNode),
+ node_has_variant(PackageNode, variant(Variant)),
+ build(PackageNode),
+ not attr("variant_value", PackageNode, Variant, _).
% if a variant is set to anything, it is considered 'set'.
-attr("variant_set", Package, Variant) :- attr("variant_set", Package, Variant, _).
+attr("variant_set", PackageNode, Variant) :- attr("variant_set", PackageNode, Variant, _).
% A variant cannot have a value that is not also a possible value
% This only applies to packages we need to build -- concrete packages may
% have been built w/different variants from older/different package versions.
error(10, "'Spec({1}={2})' is not a valid value for '{0}' variant '{1}'", Package, Variant, Value)
- :- attr("variant_value", Package, Variant, Value),
+ :- attr("variant_value", node(ID, Package), Variant, Value),
not facts(Package, variant_possible_value(Variant, Value)),
- build(Package).
+ build(node(ID, Package)).
% Some multi valued variants accept multiple values from disjoint sets.
% Ensure that we respect that constraint and we don't pick values from more
% than one set at once
error(100, "{0} variant '{1}' cannot have values '{2}' and '{3}' as they come from disjoint value sets", Package, Variant, Value1, Value2)
- :- attr("variant_value", Package, Variant, Value1),
- attr("variant_value", Package, Variant, Value2),
+ :- attr("variant_value", node(ID, Package), Variant, Value1),
+ attr("variant_value", node(ID, Package), Variant, Value2),
facts(Package, variant_value_from_disjoint_sets(Variant, Value1, Set1)),
facts(Package, variant_value_from_disjoint_sets(Variant, Value2, Set2)),
Set1 < Set2, % see[1]
- build(Package).
+ build(node(ID, Package)).
% variant_set is an explicitly set variant value. If it's not 'set',
% we revert to the default value. If it is set, we force the set value
-attr("variant_value", Package, Variant, Value)
- :- attr("node", Package),
- node_has_variant(Package, variant(Variant)),
- attr("variant_set", Package, Variant, Value).
+attr("variant_value", PackageNode, Variant, Value)
+ :- attr("node", PackageNode),
+ node_has_variant(PackageNode, variant(Variant)),
+ attr("variant_set", PackageNode, Variant, Value).
% The rules below allow us to prefer default values for variants
% whenever possible. If a variant is set in a spec, or if it is
% specified in an external, we score it as if it was a default value.
-variant_not_default(Package, Variant, Value)
- :- attr("variant_value", Package, Variant, Value),
+variant_not_default(node(ID, Package), Variant, Value)
+ :- attr("variant_value", node(ID, Package), Variant, Value),
not variant_default_value(Package, Variant, Value),
% variants set explicitly on the CLI don't count as non-default
- not attr("variant_set", Package, Variant, Value),
+ not attr("variant_set", node(ID, Package), Variant, Value),
% variant values forced by propagation don't count as non-default
- not attr("variant_propagate", Package, Variant, Value, _),
+ not attr("variant_propagate", node(ID, Package), Variant, Value, _),
% variants set on externals that we could use don't count as non-default
% this makes spack prefer to use an external over rebuilding with the
% default configuration
- not external_with_variant_set(Package, Variant, Value),
- attr("node", Package).
+ not external_with_variant_set(node(ID, Package), Variant, Value),
+ attr("node", node(ID, Package)).
% A default variant value that is not used
-variant_default_not_used(Package, Variant, Value)
+variant_default_not_used(node(ID, Package), Variant, Value)
:- variant_default_value(Package, Variant, Value),
- node_has_variant(Package, variant(Variant)),
- not attr("variant_value", Package, Variant, Value),
- attr("node", Package).
+ node_has_variant(node(ID, Package), variant(Variant)),
+ not attr("variant_value", node(ID, Package), Variant, Value),
+ attr("node", node(ID, Package)).
% The variant is set in an external spec
-external_with_variant_set(Package, Variant, Value)
- :- attr("variant_value", Package, Variant, Value),
+external_with_variant_set(node(NodeID, Package), Variant, Value)
+ :- attr("variant_value", node(NodeID, Package), Variant, Value),
condition_requirement(ID, "variant_value", Package, Variant, Value),
facts(Package, possible_external(ID, _)),
- external(Package),
- attr("node", Package).
+ external(node(NodeID, Package)),
+ attr("node", node(NodeID, Package)).
+% FIXME (node transformation): check how to define the default value
% The default value for a variant in a package is what is prescribed:
%
% 1. On the command line
@@ -661,22 +699,22 @@ external_with_variant_set(Package, Variant, Value)
variant_default_value(Package, Variant, Value)
:- facts(Package, variant_default_value_from_package_py(Variant, Value)),
not variant_default_value_from_packages_yaml(Package, Variant, _),
- not attr("variant_default_value_from_cli", Package, Variant, _).
+ not attr("variant_default_value_from_cli", node(0, Package), Variant, _).
variant_default_value(Package, Variant, Value)
:- variant_default_value_from_packages_yaml(Package, Variant, Value),
- not attr("variant_default_value_from_cli", Package, Variant, _).
+ not attr("variant_default_value_from_cli", node(0, Package), Variant, _).
variant_default_value(Package, Variant, Value) :-
- attr("variant_default_value_from_cli", Package, Variant, Value).
+ attr("variant_default_value_from_cli", node(0, Package), Variant, Value).
% Treat 'none' in a special way - it cannot be combined with other
% values even if the variant is multi-valued
-error(100, "{0} variant '{1}' cannot have values '{2}' and 'none'", Package, Variant, Value)
- :- attr("variant_value", Package, Variant, Value),
- attr("variant_value", Package, Variant, "none"),
+error(100, "{0} variant '{1}' cannot have values '{2}' and 'none'", PackageNode, Variant, Value)
+ :- attr("variant_value", PackageNode, Variant, Value),
+ attr("variant_value", PackageNode, Variant, "none"),
Value != "none",
- build(Package).
+ build(PackageNode).
% patches and dev_path are special variants -- they don't have to be
% declared in the package, so we just allow them to spring into existence
@@ -684,11 +722,11 @@ error(100, "{0} variant '{1}' cannot have values '{2}' and 'none'", Package, Var
auto_variant("dev_path").
auto_variant("patches").
-node_has_variant(Package, variant(Variant))
- :- attr("variant_set", Package, Variant, _), auto_variant(Variant).
+node_has_variant(PackageNode, variant(Variant))
+ :- attr("variant_set", PackageNode, Variant, _), auto_variant(Variant).
facts(Package, variant_single_value("dev_path"))
- :- attr("variant_set", Package, "dev_path", _).
+ :- attr("variant_set", node(ID, Package), "dev_path", _).
% suppress warnings about this atom being unset. It's only set if some
% spec or some package sets it, and without this, clingo will give
@@ -703,17 +741,17 @@ facts(Package, variant_single_value("dev_path"))
% if no platform is set, fall back to the default
:- attr("node_platform", _, Platform), not allowed_platform(Platform).
-attr("node_platform", Package, Platform)
- :- attr("node", Package),
- not attr("node_platform_set", Package),
+attr("node_platform", PackageNode, Platform)
+ :- attr("node", PackageNode),
+ not attr("node_platform_set", PackageNode),
node_platform_default(Platform).
% setting platform on a node is a hard constraint
-attr("node_platform", Package, Platform)
- :- attr("node", Package), attr("node_platform_set", Package, Platform).
+attr("node_platform", PackageNode, Platform)
+ :- attr("node", PackageNode), attr("node_platform_set", PackageNode, Platform).
% platform is set if set to anything
-attr("node_platform_set", Package) :- attr("node_platform_set", Package, _).
+attr("node_platform_set", PackageNode) :- attr("node_platform_set", PackageNode, _).
%-----------------------------------------------------------------------------
% OS semantics
@@ -722,33 +760,37 @@ attr("node_platform_set", Package) :- attr("node_platform_set", Package, _).
os(OS) :- os(OS, _).
% one os per node
-{ attr("node_os", Package, OS) : os(OS) } :- attr("node", Package).
+{ attr("node_os", PackageNode, OS) : os(OS) } :- attr("node", PackageNode).
% can't have a non-buildable OS on a node we need to build
-error(100, "Cannot select '{0} os={1}' (operating system '{1}' is not buildable)", Package, OS)
- :- build(Package),
- attr("node_os", Package, OS),
+error(100, "Cannot select '{0} os={1}' (operating system '{1}' is not buildable)", PackageNode, OS)
+ :- build(PackageNode),
+ attr("node_os", PackageNode, OS),
not buildable_os(OS).
% can't have dependencies on incompatible OS's
-error(100, "{0} and dependency {1} have incompatible operating systems 'os={2}' and 'os={3}'", Package, Dependency, PackageOS, DependencyOS)
- :- depends_on(Package, Dependency),
- attr("node_os", Package, PackageOS),
- attr("node_os", Dependency, DependencyOS),
- not os_compatible(PackageOS, DependencyOS),
- build(Package).
+error(100, "{0} and dependency {1} have incompatible operating systems 'os={2}' and 'os={3}'", PackageNode, DependencyNode, PackageNodeOS, DependencyOS)
+ :- depends_on(PackageNode, DependencyNode),
+ attr("node_os", PackageNode, PackageNodeOS),
+ attr("node_os", DependencyNode, DependencyOS),
+ not os_compatible(PackageNodeOS, DependencyOS),
+ build(PackageNode).
% give OS choice weights according to os declarations
-node_os_weight(Package, Weight)
- :- attr("node", Package),
- attr("node_os", Package, OS),
+node_os_weight(PackageNode, Weight)
+ :- attr("node", PackageNode),
+ attr("node_os", PackageNode, OS),
os(OS, Weight).
% match semantics for OS's
-node_os_match(Package, Dependency) :-
- depends_on(Package, Dependency), attr("node_os", Package, OS), attr("node_os", Dependency, OS).
-node_os_mismatch(Package, Dependency) :-
- depends_on(Package, Dependency), not node_os_match(Package, Dependency).
+node_os_match(PackageNode, DependencyNode) :-
+ depends_on(PackageNode, DependencyNode),
+ attr("node_os", PackageNode, OS),
+ attr("node_os", DependencyNode, OS).
+
+node_os_mismatch(PackageNode, DependencyNode) :-
+ depends_on(PackageNode, DependencyNode),
+ not node_os_match(PackageNode, DependencyNode).
% every OS is compatible with itself. We can use `os_compatible` to declare
os_compatible(OS, OS) :- os(OS).
@@ -764,7 +806,7 @@ os_compatible(OS1, OS3) :- os_compatible(OS1, OS2), os_compatible(OS2, OS3).
internal_error("Reused OS incompatible with build OS").
% If an OS is set explicitly respect the value
-attr("node_os", Package, OS) :- attr("node_os_set", Package, OS), attr("node", Package).
+attr("node_os", PackageNode, OS) :- attr("node_os_set", PackageNode, OS), attr("node", PackageNode).
#defined os_compatible/2.
@@ -773,132 +815,132 @@ attr("node_os", Package, OS) :- attr("node_os_set", Package, OS), attr("node", P
%-----------------------------------------------------------------------------
% Each node has only one target chosen among the known targets
-{ attr("node_target", Package, Target) : target(Target) } :- attr("node", Package).
+{ attr("node_target", PackageNode, Target) : target(Target) } :- attr("node", PackageNode).
% If a node must satisfy a target constraint, enforce it
-error(10, "'{0} target={1}' cannot satisfy constraint 'target={2}'", Package, Target, Constraint)
- :- attr("node_target", Package, Target),
- attr("node_target_satisfies", Package, Constraint),
+error(10, "'{0} target={1}' cannot satisfy constraint 'target={2}'", PackageNode, Target, Constraint)
+ :- attr("node_target", PackageNode, Target),
+ attr("node_target_satisfies", PackageNode, Constraint),
not target_satisfies(Constraint, Target).
% If a node has a target and the target satisfies a constraint, then the target
% associated with the node satisfies the same constraint
-attr("node_target_satisfies", Package, Constraint)
- :- attr("node_target", Package, Target), target_satisfies(Constraint, Target).
+attr("node_target_satisfies", PackageNode, Constraint)
+ :- attr("node_target", PackageNode, Target), target_satisfies(Constraint, Target).
% If a node has a target, all of its dependencies must be compatible with that target
-error(100, "Cannot find compatible targets for {0} and {1}", Package, Dependency)
- :- depends_on(Package, Dependency),
- attr("node_target", Package, Target),
- not node_target_compatible(Dependency, Target).
+error(100, "Cannot find compatible targets for {0} and {1}", PackageNode, DependencyNode)
+ :- depends_on(PackageNode, DependencyNode),
+ attr("node_target", PackageNode, Target),
+ not node_target_compatible(DependencyNode, Target).
% Intermediate step for performance reasons
% When the integrity constraint above was formulated including this logic
% we suffered a substantial performance penalty
-node_target_compatible(Package, Target)
- :- attr("node_target", Package, MyTarget),
+node_target_compatible(PackageNode, Target)
+ :- attr("node_target", PackageNode, MyTarget),
target_compatible(Target, MyTarget).
#defined target_satisfies/2.
% can't use targets on node if the compiler for the node doesn't support them
-error(100, "{0} compiler '{2}@{3}' incompatible with 'target={1}'", Package, Target, Compiler, Version)
- :- attr("node_target", Package, Target),
- node_compiler(Package, CompilerID),
+error(100, "{0} compiler '{2}@{3}' incompatible with 'target={1}'", PackageNode, Target, Compiler, Version)
+ :- attr("node_target", PackageNode, Target),
+ node_compiler(PackageNode, CompilerID),
not compiler_supports_target(CompilerID, Target),
compiler_name(CompilerID, Compiler),
compiler_version(CompilerID, Version),
- build(Package).
+ build(PackageNode).
% if a target is set explicitly, respect it
-attr("node_target", Package, Target)
- :- attr("node", Package), attr("node_target_set", Package, Target).
+attr("node_target", PackageNode, Target)
+ :- attr("node", PackageNode), attr("node_target_set", PackageNode, Target).
% each node has the weight of its assigned target
-node_target_weight(Package, Weight)
- :- attr("node", Package),
- attr("node_target", Package, Target),
+node_target_weight(node(ID, Package), Weight)
+ :- attr("node", node(ID, Package)),
+ attr("node_target", node(ID, Package), Target),
facts(Package, target_weight(Target, Weight)).
% compatibility rules for targets among nodes
-node_target_match(Parent, Dependency)
- :- depends_on(Parent, Dependency),
- attr("node_target", Parent, Target),
- attr("node_target", Dependency, Target).
+node_target_match(ParentNode, DependencyNode)
+ :- depends_on(ParentNode, DependencyNode),
+ attr("node_target", ParentNode, Target),
+ attr("node_target", DependencyNode, Target).
-node_target_mismatch(Parent, Dependency)
- :- depends_on(Parent, Dependency),
- not node_target_match(Parent, Dependency).
+node_target_mismatch(ParentNode, DependencyNode)
+ :- depends_on(ParentNode, DependencyNode),
+ not node_target_match(ParentNode, DependencyNode).
% disallow reusing concrete specs that don't have a compatible target
-error(100, "'{0} target={1}' is not compatible with this machine", Package, Target)
- :- attr("node", Package),
- attr("node_target", Package, Target),
+error(100, "'{0} target={1}' is not compatible with this machine", PackageNode, Target)
+ :- attr("node", PackageNode),
+ attr("node_target", PackageNode, Target),
not target(Target).
%-----------------------------------------------------------------------------
% Compiler semantics
%-----------------------------------------------------------------------------
% There must be only one compiler set per built node.
-{ node_compiler(Package, CompilerID) : compiler_id(CompilerID) } :-
- attr("node", Package),
- build(Package).
+{ node_compiler(PackageNode, CompilerID) : compiler_id(CompilerID) } :-
+ attr("node", PackageNode),
+ build(PackageNode).
% Infer the compiler that matches a reused node
-node_compiler(Package, CompilerID)
- :- attr("node_compiler_version", Package, CompilerName, CompilerVersion),
- attr("node", Package),
+node_compiler(PackageNode, CompilerID)
+ :- attr("node_compiler_version", PackageNode, CompilerName, CompilerVersion),
+ attr("node", PackageNode),
compiler_name(CompilerID, CompilerName),
compiler_version(CompilerID, CompilerVersion),
- concrete(Package).
+ concrete(PackageNode).
% Expand the internal attribute into "attr("node_compiler_version")
-attr("node_compiler_version", Package, CompilerName, CompilerVersion)
- :- node_compiler(Package, CompilerID),
+attr("node_compiler_version", PackageNode, CompilerName, CompilerVersion)
+ :- node_compiler(PackageNode, CompilerID),
compiler_name(CompilerID, CompilerName),
compiler_version(CompilerID, CompilerVersion),
- build(Package).
+ build(PackageNode).
-attr("node_compiler", Package, CompilerName)
- :- attr("node_compiler_version", Package, CompilerName, CompilerVersion).
+attr("node_compiler", PackageNode, CompilerName)
+ :- attr("node_compiler_version", PackageNode, CompilerName, CompilerVersion).
-error(100, "No valid compiler version found for '{0}'", Package)
- :- attr("node", Package),
- not node_compiler(Package, _).
+error(100, "No valid compiler version found for '{0}'", PackageNode)
+ :- attr("node", PackageNode),
+ not node_compiler(PackageNode, _).
% We can't have a compiler be enforced and select the version from another compiler
-error(100, "Cannot select a single compiler for package {0}", Package)
- :- attr("node", Package),
- 2 { attr("node_compiler_version", Package, C, V) }.
+error(100, "Cannot select a single compiler for package {0}", PackageNode)
+ :- attr("node", PackageNode),
+ 2 { attr("node_compiler_version", PackageNode, C, V) }.
-error(100, "Cannot concretize {0} with two compilers {1} and {2}@{3}", Package, Compiler1, Compiler2, Version)
- :- attr("node_compiler", Package, Compiler1),
- attr("node_compiler_version", Package, Compiler2, Version),
+error(100, "Cannot concretize {0} with two compilers {1} and {2}@{3}", PackageNode, Compiler1, Compiler2, Version)
+ :- attr("node_compiler", PackageNode, Compiler1),
+ attr("node_compiler_version", PackageNode, Compiler2, Version),
Compiler1 != Compiler2.
% If the compiler of a node cannot be satisfied, raise
-error(10, "No valid compiler for {0} satisfies '%{1}'", Package, Compiler)
- :- attr("node", Package),
- attr("node_compiler_version_satisfies", Package, Compiler, ":"),
+error(10, "No valid compiler for {0} satisfies '%{1}'", PackageNode, Compiler)
+ :- attr("node", PackageNode),
+ attr("node_compiler_version_satisfies", PackageNode, Compiler, ":"),
not compiler_version_satisfies(Compiler, ":", _).
% If the compiler of a node must satisfy a constraint, then its version
% must be chosen among the ones that satisfy said constraint
-error(100, "No valid version for '{0}' compiler '{1}' satisfies '@{2}'", Package, Compiler, Constraint)
- :- attr("node", Package),
- attr("node_compiler_version_satisfies", Package, Compiler, Constraint),
+error(100, "No valid version for '{0}' compiler '{1}' satisfies '@{2}'", PackageNode, Compiler, Constraint)
+ :- attr("node", PackageNode),
+ attr("node_compiler_version_satisfies", PackageNode, Compiler, Constraint),
not compiler_version_satisfies(Compiler, Constraint, _).
-error(100, "No valid version for '{0}' compiler '{1}' satisfies '@{2}'", Package, Compiler, Constraint)
- :- attr("node", Package),
- attr("node_compiler_version_satisfies", Package, Compiler, Constraint),
+error(100, "No valid version for '{0}' compiler '{1}' satisfies '@{2}'", PackageNode, Compiler, Constraint)
+ :- attr("node", PackageNode),
+ attr("node_compiler_version_satisfies", PackageNode, Compiler, Constraint),
not compiler_version_satisfies(Compiler, Constraint, ID),
- node_compiler(Package, ID).
+ node_compiler(PackageNode, ID).
% If the node is associated with a compiler and the compiler satisfy a constraint, then
% the compiler associated with the node satisfy the same constraint
-attr("node_compiler_version_satisfies", Package, Compiler, Constraint)
- :- node_compiler(Package, CompilerID),
+attr("node_compiler_version_satisfies", PackageNode, Compiler, Constraint)
+ :- node_compiler(PackageNode, CompilerID),
compiler_name(CompilerID, Compiler),
compiler_version_satisfies(Compiler, Constraint, CompilerID).
@@ -906,58 +948,58 @@ attr("node_compiler_version_satisfies", Package, Compiler, Constraint)
% If the compiler version was set from the command line,
% respect it verbatim
-:- attr("node_compiler_version_set", Package, Compiler, Version),
- not attr("node_compiler_version", Package, Compiler, Version).
+:- attr("node_compiler_version_set", PackageNode, Compiler, Version),
+ not attr("node_compiler_version", PackageNode, Compiler, Version).
-:- attr("node_compiler_set", Package, Compiler),
- not attr("node_compiler_version", Package, Compiler, _).
+:- attr("node_compiler_set", PackageNode, Compiler),
+ not attr("node_compiler_version", PackageNode, Compiler, _).
% Cannot select a compiler if it is not supported on the OS
% Compilers that are explicitly marked as allowed
% are excluded from this check
-error(100, "{0} compiler '%{1}@{2}' incompatible with 'os={3}'", Package, Compiler, Version, OS)
- :- attr("node_os", Package, OS),
- node_compiler(Package, CompilerID),
+error(100, "{0} compiler '%{1}@{2}' incompatible with 'os={3}'", PackageNode, Compiler, Version, OS)
+ :- attr("node_os", PackageNode, OS),
+ node_compiler(PackageNode, CompilerID),
compiler_name(CompilerID, Compiler),
compiler_version(CompilerID, Version),
not compiler_os(CompilerID, OS),
not allow_compiler(Compiler, Version),
- build(Package).
+ build(PackageNode).
% If a package and one of its dependencies don't have the
% same compiler there's a mismatch.
-compiler_match(Package, Dependency)
- :- depends_on(Package, Dependency),
- node_compiler(Package, CompilerID),
- node_compiler(Dependency, CompilerID).
+compiler_match(PackageNode, DependencyNode)
+ :- depends_on(PackageNode, DependencyNode),
+ node_compiler(PackageNode, CompilerID),
+ node_compiler(DependencyNode, CompilerID).
-compiler_mismatch(Package, Dependency)
- :- depends_on(Package, Dependency),
- not attr("node_compiler_set", Dependency, _),
- not compiler_match(Package, Dependency).
+compiler_mismatch(PackageNode, DependencyNode)
+ :- depends_on(PackageNode, DependencyNode),
+ not attr("node_compiler_set", DependencyNode, _),
+ not compiler_match(PackageNode, DependencyNode).
-compiler_mismatch_required(Package, Dependency)
- :- depends_on(Package, Dependency),
- attr("node_compiler_set", Dependency, _),
- not compiler_match(Package, Dependency).
+compiler_mismatch_required(PackageNode, DependencyNode)
+ :- depends_on(PackageNode, DependencyNode),
+ attr("node_compiler_set", DependencyNode, _),
+ not compiler_match(PackageNode, DependencyNode).
#defined compiler_os/3.
#defined allow_compiler/2.
% compilers weighted by preference according to packages.yaml
-compiler_weight(Package, Weight)
- :- node_compiler(Package, CompilerID),
+compiler_weight(node(ID, Package), Weight)
+ :- node_compiler(node(ID, Package), CompilerID),
compiler_name(CompilerID, Compiler),
compiler_version(CompilerID, V),
facts(Package, node_compiler_preference(Compiler, V, Weight)).
-compiler_weight(Package, Weight)
- :- node_compiler(Package, CompilerID),
+compiler_weight(node(ID, Package), Weight)
+ :- node_compiler(node(ID, Package), CompilerID),
compiler_name(CompilerID, Compiler),
compiler_version(CompilerID, V),
not facts(Package, node_compiler_preference(Compiler, V, _)),
default_compiler_preference(CompilerID, Weight).
-compiler_weight(Package, 100)
- :- node_compiler(Package, CompilerID),
+compiler_weight(node(ID, Package), 100)
+ :- node_compiler(node(ID, Package), CompilerID),
compiler_name(CompilerID, Compiler),
compiler_version(CompilerID, V),
not facts(Package, node_compiler_preference(Compiler, V, _)),
@@ -965,8 +1007,8 @@ compiler_weight(Package, 100)
% For the time being, be strict and reuse only if the compiler match one we have on the system
error(100, "Compiler {1}@{2} requested for {0} cannot be found. Set install_missing_compilers:true if intended.", Package, Compiler, Version)
- :- attr("node_compiler_version", Package, Compiler, Version),
- not node_compiler(Package, _).
+ :- attr("node_compiler_version", node(ID, Package), Compiler, Version),
+ not node_compiler(node(ID, Package), _).
#defined node_compiler_preference/4.
#defined default_compiler_preference/3.
@@ -976,21 +1018,23 @@ error(100, "Compiler {1}@{2} requested for {0} cannot be found. Set install_miss
%-----------------------------------------------------------------------------
% propagate flags when compiler match
-can_inherit_flags(Package, Dependency, FlagType)
- :- depends_on(Package, Dependency),
- node_compiler(Package, CompilerID),
- node_compiler(Dependency, CompilerID),
- not attr("node_flag_set", Dependency, FlagType, _),
- compiler_id(CompilerID),
- flag_type(FlagType).
-
-node_flag_inherited(Dependency, FlagType, Flag)
- :- attr("node_flag_set", Package, FlagType, Flag), can_inherit_flags(Package, Dependency, FlagType),
- attr("node_flag_propagate", Package, FlagType).
+can_inherit_flags(PackageNode, DependencyNode, FlagType)
+ :- depends_on(PackageNode, DependencyNode),
+ node_compiler(PackageNode, CompilerID),
+ node_compiler(DependencyNode, CompilerID),
+ not attr("node_flag_set", DependencyNode, FlagType, _),
+ compiler_id(CompilerID),
+ flag_type(FlagType).
+
+node_flag_inherited(DependencyNode, FlagType, Flag)
+ :- attr("node_flag_set", PackageNode, FlagType, Flag),
+ can_inherit_flags(PackageNode, DependencyNode, FlagType),
+ attr("node_flag_propagate", PackageNode, FlagType).
+
% Ensure propagation
-:- node_flag_inherited(Package, FlagType, Flag),
- can_inherit_flags(Package, Dependency, FlagType),
- attr("node_flag_propagate", Package, FlagType).
+:- node_flag_inherited(PackageNode, FlagType, Flag),
+ can_inherit_flags(PackageNode, DependencyNode, FlagType),
+ attr("node_flag_propagate", PackageNode, FlagType).
error(100, "{0} and {1} cannot both propagate compiler flags '{2}' to {3}", Source1, Source2, Package, FlagType) :-
depends_on(Source1, Package),
@@ -1002,37 +1046,41 @@ error(100, "{0} and {1} cannot both propagate compiler flags '{2}' to {3}", Sour
Source1 < Source2.
% remember where flags came from
-attr("node_flag_source", Package, FlagType, Package) :- attr("node_flag_set", Package, FlagType, _).
-attr("node_flag_source", Dependency, FlagType, Q)
- :- attr("node_flag_source", Package, FlagType, Q), node_flag_inherited(Dependency, FlagType, _),
- attr("node_flag_propagate", Package, FlagType).
+attr("node_flag_source", PackageNode, FlagType, PackageNode)
+ :- attr("node_flag_set", PackageNode, FlagType, _).
+
+attr("node_flag_source", DependencyNode, FlagType, Q)
+ :- attr("node_flag_source", PackageNode, FlagType, Q),
+ node_flag_inherited(DependencyNode, FlagType, _),
+ attr("node_flag_propagate", PackageNode, FlagType).
% compiler flags from compilers.yaml are put on nodes if compiler matches
-attr("node_flag", Package, FlagType, Flag)
- :- compiler_flag(CompilerID, FlagType, Flag),
- node_compiler(Package, CompilerID),
- flag_type(FlagType),
- compiler_id(CompilerID),
- compiler_name(CompilerID, CompilerName),
- compiler_version(CompilerID, Version).
-
-attr("node_flag_compiler_default", Package)
- :- not attr("node_flag_set", Package, FlagType, _),
- compiler_flag(CompilerID, FlagType, Flag),
- node_compiler(Package, CompilerID),
- flag_type(FlagType),
- compiler_id(CompilerID),
- compiler_name(CompilerID, CompilerName),
- compiler_version(CompilerID, Version).
+attr("node_flag", PackageNode, FlagType, Flag)
+ :- compiler_flag(CompilerID, FlagType, Flag),
+ node_compiler(PackageNode, CompilerID),
+ flag_type(FlagType),
+ compiler_id(CompilerID),
+ compiler_name(CompilerID, CompilerName),
+ compiler_version(CompilerID, Version).
+
+attr("node_flag_compiler_default", PackageNode)
+ :- not attr("node_flag_set", PackageNode, FlagType, _),
+ compiler_flag(CompilerID, FlagType, Flag),
+ node_compiler(PackageNode, CompilerID),
+ flag_type(FlagType),
+ compiler_id(CompilerID),
+ compiler_name(CompilerID, CompilerName),
+ compiler_version(CompilerID, Version).
% if a flag is set to something or inherited, it's included
-attr("node_flag", Package, FlagType, Flag) :- attr("node_flag_set", Package, FlagType, Flag).
-attr("node_flag", Package, FlagType, Flag)
- :- node_flag_inherited(Package, FlagType, Flag).
+attr("node_flag", PackageNode, FlagType, Flag) :- attr("node_flag_set", PackageNode, FlagType, Flag).
+attr("node_flag", PackageNode, FlagType, Flag) :- node_flag_inherited(PackageNode, FlagType, Flag).
% if no node flags are set for a type, there are no flags.
-attr("no_flags", Package, FlagType)
- :- not attr("node_flag", Package, FlagType, _), attr("node", Package), flag_type(FlagType).
+attr("no_flags", PackageNode, FlagType)
+ :- not attr("node_flag", PackageNode, FlagType, _),
+ attr("node", PackageNode),
+ flag_type(FlagType).
#defined compiler_flag/3.
@@ -1041,22 +1089,22 @@ attr("no_flags", Package, FlagType)
% Installed packages
%-----------------------------------------------------------------------------
% the solver is free to choose at most one installed hash for each package
-{ attr("hash", Package, Hash) : installed_hash(Package, Hash) } 1
- :- attr("node", Package), internal_error("Package must resolve to at most one hash").
+{ attr("hash", node(ID, Package), Hash) : installed_hash(Package, Hash) } 1
+ :- attr("node", node(ID, Package)), internal_error("Package must resolve to at most one hash").
% you can't choose an installed hash for a dev spec
-:- attr("hash", Package, Hash), attr("variant_value", Package, "dev_path", _).
+:- attr("hash", PackageNode, Hash), attr("variant_value", PackageNode, "dev_path", _).
% You can't install a hash, if it is not installed
-:- attr("hash", Package, Hash), not installed_hash(Package, Hash).
+:- attr("hash", node(ID, Package), Hash), not installed_hash(Package, Hash).
% This should be redundant given the constraint above
-:- attr("node", Package), 2 { attr("hash", Package, Hash) }.
+:- attr("node", PackageNode), 2 { attr("hash", PackageNode, Hash) }.
% if a hash is selected, we impose all the constraints that implies
-impose(Hash, Package) :- attr("hash", Package, Hash).
+impose(Hash, PackageNode) :- attr("hash", PackageNode, Hash).
% if we haven't selected a hash for a package, we'll be building it
-build(Package) :- not attr("hash", Package, _), attr("node", Package).
+build(PackageNode) :- not attr("hash", PackageNode, _), attr("node", PackageNode).
% Minimizing builds is tricky. We want a minimizing criterion
@@ -1073,11 +1121,11 @@ build(Package) :- not attr("hash", Package, _), attr("node", Package).
% 200+ Shifted priorities for build nodes; correspond to priorities 0 - 99.
% 100 - 199 Unshifted priorities. Currently only includes minimizing #builds.
% 0 - 99 Priorities for non-built nodes.
-build_priority(Package, 200) :- build(Package), attr("node", Package), optimize_for_reuse().
-build_priority(Package, 0) :- not build(Package), attr("node", Package), optimize_for_reuse().
+build_priority(PackageNode, 200) :- build(PackageNode), attr("node", PackageNode), optimize_for_reuse().
+build_priority(PackageNode, 0) :- not build(PackageNode), attr("node", PackageNode), optimize_for_reuse().
% don't adjust build priorities if reuse is not enabled
-build_priority(Package, 0) :- attr("node", Package), not optimize_for_reuse().
+build_priority(PackageNode, 0) :- attr("node", PackageNode), not optimize_for_reuse().
% don't assign versions from installed packages unless reuse is enabled
% NOTE: that "installed" means the declared version was only included because
@@ -1090,8 +1138,8 @@ build_priority(Package, 0) :- attr("node", Package), not optimize_for_reuse().
% currently *won't* force versions for `bar`'s build dependencies -- `--fresh`
% will instead build the latest bar. When we actually include transitive
% build deps in the solve, consider using them as a preference to resolve this.
-:- attr("version", Package, Version),
- version_weight(Package, Weight),
+:- attr("version", node(ID, Package), Version),
+ version_weight(node(ID, Package), Weight),
facts(Package, version_declared(Version, Weight, "installed")),
not optimize_for_reuse().
@@ -1121,7 +1169,7 @@ build_priority(Package, 0) :- attr("node", Package), not optimize_for_reuse().
% Try hard to reuse installed packages (i.e., minimize the number built)
opt_criterion(100, "number of packages to build (vs. reuse)").
#minimize { 0@100: #true }.
-#minimize { 1@100,Package : build(Package), optimize_for_reuse() }.
+#minimize { 1@100,PackageNode : build(PackageNode), optimize_for_reuse() }.
#defined optimize_for_reuse/0.
% A condition group specifies one or more specs that must be satisfied.
@@ -1131,9 +1179,9 @@ opt_criterion(75, "requirement weight").
#minimize{ 0@275: #true }.
#minimize{ 0@75: #true }.
#minimize {
- Weight@75+Priority,Package,Group
- : requirement_weight(Package, Group, Weight),
- build_priority(Package, Priority)
+ Weight@75+Priority,PackageNode,Group
+ : requirement_weight(PackageNode, Group, Weight),
+ build_priority(PackageNode, Priority)
}.
% Minimize the number of deprecated versions being used
@@ -1141,9 +1189,9 @@ opt_criterion(73, "deprecated versions used").
#minimize{ 0@273: #true }.
#minimize{ 0@73: #true }.
#minimize{
- 1@73+Priority,Package
- : attr("deprecated", Package, _),
- build_priority(Package, Priority)
+ 1@73+Priority,PackageNode
+ : attr("deprecated", PackageNode, _),
+ build_priority(PackageNode, Priority)
}.
% Minimize the:
@@ -1155,38 +1203,39 @@ opt_criterion(70, "version weight").
#minimize{ 0@70: #true }.
#minimize {
Weight@70+Priority
- : attr("root", Package), version_weight(Package, Weight),
- build_priority(Package, Priority)
+ : attr("root", PackageNode),
+ version_weight(PackageNode, Weight),
+ build_priority(PackageNode, Priority)
}.
opt_criterion(65, "number of non-default variants (roots)").
#minimize{ 0@265: #true }.
#minimize{ 0@65: #true }.
#minimize {
- 1@65+Priority,Package,Variant,Value
- : variant_not_default(Package, Variant, Value),
- attr("root", Package),
- build_priority(Package, Priority)
+ 1@65+Priority,PackageNode,Variant,Value
+ : variant_not_default(PackageNode, Variant, Value),
+ attr("root", PackageNode),
+ build_priority(PackageNode, Priority)
}.
opt_criterion(60, "preferred providers for roots").
#minimize{ 0@260: #true }.
#minimize{ 0@60: #true }.
#minimize{
- Weight@60+Priority,Provider,Virtual
- : provider_weight(Provider, Virtual, Weight),
- attr("root", Provider),
- build_priority(Provider, Priority)
+ Weight@60+Priority,ProviderNode,Virtual
+ : provider_weight(ProviderNode, Virtual, Weight),
+ attr("root", ProviderNode),
+ build_priority(ProviderNode, Priority)
}.
opt_criterion(55, "default values of variants not being used (roots)").
#minimize{ 0@255: #true }.
#minimize{ 0@55: #true }.
#minimize{
- 1@55+Priority,Package,Variant,Value
- : variant_default_not_used(Package, Variant, Value),
- attr("root", Package),
- build_priority(Package, Priority)
+ 1@55+Priority,PackageNode,Variant,Value
+ : variant_default_not_used(PackageNode, Variant, Value),
+ attr("root", PackageNode),
+ build_priority(PackageNode, Priority)
}.
% Try to use default variants or variants that have been set
@@ -1194,10 +1243,10 @@ opt_criterion(50, "number of non-default variants (non-roots)").
#minimize{ 0@250: #true }.
#minimize{ 0@50: #true }.
#minimize {
- 1@50+Priority,Package,Variant,Value
- : variant_not_default(Package, Variant, Value),
- not attr("root", Package),
- build_priority(Package, Priority)
+ 1@50+Priority,PackageNode,Variant,Value
+ : variant_not_default(PackageNode, Variant, Value),
+ not attr("root", PackageNode),
+ build_priority(PackageNode, Priority)
}.
% Minimize the weights of the providers, i.e. use as much as
@@ -1206,9 +1255,10 @@ opt_criterion(45, "preferred providers (non-roots)").
#minimize{ 0@245: #true }.
#minimize{ 0@45: #true }.
#minimize{
- Weight@45+Priority,Provider,Virtual
- : provider_weight(Provider, Virtual, Weight), not attr("root", Provider),
- build_priority(Provider, Priority)
+ Weight@45+Priority,ProviderNode,Virtual
+ : provider_weight(ProviderNode, Virtual, Weight),
+ not attr("root", ProviderNode),
+ build_priority(ProviderNode, Priority)
}.
% Try to minimize the number of compiler mismatches in the DAG.
@@ -1216,18 +1266,18 @@ opt_criterion(40, "compiler mismatches that are not from CLI").
#minimize{ 0@240: #true }.
#minimize{ 0@40: #true }.
#minimize{
- 1@40+Priority,Package,Dependency
- : compiler_mismatch(Package, Dependency),
- build_priority(Package, Priority)
+ 1@40+Priority,PackageNode,DependencyNode
+ : compiler_mismatch(PackageNode, DependencyNode),
+ build_priority(PackageNode, Priority)
}.
opt_criterion(39, "compiler mismatches that are not from CLI").
#minimize{ 0@239: #true }.
#minimize{ 0@39: #true }.
#minimize{
- 1@39+Priority,Package,Dependency
- : compiler_mismatch_required(Package, Dependency),
- build_priority(Package, Priority)
+ 1@39+Priority,PackageNode,DependencyNode
+ : compiler_mismatch_required(PackageNode, DependencyNode),
+ build_priority(PackageNode, Priority)
}.
% Try to minimize the number of compiler mismatches in the DAG.
@@ -1235,18 +1285,18 @@ opt_criterion(35, "OS mismatches").
#minimize{ 0@235: #true }.
#minimize{ 0@35: #true }.
#minimize{
- 1@35+Priority,Package,Dependency
- : node_os_mismatch(Package, Dependency),
- build_priority(Package, Priority)
+ 1@35+Priority,PackageNode,DependencyNode
+ : node_os_mismatch(PackageNode, DependencyNode),
+ build_priority(PackageNode, Priority)
}.
opt_criterion(30, "non-preferred OS's").
#minimize{ 0@230: #true }.
#minimize{ 0@30: #true }.
#minimize{
- Weight@30+Priority,Package
- : node_os_weight(Package, Weight),
- build_priority(Package, Priority)
+ Weight@30+Priority,PackageNode
+ : node_os_weight(PackageNode, Weight),
+ build_priority(PackageNode, Priority)
}.
% Choose more recent versions for nodes
@@ -1254,9 +1304,9 @@ opt_criterion(25, "version badness").
#minimize{ 0@225: #true }.
#minimize{ 0@25: #true }.
#minimize{
- Weight@25+Priority,Package
- : version_weight(Package, Weight),
- build_priority(Package, Priority)
+ Weight@25+Priority,PackageNode
+ : version_weight(PackageNode, Weight),
+ build_priority(PackageNode, Priority)
}.
% Try to use all the default values of variants
@@ -1264,10 +1314,10 @@ opt_criterion(20, "default values of variants not being used (non-roots)").
#minimize{ 0@220: #true }.
#minimize{ 0@20: #true }.
#minimize{
- 1@20+Priority,Package,Variant,Value
- : variant_default_not_used(Package, Variant, Value),
- not attr("root", Package),
- build_priority(Package, Priority)
+ 1@20+Priority,PackageNode,Variant,Value
+ : variant_default_not_used(PackageNode, Variant, Value),
+ not attr("root", PackageNode),
+ build_priority(PackageNode, Priority)
}.
% Try to use preferred compilers
@@ -1275,9 +1325,9 @@ opt_criterion(15, "non-preferred compilers").
#minimize{ 0@215: #true }.
#minimize{ 0@15: #true }.
#minimize{
- Weight@15+Priority,Package
- : compiler_weight(Package, Weight),
- build_priority(Package, Priority)
+ Weight@15+Priority,PackageNode
+ : compiler_weight(PackageNode, Weight),
+ build_priority(PackageNode, Priority)
}.
% Minimize the number of mismatches for targets in the DAG, try
@@ -1286,18 +1336,18 @@ opt_criterion(10, "target mismatches").
#minimize{ 0@210: #true }.
#minimize{ 0@10: #true }.
#minimize{
- 1@10+Priority,Package,Dependency
- : node_target_mismatch(Package, Dependency),
- build_priority(Package, Priority)
+ 1@10+Priority,PackageNode,Dependency
+ : node_target_mismatch(PackageNode, Dependency),
+ build_priority(PackageNode, Priority)
}.
opt_criterion(5, "non-preferred targets").
#minimize{ 0@205: #true }.
#minimize{ 0@5: #true }.
#minimize{
- Weight@5+Priority,Package
- : node_target_weight(Package, Weight),
- build_priority(Package, Priority)
+ Weight@5+Priority,PackageNode
+ : node_target_weight(PackageNode, Weight),
+ build_priority(PackageNode, Priority)
}.
%-----------------
@@ -1305,28 +1355,28 @@ opt_criterion(5, "non-preferred targets").
%-----------------
#heuristic literal_solved(ID) : literal(ID). [1, sign]
#heuristic literal_solved(ID) : literal(ID). [50, init]
-#heuristic attr("hash", Package, Hash) : attr("root", Package). [45, init]
+#heuristic attr("hash", PackageNode, Hash) : attr("root", PackageNode). [45, init]
-#heuristic attr("version", Package, Version) : facts(Package, version_declared(Version, 0)), attr("root", Package). [40, true]
-#heuristic version_weight(Package, 0) : facts(Package, version_declared(Version, 0)), attr("root", Package). [40, true]
-#heuristic attr("variant_value", Package, Variant, Value) : variant_default_value(Package, Variant, Value), attr("root", Package). [40, true]
-#heuristic attr("node_target", Package, Target) : facts(Package, target_weight(Target, 0)), attr("root", Package). [40, true]
-#heuristic node_target_weight(Package, 0) : attr("root", Package). [40, true]
-#heuristic node_compiler(Package, CompilerID) : default_compiler_preference(ID, 0), compiler_id(ID), attr("root", Package). [40, true]
+#heuristic attr("version", node(0, Package), Version) : facts(Package, version_declared(Version, 0)), attr("root", node(0, Package)). [40, true]
+#heuristic version_weight(node(0, Package), 0) : facts(Package, version_declared(Version, 0)), attr("root", node(0, Package)). [40, true]
+#heuristic attr("variant_value", node(0, Package), Variant, Value) : variant_default_value(Package, Variant, Value), attr("root", node(0, Package)). [40, true]
+#heuristic attr("node_target", node(0, Package), Target) : facts(Package, target_weight(Target, 0)), attr("root", node(0, Package)). [40, true]
+#heuristic node_target_weight(node(0, Package), 0) : attr("root", node(0, Package)). [40, true]
+#heuristic node_compiler(node(0, Package), CompilerID) : default_compiler_preference(ID, 0), compiler_id(ID), attr("root", node(0, Package)). [40, true]
-#heuristic provider(Package, Virtual) : possible_provider_weight(Package, Virtual, 0, _), attr("virtual_node", Virtual). [30, true]
+#heuristic provider(PackageNode, VirtualNode) : possible_provider_weight(PackageNode, VirtualNode, 0, _), attr("virtual_node", VirtualNode). [30, true]
#heuristic provider_weight(Package, Virtual, 0, R) : possible_provider_weight(Package, Virtual, 0, R), attr("virtual_node", Virtual). [30, true]
#heuristic attr("node", Package) : possible_provider_weight(Package, Virtual, 0, _), attr("virtual_node", Virtual). [30, true]
-#heuristic attr("version", Package, Version) : facts(Package, version_declared(Version, 0)), attr("node", Package). [20, true]
-#heuristic version_weight(Package, 0) : facts(Package, version_declared(Version, 0)), attr("node", Package). [20, true]
+#heuristic attr("version", node(ID, Package), Version) : facts(Package, version_declared(Version, 0)), attr("node", node(ID, Package)). [20, true]
+#heuristic version_weight(node(ID, Package), 0) : facts(Package, version_declared(Version, 0)), attr("node", node(ID, Package)). [20, true]
-#heuristic attr("node_target", Package, Target) : facts(Package, target_weight(Target, 0)), attr("node", Package). [20, true]
+#heuristic attr("node_target", node(ID, Package), Target) : facts(Package, target_weight(Target, 0)), attr("node", node(ID, Package)). [20, true]
#heuristic node_target_weight(Package, 0) : attr("node", Package). [20, true]
-#heuristic node_compiler(Package, CompilerID) : default_compiler_preference(ID, 0), compiler_id(ID), attr("node", Package). [15, true]
+#heuristic node_compiler(node(ID, Package), ID) : default_compiler_preference(ID, 0), compiler_id(ID), attr("node", node(NodeID, Package)). [15, true]
-#heuristic attr("variant_value", Package, Variant, Value) : variant_default_value(Package, Variant, Value), attr("node", Package). [10, true]
-#heuristic attr("node_os", Package, OS) : buildable_os(OS). [10, true]
+#heuristic attr("variant_value", node(ID, Package), Variant, Value) : variant_default_value(Package, Variant, Value), attr("node", node(ID, Package)). [10, true]
+#heuristic attr("node_os", PackageNode, OS) : buildable_os(OS). [10, true]
%-----------
% Notes
diff --git a/lib/spack/spack/spec.py b/lib/spack/spack/spec.py
index af534e3f84..561cd7baba 100644
--- a/lib/spack/spack/spec.py
+++ b/lib/spack/spack/spec.py
@@ -2983,9 +2983,10 @@ class Spec:
providers = [spec.name for spec in answer.values() if spec.package.provides(name)]
name = providers[0]
- assert name in answer
+ node = spack.solver.asp.SpecBuilder.root_node(pkg=name)
+ assert node in answer, f"cannot find {name} in the list of specs {','.join(answer.keys())}"
- concretized = answer[name]
+ concretized = answer[node]
self._dup(concretized)
def concretize(self, tests=False):
@@ -3519,7 +3520,8 @@ class Spec:
for value in values:
if self.variants.get(variant_name):
msg = (
- "Cannot append a value to a single-valued " "variant with an already set value"
+ f"cannot append the new value '{value}' to the single-valued "
+ f"variant '{self.variants[variant_name]}'"
)
assert pkg_variant.multi, msg
self.variants[variant_name].append(value)