summaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/spack/docs/basic_usage.rst61
-rw-r--r--lib/spack/docs/configuration.rst11
l---------lib/spack/env/cray/CC1
l---------lib/spack/env/cray/cc1
l---------lib/spack/env/cray/ftn1
-rw-r--r--lib/spack/spack/concretize.py179
-rw-r--r--lib/spack/spack/config.py8
-rw-r--r--lib/spack/spack/modules.py1
-rw-r--r--lib/spack/spack/platforms/cray_xc.py3
-rw-r--r--lib/spack/spack/preferred_packages.py7
10 files changed, 166 insertions, 107 deletions
diff --git a/lib/spack/docs/basic_usage.rst b/lib/spack/docs/basic_usage.rst
index 948092047b..df9a3901bf 100644
--- a/lib/spack/docs/basic_usage.rst
+++ b/lib/spack/docs/basic_usage.rst
@@ -546,7 +546,7 @@ More formally, a spec consists of the following pieces:
boolean variants
* ``name=<value>`` Optional compiler flag specifiers. Valid flag names are
``cflags``, ``cxxflags``, ``fflags``, ``cppflags``, ``ldflags``, and ``ldlibs``.
-* ``target=<value> os=<value>`` Optional architecture specifier
+* ``target=<value> os=<value>`` Optional architecture specifier
(``target=haswell os=CNL10``)
* ``^`` Dependency specs (``^callpath@1.1``)
@@ -764,12 +764,12 @@ words ``target`` and/or ``os`` (``target=x86-64 os=debian7``). You can also
use the triplet form of platform, operating system and processor.
.. code-block:: sh
-
+
spack install libelf arch=cray_xc-CNL10-haswell
Users on non-Cray systems won't have to worry about specifying the architecture.
Spack will autodetect what kind of operating system is on your machine as well
-as the processor. For more information on how the architecture can be
+as the processor. For more information on how the architecture can be
used on Cray machines, check here :ref:`spack-cray`
@@ -1147,11 +1147,12 @@ packages use RPATH to find their dependencies: this can be true in
particular for Python extensions, which are currently *not* built with
RPATH.
-Modules may be loaded recursively with the command:
+Modules may be loaded recursively with the ``load`` command's
+``--dependencies`` or ``-r`` argument:
.. code-block:: sh
- $ module load `spack module tcl --dependencies <spec>...
+ $ spack load --dependencies <spec> ...
More than one spec may be placed on the command line here.
@@ -1793,36 +1794,36 @@ A nicer error message is TBD in future versions of Spack.
Spack on Cray
-----------------------------
-Spack differs slightly when used on a Cray system. The architecture spec
+Spack differs slightly when used on a Cray system. The architecture spec
can differentiate between the front-end and back-end processor and operating system.
-For example, on Edison at NERSC, the back-end target processor
+For example, on Edison at NERSC, the back-end target processor
is \"Ivy Bridge\", so you can specify to use the back-end this way:
.. code-block:: sh
-
+
spack install zlib target=ivybridge
You can also use the operating system to build against the back-end:
.. code-block:: sh
-
+
spack install zlib os=CNL10
-Notice that the name includes both the operating system name and the major
+Notice that the name includes both the operating system name and the major
version number concatenated together.
-Alternatively, if you want to build something for the front-end,
-you can specify the front-end target processor. The processor for a login node
+Alternatively, if you want to build something for the front-end,
+you can specify the front-end target processor. The processor for a login node
on Edison is \"Sandy bridge\" so we specify on the command line like so:
.. code-block:: sh
-
+
spack install zlib target=sandybridge
And the front-end operating system is:
.. code-block:: sh
-
+
spack install zlib os=SuSE11
@@ -1830,13 +1831,13 @@ And the front-end operating system is:
Cray compiler detection
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Spack can detect compilers using two methods. For the front-end, we treat
-everything the same. The difference lies in back-end compiler detection.
-Back-end compiler detection is made via the Tcl module avail command.
-Once it detects the compiler it writes the appropriate PrgEnv and compiler
-module name to compilers.yaml and sets the paths to each compiler with Cray\'s
-compiler wrapper names (i.e. cc, CC, ftn). During build time, Spack will load
-the correct PrgEnv and compiler module and will call appropriate wrapper.
+Spack can detect compilers using two methods. For the front-end, we treat
+everything the same. The difference lies in back-end compiler detection.
+Back-end compiler detection is made via the Tcl module avail command.
+Once it detects the compiler it writes the appropriate PrgEnv and compiler
+module name to compilers.yaml and sets the paths to each compiler with Cray\'s
+compiler wrapper names (i.e. cc, CC, ftn). During build time, Spack will load
+the correct PrgEnv and compiler module and will call appropriate wrapper.
The compilers.yaml config file will also differ. There is a
modules section that is filled with the compiler\'s Programming Environment
@@ -1849,8 +1850,8 @@ and module name. On other systems, this field is empty []::
- intel/15.0.109
...
-As mentioned earlier, the compiler paths will look different on a Cray system.
-Since most compilers are invoked using cc, CC and ftn, the paths for each
+As mentioned earlier, the compiler paths will look different on a Cray system.
+Since most compilers are invoked using cc, CC and ftn, the paths for each
compiler are replaced with their respective Cray compiler wrapper names::
...
@@ -1862,7 +1863,7 @@ compiler are replaced with their respective Cray compiler wrapper names::
...
As opposed to an explicit path to the compiler executable. This allows Spack
-to call the Cray compiler wrappers during build time.
+to call the Cray compiler wrappers during build time.
For more on compiler configuration, check out :ref:`compiler-config`.
@@ -1889,11 +1890,11 @@ Here\'s an example of an external configuration for cray modules:
This tells Spack that for whatever package that depends on mpi, load the
cray-mpich module into the environment. You can then be able to use whatever
environment variables, libraries, etc, that are brought into the environment
-via module load.
+via module load.
-You can set the default compiler that Spack can use for each compiler type.
-If you want to use the Cray defaults, then set them under *all:* in packages.yaml.
-In the compiler field, set the compiler specs in your order of preference.
+You can set the default compiler that Spack can use for each compiler type.
+If you want to use the Cray defaults, then set them under *all:* in packages.yaml.
+In the compiler field, set the compiler specs in your order of preference.
Whenever you build with that compiler type, Spack will concretize to that version.
Here is an example of a full packages.yaml used at NERSC
@@ -1921,11 +1922,11 @@ Here is an example of a full packages.yaml used at NERSC
Here we tell spack that whenever we want to build with gcc use version 5.2.0 or
if we want to build with intel compilers, use version 16.0.0.109. We add a spec
-for each compiler type for each cray modules. This ensures that for each
+for each compiler type for each cray modules. This ensures that for each
compiler on our system we can use that external module.
-For more on external packages check out the section :ref:`sec-external_packages`.
+For more on external packages check out the section :ref:`sec-external_packages`.
Getting Help
-----------------------
diff --git a/lib/spack/docs/configuration.rst b/lib/spack/docs/configuration.rst
index f2ffa07264..d39c932021 100644
--- a/lib/spack/docs/configuration.rst
+++ b/lib/spack/docs/configuration.rst
@@ -142,8 +142,9 @@ Here's an example packages.yaml file that sets preferred packages:
.. code-block:: sh
packages:
- dyninst:
+ opencv:
compiler: [gcc@4.9]
+ variants: +debug
gperftools:
version: [2.2, 2.4, 2.3]
all:
@@ -153,17 +154,17 @@ Here's an example packages.yaml file that sets preferred packages:
At a high level, this example is specifying how packages should be
-concretized. The dyninst package should prefer using gcc 4.9.
-The gperftools package should prefer version
+concretized. The opencv package should prefer using gcc 4.9 and
+be built with debug options. The gperftools package should prefer version
2.2 over 2.4. Every package on the system should prefer mvapich for
-its MPI and gcc 4.4.7 (except for Dyninst, which overrides this by preferring gcc 4.9).
+its MPI and gcc 4.4.7 (except for opencv, which overrides this by preferring gcc 4.9).
These options are used to fill in implicit defaults. Any of them can be overwritten
on the command line if explicitly requested.
Each packages.yaml file begins with the string ``packages:`` and
package names are specified on the next level. The special string ``all``
applies settings to each package. Underneath each package name is
-one or more components: ``compiler``, ``version``,
+one or more components: ``compiler``, ``variants``, ``version``,
or ``providers``. Each component has an ordered list of spec
``constraints``, with earlier entries in the list being preferred over
later entries.
diff --git a/lib/spack/env/cray/CC b/lib/spack/env/cray/CC
new file mode 120000
index 0000000000..82c2b8e90a
--- /dev/null
+++ b/lib/spack/env/cray/CC
@@ -0,0 +1 @@
+../cc \ No newline at end of file
diff --git a/lib/spack/env/cray/cc b/lib/spack/env/cray/cc
new file mode 120000
index 0000000000..82c2b8e90a
--- /dev/null
+++ b/lib/spack/env/cray/cc
@@ -0,0 +1 @@
+../cc \ No newline at end of file
diff --git a/lib/spack/env/cray/ftn b/lib/spack/env/cray/ftn
new file mode 120000
index 0000000000..82c2b8e90a
--- /dev/null
+++ b/lib/spack/env/cray/ftn
@@ -0,0 +1 @@
+../cc \ No newline at end of file
diff --git a/lib/spack/spack/concretize.py b/lib/spack/spack/concretize.py
index 386df08b2e..5180f3cf04 100644
--- a/lib/spack/spack/concretize.py
+++ b/lib/spack/spack/concretize.py
@@ -40,12 +40,12 @@ import spack.architecture
import spack.error
from spack.version import *
from functools import partial
-from spec import DependencyMap
from itertools import chain
from spack.config import *
class DefaultConcretizer(object):
+
"""This class doesn't have any state, it just provides some methods for
concretization. You can subclass it to override just some of the
default concretization strategies, or you can override all of them.
@@ -61,14 +61,17 @@ class DefaultConcretizer(object):
if not providers:
raise UnsatisfiableProviderSpecError(providers[0], spec)
spec_w_preferred_providers = find_spec(
- spec, lambda(x): spack.pkgsort.spec_has_preferred_provider(x.name, spec.name))
+ spec, lambda x: spack.pkgsort.spec_has_preferred_provider(x.name, spec.name)) # NOQA: ignore=E501
if not spec_w_preferred_providers:
spec_w_preferred_providers = spec
- provider_cmp = partial(spack.pkgsort.provider_compare, spec_w_preferred_providers.name, spec.name)
+ provider_cmp = partial(spack.pkgsort.provider_compare,
+ spec_w_preferred_providers.name,
+ spec.name)
candidates = sorted(providers, cmp=provider_cmp)
- # For each candidate package, if it has externals, add those to the usable list.
- # if it's not buildable, then *only* add the externals.
+ # For each candidate package, if it has externals, add those
+ # to the usable list. if it's not buildable, then *only* add
+ # the externals.
usable = []
for cspec in candidates:
if is_spec_buildable(cspec):
@@ -85,7 +88,7 @@ class DefaultConcretizer(object):
def cmp_externals(a, b):
if a.name != b.name and (not a.external or a.external_module and
- not b.external and b.external_module):
+ not b.external and b.external_module):
# We're choosing between different providers, so
# maintain order from provider sort
return candidates.index(a) - candidates.index(b)
@@ -114,26 +117,26 @@ class DefaultConcretizer(object):
# Find the nearest spec in the dag that has a compiler. We'll
# use that spec to calibrate compiler compatibility.
- abi_exemplar = find_spec(spec, lambda(x): x.compiler)
+ abi_exemplar = find_spec(spec, lambda x: x.compiler)
if not abi_exemplar:
abi_exemplar = spec.root
# Make a list including ABI compatibility of specs with the exemplar.
strict = [spack.abi.compatible(c, abi_exemplar) for c in candidates]
- loose = [spack.abi.compatible(c, abi_exemplar, loose=True) for c in candidates]
+ loose = [spack.abi.compatible(c, abi_exemplar, loose=True)
+ for c in candidates]
keys = zip(strict, loose, candidates)
# Sort candidates from most to least compatibility.
# Note:
# 1. We reverse because True > False.
# 2. Sort is stable, so c's keep their order.
- keys.sort(key=lambda k:k[:2], reverse=True)
+ keys.sort(key=lambda k: k[:2], reverse=True)
# Pull the candidates back out and return them in order
- candidates = [c for s,l,c in keys]
+ candidates = [c for s, l, c in keys]
return candidates
-
def concretize_version(self, spec):
"""If the spec is already concrete, return. Otherwise take
the preferred version from spackconfig, and default to the package's
@@ -167,7 +170,8 @@ class DefaultConcretizer(object):
if valid_versions:
# Disregard @develop and take the next valid version
- if ver(valid_versions[0]) == ver('develop') and len(valid_versions) > 1:
+ if ver(valid_versions[0]) == ver('develop') and \
+ len(valid_versions) > 1:
spec.versions = ver([valid_versions[1]])
else:
spec.versions = ver([valid_versions[0]])
@@ -193,40 +197,45 @@ class DefaultConcretizer(object):
return True # Things changed
def _concretize_operating_system(self, spec):
- platform = spec.architecture.platform
if spec.architecture.platform_os is not None and isinstance(
- spec.architecture.platform_os,spack.architecture.OperatingSystem):
+ spec.architecture.platform_os,
+ spack.architecture.OperatingSystem):
return False
if spec.root.architecture and spec.root.architecture.platform_os:
- if isinstance(spec.root.architecture.platform_os,spack.architecture.OperatingSystem):
- spec.architecture.platform_os = spec.root.architecture.platform_os
+ if isinstance(spec.root.architecture.platform_os,
+ spack.architecture.OperatingSystem):
+ spec.architecture.platform_os = \
+ spec.root.architecture.platform_os
else:
- spec.architecture.platform_os = spec.architecture.platform.operating_system('default_os')
- return True #changed
+ spec.architecture.platform_os = \
+ spec.architecture.platform.operating_system('default_os')
+ return True # changed
def _concretize_target(self, spec):
- platform = spec.architecture.platform
if spec.architecture.target is not None and isinstance(
spec.architecture.target, spack.architecture.Target):
return False
if spec.root.architecture and spec.root.architecture.target:
- if isinstance(spec.root.architecture.target,spack.architecture.Target):
+ if isinstance(spec.root.architecture.target,
+ spack.architecture.Target):
spec.architecture.target = spec.root.architecture.target
else:
- spec.architecture.target = spec.architecture.platform.target('default_target')
- return True #changed
+ spec.architecture.target = spec.architecture.platform.target(
+ 'default_target')
+ return True # changed
def _concretize_platform(self, spec):
if spec.architecture.platform is not None and isinstance(
spec.architecture.platform, spack.architecture.Platform):
return False
if spec.root.architecture and spec.root.architecture.platform:
- if isinstance(spec.root.architecture.platform,spack.architecture.Platform):
+ if isinstance(spec.root.architecture.platform,
+ spack.architecture.Platform):
spec.architecture.platform = spec.root.architecture.platform
else:
spec.architecture.platform = spack.architecture.platform()
- return True #changed?
+ return True # changed?
def concretize_architecture(self, spec):
"""If the spec is empty provide the defaults of the platform. If the
@@ -245,25 +254,29 @@ class DefaultConcretizer(object):
return True
# Concretize the operating_system and target based of the spec
- ret = any((self._concretize_platform(spec),
- self._concretize_operating_system(spec),
- self._concretize_target(spec)))
+ ret = any((self._concretize_platform(spec),
+ self._concretize_operating_system(spec),
+ self._concretize_target(spec)))
return ret
-
-
def concretize_variants(self, spec):
"""If the spec already has variants filled in, return. Otherwise, add
- the default variants from the package specification.
+ the user preferences from packages.yaml or the default variants from
+ the package specification.
"""
changed = False
+ preferred_variants = spack.pkgsort.spec_preferred_variants(
+ spec.package_class.name)
for name, variant in spec.package_class.variants.items():
if name not in spec.variants:
- spec.variants[name] = spack.spec.VariantSpec(name, variant.default)
changed = True
+ if name in preferred_variants:
+ spec.variants[name] = preferred_variants.get(name)
+ else:
+ spec.variants[name] = \
+ spack.spec.VariantSpec(name, variant.default)
return changed
-
def concretize_compiler(self, spec):
"""If the spec already has a compiler, we're done. If not, then take
the compiler used for the nearest ancestor with a compiler
@@ -278,30 +291,32 @@ class DefaultConcretizer(object):
"""
# Pass on concretizing the compiler if the target is not yet determined
if not spec.architecture.platform_os:
- #Although this usually means changed, this means awaiting other changes
+ # Although this usually means changed, this means awaiting other
+ # changes
return True
# Only use a matching compiler if it is of the proper style
- # Takes advantage of the proper logic already existing in compiler_for_spec
- # Should think whether this can be more efficient
+ # Takes advantage of the proper logic already existing in
+ # compiler_for_spec Should think whether this can be more
+ # efficient
def _proper_compiler_style(cspec, arch):
platform = arch.platform
compilers = spack.compilers.compilers_for_spec(cspec,
platform=platform)
return filter(lambda c: c.operating_system ==
- arch.platform_os, compilers)
- #return compilers
-
+ arch.platform_os, compilers)
+ # return compilers
all_compilers = spack.compilers.all_compilers()
if (spec.compiler and
spec.compiler.concrete and
- spec.compiler in all_compilers):
+ spec.compiler in all_compilers):
return False
- #Find the another spec that has a compiler, or the root if none do
- other_spec = spec if spec.compiler else find_spec(spec, lambda(x) : x.compiler)
+ # Find the another spec that has a compiler, or the root if none do
+ other_spec = spec if spec.compiler else find_spec(
+ spec, lambda x: x.compiler)
if not other_spec:
other_spec = spec.root
@@ -313,9 +328,12 @@ class DefaultConcretizer(object):
spec.compiler = other_compiler.copy()
return True
- # Filter the compilers into a sorted list based on the compiler_order from spackconfig
- compiler_list = all_compilers if not other_compiler else spack.compilers.find(other_compiler)
- cmp_compilers = partial(spack.pkgsort.compiler_compare, other_spec.name)
+ # Filter the compilers into a sorted list based on the compiler_order
+ # from spackconfig
+ compiler_list = all_compilers if not other_compiler else \
+ spack.compilers.find(other_compiler)
+ cmp_compilers = partial(
+ spack.pkgsort.compiler_compare, other_spec.name)
matches = sorted(compiler_list, cmp=cmp_compilers)
if not matches:
raise UnavailableCompilerVersionError(other_compiler)
@@ -330,7 +348,6 @@ class DefaultConcretizer(object):
assert(spec.compiler.concrete)
return True # things changed.
-
def concretize_compiler_flags(self, spec):
"""
The compiler flags are updated to match those of the spec whose
@@ -338,54 +355,66 @@ class DefaultConcretizer(object):
Default specs set at the compiler level will still be added later.
"""
-
if not spec.architecture.platform_os:
- #Although this usually means changed, this means awaiting other changes
+ # Although this usually means changed, this means awaiting other
+ # changes
return True
ret = False
for flag in spack.spec.FlagMap.valid_compiler_flags():
try:
nearest = next(p for p in spec.traverse(direction='parents')
- if ((p.compiler == spec.compiler and p is not spec)
- and flag in p.compiler_flags))
- if not flag in spec.compiler_flags or \
- not (sorted(spec.compiler_flags[flag]) >= sorted(nearest.compiler_flags[flag])):
+ if ((p.compiler == spec.compiler and
+ p is not spec) and
+ flag in p.compiler_flags))
+ if flag not in spec.compiler_flags or \
+ not (sorted(spec.compiler_flags[flag]) >=
+ sorted(nearest.compiler_flags[flag])):
if flag in spec.compiler_flags:
- spec.compiler_flags[flag] = list(set(spec.compiler_flags[flag]) |
- set(nearest.compiler_flags[flag]))
+ spec.compiler_flags[flag] = list(
+ set(spec.compiler_flags[flag]) |
+ set(nearest.compiler_flags[flag]))
else:
- spec.compiler_flags[flag] = nearest.compiler_flags[flag]
+ spec.compiler_flags[
+ flag] = nearest.compiler_flags[flag]
ret = True
except StopIteration:
- if (flag in spec.root.compiler_flags and ((not flag in spec.compiler_flags) or
- sorted(spec.compiler_flags[flag]) != sorted(spec.root.compiler_flags[flag]))):
+ if (flag in spec.root.compiler_flags and
+ ((flag not in spec.compiler_flags) or
+ sorted(spec.compiler_flags[flag]) !=
+ sorted(spec.root.compiler_flags[flag]))):
if flag in spec.compiler_flags:
- spec.compiler_flags[flag] = list(set(spec.compiler_flags[flag]) |
- set(spec.root.compiler_flags[flag]))
+ spec.compiler_flags[flag] = list(
+ set(spec.compiler_flags[flag]) |
+ set(spec.root.compiler_flags[flag]))
else:
- spec.compiler_flags[flag] = spec.root.compiler_flags[flag]
+ spec.compiler_flags[
+ flag] = spec.root.compiler_flags[flag]
ret = True
else:
- if not flag in spec.compiler_flags:
+ if flag not in spec.compiler_flags:
spec.compiler_flags[flag] = []
# Include the compiler flag defaults from the config files
# This ensures that spack will detect conflicts that stem from a change
# in default compiler flags.
- compiler = spack.compilers.compiler_for_spec(spec.compiler, spec.architecture)
+ compiler = spack.compilers.compiler_for_spec(
+ spec.compiler, spec.architecture)
for flag in compiler.flags:
if flag not in spec.compiler_flags:
spec.compiler_flags[flag] = compiler.flags[flag]
if compiler.flags[flag] != []:
ret = True
else:
- if ((sorted(spec.compiler_flags[flag]) != sorted(compiler.flags[flag])) and
- (not set(spec.compiler_flags[flag]) >= set(compiler.flags[flag]))):
+ if ((sorted(spec.compiler_flags[flag]) !=
+ sorted(compiler.flags[flag])) and
+ (not set(spec.compiler_flags[flag]) >=
+ set(compiler.flags[flag]))):
ret = True
- spec.compiler_flags[flag] = list(set(spec.compiler_flags[flag]) |
- set(compiler.flags[flag]))
+ spec.compiler_flags[flag] = list(
+ set(spec.compiler_flags[flag]) |
+ set(compiler.flags[flag]))
return ret
@@ -396,8 +425,8 @@ def find_spec(spec, condition):
# First search parents, then search children
deptype = ('build', 'link')
dagiter = chain(
- spec.traverse(direction='parents', deptype=deptype, root=False),
- spec.traverse(direction='children', deptype=deptype, root=False))
+ spec.traverse(direction='parents', deptype=deptype, root=False),
+ spec.traverse(direction='children', deptype=deptype, root=False))
visited = set()
for relative in dagiter:
if condition(relative):
@@ -406,8 +435,10 @@ def find_spec(spec, condition):
# Then search all other relatives in the DAG *except* spec
for relative in spec.root.traverse(deptypes=spack.alldeps):
- if relative is spec: continue
- if id(relative) in visited: continue
+ if relative is spec:
+ continue
+ if id(relative) in visited:
+ continue
if condition(relative):
return relative
@@ -454,8 +485,10 @@ def cmp_specs(lhs, rhs):
class UnavailableCompilerVersionError(spack.error.SpackError):
+
"""Raised when there is no available compiler that satisfies a
compiler spec."""
+
def __init__(self, compiler_spec):
super(UnavailableCompilerVersionError, self).__init__(
"No available compiler version matches '%s'" % compiler_spec,
@@ -463,16 +496,20 @@ class UnavailableCompilerVersionError(spack.error.SpackError):
class NoValidVersionError(spack.error.SpackError):
+
"""Raised when there is no way to have a concrete version for a
particular spec."""
+
def __init__(self, spec):
super(NoValidVersionError, self).__init__(
- "There are no valid versions for %s that match '%s'" % (spec.name, spec.versions))
+ "There are no valid versions for %s that match '%s'" % (spec.name, spec.versions)) # NOQA: ignore=E501
class NoBuildError(spack.error.SpackError):
+
"""Raised when a package is configured with the buildable option False, but
no satisfactory external versions can be found"""
+
def __init__(self, spec):
super(NoBuildError, self).__init__(
- "The spec '%s' is configured as not buildable, and no matching external installs were found" % spec.name)
+ "The spec '%s' is configured as not buildable,and no matching external installs were found" % spec.name) # NOQA: ignore=E501
diff --git a/lib/spack/spack/config.py b/lib/spack/spack/config.py
index 8b5e96f97d..e2e7dbc0ee 100644
--- a/lib/spack/spack/config.py
+++ b/lib/spack/spack/config.py
@@ -257,7 +257,13 @@ section_schemas = {
'paths': {
'type' : 'object',
'default' : {},
- }
+ },
+ 'variants': {
+ 'oneOf' : [
+ { 'type' : 'string' },
+ { 'type' : 'array',
+ 'items' : { 'type' : 'string' } },
+ ], },
},},},},},},
'modules': {
diff --git a/lib/spack/spack/modules.py b/lib/spack/spack/modules.py
index 72656b8ae0..db8b20ae42 100644
--- a/lib/spack/spack/modules.py
+++ b/lib/spack/spack/modules.py
@@ -471,6 +471,7 @@ class Dotkit(EnvModule):
path = join_path(spack.share_path, 'dotkit')
environment_modifications_formats = {
PrependPath: 'dk_alter {name} {value}\n',
+ RemovePath: 'dk_unalter {name} {value}\n',
SetEnv: 'dk_setenv {name} {value}\n'
}
diff --git a/lib/spack/spack/platforms/cray_xc.py b/lib/spack/spack/platforms/cray_xc.py
index 2b065d5bbd..03d0383cc5 100644
--- a/lib/spack/spack/platforms/cray_xc.py
+++ b/lib/spack/spack/platforms/cray_xc.py
@@ -1,8 +1,10 @@
import os
+import spack
from spack.architecture import Platform, Target
from spack.operating_systems.linux_distro import LinuxDistro
from spack.operating_systems.cnl import Cnl
from spack.util.executable import which
+from llnl.util.filesystem import join_path
class CrayXc(Platform):
@@ -53,6 +55,7 @@ class CrayXc(Platform):
cray_wrapper_names = join_path(spack.build_env_path, 'cray')
if os.path.isdir(cray_wrapper_names):
env.prepend_path('PATH', cray_wrapper_names)
+ env.prepend_path('SPACK_ENV_PATHS', cray_wrapper_names)
@classmethod
def detect(self):
diff --git a/lib/spack/spack/preferred_packages.py b/lib/spack/spack/preferred_packages.py
index 1b94f03de7..5f18e212b6 100644
--- a/lib/spack/spack/preferred_packages.py
+++ b/lib/spack/spack/preferred_packages.py
@@ -158,6 +158,13 @@ class PreferredPackages(object):
return bool(self._order_for_package(pkgname, 'providers',
provider_str, False))
+ def spec_preferred_variants(self, pkgname):
+ """Return a VariantMap of preferred variants and their values"""
+ variants = self.preferred.get(pkgname, {}).get('variants', '')
+ if not isinstance(variants, basestring):
+ variants = "".join(variants)
+ return spack.spec.Spec(pkgname + variants).variants
+
def version_compare(self, pkgname, a, b):
"""Return less-than-0, 0, or greater than 0 if version a of pkgname is
respectively less-than, equal-to, or greater-than version b of
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2024-08-24 15:39:26 +0000