hlrs-software-stack/spack
7
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

First possibly working version of the crayport. Not sufficiently tested at all.

Browse source
This commit is contained in:
Gregory Becker 2015-11-11 14:22:07 -08:00
parent 95a34628a3
commit 271a839957
7 changed files with 46 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

41
lib/spack/spack/architecture.py
View file

@ -61,18 +61,20 @@ def __init__(self,name, module_name=None):
def set_architecture(self, architecture): # Target should get the architecture class.
self.architecture = architecture
@property
def compiler_strategy(self):
if default_strategy:
return default_strategy
elif self.module_name: # If there is a module_name given then use MODULES
if self.module_name: # If there is a module_name given then use MODULES
return "MODULES"
else:
return "PATH"
def __str__(self):
return self.name
class Architecture(object):
""" Abstract class that each type of Architecture will subclass. Will return a instance of it once it
""" Abstract class that each type of Architecture will subclass. Will return a instance of it once it
is returned
"""
@ -110,12 +112,15 @@ def target(self, name):
@classmethod
def detect(self):
""" Subclass is responsible for implementing this method.
""" Subclass is responsible for implementing this method.
Returns True if the architecture detects if it is the current architecture
and False if it's not.
"""
raise NotImplementedError()
def __repr__(self):
return self.__str__
def __str__(self):
return self.name
@ -123,7 +128,7 @@ def __str__(self):
def get_sys_type_from_spack_globals():
"""Return the SYS_TYPE from spack globals, or None if it isn't set."""
if not hasattr(spack, "sys_type"):
return None
return None
elif hasattr(spack.sys_type, "__call__"):
return spack.sys_type() #If in __init__.py there is a sys_type() then call that
else:
@ -147,7 +152,7 @@ def get_mac_sys_type():
def get_sys_type_from_uname():
""" Returns a sys_type from the uname argument
""" Returns a sys_type from the uname argument
Front-end config
"""
try:
@ -158,8 +163,8 @@ def get_sys_type_from_uname():
return None
def get_sys_type_from_config_file():
spack_home_dir = os.environ["HOME"] + "/.spack"
spack_home_dir = os.environ["HOME"] + "/.spack"
yaml_file = os.path.join(spack_home_dir, 'architecture.yaml')
try:
config_dict = yaml.load(open(yaml_file)) # Fix this to have yaml.load()
@ -167,7 +172,7 @@ def get_sys_type_from_config_file():
front = arch['front']
back = arch['back']
return Architecture(front,back)
except:
print "No architecture.yaml config file found"
return None
@ -182,7 +187,7 @@ def all_architectures():
mod = imp.load_source(mod_name, path)
class_name = mod_to_class(name)
if not hasattr(mod, class_name):
tty.die('No class %s defined in %s' % (class_name, mod_name))
tty.die('No class %s defined in %s' % (class_name, mod_name))
cls = getattr(mod, class_name)
if not inspect.isclass(cls):
tty.die('%s.%s is not a class' % (mod_name, class_name))
@ -197,15 +202,15 @@ def sys_type():
1. YAML file that the user specifies the name of the architecture. e.g Cray-XC40 or Cray-XC30
2. UNAME
3. GLOBALS
4. MAC OSX
4. MAC OSX
Yaml should be a priority here because we want the user to be able to specify the type of architecture to use.
If there is no yaml present then it should move on to the next function and stop immediately once it gets a
If there is no yaml present then it should move on to the next function and stop immediately once it gets a
arch name
"""
# Try to create an architecture object using the config file FIRST
architecture_list = all_architectures()
architecture_list.sort(key = lambda a: a.priority)
architecture_list = all_architectures()
architecture_list.sort(key = lambda a: a.priority)
for arch in architecture_list:
if arch.detect():
return arch()

13
lib/spack/spack/architectures/linux.py
View file

@ -1,14 +1,15 @@
import subprocess
from spack.architecture import Architecture
import subprocess
from spack.architecture import Architecture, Target
class Linux(Architecture):
priority = 60
front_end = "x86_64"
back_end = "x86_64"
default = "x86_64"
priority = 60
front_end = 'linux'
back_end = 'linux'
default = 'linux'
def __init__(self):
super(Linux, self).__init__('linux')
self.add_target('linux', Target('linux'))
@classmethod
def detect(self):

6
lib/spack/spack/build_environment.py
View file

@ -88,13 +88,13 @@ def __call__(self, *args, **kwargs):
def load_module(mod):
"""Takes a module name and removes modules until it is possible to
load that module. It then loads the provided module. Depends on the
load that module. It then loads the provided module. Depends on the
modulecmd implementation of modules used in cray and lmod.
"""
#Create an executable of the module command that will output python code
modulecmd = which('modulecmd')
modulecmd.add_default_arg('python')
# Read the module and remove any conflicting modules
# We do this without checking that they are already installed
# for ease of programming because unloading a module that is not
@ -102,7 +102,7 @@ def load_module(mod):
text = modulecmd('show', mod, return_oe=True).split()
for i, word in enumerate(text):
if word == 'conflict':
exec(compile(modulecmd('unload', text[i+1], return_oe=True), '<string>', 'exec'))
exec(compile(modulecmd('unload', text[i+1], return_oe=True), '<string>', 'exec'))
# Load the module now that there are no conflicts
load = modulecmd('load', mod, return_oe=True)
exec(compile(load, '<string>', 'exec'))

8
lib/spack/spack/compiler.py
View file

@ -307,8 +307,12 @@ def __repr__(self):
def __str__(self):
"""Return a string represntation of the compiler toolchain."""
return "%s(%s)" % (
self.name, '\n '.join((str(s) for s in (self.cc, self.cxx, self.f77, self.fc))))
if self.modules:
return "%s(%s)" % (
self.name, '\n '.join((str(s) for s in (self.cc, self.cxx, self.f77, self.fc, self.modules))))
else:
return "%s(%s)" % (
self.name, '\n '.join((str(s) for s in (self.cc, self.cxx, self.f77, self.fc))))
class CompilerAccessError(spack.error.SpackError):

6
lib/spack/spack/compilers/__init__.py
View file

@ -44,15 +44,15 @@
_imported_compilers_module = 'spack.compilers'
_required_instance_vars = ['cc', 'cxx', 'f77', 'fc']
_optional_instance_vars = ['module']
_optional_instance_vars = ['modules']
_default_order = ['gcc', 'intel', 'pgi', 'clang', 'xlc']
def _auto_compiler_spec(function):
def converter(cspec_like):
def converter(cspec_like, *args):
if not isinstance(cspec_like, spack.spec.CompilerSpec):
cspec_like = spack.spec.CompilerSpec(cspec_like)
return function(cspec_like)
return function(cspec_like, *args)
return converter

28
lib/spack/spack/concretize.py
View file

@ -97,32 +97,6 @@ def concretize_version(self, spec):
def concretize_architecture(self, spec):
"""If the spec already had an architecture, return. Otherwise if
the root of the DAG has an architecture, then use that.
Otherwise take the system's default architecture.
Intuition: Architectures won't be set a lot, and generally you
want the host system's architecture. When architectures are
mised in a spec, it is likely because the tool requries a
cross-compiled component, e.g. for tools that run on BlueGene
or Cray machines. These constraints will likely come directly
from packages, so require the user to be explicit if they want
to mess with the architecture, and revert to the default when
they're not explicit.
"""
if spec.architecture is not None:
return False
if spec.root.architecture:
spec.architecture = spec.root.architecture
else:
spec.architecture = spack.architecture.sys_type()
assert(spec.architecture is not None)
return True # changed
def new_concretize_architecture(self, spec):
"""If the spec already has an architecture and it is a an architecture type,
return. Otherwise, if it has an architecture that is a string type, generate an
architecture based on that type. If it has no architecture and the root of the
@ -146,7 +120,7 @@ def new_concretize_architecture(self, spec):
else:
arch = spack.architecture.sys_type()
spec.architecture = arch.target('default')
return True #changed

5
lib/spack/spack/config.py
View file

@ -199,6 +199,7 @@ def get_config(category_name):
category.result_dict = _merge_dicts(category.result_dict, result)
else:
category.result_dict = result
return category.result_dict
@ -208,7 +209,7 @@ def get_compilers_config(arch=None):
configuration"""
global _compiler_by_arch
if not arch:
arch = spack.architecture.sys_type()
arch = str(spack.architecture.sys_type())
if arch in _compiler_by_arch:
return _compiler_by_arch[arch]
@ -305,7 +306,7 @@ def add_to_compiler_config(addition_dict, scope=None, arch=None):
"""Add compilerss to the configuration files"""
if not arch:
arch = spack.architecture.sys_type()
add_to_config('compilers', { arch : addition_dict }, scope)
add_to_config('compilers', { str(arch) : addition_dict }, scope)
clear_config_caches()