Merge branch '2020' of...

Merge branch '2020' of ssh://gitlab.version.fz-juelich.de:10022/hps-public/easybuild-repository into 2020

Custom_MNS/custom_hierarchical_mns.py

+##
+# Copyright 2013-2016 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://vscentrum.be/nl/en),
+# the Hercules foundation (http://www.herculesstichting.be/in_English)
+# and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en).
+#
+# http://github.com/hpcugent/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/>.
+##
+"""
+Implementation of an example hierarchical module naming scheme.
+
+@author: Kenneth Hoste (Ghent University)
+@author: Markus Geimer (Forschungszentrum Juelich GmbH)
+"""
+
+import os
+import re
+from easybuild.base import fancylogger
+
+from easybuild.tools.build_log import EasyBuildError
+from easybuild.tools.module_naming_scheme.hierarchical_mns import HierarchicalMNS
+from easybuild.tools.module_naming_scheme.toolchain import det_toolchain_compilers, det_toolchain_mpi
+
+CORE = 'Core'
+COMPILER = 'Compiler'
+MPI = 'MPI'
+
+MODULECLASS_COMPILER = 'compiler'
+MODULECLASS_MPI = 'mpi'
+
+GCCCORE = 'GCCcore'
+
+# note: names in keys are ordered alphabetically
+COMP_NAME_VERSION_TEMPLATES = {
+    'icc,ifort': ('intel', '%(icc)s'),
+    'Clang,GCC': ('Clang-GCC', '%(Clang)s-%(GCC)s'),
+    'CUDA,GCC': ('GCC-CUDA', '%(GCC)s-%(CUDA)s'),
+    'xlc,xlf': ('xlcxlf', '%(xlc)s'),
+}
+
+class CustomHierarchicalMNS(HierarchicalMNS):
+    """Class implementing an example hierarchical module naming scheme."""
+    def is_short_modname_for(self, short_modname, name):
+        """
+        Determine whether the specified (short) module name is a module for software with the specified name.
+        Default implementation checks via a strict regex pattern, and assumes short module names are of the form:
+            <name>/<version>[-<toolchain>]
+        """
+        # We rename our iccifort compiler to INTEL and this needs a hard fix because it is a toolchain
+        if name == 'iccifort':
+            modname_regex = re.compile('^%s/\S+$' % re.escape('Intel'))
+        elif name == 'psmpi':
+            modname_regex = re.compile('^%s/\S+$' % re.escape('ParaStationMPI'))
+        elif name == 'impi':
+            modname_regex = re.compile('^%s/\S+$' % re.escape('IntelMPI'))
+        else:
+            modname_regex = re.compile('^%s/\S+$' % re.escape(name))
+        res = bool(modname_regex.match(short_modname))
+
+        self.log.debug("Checking whether '%s' is a module name for software with name '%s' via regex %s: %s",
+                       short_modname, name, modname_regex.pattern, res)
+
+        return res
+
+    def det_module_subdir(self, ec):
+        """
+        Determine module subdirectory, relative to the top of the module path.
+        This determines the separation between module names exposed to users, and what's part of the $MODULEPATH.
+        Examples: Core, Compiler/GCC/4.8.3, MPI/GCC/4.8.3/OpenMPI/1.6.5
+        """
+        tc_comps = det_toolchain_compilers(ec)
+        tc_comp_info = self.det_toolchain_compilers_name_version(tc_comps)
+        # determine prefix based on type of toolchain used
+        if tc_comp_info is None:
+            # no compiler in toolchain, dummy toolchain => Core module
+            subdir = CORE
+        else:
+            tc_comp_name, tc_comp_ver = tc_comp_info
+            tc_mpi = det_toolchain_mpi(ec)
+            if tc_mpi is None:
+                # compiler-only toolchain => Compiler/<compiler_name>/<compiler_version> namespace
+                # but we want the mpi module class to stand alone
+                if ec['moduleclass'] == MODULECLASS_MPI:
+                    subdir = os.path.join(COMPILER, MODULECLASS_MPI, tc_comp_name, tc_comp_ver)
+                else:
+                    subdir = os.path.join(COMPILER, tc_comp_name, tc_comp_ver)
+            else:
+                # compiler-MPI toolchain => MPI/<comp_name>/<comp_version>/<MPI_name>/<MPI_version> namespace
+                tc_mpi_fullver = self.det_full_version(tc_mpi)
+                subdir = os.path.join(MPI, tc_comp_name, tc_comp_ver, tc_mpi['name'], tc_mpi_fullver)
+
+        return subdir
+
+    def det_modpath_extensions(self, ec):
+        """
+        Determine module path extensions, if any.
+        Examples: Compiler/GCC/4.8.3 (for GCC/4.8.3 module), MPI/GCC/4.8.3/OpenMPI/1.6.5 (for OpenMPI/1.6.5 module)
+        """
+        modclass = ec['moduleclass']
+        tc_comps = det_toolchain_compilers(ec)
+        tc_comp_info = self.det_toolchain_compilers_name_version(tc_comps)
+
+        paths = []
+        if modclass == MODULECLASS_COMPILER or ec['name'] in ['iccifort']:
+            # obtain list of compilers based on that extend $MODULEPATH in some way other than <name>/<version>
+            extend_comps = []
+            # exclude GCC for which <name>/<version> is used as $MODULEPATH extension
+            excluded_comps = ['GCC']
+            for comps in COMP_NAME_VERSION_TEMPLATES.keys():
+                extend_comps.extend([comp for comp in comps.split(',') if comp not in excluded_comps])
+
+            comp_name_ver = None
+            if ec['name'] in extend_comps:
+                for key in COMP_NAME_VERSION_TEMPLATES:
+                    if ec['name'] in key.split(','):
+                        comp_name, comp_ver_tmpl = COMP_NAME_VERSION_TEMPLATES[key]
+                        comp_versions = {ec['name']: self.det_full_version(ec)}
+                        if ec['name'] == 'ifort':
+                            # 'icc' key should be provided since it's the only one used in the template
+                            comp_versions.update({'icc': self.det_full_version(ec)})
+                        if tc_comp_info is not None:
+                            # also provide toolchain version for non-dummy toolchains
+                            comp_versions.update({tc_comp_info[0]: tc_comp_info[1]})
+
+                        comp_name_ver = [comp_name, comp_ver_tmpl % comp_versions]
+                        break
+            else:
+                comp_name_ver = [ec['name'], self.det_full_version(ec)]
+                # Handle the case where someone only wants iccifort to extend the path
+                # This means icc/ifort are not of the moduleclass compiler but iccifort is
+                if ec['name'] == 'iccifort':
+                    comp_name_ver = ['intel', self.det_full_version(ec)]
+            # Exclude extending the path for icc/ifort, the iccifort special case is handled above
+            if ec['name'] not in ['icc', 'ifort']:
+                paths.append(os.path.join(COMPILER, *comp_name_ver))
+                # Always extend to capture the MPI implementations too (which are in a separate directory)
+                if ec['name'] not in [GCCCORE]:
+                    paths.append(os.path.join(COMPILER, MODULECLASS_MPI, *comp_name_ver))
+        elif modclass == MODULECLASS_MPI:
+            if tc_comp_info is None:
+                raise EasyBuildError("No compiler available in toolchain %s used to install MPI library %s v%s, "
+                                     "which is required by the active module naming scheme.",
+                                     ec['toolchain'], ec['name'], ec['version'])
+            else:
+                tc_comp_name, tc_comp_ver = tc_comp_info
+                fullver = self.det_full_version(ec)
+                paths.append(os.path.join(MPI, tc_comp_name, tc_comp_ver, ec['name'], fullver))
+
+        return paths

Custom_Toolchains/compiler/pgi.py

+##
+# Copyright 2015 Bart Oldeman
+#
+# This file is triple-licensed under GPLv2 (see below), MIT, and
+# BSD three-clause licenses.
+#
+# 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),
+# the Hercules foundation (http://www.herculesstichting.be/in_English)
+# 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 PGI compilers (pgcc, pgc++, pgf90/pgfortran) as toolchain compilers.
+
+:author: Bart Oldeman (McGill University, Calcul Quebec, Compute Canada)
+:author: Damian Alvarez (Forschungszentrum Juelich GmbH)
+"""
+
+from distutils.version import LooseVersion
+
+import easybuild.tools.systemtools as systemtools
+from easybuild.tools.build_log import EasyBuildError
+from easybuild.tools.toolchain.compiler import Compiler
+
+
+TC_CONSTANT_PGI = "PGI"
+
+
+class Pgi(Compiler):
+    """PGI compiler class
+    """
+
+    COMPILER_MODULE_NAME = ['PGI']
+
+    COMPILER_FAMILY = TC_CONSTANT_PGI
+
+    # References:
+    # http://www.pgroup.com/doc/pgiref.pdf
+    # http://www.pgroup.com/products/freepgi/freepgi_ref/ch02.html#Mflushz
+    # http://www.pgroup.com/products/freepgi/freepgi_ref/ch02.html#Mfprelaxed
+    # http://www.pgroup.com/products/freepgi/freepgi_ref/ch02.html#Mfpapprox
+    COMPILER_UNIQUE_OPTION_MAP = {
+        'i8': 'i8',
+        'r8': 'r8',
+        'optarch': '', # PGI by default generates code for the arch it is running on!
+        'openmp': 'mp',
+        'ieee': 'Kieee',
+        'strict': ['Mnoflushz','Kieee'],
+        'precise': ['Mnoflushz'],
+        'defaultprec': ['Mflushz'],
+        'loose': ['Mfprelaxed'],
+        'veryloose': ['Mfprelaxed=div,order,intrinsic,recip,sqrt,rsqrt', 'Mfpapprox'],
+        'vectorize': {False: 'Mnovect', True: 'Mvect'},
+    }
+
+    # used when 'optarch' toolchain option is enabled (and --optarch is not specified)
+    COMPILER_OPTIMAL_ARCHITECTURE_OPTION = {
+        (systemtools.X86_64, systemtools.AMD): '',
+        (systemtools.X86_64, systemtools.INTEL): '',
+    }
+    # used with --optarch=GENERIC
+    COMPILER_GENERIC_OPTION = {
+        (systemtools.X86_64, systemtools.AMD): 'tp=x64',
+        (systemtools.X86_64, systemtools.INTEL): 'tp=x64',
+    }
+
+    COMPILER_CC = 'pgcc'
+    # C++ compiler command is version-dependent, see below
+    COMPILER_CXX = None
+
+    COMPILER_F77 = 'pgf77'
+    COMPILER_F90 = 'pgf90'
+    COMPILER_FC = 'pgfortran'
+
+    LINKER_TOGGLE_STATIC_DYNAMIC = {
+        'static': '-Bstatic',
+        'dynamic':'-Bdynamic',
+    }
+
+    def _set_compiler_flags(self):
+        """Set -tp=x64 if optarch is set to False."""
+        if not self.options.get('optarch', False):
+            self.variables.nextend('OPTFLAGS', ['tp=x64'])
+        super(Pgi, self)._set_compiler_flags()
+
+    def _set_compiler_vars(self):
+        """Set the compiler variables"""
+        pgi_version = self.get_software_version(self.COMPILER_MODULE_NAME)[0]
+
+        # based on feedback from PGI support: use pgc++ with PGI 14.10 and newer, pgCC for older versions
+        if LooseVersion(pgi_version) >= LooseVersion('14.10'):
+            self.COMPILER_CXX = 'pgc++'
+        else:
+            self.COMPILER_CXX = 'pgCC'
+
+        if LooseVersion(pgi_version) >= LooseVersion('19.1'):
+            self.COMPILER_F77 = 'pgfortran'
+        else:
+            self.COMPILER_F77 = 'pgf77'
+
+        super(Pgi, self)._set_compiler_vars()

Custom_Toolchains/fft/intelfftw.py

+##
+# Copyright 2012-2018 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 Intel FFTW as toolchain FFT library.
+
+:author: Stijn De Weirdt (Ghent University)
+:author: Kenneth Hoste (Ghent University)
+"""
+import os
+from distutils.version import LooseVersion
+
+from easybuild.tools.build_log import EasyBuildError, dry_run_warning
+from easybuild.tools.config import build_option
+from easybuild.toolchains.fft.fftw import Fftw
+from easybuild.tools.modules import get_software_root, get_software_version
+
+
+class IntelFFTW(Fftw):
+    """FFTW wrapper functionality of Intel MKL"""
+
+    FFT_MODULE_NAME = ['imkl']
+
+    FFT_LIB_GROUP = True
+    FFT_LIB_STATIC = True
+
+    def _set_fftw_variables(self):
+        if not hasattr(self, 'BLAS_LIB_DIR'):
+            raise EasyBuildError("_set_fftw_variables: IntelFFT based on IntelMKL (no BLAS_LIB_DIR found)")
+
+        imklver = get_software_version(self.FFT_MODULE_NAME[0])
+
+        picsuff = ''
+        if self.options.get('pic', None):
+            picsuff = '_pic'
+        bitsuff = '_lp64'
+        if self.options.get('i8', None):
+            bitsuff = '_ilp64'
+        compsuff = '_intel'
+        if get_software_root('icc') is None:
+            if get_software_root('PGI'):
+                compsuff = '_pgi'
+            elif get_software_root('GCC') or get_software_root('GCCcore'):
+                compsuff = '_gnu'
+            else:
+                raise EasyBuildError("Not using Intel compilers, PGI nor GCC, don't know compiler suffix for FFTW libraries.")
+
+        interface_lib = "fftw3xc%s%s" % (compsuff, picsuff)
+        fftw_libs = [interface_lib]
+        cluster_interface_lib = None
+        if self.options.get('usempi', False):
+            # add cluster interface for recent imkl versions
+            if LooseVersion(imklver) >= LooseVersion('10.3'):
+                suff = picsuff
+                if LooseVersion(imklver) >= LooseVersion('11.0.2'):
+                    suff = bitsuff + suff
+                cluster_interface_lib = 'fftw3x_cdft%s' % suff
+                fftw_libs.append(cluster_interface_lib)
+            fftw_libs.append("mkl_cdft_core")  # add cluster dft
+            fftw_libs.extend(self.variables['LIBBLACS'].flatten()) # add BLACS; use flatten because ListOfList
+
+        self.log.debug('fftw_libs %s' % fftw_libs.__repr__())
+        fftw_libs.extend(self.variables['LIBBLAS'].flatten())  # add BLAS libs (contains dft)
+        self.log.debug('fftw_libs %s' % fftw_libs.__repr__())
+
+        self.FFT_LIB_DIR = self.BLAS_LIB_DIR
+        self.FFT_INCLUDE_DIR = [os.path.join(d, 'fftw') for d in self.BLAS_INCLUDE_DIR]
+
+        # building the FFTW interfaces is optional,
+        # so make sure libraries are there before FFT_LIB is set
+        imklroot = get_software_root(self.FFT_MODULE_NAME[0])
+        fft_lib_dirs = [os.path.join(imklroot, d) for d in self.FFT_LIB_DIR]
+        fftw_lib_exists = lambda x: any([os.path.exists(os.path.join(d, "lib%s.a" % x)) for d in fft_lib_dirs])
+        if not fftw_lib_exists(interface_lib) and LooseVersion(imklver) >= LooseVersion("10.2"):
+            # interface libs can be optional:
+            # MKL >= 10.2 include fftw3xc and fftw3xf interfaces in LIBBLAS=libmkl_gf/libmkl_intel
+            # See https://software.intel.com/en-us/articles/intel-mkl-main-libraries-contain-fftw3-interfaces
+            # The cluster interface libs (libfftw3x_cdft*) can be omitted if the toolchain does not provide MPI-FFTW
+            # interfaces.
+            fftw_libs = [l for l in fftw_libs if l not in [interface_lib, cluster_interface_lib]]
+
+        # filter out libraries from list of FFTW libraries to check for if they are not provided by Intel MKL
+        check_fftw_libs = [lib for lib in fftw_libs if lib not in ['dl', 'gfortran']]
+
+        if all([fftw_lib_exists(lib) for lib in check_fftw_libs]):
+            self.FFT_LIB = fftw_libs
+        else:
+            msg = "Not all FFTW interface libraries %s are found in %s" % (check_fftw_libs, fft_lib_dirs)
+            msg += ", can't set $FFT_LIB."
+            if self.dry_run:
+                dry_run_warning(msg, silent=build_option('silent'))
+            else:
+                raise EasyBuildError(msg)

Custom_Toolchains/gcccoremkl.py

+##
+# Copyright 2013-2018 Ghent University
+#
+# This file is triple-licensed under GPLv2 (see below), MIT, and
+# BSD three-clause licenses.
+#
+# 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/>.
+##
+"""
+EasyBuild support for gpsmkl compiler toolchain (includes GCC, ParaStation MPI and MKL).
+"""
+
+from easybuild.toolchains.gcccore import GCCcore
+from easybuild.toolchains.fft.intelfftw import IntelFFTW
+from easybuild.toolchains.linalg.intelmkl import IntelMKL
+
+class Gcccoremkl(GCCcore, IntelMKL, IntelFFTW):
+    """Compiler toolchain with GCCcore and MKL."""
+    NAME = 'gcccoremkl'
+    SUBTOOLCHAIN = GCCcore.NAME

Custom_Toolchains/gmvapich2c.py

+##
+# Copyright 2012-2016 Ghent University
+# Copyright 2016-2016 Forschungszentrum Juelich
+#
+# 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://vscentrum.be/nl/en),
+# Flemish Research Foundation (FWO) (http://www.fwo.be/en)
+# and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en).
+#
+# http://github.com/hpcugent/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/>.
+##
+"""
+EasyBuild support for gmvapich2 compiler toolchain (includes GCC and MVAPICH2, and CUDA as a dependency).
+
+@author: Kenneth Hoste (Ghent University)
+@author: Damian Alvarez (Forschungszentrum Juelich)
+"""
+
+from easybuild.toolchains.gcc import GccToolchain
+# We pull in MPI and CUDA at once so this maps nicely to HMNS
+from easybuild.toolchains.mpi.mvapich2 import Mvapich2
+from easybuild.toolchains.compiler.cuda import Cuda
+
+# Order matters here!
+class Gmvapich2c(GccToolchain, Cuda, Mvapich2):
+    """Compiler toolchain with GCC and MVAPICH2, and CUDA as a dependency."""
+    NAME = 'gmvapich2c'
+    SUBTOOLCHAIN = GccToolchain.NAME

Custom_Toolchains/gmvmklc.py

+##
+# Copyright 2016-2016 Ghent University
+# Copyright 2016-2016 Forschungszentrum Juelich
+#
+# This file is triple-licensed under GPLv2 (see below), MIT, and
+# BSD three-clause licenses.
+#
+# 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://vscentrum.be/nl/en),
+# Flemish Research Foundation (FWO) (http://www.fwo.be/en)
+# and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en).
+#
+# http://github.com/hpcugent/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/>.
+##
+"""
+EasyBuild support for gmvmklc compiler toolchain (includes GCC, MVAPICH2 and MKL, and CUDA as dependency).
+
+@author: Damian Alvarez (Forschungszentrum Juelich)
+"""
+
+from easybuild.toolchains.gmvapich2c import Gmvapich2c
+from easybuild.toolchains.fft.intelfftw import IntelFFTW
+from easybuild.toolchains.linalg.intelmkl import IntelMKL
+
+
+class Gmvmklc(Gmvapich2c, IntelMKL, IntelFFTW):
+    """Compiler toolchain with GCC, MVAPICH2 and MKL, and CUDA as dependency."""
+    NAME = 'gmvmklc'
+    SUBTOOLCHAIN = Gmvapich2c.NAME

Custom_Toolchains/gmvolfc.py

+##
+# Copyright 2016-2016 Ghent University
+# Copyright 2016-2016 Forschungszentrum Juelich
+#
+# This file is triple-licensed under GPLv2 (see below), MIT, and
+# BSD three-clause licenses.
+#
+# 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://vscentrum.be/nl/en),
+# Flemish Research Foundation (FWO) (http://www.fwo.be/en)
+# and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en).
+#
+# http://github.com/hpcugent/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/>.
+##
+"""
+EasyBuild support for gmvolfc compiler toolchain (includes GCC, MVAPICH2, OpenBLAS, LAPACK, ScaLAPACK 
+and FFTW, and CUDA as dependency).
+
+@author: Damian Alvarez (Forschungszentrum Juelich)
+"""
+
+from easybuild.toolchains.gmvapich2c import Gmvapich2c
+from easybuild.toolchains.fft.fftw import Fftw
+from easybuild.toolchains.linalg.openblas import OpenBLAS
+from easybuild.toolchains.linalg.scalapack import ScaLAPACK
+
+
+class Gmvolfc(Gmvapich2c, OpenBLAS, ScaLAPACK, Fftw):
+    """Compiler toolchain with GCC, MVAPICH2, OpenBLAS, ScaLAPACK and FFTW, and CUDA as dependency."""
+    NAME = 'gmvolfc'
+    SUBTOOLCHAIN = Gmvapich2c.NAME

Custom_Toolchains/gpsmkl.py

+##
+# Copyright 2013-2018 Ghent University
+#
+# This file is triple-licensed under GPLv2 (see below), MIT, and
+# BSD three-clause licenses.
+#
+# 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/>.
+##
+"""
+EasyBuild support for gpsmkl compiler toolchain (includes GCC, ParaStation MPI and MKL).
+
+"""
+
+from easybuild.toolchains.gpsmpi import Gpsmpi
+from easybuild.toolchains.fft.intelfftw import IntelFFTW
+from easybuild.toolchains.linalg.intelmkl import IntelMKL
+
+
+class Gpsmkl(Gpsmpi, IntelMKL, IntelFFTW):
+    """Compiler toolchain with GCC, Parastation MPI and MKL."""
+    NAME = 'gpsmkl'
+    SUBTOOLCHAIN = Gpsmpi.NAME

Custom_Toolchains/imvapich2c.py

+##
+# Copyright 2016-2016 Ghent University
+# Copyright 2016-2016 Forschungszentrum Juelich
+#
+# 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://vscentrum.be/nl/en),
+# Flemish Research Foundation (FWO) (http://www.fwo.be/en)
+# and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en).
+#
+# http://github.com/hpcugent/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/>.
+##
+"""
+EasyBuild support for imvapich2c compiler toolchain (includes Intel and MVAPICH2, and CUDA as dependency).
+
+@author: Damian Alvarez (Forschungszentrum Juelich)
+"""
+
+from easybuild.toolchains.iccifort import IccIfort
+# We pull in MPI and CUDA at once so this maps nicely to HMNS
+from easybuild.toolchains.mpi.mvapich2 import Mvapich2
+from easybuild.toolchains.compiler.cuda import Cuda
+
+# Order matters here!
+class Imvapich2c(IccIfort, Cuda, Mvapich2):
+    """Compiler toolchain with Intel and MVAPICH2, with CUDA as dependency."""
+    NAME = 'imvapich2c'
+    SUBTOOLCHAIN = IccIfort.NAME

Custom_Toolchains/imvmklc.py

+##
+# Copyright 2016-2016 Ghent University
+# Copyright 2016-2016 Forschungszentrum Juelich
+#
+# This file is triple-licensed under GPLv2 (see below), MIT, and
+# BSD three-clause licenses.
+#
+# 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://vscentrum.be/nl/en),
+# Flemish Research Foundation (FWO) (http://www.fwo.be/en)
+# and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en).
+#
+# http://github.com/hpcugent/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/>.
+##
+"""
+EasyBuild support for imvmklc compiler toolchain (includes Intel, MVAPICH2 and MKL, and CUDA as dependency).
+
+@author: Damian Alvarez (Forschungszentrum Juelich)
+"""
+
+from easybuild.toolchains.imvapich2c import Imvapich2c
+from easybuild.toolchains.fft.intelfftw import IntelFFTW
+from easybuild.toolchains.linalg.intelmkl import IntelMKL
+
+
+class Imvmklc(Imvapich2c, IntelMKL, IntelFFTW):
+    """Compiler toolchain with Intel, MVAPICH2 and MKL, and CUDA as dependency."""
+    NAME = 'imvmklc'
+    SUBTOOLCHAIN = Imvapich2c.NAME

Custom_Toolchains/pmvapich2c.py

+##
+# Copyright 2016-2016 Ghent University
+# Copyright 2016-2016 Forschungszentrum Juelich
+#
+# 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://vscentrum.be/nl/en),
+# Flemish Research Foundation (FWO) (http://www.fwo.be/en)
+# and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en).
+#
+# http://github.com/hpcugent/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/>.
+##
+"""
+EasyBuild support for pmvapich2c compiler toolchain (includes PGI and MVAPICH2, and CUDA as dependency).
+
+@author: Damian Alvarez (Forschungszentrum Juelich)
+"""
+
+from easybuild.toolchains.pgi import PgiToolchain
+# We pull in MPI and CUDA at once so this maps nicely to HMNS
+from easybuild.toolchains.mpi.mvapich2 import Mvapich2
+from easybuild.toolchains.compiler.cuda import Cuda
+
+# Order matters!
+class Pmvapich2c(PgiToolchain, Cuda, Mvapich2):
+    """Compiler toolchain with PGI and MVAPICH2, with CUDA as dependency."""
+    NAME = 'pmvapich2c'
+    SUBTOOLCHAIN = PgiToolchain.NAME

Custom_Toolchains/pmvmklc.py

+##
+# Copyright 2016-2016 Ghent University
+# Copyright 2016-2016 Forschungszentrum Juelich
+#
+# This file is triple-licensed under GPLv2 (see below), MIT, and
+# BSD three-clause licenses.
+#
+# 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://vscentrum.be/nl/en),
+# Flemish Research Foundation (FWO) (http://www.fwo.be/en)
+# and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en).
+#
+# http://github.com/hpcugent/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/>.
+##
+"""
+EasyBuild support for pmvmklc compiler toolchain (includes PGI, MVAPICH2 and MKL, and CUDA as dependency).
+
+@author: Damian Alvarez (Forschungszentrum Juelich)
+"""
+
+from easybuild.toolchains.pmvapich2c import Pmvapich2c
+from easybuild.toolchains.fft.intelfftw import IntelFFTW
+from easybuild.toolchains.linalg.intelmkl import IntelMKL
+
+
+class Pmvmklc(Pmvapich2c, IntelMKL, IntelFFTW):
+    """Compiler toolchain with PGI, MVAPICH2 and MKL, and CUDA as dependency."""
+    NAME = 'pmvmklc'
+    SUBTOOLCHAIN = Pmvapich2c.NAME