deprecate 'dummy' toolchain, replace with 'system' toolchain

easybuild/framework/easyblock.py

@@ -90,7 +90,6 @@
 from easybuild.tools.package.utilities import package
 from easybuild.tools.py2vs3 import extract_method_name, string_type
 from easybuild.tools.repository.repository import init_repository
-from easybuild.tools.toolchain.toolchain import DUMMY_TOOLCHAIN_NAME
 from easybuild.tools.systemtools import det_parallelism, use_group
 from easybuild.tools.utilities import INDENT_4SPACES, get_class_for, quote_str, remove_unwanted_chars, trace_msg
 from easybuild.tools.version import this_is_easybuild, VERBOSE_VERSION, VERSION
@@ -1027,7 +1026,7 @@ def make_module_dep(self, unload_info=None):
 
         # include toolchain as first dependency to load
         tc_mod = None
-        if self.toolchain.name != DUMMY_TOOLCHAIN_NAME:
+        if not self.toolchain.is_system_toolchain():
             tc_mod = self.toolchain.det_short_module_name()
             self.log.debug("Toolchain to load in generated module (before excluding any deps): %s", tc_mod)
 
@@ -1355,7 +1354,7 @@ def load_module(self, mod_paths=None, purge=True, extra_modules=None):
             # for flat module naming schemes, we can load the module directly;
             # for non-flat (hierarchical) module naming schemes, we may need to load the toolchain module first
             # to update $MODULEPATH such that the module can be loaded using the short module name
-            if self.mod_subdir and self.toolchain.name != DUMMY_TOOLCHAIN_NAME:
+            if self.mod_subdir and not self.toolchain.is_system_toolchain():
                 mods.insert(0, self.toolchain.det_short_module_name())
 
             # pass initial environment, to use it for resetting the environment before loading the modules

easybuild/framework/easyconfig/constants.py

@@ -50,4 +50,5 @@
     'OS_NAME': (get_os_name(), "System name (e.g. 'fedora' or 'RHEL')"),
     'OS_VERSION': (get_os_version(), "System version"),
     'SYS_PYTHON_VERSION': (platform.python_version(), "System Python version (platform.python_version())"),
+    'SYSTEM': ({'name': 'system', 'version': 'system'}, "System toolchain"),
 }

easybuild/framework/easyconfig/easyconfig.py

@@ -68,7 +68,7 @@
 from easybuild.tools.modules import modules_tool
 from easybuild.tools.py2vs3 import OrderedDict, string_type
 from easybuild.tools.systemtools import check_os_dependency
-from easybuild.tools.toolchain.toolchain import DUMMY_TOOLCHAIN_NAME, DUMMY_TOOLCHAIN_VERSION
+from easybuild.tools.toolchain.toolchain import SYSTEM_TOOLCHAIN_NAME, is_system_toolchain
 from easybuild.tools.toolchain.toolchain import TOOLCHAIN_CAPABILITIES, TOOLCHAIN_CAPABILITY_CUDA
 from easybuild.tools.toolchain.utilities import get_toolchain, search_toolchain
 from easybuild.tools.utilities import flatten, get_class_for, nub, quote_py_str, remove_unwanted_chars
@@ -144,18 +144,18 @@ def det_subtoolchain_version(current_tc, subtoolchain_name, optional_toolchains,
     """
     Returns unique version for subtoolchain, in tc dict.
     If there is no unique version:
-    * use '' for dummy, if dummy is not skipped.
+    * use '' for system, if system is not skipped.
     * return None for skipped subtoolchains, that is,
-      optional toolchains or dummy without add_dummy_to_minimal_toolchains.
+      optional toolchains or system toolchain without add_system_to_minimal_toolchains.
     * in all other cases, raises an exception.
     """
     uniq_subtc_versions = set([subtc['version'] for subtc in cands if subtc['name'] == subtoolchain_name])
     # init with "skipped"
     subtoolchain_version = None
 
-    # dummy toolchain: bottom of the hierarchy
-    if subtoolchain_name == DUMMY_TOOLCHAIN_NAME:
-        if build_option('add_dummy_to_minimal_toolchains') and not incl_capabilities:
+    # system toolchain: bottom of the hierarchy
+    if is_system_toolchain(subtoolchain_name):
+        if build_option('add_system_to_minimal_toolchains') and not incl_capabilities:
             subtoolchain_version = ''
     elif len(uniq_subtc_versions) == 1:
         subtoolchain_version = list(uniq_subtc_versions)[0]
@@ -177,7 +177,7 @@ def get_toolchain_hierarchy(parent_toolchain, incl_capabilities=False):
     Determine list of subtoolchains for specified parent toolchain.
     Result starts with the most minimal subtoolchains first, ends with specified toolchain.
 
-    The dummy toolchain is considered the most minimal subtoolchain only if the add_dummy_to_minimal_toolchains
+    The system toolchain is considered the most minimal subtoolchain only if the add_system_to_minimal_toolchains
     build option is enabled.
 
     The most complex hierarchy we have now is goolfc which works as follows:
@@ -192,7 +192,7 @@ def get_toolchain_hierarchy(parent_toolchain, incl_capabilities=False):
               /  |
       GCCcore(*) |
               \  |
-             (dummy: only considered if --add-dummy-to-minimal-toolchains configuration option is enabled)
+             (system: only considered if --add-system-to-minimal-toolchains configuration option is enabled)
 
     :param parent_toolchain: dictionary with name/version of parent toolchain
     :param incl_capabilities: also register toolchain capabilities in result
@@ -864,7 +864,7 @@ def filter_deps(self, deps):
     def dependencies(self, build_only=False):
         """
         Returns an array of parsed dependencies (after filtering, if requested)
-        dependency = {'name': '', 'version': '', 'dummy': (False|True), 'versionsuffix': '', 'toolchain': ''}
+        dependency = {'name': '', 'version': '', 'system': (False|True), 'versionsuffix': '', 'toolchain': ''}
         Iterable builddependencies are flattened when not iterating.
 
         :param build_only: only return build dependencies, discard others
@@ -927,7 +927,7 @@ def toolchain(self):
             tcdeps = None
             tcname, tcversion = self['toolchain']['name'], self['toolchain']['version']
 
-            if tcname != DUMMY_TOOLCHAIN_NAME:
+            if not is_system_toolchain(tcname):
                 tc_ecfile = robot_find_easyconfig(tcname, tcversion)
                 if tc_ecfile is None:
                     self.log.debug("No easyconfig found for toolchain %s version %s, can't determine dependencies",
@@ -950,7 +950,7 @@ def all_dependencies(self):
         if self._all_dependencies is None:
             self.log.debug("Composing list of all dependencies (incl. toolchain)")
             self._all_dependencies = copy.deepcopy(self.dependencies())
-            if self['toolchain']['name'] != DUMMY_TOOLCHAIN_NAME:
+            if not is_system_toolchain(self['toolchain']['name']):
                 self._all_dependencies.append(self.toolchain.as_dict())
 
         return self._all_dependencies
@@ -1110,7 +1110,7 @@ def _parse_dependency(self, dep, hidden=False, build_only=False):
         of these attributes, 'name' and 'version' are mandatory
 
         output dict contains these attributes:
-        ['name', 'version', 'versionsuffix', 'dummy', 'toolchain', 'short_mod_name', 'full_mod_name', 'hidden',
+        ['name', 'version', 'versionsuffix', 'system', 'toolchain', 'short_mod_name', 'full_mod_name', 'hidden',
          'external_module']
 
         :param hidden: indicate whether corresponding module file should be installed hidden ('.'-prefixed)
@@ -1131,8 +1131,8 @@ def _parse_dependency(self, dep, hidden=False, build_only=False):
             # toolchain with which this dependency is installed
             'toolchain': None,
             'toolchain_inherited': False,
-            # boolean indicating whether we're dealing with a dummy toolchain for this dependency
-            'dummy': False,
+            # boolean indicating whether we're dealing with a system toolchain for this dependency
+            SYSTEM_TOOLCHAIN_NAME: False,
             # boolean indicating whether the module for this dependency is (to be) installed hidden
             'hidden': hidden,
             # boolean indicating whether this this a build-only dependency
@@ -1146,9 +1146,9 @@ def _parse_dependency(self, dep, hidden=False, build_only=False):
         if isinstance(dep, dict):
             dependency.update(dep)
 
-            # make sure 'dummy' key is handled appropriately
-            if 'dummy' in dep and 'toolchain' not in dep:
-                dependency['toolchain'] = dep['dummy']
+            # make sure 'system' key is handled appropriately
+            if SYSTEM_TOOLCHAIN_NAME in dep and 'toolchain' not in dep:
+                dependency['toolchain'] = dep[SYSTEM_TOOLCHAIN_NAME]
 
             if dep.get('external_module', False):
                 dependency.update(self.handle_external_module_metadata(dep['full_mod_name']))
@@ -1198,9 +1198,9 @@ def _parse_dependency(self, dep, hidden=False, build_only=False):
             self.log.debug("Inheriting parent toolchain %s for dep %s (until deps are finalised)", tc, dependency)
             dependency['toolchain_inherited'] = True
 
-        # (true) boolean value simply indicates that a dummy toolchain is used
+        # (true) boolean value simply indicates that a system toolchain is used
         elif isinstance(tc_spec, bool) and tc_spec:
-                tc = {'name': DUMMY_TOOLCHAIN_NAME, 'version': DUMMY_TOOLCHAIN_VERSION}
+                tc = {'name': SYSTEM_TOOLCHAIN_NAME, 'version': ''}
 
         # two-element list/tuple value indicates custom toolchain specification
         elif isinstance(tc_spec, (list, tuple,)):
@@ -1256,9 +1256,9 @@ def _finalize_dependencies(self):
                     self.log.debug("Skipping filtered dependency %s when finalising dependencies", orig_dep['name'])
                     continue
 
-                # handle dependencies with inherited (non-dummy) toolchain
+                # handle dependencies with inherited (non-system) toolchain
                 # this *must* be done after parsing all dependencies, to avoid problems with templates like %(pyver)s
-                if dep['toolchain_inherited'] and dep['toolchain']['name'] != DUMMY_TOOLCHAIN_NAME:
+                if dep['toolchain_inherited'] and not is_system_toolchain(dep['toolchain']['name']):
                     tc = None
                     dep_str = '%s %s%s' % (dep['name'], dep['version'], dep['versionsuffix'])
                     self.log.debug("Figuring out toolchain to use for dep %s...", dep)
@@ -1284,8 +1284,8 @@ def _finalize_dependencies(self):
                         dep['toolchain_inherited'] = orig_dep['toolchain_inherited'] = False
 
                 if not dep['external_module']:
-                    # make sure 'dummy' is set correctly
-                    orig_dep['dummy'] = dep['toolchain']['name'] == DUMMY_TOOLCHAIN_NAME
+                    # make sure 'system' is set correctly
+                    orig_dep[SYSTEM_TOOLCHAIN_NAME] = is_system_toolchain(dep['toolchain']['name'])
 
                     # set module names
                     orig_dep['short_mod_name'] = ActiveMNS().det_short_module_name(dep)
@@ -1683,7 +1683,7 @@ def process_easyconfig(path, build_specs=None, validate=True, parse_only=False,
                 easyconfig['dependencies'].append(dep)
 
             # add toolchain as dependency too
-            if ec['toolchain']['name'] != DUMMY_TOOLCHAIN_NAME:
+            if not is_system_toolchain(ec['toolchain']['name']):
                 tc = ec.toolchain.as_dict()
                 _log.debug("Adding toolchain %s as dependency for app %s." % (tc, name))
                 easyconfig['dependencies'].append(tc)
@@ -1845,7 +1845,7 @@ def robot_find_subtoolchain_for_dep(dep, modtool, parent_tc=None, parent_first=F
         print_warning(warning_msg, silent=build_option('silent'))
         toolchain_hierarchy = []
 
-    # start with subtoolchains first, i.e. first (dummy or) compiler-only toolchain, etc.,
+    # start with subtoolchains first, i.e. first (system or) compiler-only toolchain, etc.,
     # unless parent toolchain should be considered first
     if parent_first:
         toolchain_hierarchy = toolchain_hierarchy[::-1]

easybuild/framework/easyconfig/format/one.py

@@ -44,6 +44,7 @@
 from easybuild.framework.easyconfig.templates import to_template_str
 from easybuild.tools.build_log import EasyBuildError, print_msg
 from easybuild.tools.filetools import read_file, write_file
+from easybuild.tools.toolchain.toolchain import SYSTEM_TOOLCHAIN_NAME
 from easybuild.tools.py2vs3 import string_type
 from easybuild.tools.utilities import INDENT_4SPACES, quote_py_str
 
@@ -72,7 +73,7 @@ def dump_dependency(dep, toolchain):
         # mininal spec: (name, version)
         tup = (dep['name'], dep['version'])
         if dep['toolchain'] != toolchain:
-            if dep['dummy']:
+            if dep[SYSTEM_TOOLCHAIN_NAME]:
                 tup += (dep['versionsuffix'], True)
             else:
                 tup += (dep['versionsuffix'], (dep['toolchain']['name'], dep['toolchain']['version']))

easybuild/framework/easyconfig/format/version.py

@@ -45,8 +45,6 @@
 
 class EasyVersion(LooseVersion):
     """Exact LooseVersion. No modifications needed (yet)"""
-    # TODO: replace all LooseVersion with EasyVersion in eb, after moving EasyVersion to easybuild/tools?
-    # TODO: is dummy some magic version? (ie do we need special attributes for dummy versions?)
 
     def __len__(self):
         """Determine length of this EasyVersion instance."""
@@ -152,7 +150,7 @@ def test(self, test_version):
         try:
             res = self.operator(test_version, self.version)
         except TypeError:
-            # fallback for case when 'dummy' version is compared with proper version
+            # fallback for case when string-value version (e.g. 'dummy') is compared with proper version
             # this results in a TypeError in Python 3 (comparing 'str' with 'int'), but not in Python 2
             # any comparison is meaningless in this case, so always returning True as result should be fine
             res = True

easybuild/framework/easyconfig/tools.py

@@ -57,7 +57,7 @@
 from easybuild.tools.github import fetch_easyconfigs_from_pr, download_repo
 from easybuild.tools.multidiff import multidiff
 from easybuild.tools.py2vs3 import OrderedDict
-from easybuild.tools.toolchain.toolchain import DUMMY_TOOLCHAIN_NAME
+from easybuild.tools.toolchain.toolchain import is_system_toolchain
 from easybuild.tools.toolchain.utilities import search_toolchain
 from easybuild.tools.utilities import only_if_module_is_available, quote_str
 from easybuild.tools.version import VERSION as EASYBUILD_VERSION
@@ -441,7 +441,7 @@ def find_related_easyconfigs(path, ec):
     toolchain_name = ec['toolchain']['name']
     toolchain_name_pattern = r'-%s-\S+' % toolchain_name
     toolchain_pattern = '-%s-%s' % (toolchain_name, ec['toolchain']['version'])
-    if toolchain_name == DUMMY_TOOLCHAIN_NAME:
+    if is_system_toolchain(toolchain_name):
         toolchain_name_pattern = ''
         toolchain_pattern = ''
 

easybuild/framework/easyconfig/tweak.py

@@ -43,6 +43,7 @@
 from distutils.version import LooseVersion
 
 from easybuild.base import fancylogger
+from easybuild.framework.easyconfig.constants import EASYCONFIG_CONSTANTS
 from easybuild.framework.easyconfig.default import get_easyconfig_parameter_default
 from easybuild.framework.easyconfig.easyconfig import EasyConfig, create_paths, process_easyconfig
 from easybuild.framework.easyconfig.easyconfig import get_toolchain_hierarchy, ActiveMNS
@@ -53,7 +54,7 @@
 from easybuild.tools.filetools import read_file, write_file
 from easybuild.tools.module_naming_scheme.utilities import det_full_ec_version
 from easybuild.tools.robot import resolve_dependencies, robot_find_easyconfig
-from easybuild.tools.toolchain.toolchain import DUMMY_TOOLCHAIN_NAME
+from easybuild.tools.toolchain.toolchain import SYSTEM_TOOLCHAIN_NAME
 from easybuild.tools.toolchain.toolchain import TOOLCHAIN_CAPABILITIES
 from easybuild.tools.utilities import flatten, nub, quote_str
 
@@ -248,7 +249,13 @@ def tweak_one(orig_ec, tweaked_ec, tweaks, targetdir=None):
         if not res:
             raise EasyBuildError("No toolchain found in easyconfig file %s: %s", orig_ec, ectxt)
 
-        toolchain = eval(res.group(1))
+        # need to treat toolchain specified via 'SYSTEM' constant separately,
+        # since SYSTEM constant is not defined during 'eval'
+        if res.group(1) == 'SYSTEM':
+            toolchain = copy.copy(EASYCONFIG_CONSTANTS['SYSTEM'][0])
+        else:
+            toolchain = eval(res.group(1))
+
         for key in ['name', 'version']:
             tc_key = "toolchain_%s" % key
             if tc_key in keys:
@@ -455,7 +462,7 @@ def select_or_generate_ec(fp, paths, specs):
     # find ALL available easyconfig files for specified software
     cfg = {
         'version': '*',
-        'toolchain': {'name': DUMMY_TOOLCHAIN_NAME, 'version': '*'},
+        'toolchain': {'name': SYSTEM_TOOLCHAIN_NAME, 'version': '*'},
         'versionprefix': '*',
         'versionsuffix': '*',
     }

easybuild/toolchains/clanggcc.py

@@ -32,7 +32,7 @@
 """
 from easybuild.toolchains.compiler.clang import Clang
 from easybuild.toolchains.compiler.gcc import Gcc
-from easybuild.tools.toolchain.toolchain import DUMMY_TOOLCHAIN_NAME
+from easybuild.tools.toolchain.toolchain import SYSTEM_TOOLCHAIN_NAME
 
 
 TC_CONSTANT_CLANGGCC = "ClangGCC"
@@ -43,4 +43,4 @@ class ClangGcc(Clang, Gcc):
     NAME = 'ClangGCC'
     COMPILER_MODULE_NAME = ['Clang', 'GCC']
     COMPILER_FAMILY = TC_CONSTANT_CLANGGCC
-    SUBTOOLCHAIN = DUMMY_TOOLCHAIN_NAME
+    SUBTOOLCHAIN = SYSTEM_TOOLCHAIN_NAME

easybuild/toolchains/compiler/systemcompiler.py

@@ -0,0 +1,40 @@
+##
+# Copyright 2019-2019 Ghent University
+#
+# This file is part of EasyBuild,
+# originally created by the HPC team of Ghent University (http://ugent.be/hpc/en),
+# with support of Ghent University (http://ugent.be/hpc),
+# the Flemish Supercomputer Centre (VSC) (https://www.vscentrum.be),
+# Flemish Research Foundation (FWO) (http://www.fwo.be/en)
+# and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en).
+#
+# https://github.com/easybuilders/easybuild
+#
+# EasyBuild is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation v2.
+#
+# EasyBuild is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with EasyBuild.  If not, see <http://www.gnu.org/licenses/>.
+##
+"""
+Support for system compiler.
+
+:author: Kenneth Hoste (Ghent University)
+"""
+
+from easybuild.tools.toolchain.compiler import Compiler
+
+
+TC_CONSTANT_SYSTEM = 'SYSTEM'
+
+
+class SystemCompiler(Compiler):
+    """System compiler"""
+    COMPILER_MODULE_NAME = []
+    COMPILER_FAMILY = TC_CONSTANT_SYSTEM

easybuild/toolchains/craycce.py

@@ -31,10 +31,10 @@
 from easybuild.toolchains.compiler.craype import CrayPECray
 from easybuild.toolchains.linalg.libsci import LibSci
 from easybuild.toolchains.mpi.craympich import CrayMPICH
-from easybuild.tools.toolchain.toolchain import DUMMY_TOOLCHAIN_NAME
+from easybuild.tools.toolchain.toolchain import SYSTEM_TOOLCHAIN_NAME
 
 
 class CrayCCE(CrayPECray, CrayMPICH, LibSci):
     """Compiler toolchain for Cray Programming Environment for Cray Compiling Environment (CCE) (PrgEnv-cray)."""
     NAME = 'CrayCCE'
-    SUBTOOLCHAIN = DUMMY_TOOLCHAIN_NAME
+    SUBTOOLCHAIN = SYSTEM_TOOLCHAIN_NAME

easybuild/toolchains/craygnu.py

@@ -31,10 +31,10 @@
 from easybuild.toolchains.compiler.craype import CrayPEGCC
 from easybuild.toolchains.linalg.libsci import LibSci
 from easybuild.toolchains.mpi.craympich import CrayMPICH
-from easybuild.tools.toolchain.toolchain import DUMMY_TOOLCHAIN_NAME
+from easybuild.tools.toolchain.toolchain import SYSTEM_TOOLCHAIN_NAME
 
 
 class CrayGNU(CrayPEGCC, CrayMPICH, LibSci):
     """Compiler toolchain for Cray Programming Environment for GCC compilers (PrgEnv-gnu)."""
     NAME = 'CrayGNU'
-    SUBTOOLCHAIN = DUMMY_TOOLCHAIN_NAME
+    SUBTOOLCHAIN = SYSTEM_TOOLCHAIN_NAME