Skip to content
Snippets Groups Projects
Commit 82905059 authored by Damian Alvarez's avatar Damian Alvarez
Browse files

Merge branch '2020' of...

parents dee6930b 0f5a025b
Branches
No related tags found
No related merge requests found
##
# 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
##
# 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()
##
# 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)
##
# 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
##
# 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
##
# 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
##
# 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
##
# 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
##
# 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
##
# 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
##
# 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
##
# 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
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment