Merge pull request #1376 from mpbelhorn/olcf/unified_cray_platform

Olcf/unified cray platform

lib/spack/spack/config.py

@@ -266,6 +266,19 @@
                                     ], },
                         },},},},},},
 
+    'targets': {
+        '$schema': 'http://json-schema.org/schema#',
+        'title': 'Spack target configuration file schema',
+        'type': 'object',
+        'additionalProperties': False,
+        'patternProperties': {
+            r'targets:?': {
+                'type': 'object',
+                'default': {},
+                'additionalProperties': False,
+                'patternProperties': {
+                    r'\w[\w-]*': { # target name
+                        'type': 'string' ,},},},},},
     'modules': {
         '$schema': 'http://json-schema.org/schema#',
         'title': 'Spack module file configuration file schema',

lib/spack/spack/operating_systems/cnl.py

@@ -7,11 +7,12 @@
 from spack.util.multiproc import parmap
 import spack.compilers
 
+
 class Cnl(OperatingSystem):
     """ Compute Node Linux (CNL) is the operating system used for the Cray XC
     series super computers. It is a very stripped down version of GNU/Linux.
     Any compilers found through this operating system will be used with
-    modules. If updated, user must make sure that version and name are 
+    modules. If updated, user must make sure that version and name are
     updated to indicate that OS has been upgraded (or downgraded)
     """
     def __init__(self):
@@ -19,17 +20,19 @@ def __init__(self):
         version = '10'
         super(Cnl, self).__init__(name, version)
 
+    def __str__(self):
+        return self.name
 
     def find_compilers(self, *paths):
         types = spack.compilers.all_compiler_types()
-        compiler_lists = parmap(lambda cmp_cls: self.find_compiler(cmp_cls, *paths), types)
+        compiler_lists = parmap(
+            lambda cmp_cls: self.find_compiler(cmp_cls, *paths), types)
 
         # ensure all the version calls we made are cached in the parent
         # process, as well.  This speeds up Spack a lot.
-        clist = reduce(lambda x,y: x+y, compiler_lists)
+        clist = reduce(lambda x, y: x + y, compiler_lists)
         return clist
 
-
     def find_compiler(self, cmp_cls, *paths):
         compilers = []
         if cmp_cls.PrgEnv:
@@ -45,13 +48,16 @@ def find_compiler(self, cmp_cls, *paths):
             if paths:
                 module_paths = ':' + ':'.join(p for p in paths)
                 os.environ['MODULEPATH'] = module_paths
-        
-            output = modulecmd('avail', cmp_cls.PrgEnv_compiler, output=str, error=str)
-            matches = re.findall(r'(%s)/([\d\.]+[\d])' % cmp_cls.PrgEnv_compiler, output)
+
+            output = modulecmd(
+                'avail', cmp_cls.PrgEnv_compiler, output=str, error=str)
+            matches = re.findall(
+                r'(%s)/([\d\.]+[\d])' % cmp_cls.PrgEnv_compiler, output)
             for name, version in matches:
                 v = version
-                comp = cmp_cls(spack.spec.CompilerSpec(name + '@' + v), self,
-                           ['cc', 'CC', 'ftn'], [cmp_cls.PrgEnv, name +'/' + v])
+                comp = cmp_cls(
+                    spack.spec.CompilerSpec(name + '@' + v), self,
+                    ['cc', 'CC', 'ftn'], [cmp_cls.PrgEnv, name + '/' + v])
 
                 compilers.append(comp)
 

lib/spack/spack/platforms/cray.py

@@ -0,0 +1,105 @@
+import os
+import re
+import spack.config
+import llnl.util.tty as tty
+from spack.util.executable import which
+from spack.architecture import Platform, Target, NoPlatformError
+from spack.operating_systems.linux_distro import LinuxDistro
+from spack.operating_systems.cnl import Cnl
+
+
+# Craype- module prefixes that are not valid CPU targets.
+NON_TARGETS = ('hugepages', 'network', 'target', 'accel', 'xtpe')
+
+
+def _target_from_clean_env(name):
+    '''Return the default back_end target as loaded in a clean login session.
+
+    A bash subshell is launched with a wiped environment and the list of loaded
+    modules is parsed for the first acceptable CrayPE target.
+    '''
+    # Based on the incantation:
+    # echo "$(env - USER=$USER /bin/bash -l -c 'module list -lt')"
+    targets = []
+    if name != 'front_end':
+        env = which('env')
+        env.add_default_arg('-')
+        # CAUTION - $USER is generally needed to initialize the environment.
+        # There may be other variables needed for general success.
+        output = env('USER=%s' % os.environ['USER'],
+                     '/bin/bash', '--noprofile', '--norc', '-c',
+                     '. /etc/profile; module list -lt',
+                     output=str, error=str)
+        default_modules = [i for i in output.splitlines()
+                           if len(i.split()) == 1]
+        tty.debug("Found default modules:",
+                  *["      " + mod for mod in default_modules])
+        pattern = 'craype-(?!{0})(\S*)'.format('|'.join(NON_TARGETS))
+        for mod in default_modules:
+            if 'craype-' in mod:
+                targets.extend(re.findall(pattern, mod))
+    return targets[0] if targets else None
+
+
+class Cray(Platform):
+    priority = 10
+
+    def __init__(self):
+        ''' Create a Cray system platform.
+
+        Target names should use craype target names but not include the
+        'craype-' prefix. Uses first viable target from:
+          self
+          envars [SPACK_FRONT_END, SPACK_BACK_END]
+          configuration file "targets.yaml" with keys 'front_end', 'back_end'
+          scanning /etc/bash/bashrc.local for back_end only
+        '''
+        super(Cray, self).__init__('cray')
+
+        # Get targets from config or make best guess from environment:
+        conf = spack.config.get_config('targets')
+        for name in ('front_end', 'back_end'):
+            _target = getattr(self, name, None)
+            if _target is None:
+                _target = os.environ.get('SPACK_' + name.upper())
+            if _target is None:
+                _target = conf.get(name)
+            if _target is None:
+                _target = _target_from_clean_env(name)
+            setattr(self, name, _target)
+
+            if _target is not None:
+                self.add_target(name, Target(_target, 'craype-' + _target))
+                self.add_target(_target, Target(_target, 'craype-' + _target))
+
+        if self.back_end is not None:
+            self.default = self.back_end
+            self.add_target(
+                'default', Target(self.default, 'craype-' + self.default))
+        else:
+            raise NoPlatformError()
+
+        front_distro = LinuxDistro()
+        back_distro = Cnl()
+
+        self.default_os = str(back_distro)
+        self.back_os = self.default_os
+        self.front_os = str(front_distro)
+
+        self.add_operating_system(self.back_os, back_distro)
+        self.add_operating_system(self.front_os, front_distro)
+
+    @classmethod
+    def setup_platform_environment(self, pkg, env):
+        """ Change the linker to default dynamic to be more
+            similar to linux/standard linker behavior
+        """
+        env.set('CRAYPE_LINK_TYPE', 'dynamic')
+        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):
+        return os.environ.get('CRAYPE_VERSION') is not None