def getter(node):

for name in names:

result = getattr(node, name, None)

if result:

return result

raise KeyError("node has no such keys: %s" % names)

0: 'spec',

1: 'external',

2: 'packages_yaml',

3: 'package_py'

"""Construct an ordered mapping from criteria names to indices in the cost list."""

# pull optimization criteria names out of the solution

priorities_names = []

num_fixed = 0

for pred, args in tuples:

if pred != "opt_criterion":

continue

priority, name = args[:2]

priority = int(priority)

# add the priority of this opt criterion and its name

priorities_names.append((priority, name))

# if the priority is less than fixed_priority_offset, then it

# has an associated build priority -- the same criterion but for

# nodes that we have to build.

if priority < fixed_priority_offset:

build_priority = priority + build_priority_offset

priorities_names.append((build_priority, name))

else:

num_fixed += 1

# sort the criteria by priority

priorities_names = sorted(priorities_names, reverse=True)

assert len(priorities_names) == len(costs), "Wrong number of optimization criteria!"

# split list into three parts: build criteria, fixed criteria, non-build criteria

num_criteria = len(priorities_names)

num_build = (num_criteria - num_fixed) // 2

build = priorities_names[:num_build]

fixed = priorities_names[num_build:num_build + num_fixed]

installed = priorities_names[num_build + num_fixed:]

# mapping from priority to index in cost list

indices = dict((p, i) for i, (p, n) in enumerate(priorities_names))

# make a list that has each name with its build and non-build priority

criteria = [

(p - fixed_priority_offset + num_build, None, name) for p, name in fixed

]

for (i, name), (b, _) in zip(installed, build):

criteria.append((indices[i], indices[b], name))

if isinstance(pkg, string_types):

return spack.repo.path.get_pkg_class(pkg)

else:

"""Quote string if needed for it to be a valid identifier."""

if isinstance(thing, AspObject):

return thing

elif isinstance(thing, bool):

return '"%s"' % str(thing)

elif isinstance(thing, int):

return str(thing)

else:

def __init__(self, name, args=None):

self.name = name

self.args = () if args is None else args

def _cmp_key(self):

return (self.name, self.args)

def __call__(self, *args):

return AspFunction(self.name, args)

def symbol(self, positive=True):

def argify(arg):

if isinstance(arg, bool):

return clingo.String(str(arg))

elif isinstance(arg, int):

return clingo.Number(arg)

else:

return clingo.String(str(arg))

return clingo.Function(

self.name, [argify(arg) for arg in self.args], positive=positive)

def __str__(self):

return "%s(%s)" % (

self.name, ', '.join(str(_id(arg)) for arg in self.args))

def __repr__(self):

"""Extend a list of flags, preserving order and precedence.

for flag in new_flags:

if flag in flag_list:

flag_list.remove(flag)

"""Return True if flag dicts contain the same flags regardless of order."""

types = set(flag_dict_1.keys()).union(set(flag_dict_2.keys()))

for t in types:

values1 = set(flag_dict_1.get(t, []))

values2 = set(flag_dict_2.get(t, []))

"""Ensure all packages mentioned in specs exist."""

repo = spack.repo.path

for spec in specs:

for s in spec.traverse():

try:

check_passed = repo.exists(s.name) or repo.is_virtual(s.name)

except Exception as e:

msg = 'Cannot find package: {0}'.format(str(e))

check_passed = False

tty.debug(msg)

if not check_passed:

"""Result of an ASP solve."""

def __init__(self, specs, asp=None):

self.asp = asp

self.satisfiable = None

self.optimal = None

self.warnings = None

self.nmodels = 0

# Saved control object for reruns when necessary

self.control = None

# specs ordered by optimization level

self.answers = []

self.cores = []

# names of optimization criteria

self.criteria = []

# Abstract user requests

self.abstract_specs = specs

# Concrete specs

self._concrete_specs = None

def format_core(self, core):

"""

assert self.control

symbols = dict(

(a.literal, a.symbol)

for a in self.control.symbolic_atoms

)

core_symbols = []

for atom in core:

sym = symbols[atom]

if sym.name in ("rule", "error"):

# these are special symbols we use to get messages in the core

sym = sym.arguments[0].string

core_symbols.append(sym)

return sorted(str(symbol) for symbol in core_symbols)

def minimize_core(self, core):

"""

assert self.control

min_core = core[:]

for fact in core:

# Try solving without this fact

min_core.remove(fact)

ret = self.control.solve(assumptions=min_core)

if not ret.unsatisfiable:

min_core.append(fact)

return min_core

def minimal_cores(self):

"""

return [self.minimize_core(core) for core in self.cores]

def format_minimal_cores(self):

"""List of facts for each core

string_list = []

for core in self.minimal_cores():

if string_list:

string_list.append('\n')

string_list.extend(self.format_core(core))

return string_list

def format_cores(self):

"""List of facts for each core

string_list = []

for core in self.cores:

if string_list:

string_list.append('\n')

string_list.extend(self.format_core(core))

return string_list

def raise_if_unsat(self):

"""

if self.satisfiable:

return

constraints = self.abstract_specs

if len(constraints) == 1:

constraints = constraints[0]

if minimize_cores:

conflicts = self.format_minimal_cores()

else:

conflicts = self.format_cores()

raise UnsatisfiableSpecError(constraints, conflicts=conflicts)

@property

def specs(self):

"""List of concretized specs satisfying the initial

# The specs were already computed, return them

if self._concrete_specs:

return self._concrete_specs

# Assert prerequisite

msg = 'cannot compute specs ["satisfiable" is not True ]'

assert self.satisfiable, msg

self._concrete_specs = []

best = min(self.answers)

opt, _, answer = best

for input_spec in self.abstract_specs:

key = input_spec.name

if input_spec.virtual:

providers = [spec.name for spec in answer.values()

if spec.package.provides(key)]

key = providers[0]

self._concrete_specs.append(answer[key])

normalized_yaml = copy.copy(packages_yaml)

for pkg_name in packages_yaml:

is_virtual = spack.repo.path.is_virtual(pkg_name)

if pkg_name == 'all' or not is_virtual:

continue

# Remove the virtual entry from the normalized configuration

data = normalized_yaml.pop(pkg_name)

is_buildable = data.get('buildable', True)

if not is_buildable:

for provider in spack.repo.path.providers_for(pkg_name):

entry = normalized_yaml.setdefault(provider.name, {})

entry['buildable'] = False

externals = data.get('externals', [])

keyfn = lambda x: spack.spec.Spec(x['spec']).name

for provider, specs in itertools.groupby(externals, key=keyfn):

entry = normalized_yaml.setdefault(provider, {})

entry.setdefault('externals', []).extend(specs)

global clingo, ASTType, parse_files

if not clingo:

with spack.bootstrap.ensure_bootstrap_configuration():

spack.bootstrap.ensure_clingo_importable_or_raise()

import clingo

from clingo.ast import ASTType

try:

from clingo.ast import parse_files

except ImportError:

# older versions of clingo have this one namespace up

def __init__(self, cores=True):

"""Driver for the Python clingo interface.

bootstrap_clingo()

self.out = llnl.util.lang.Devnull()

self.cores = cores

def title(self, name, char):

self.out.write('\n')

self.out.write("%" + (char * 76))

self.out.write('\n')

self.out.write("%% %s\n" % name)

self.out.write("%" + (char * 76))

self.out.write('\n')

def h1(self, name):

self.title(name, "=")

def h2(self, name):

self.title(name, "-")

def newline(self):

self.out.write('\n')

def fact(self, head, assumption=False):

"""ASP fact (a rule without a body).

symbol = head.symbol() if hasattr(head, 'symbol') else head

self.out.write("%s.\n" % str(symbol))

atom = self.backend.add_atom(symbol)

# with `--show-cores=full or --show-cores=minimized, make all facts

# choices/assumptions, otherwise only if assumption=True

choice = self.cores and (full_cores or assumption)

self.backend.add_rule([atom], [], choice=choice)

if choice:

self.assumptions.append(atom)

def solve(

self,

setup,

specs,

nmodels=0,

timers=False,

stats=False,

out=None,

setup_only=False

):

"""Set up the input and solve for dependencies of ``specs``.

# allow solve method to override the output stream

if out is not None:

self.out = out

timer = spack.util.timer.Timer()

# Initialize the control object for the solver

self.control = clingo.Control()

self.control.configuration.configuration = 'tweety'

self.control.configuration.solve.models = nmodels

self.control.configuration.solver.heuristic = 'Domain'

self.control.configuration.solve.parallel_mode = '1'

self.control.configuration.solver.opt_strategy = "usc,one"

# set up the problem -- this generates facts and rules

self.assumptions = []

with self.control.backend() as backend:

self.backend = backend

setup.setup(self, specs)

timer.phase("setup")

# read in the main ASP program and display logic -- these are

# handwritten, not generated, so we load them as resources

parent_dir = os.path.dirname(__file__)

# extract error messages from concretize.lp by inspecting its AST

with self.backend:

def visit(node):

if ast_type(node) == ASTType.Rule:

for term in node.body:

if ast_type(term) == ASTType.Literal:

if ast_type(term.atom) == ASTType.SymbolicAtom:

if ast_sym(term.atom).name == "error":

arg = ast_sym(ast_sym(term.atom).arguments[0])

self.fact(fn.error(arg.string), assumption=True)

path = os.path.join(parent_dir, 'concretize.lp')

parse_files([path], visit)

# If we're only doing setup, just return an empty solve result

if setup_only:

return Result(specs)

# Load the file itself

self.control.load(os.path.join(parent_dir, 'concretize.lp'))

self.control.load(os.path.join(parent_dir, "display.lp"))

timer.phase("load")

# Grounding is the first step in the solve -- it turns our facts

# and first-order logic rules into propositional logic.

self.control.ground([("base", [])])

timer.phase("ground")

# With a grounded program, we can run the solve.

result = Result(specs)

models = [] # stable models if things go well

cores = [] # unsatisfiable cores if they do not

def on_model(model):

models.append((model.cost, model.symbols(shown=True, terms=True)))

solve_kwargs = {"assumptions": self.assumptions,

"on_model": on_model,

"on_core": cores.append}

if clingo_cffi:

solve_kwargs["on_unsat"] = cores.append

solve_result = self.control.solve(**solve_kwargs)

timer.phase("solve")

# once done, construct the solve result

result.satisfiable = solve_result.satisfiable

def stringify(x):

if clingo_cffi:

# Clingo w/ CFFI will throw an exception on failure

try:

return x.string

except RuntimeError:

return str(x)

else:

return x.string or str(x)

if result.satisfiable:

# build spec from the best model

builder = SpecBuilder(specs)

min_cost, best_model = min(models)

tuples = [

(sym.name, [stringify(a) for a in sym.arguments])

for sym in best_model

]

answers = builder.build_specs(tuples)

# add best spec to the results

result.answers.append((list(min_cost), 0, answers))

result.criteria = build_criteria_names(min_cost, tuples)

# record the number of models the solver considered

result.nmodels = len(models)

elif cores:

result.control = self.control

result.cores.extend(cores)

if timers:

timer.write_tty()

print()

if stats:

print("Statistics:")

pprint.pprint(self.control.statistics)

"""Class to set up and run a Spack concretization solve."""

def __init__(self, reuse=False, tests=False):

self.gen = None # set by setup()

self.declared_versions = {}

self.possible_versions = {}

self.deprecated_versions = {}

self.possible_virtuals = None

self.possible_compilers = []

self.possible_oses = set()

self.variant_values_from_specs = set()

self.version_constraints = set()

self.target_constraints = set()

self.compiler_version_constraints = set()

self.post_facts = []

# hashes we've already added facts for

self.seen_hashes = set()

# id for dummy variables

self._condition_id_counter = itertools.count()

# Caches to optimize the setup phase of the solver

self.target_specs_cache = None

# whether to add installed/binary hashes to the solve

self.reuse = reuse

# whether to add installed/binary hashes to the solve

self.tests = tests

def pkg_version_rules(self, pkg):

"""Output declared versions of a package.

def key_fn(version):

# Origins are sorted by order of importance:

# 1. Spec from command line

# 2. Externals

# 3. Package preferences

# 4. Directives in package.py

return version.origin, version.idx

pkg = packagize(pkg)

declared_versions = self.declared_versions[pkg.name]

most_to_least_preferred = sorted(declared_versions, key=key_fn)

for weight, declared_version in enumerate(most_to_least_preferred):

self.gen.fact(fn.version_declared(

pkg.name, declared_version.version, weight,

version_origin_str[declared_version.origin]

))

# Declare deprecated versions for this package, if any

deprecated = self.deprecated_versions[pkg.name]

for v in sorted(deprecated):

self.gen.fact(fn.deprecated_version(pkg.name, v))

def spec_versions(self, spec):

"""Return list of clauses expressing spec's version constraints."""

spec = specify(spec)

assert spec.name

if spec.concrete:

return [fn.version(spec.name, spec.version)]

if spec.versions == spack.version.ver(":"):

return []

# record all version constraints for later

self.version_constraints.add((spec.name, spec.versions))

return [fn.version_satisfies(spec.name, spec.versions)]

def target_ranges(self, spec, single_target_fn):

target = spec.architecture.target

# Check if the target is a concrete target

if str(target) in archspec.cpu.TARGETS:

return [single_target_fn(spec.name, target)]

self.target_constraints.add(target)

return [fn.node_target_satisfies(spec.name, target)]

def conflict_rules(self, pkg):

for trigger, constraints in pkg.conflicts.items():

trigger_id = self.condition(spack.spec.Spec(trigger), name=pkg.name)

self.gen.fact(fn.conflict_trigger(trigger_id))

for constraint, _ in constraints:

constraint_id = self.condition(constraint, name=pkg.name)

self.gen.fact(fn.conflict(pkg.name, trigger_id, constraint_id))

self.gen.newline()

def available_compilers(self):

"""Facts about available compilers."""

self.gen.h2("Available compilers")

compilers = self.possible_compilers

compiler_versions = collections.defaultdict(lambda: set())

for compiler in compilers:

compiler_versions[compiler.name].add(compiler.version)

for compiler in sorted(compiler_versions):

for v in sorted(compiler_versions[compiler]):

self.gen.fact(fn.compiler_version(compiler, v))

self.gen.newline()

def compiler_defaults(self):

"""Set compiler defaults, given a list of possible compilers."""

self.gen.h2("Default compiler preferences")

compiler_list = self.possible_compilers.copy()

compiler_list = sorted(

compiler_list, key=lambda x: (x.name, x.version), reverse=True)

ppk = spack.package_prefs.PackagePrefs("all", 'compiler', all=False)

matches = sorted(compiler_list, key=ppk)

for i, cspec in enumerate(matches):

f = fn.default_compiler_preference(cspec.name, cspec.version, i)

self.gen.fact(f)

# Enumerate target families. This may be redundant, but compilers with

# custom versions will be able to concretize properly.

for entry in spack.compilers.all_compilers_config():

compiler_entry = entry['compiler']

cspec = spack.spec.CompilerSpec(compiler_entry['spec'])

if not compiler_entry.get('target', None):

continue

self.gen.fact(fn.compiler_supports_target(

cspec.name, cspec.version, compiler_entry['target']

))

def compiler_supports_os(self):

compilers_yaml = spack.compilers.all_compilers_config()

for entry in compilers_yaml:

c = spack.spec.CompilerSpec(entry['compiler']['spec'])

operating_system = entry['compiler']['operating_system']

self.gen.fact(fn.compiler_supports_os(

c.name, c.version, operating_system

))

def package_compiler_defaults(self, pkg):

"""Facts about packages' compiler prefs."""

packages = spack.config.get("packages")

pkg_prefs = packages.get(pkg.name)

if not pkg_prefs or "compiler" not in pkg_prefs:

return

compiler_list = self.possible_compilers.copy()

compiler_list = sorted(

compiler_list, key=lambda x: (x.name, x.version), reverse=True)

ppk = spack.package_prefs.PackagePrefs(pkg.name, 'compiler', all=False)

matches = sorted(compiler_list, key=ppk)

for i, cspec in enumerate(reversed(matches)):

self.gen.fact(fn.node_compiler_preference(

pkg.name, cspec.name, cspec.version, -i * 100

))

def pkg_rules(self, pkg, tests):

pkg = packagize(pkg)

# versions

self.pkg_version_rules(pkg)

self.gen.newline()

# variants

for name, entry in sorted(pkg.variants.items()):

variant, when = entry

for w in when:

cond_id = self.condition(w, name=pkg.name)

self.gen.fact(fn.variant_condition(cond_id, pkg.name, name))

single_value = not variant.multi

if single_value:

self.gen.fact(fn.variant_single_value(pkg.name, name))

self.gen.fact(

fn.variant_default_value_from_package_py(

pkg.name, name, variant.default)

)

else:

spec_variant = variant.make_default()

defaults = spec_variant.value

for val in sorted(defaults):

self.gen.fact(

fn.variant_default_value_from_package_py(

pkg.name, name, val)

)

values = variant.values

if values is None:

values = []

elif isinstance(values, spack.variant.DisjointSetsOfValues):

union = set()

# Encode the disjoint sets in the logic program

for sid, s in enumerate(values.sets):

for value in s:

self.gen.fact(fn.variant_value_from_disjoint_sets(

pkg.name, name, value, sid

))

union.update(s)

values = union

# make sure that every variant has at least one possible value

if not values:

values = [variant.default]

for value in sorted(values):

self.gen.fact(fn.variant_possible_value(pkg.name, name, value))

if hasattr(value, 'when'):

required = spack.spec.Spec('{0}={1}'.format(name, value))

imposed = spack.spec.Spec(value.when)

imposed.name = pkg.name

self.condition(

required_spec=required, imposed_spec=imposed, name=pkg.name

)

if variant.sticky:

self.gen.fact(fn.variant_sticky(pkg.name, name))

self.gen.newline()

# conflicts

self.conflict_rules(pkg)

# default compilers for this package

self.package_compiler_defaults(pkg)

# virtuals

self.package_provider_rules(pkg)

# dependencies

self.package_dependencies_rules(pkg)

# virtual preferences

self.virtual_preferences(

pkg.name,

lambda v, p, i: self.gen.fact(

fn.pkg_provider_preference(pkg.name, v, p, i)

)

)

def condition(self, required_spec, imposed_spec=None, name=None):

"""Generate facts for a dependency or virtual provider condition.

named_cond = required_spec.copy()

named_cond.name = named_cond.name or name

assert named_cond.name, "must provide name for anonymous condtions!"

condition_id = next(self._condition_id_counter)

self.gen.fact(fn.condition(condition_id))

# requirements trigger the condition

requirements = self.spec_clauses(

named_cond, body=True, required_from=name)

for pred in requirements:

self.gen.fact(

fn.condition_requirement(condition_id, pred.name, *pred.args)

)

if imposed_spec:

self.impose(condition_id, imposed_spec, node=False, name=name)

return condition_id

def impose(self, condition_id, imposed_spec, node=True, name=None, body=False):

imposed_constraints = self.spec_clauses(

imposed_spec, body=body, required_from=name)

for pred in imposed_constraints:

# imposed "node"-like conditions are no-ops

if not node and pred.name in ("node", "virtual_node"):

continue

self.gen.fact(

fn.imposed_constraint(condition_id, pred.name, *pred.args)

)

def package_provider_rules(self, pkg):

for provider_name in sorted(set(s.name for s in pkg.provided.keys())):

self.gen.fact(fn.possible_provider(pkg.name, provider_name))

for provided, whens in pkg.provided.items():

for when in whens:

condition_id = self.condition(when, provided, pkg.name)

self.gen.fact(fn.provider_condition(

condition_id, when.name, provided.name

))

self.gen.newline()

def package_dependencies_rules(self, pkg):

"""Translate 'depends_on' directives into ASP logic."""

for _, conditions in sorted(pkg.dependencies.items()):

for cond, dep in sorted(conditions.items()):

deptypes = dep.type.copy()

# Skip test dependencies if they're not requested

if not self.tests:

deptypes.discard("test")

# ... or if they are requested only for certain packages

if not isinstance(self.tests, bool) and pkg.name not in self.tests:

deptypes.discard("test")

# if there are no dependency types to be considered

# anymore, don't generate the dependency

if not deptypes:

continue

condition_id = self.condition(cond, dep.spec, pkg.name)

self.gen.fact(fn.dependency_condition(

condition_id, pkg.name, dep.spec.name

))

for t in sorted(deptypes):

# there is a declared dependency of type t

self.gen.fact(fn.dependency_type(condition_id, t))

self.gen.newline()

def virtual_preferences(self, pkg_name, func):

"""Call func(vspec, provider, i) for each of pkg's provider prefs."""