def test_toolchain_21(self):
"""Toolchain"""
tc = toolchain(CC='gcc', CFLAGS='-O2')
g = gdrcopy(toolchain=tc, version='2.1')
self.assertEqual(str(g),
r'''# GDRCOPY version 2.1
RUN apt-get update -y && \
DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
make \
wget && \
rm -rf /var/lib/apt/lists/*
RUN mkdir -p /var/tmp && wget -q -nc --no-check-certificate -P /var/tmp https://github.com/NVIDIA/gdrcopy/archive/v2.1.tar.gz && \
mkdir -p /var/tmp && tar -x -f /var/tmp/v2.1.tar.gz -C /var/tmp -z && \
cd /var/tmp/gdrcopy-2.1 && \
mkdir -p /usr/local/gdrcopy/include /usr/local/gdrcopy/lib64 && \
make CC=gcc COMMONCFLAGS=-O2 PREFIX=/usr/local/gdrcopy lib lib_install && \
rm -rf /var/tmp/gdrcopy-2.1 /var/tmp/v2.1.tar.gz
ENV CPATH=/usr/local/gdrcopy/include:$CPATH \
LD_LIBRARY_PATH=/usr/local/gdrcopy/lib64:$LD_LIBRARY_PATH \
LIBRARY_PATH=/usr/local/gdrcopy/lib64:$LIBRARY_PATH''')
def __init__(self, **kwargs):
"""Initialize building block"""
super(gnu, self).__init__(**kwargs)
self.__baseurl = kwargs.get('baseurl', 'http://ftpmirror.gnu.org/gcc')
self.__cc = kwargs.get('cc', True)
self.configure_opts = kwargs.get('configure_opts',
['--disable-multilib'])
self.__cxx = kwargs.get('cxx', True)
self.__extra_repo = kwargs.get('extra_repository', False)
self.__fortran = kwargs.get('fortran', True)
self.__openacc = kwargs.get('openacc', False)
self.__ospackages = kwargs.get('ospackages', [])
self.prefix = kwargs.get('prefix', '/usr/local/gnu')
self.__source = kwargs.get('source', False)
self.__version = kwargs.get('version', None)
self.__wd = '/var/tmp' # working directory
self.__commands = [] # Filled in below
self.__compiler_debs = [] # Filled in below
self.__compiler_rpms = [] # Filled in below
self.__compiler_zypper_rpms = [] # Filled in below
self.__extra_repo_apt = [] # Filled in below
self.__runtime_debs = ['libgomp1']
self.__runtime_rpms = ['libgomp']
self.__runtime_zypper_rpms = ['libgomp1']
# Output toolchain
self.toolchain = toolchain()
if self.__source:
self.__build()
else:
self.__repository()
# Set the Linux distribution specific parameters
self.__distro()
# Fill in container instructions
self.__instructions()
def __init__(self, **kwargs):
"""Initialize building block"""
super(netcdf, self).__init__(**kwargs)
self.configure_opts = kwargs.get('configure_opts', [])
self.__baseurl = 'https://www.unidata.ucar.edu/downloads/netcdf/ftp'
self.__check = kwargs.get('check', False)
self.__cxx = kwargs.get('cxx', True)
self.__fortran = kwargs.get('fortran', True)
self.__hdf5_dir = kwargs.get('hdf5_dir', '/usr/local/hdf5')
self.__ospackages = kwargs.get('ospackages', [])
self.prefix = kwargs.get('prefix', '/usr/local/netcdf')
self.__runtime_ospackages = [] # Filled in by __distro()
self.__toolchain = kwargs.get('toolchain', toolchain())
self.__version = kwargs.get('version', '4.7.0')
self.__version_cxx = kwargs.get('version_cxx', '4.3.0')
self.__version_fortran = kwargs.get('version_fortran', '4.4.5')
self.__wd = '/var/tmp'
self.__commands = [] # Filled in by __setup()
# Set the Linux distribution specific parameters
self.__distro()
# C interface (required)
self.__setup()
# C++ interface (optional)
if self.__cxx:
self.__setup_optional(pkg='netcdf-cxx4',
version=self.__version_cxx)
# Fotran interface (optional)
if self.__fortran:
self.__setup_optional(pkg='netcdf-fortran',
version=self.__version_fortran)
# Fill in container instructions
self.__instructions()
def __init__(self, **kwargs):
"""Initialize building block"""
super(openblas, self).__init__(**kwargs)
self.__baseurl = kwargs.get('baseurl', 'https://github.com/xianyi/OpenBLAS/archive')
self.__make_opts = kwargs.get('make_opts', ['USE_OPENMP=1'])
self.__ospackages = kwargs.get('ospackages', ['make', 'perl', 'tar',
'wget'])
self.__prefix = kwargs.get('prefix', '/usr/local/openblas')
self.__toolchain = kwargs.get('toolchain', toolchain())
self.__version = kwargs.get('version', '0.3.6')
self.__commands = [] # Filled in by __setup()
self.__wd = '/var/tmp' # working directory
# Construct the series of steps to execute
self.__setup()
# Fill in container instructions
self.__instructions()
def test_toolchain(self):
"""Toolchain specified"""
cm = ConfigureMake()
tc = toolchain(CC='mycc',
CXX='mycxx',
FC='myfc',
F77='myf77',
F90='myf90',
CFLAGS='-g -O3',
CPPFLAGS='-DFOO -DBAR',
CXXFLAGS='-g -O3',
FCFLAGS='-g -O3',
FFLAGS='-g -O3',
LD_LIBRARY_PATH='/opt/mysw/lib:/opt/yoursw/lib',
LDFLAGS='-Wl,--start-group foo.o bar.o -Wl,--endgroup')
configure = cm.configure_step(toolchain=tc)
self.assertEqual(
configure,
'''CC=mycc CFLAGS='-g -O3' CPPFLAGS='-DFOO -DBAR' CXX=mycxx CXXFLAGS='-g -O3' F77=myf77 F90=myf90 FC=myfc FCFLAGS='-g -O3' FFLAGS='-g -O3' LD_LIBRARY_PATH=/opt/mysw/lib:/opt/yoursw/lib LDFLAGS='-Wl,--start-group foo.o bar.o -Wl,--endgroup' ./configure --prefix=/usr/local'''
)
def __init__(self, **kwargs):
"""Initialize building block"""
# Trouble getting MRO with kwargs working correctly, so just call
# the parent class constructors manually for now.
#super(pnetcdf, self).__init__(**kwargs)
ConfigureMake.__init__(self, **kwargs)
rm.__init__(self, **kwargs)
tar.__init__(self, **kwargs)
wget.__init__(self, **kwargs)
self.configure_opts = kwargs.get('configure_opts', ['--enable-shared'])
self.prefix = kwargs.get('prefix', '/usr/local/pnetcdf')
self.__baseurl = kwargs.get(
'baseurl',
'http://cucis.ece.northwestern.edu/projects/PnetCDF/Release')
self.__check = kwargs.get('check', False)
self.__ospackages = kwargs.get('ospackages',
['m4', 'make', 'tar', 'wget'])
self.__toolchain = kwargs.get(
'toolchain',
toolchain(CC='mpicc',
CXX='mpicxx',
F77='mpif77',
F90='mpif90',
FC='mpifort'))
self.__version = kwargs.get('version', '1.10.0')
self.__commands = [] # Filled in by __setup()
self.__environment_variables = {
'PATH':
'{}:$PATH'.format(os.path.join(self.prefix, 'bin')),
'LD_LIBRARY_PATH':
'{}:$LD_LIBRARY_PATH'.format(os.path.join(self.prefix, 'lib'))
}
self.__wd = '/var/tmp' # working directory
# Construct the series of steps to execute
self.__setup()
def __init__(self, **kwargs):
"""Initialize building block"""
super(catalyst, self).__init__(**kwargs)
self.cmake_opts = kwargs.get('cmake_opts', [])
self.__edition = kwargs.get('edition', 'Base-Enable-Python-Essentials-Extras-Rendering-Base')
self.__ospackages = kwargs.get('ospackages', [])
self.prefix = kwargs.get('prefix', '/usr/local/catalyst')
self.__runtime_ospackages = [] # Filled in by __distro()
# Input toolchain, i.e., what to use when building
self.__toolchain = kwargs.get('toolchain', toolchain())
self.__version = kwargs.get('version', '5.6.1')
self.__url = r'https://www.paraview.org/paraview-downloads/download.php?submit=Download\&version={0}\&type=catalyst\&os=Sources\&downloadFile={1}'
self.__commands = [] # Filled in by __setup()
self.__wd = '/var/tmp' # working directory
# Validate edition choice
if self.__edition not in [
'Base', 'Base-Essentials', 'Base-Essentials-Extras',
'Base-Essentials-Extras-Rendering-Base',
'Base-Enable-Python', 'Base-Enable-Python-Essentials',
'Base-Enable-Python-Essentials-Extras',
'Base-Enable-Python-Essentials-Extras-Rendering-Base']:
logging.warning('Invalid Catalyst edition "{0}", defaulting to '
'Base-Essentials'.format(self.__edition))
self.__edition = 'Base-Essentials'
self.__basename = 'Catalyst-v{0}-{1}'.format(self.__version,
self.__edition)
# Set the Linux distribution specific parameters
self.__distro()
# Construct the series of steps to execute
self.__setup()
# Fill in container instructions
self.__instructions()
def __init__(self, **kwargs):
"""Initialize building block"""
# Trouble getting MRO with kwargs working correctly, so just call
# the parent class constructors manually for now.
#super(ucx, self).__init__(**kwargs)
ConfigureMake.__init__(self, **kwargs)
ldconfig.__init__(self, **kwargs)
rm.__init__(self, **kwargs)
tar.__init__(self, **kwargs)
wget.__init__(self, **kwargs)
self.configure_opts = kwargs.get('configure_opts', [
'--enable-optimizations', '--disable-logging', '--disable-debug',
'--disable-assertions', '--disable-params-check',
'--disable-doxygen-doc'
])
self.prefix = kwargs.get('prefix', '/usr/local/ucx')
self.__baseurl = kwargs.get(
'baseurl', 'https://github.com/openucx/ucx/releases/download')
self.__cuda = kwargs.get('cuda', True)
self.__gdrcopy = kwargs.get('gdrcopy', '')
self.__knem = kwargs.get('knem', '')
self.__ospackages = kwargs.get('ospackages', [])
self.__toolchain = kwargs.get('toolchain', toolchain())
self.__version = kwargs.get('version', '1.4.0')
self.__xpmem = kwargs.get('xpmem', '')
self.__commands = [] # Filled in by __setup()
self.__environment_variables = {
'PATH': '{}:$PATH'.format(os.path.join(self.prefix, 'bin'))
}
self.__wd = '/var/tmp' # working directory
# Set the Linux distribution specific parameters
self.__distro()
# Construct the series of steps to execute
self.__setup()
def __init__(self, **kwargs):
"""Initialize building block"""
# Trouble getting MRO with kwargs working correctly, so just call
# the parent class constructors manually for now.
#super(hdf5, self).__init__(**kwargs)
ConfigureMake.__init__(self, **kwargs)
rm.__init__(self, **kwargs)
tar.__init__(self, **kwargs)
wget.__init__(self, **kwargs)
self.configure_opts = kwargs.get('configure_opts',
['--enable-cxx', '--enable-fortran'])
self.prefix = kwargs.get('prefix', '/usr/local/hdf5')
self.__baseurl = kwargs.get(
'baseurl', 'http://www.hdfgroup.org/ftp/HDF5/releases')
self.__check = kwargs.get('check', False)
self.__directory = kwargs.get('directory', '')
self.__ospackages = kwargs.get('ospackages', [])
self.__runtime_ospackages = [] # Filled in by __distro()
self.__toolchain = kwargs.get('toolchain', toolchain())
self.__version = kwargs.get('version', '1.10.1')
self.__commands = [] # Filled in by __setup()
self.__environment_variables = {
'HDF5_DIR':
self.prefix,
'PATH':
'{}:$PATH'.format(os.path.join(self.prefix, 'bin')),
'LD_LIBRARY_PATH':
'{}:$LD_LIBRARY_PATH'.format(os.path.join(self.prefix, 'lib'))
}
self.__wd = '/var/tmp' # working directory
# Set the Linux distribution specific parameters
self.__distro()
# Construct the series of steps to execute
self.__setup()
def test_ldconfig(self):
"""ldconfig option"""
tc = toolchain(CC='gcc', FC='gfortran')
o = openblas(ldconfig=True, toolchain=tc, version='0.3.3')
self.assertEqual(
str(o), r'''# OpenBLAS version 0.3.3
RUN apt-get update -y && \
DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
make \
perl \
tar \
wget && \
rm -rf /var/lib/apt/lists/*
RUN mkdir -p /var/tmp && wget -q -nc --no-check-certificate -P /var/tmp https://github.com/xianyi/OpenBLAS/archive/v0.3.3.tar.gz && \
mkdir -p /var/tmp && tar -x -f /var/tmp/v0.3.3.tar.gz -C /var/tmp -z && \
cd /var/tmp/OpenBLAS-0.3.3 && \
make CC=gcc FC=gfortran USE_OPENMP=1 && \
mkdir -p /usr/local/openblas && \
cd /var/tmp/OpenBLAS-0.3.3 && \
make install PREFIX=/usr/local/openblas && \
echo "/usr/local/openblas/lib" >> /etc/ld.so.conf.d/hpccm.conf && ldconfig && \
rm -rf /var/tmp/OpenBLAS-0.3.3 /var/tmp/v0.3.3.tar.gz''')
def __init__(self, **kwargs):
"""Initialize building block"""
super(llvm, self).__init__(**kwargs)
self.__extra_repo = kwargs.get('extra_repository', False)
self.__version = kwargs.get('version', None)
self.__commands = [] # Filled in below
self.__compiler_debs = ['clang'] # Filled in below
self.__compiler_rpms = ['clang'] # Filled in below
self.__ospackages = kwargs.get('ospackages', [])
self.__runtime_debs = ['libclang1']
self.__runtime_rpms = ['llvm-libs']
# Output toolchain
self.toolchain = toolchain()
self.toolchain.CC = 'clang'
self.toolchain.CXX = 'clang++'
# Install an alternate version, i.e., not the default for
# the Linux distribution
if self.__version:
# Adjust package names based on specified version
self.__compiler_debs = [
'{0}-{1}'.format(x, self.__version)
for x in self.__compiler_debs]
self.__compiler_rpms = [
'llvm-toolset-{0}-{1}'.format(self.__version, x)
for x in self.__compiler_rpms]
self.__runtime_rpms = [
'llvm-toolset-{0}-runtime'.format(self.__version),
'llvm-toolset-{0}-libomp'.format(self.__version),
'llvm-toolset-{0}-compiler-rt'.format(self.__version)]
self.__distro()
# Fill in container instructions
self.__instructions()
def __init__(self, **kwargs):
"""Initialize building block"""
# Trouble getting MRO with kwargs working correctly, so just call
# the parent class constructors manually for now.
#super(pgi, self).__init__(**kwargs)
tar.__init__(self, **kwargs)
wget.__init__(self, **kwargs)
self.__basepath = '/opt/pgi/linux86-64/'
self.__commands = [] # Filled in by __setup()
# By setting this value to True, you agree to the PGI End-User
# License Agreement (https://www.pgroup.com/doc/LICENSE.txt)
self.__eula = kwargs.get('eula', False)
self.__mpi = kwargs.get('mpi', False)
self.__ospackages = kwargs.get('ospackages', [])
self.__referer = r'https://www.pgroup.com/products/community.htm?utm_source=hpccm\&utm_medium=wgt\&utm_campaign=CE\&nvid=nv-int-14-39155'
self.__system_cuda = kwargs.get('system_cuda', False)
self.__tarball = kwargs.get('tarball', '')
self.__url = 'https://www.pgroup.com/support/downloader.php?file=pgi-community-linux-x64'
# The version is fragile since the latest version is
# automatically downloaded, which may not match this default.
self.__version = kwargs.get('version', '18.4')
self.__wd = '/var/tmp' # working directory
self.toolchain = toolchain(CC='pgcc',
CXX='pgc++',
F77='pgfortran',
F90='pgfortran',
FC='pgfortran')
# Set the Linux distribution specific parameters
self.__distro()
# Construct the series of steps to execute
self.__setup()
def test_defaults_ubuntu(self):
"""Default openblas building block"""
tc = toolchain(CC='gcc', FC='gfortran')
o = openblas(toolchain=tc)
self.assertEqual(
str(o), r'''# OpenBLAS version 0.3.10
RUN apt-get update -y && \
DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
make \
perl \
tar \
wget && \
rm -rf /var/lib/apt/lists/*
RUN mkdir -p /var/tmp && wget -q -nc --no-check-certificate -P /var/tmp https://github.com/xianyi/OpenBLAS/archive/v0.3.10.tar.gz && \
mkdir -p /var/tmp && tar -x -f /var/tmp/v0.3.10.tar.gz -C /var/tmp -z && \
cd /var/tmp/OpenBLAS-0.3.10 && \
make CC=gcc FC=gfortran USE_OPENMP=1 && \
mkdir -p /usr/local/openblas && \
cd /var/tmp/OpenBLAS-0.3.10 && \
make install PREFIX=/usr/local/openblas && \
rm -rf /var/tmp/OpenBLAS-0.3.10 /var/tmp/v0.3.10.tar.gz
ENV LD_LIBRARY_PATH=/usr/local/openblas/lib:$LD_LIBRARY_PATH''')
def __init__(self, **kwargs):
"""Initialize building block"""
super(pnetcdf, self).__init__(**kwargs)
self.configure_opts = kwargs.get('configure_opts', ['--enable-shared'])
self.prefix = kwargs.get('prefix', '/usr/local/pnetcdf')
self.__baseurl = kwargs.get(
'baseurl',
'http://cucis.ece.northwestern.edu/projects/PnetCDF/Release')
self.__check = kwargs.get('check', False)
self.__ospackages = kwargs.get('ospackages',
['m4', 'make', 'tar', 'wget'])
self.__runtime_ospackages = [] # Filled in by __distro()
self.__toolchain = kwargs.get(
'toolchain',
toolchain(CC='mpicc',
CXX='mpicxx',
F77='mpif77',
F90='mpif90',
FC='mpifort'))
self.__version = kwargs.get('version', '1.10.0')
self.__commands = [] # Filled in by __setup()
self.__environment_variables = {
'PATH': '{}:$PATH'.format(posixpath.join(self.prefix, 'bin'))
}
self.__wd = '/var/tmp' # working directory
# Set the Linux distribution specific parameters
self.__distro()
# Construct the series of steps to execute
self.__setup()
# Fill in container instructions
self.__instructions()
def __init__(self, **kwargs):
"""Initialize building block"""
super(intel_psxe, self).__init__(**kwargs)
# By setting this value to True, you agree to the
# corresponding Intel End User License Agreement
# (https://software.intel.com/en-us/articles/end-user-license-agreement)
self.__eula = kwargs.get('eula', False)
self.__components = kwargs.get(
'components', ['intel-icc__x86_64', 'intel-ifort__x86_64'])
self.__license = kwargs.get('license', None)
self.__ospackages = kwargs.get('ospackages', ['cpio'])
self.__prefix = kwargs.get('prefix', '/opt/intel')
self.__tarball = kwargs.get('tarball', None)
self.__wd = '/var/tmp' # working directory
self.toolchain = toolchain(CC='icc',
CXX='icpc',
F77='ifort',
F90='ifort',
FC='ifort')
self.__commands = [] # Filled in by __setup()
self.__environment_variables = {
'PATH':
'{}:$PATH'.format(os.path.join(self.__prefix, 'bin')),
'LD_LIBRARY_PATH':
'{}:$LD_LIBRARY_PATH'.format(
os.path.join(self.__prefix, 'lib', 'intel64'))
}
# Construct the series of steps to execute
self.__setup()
# Fill in container instructions
self.__instructions()
def __init__(self, **kwargs):
"""Initialize building block"""
# Trouble getting MRO with kwargs working correctly, so just call
# the parent class constructors manually for now.
#super(llvm, self).__init__(**kwargs)
self.__extra_repo = kwargs.get('extra_repository', False)
self.__version = kwargs.get('version', None)
self.__commands = [] # Filled in below
self.__compiler_debs = ['clang'] # Filled in below
self.__compiler_rpms = ['clang'] # Filled in below
self.__environment = {} # Filled in below
self.__runtime_debs = ['libclang1']
self.__runtime_rpms = ['llvm-libs']
# Output toolchain
self.toolchain = toolchain()
self.toolchain.CC = 'clang'
self.toolchain.CXX = 'clang++'
# Install an alternate version, i.e., not the default for
# the Linux distribution
if self.__version:
# Adjust package names based on specified version
self.__compiler_debs = [
'{0}-{1}'.format(x, self.__version)
for x in self.__compiler_debs]
self.__compiler_rpms = [
'llvm-toolset-{0}-{1}'.format(self.__version, x)
for x in self.__compiler_rpms]
self.__runtime_rpms = [
'llvm-toolset-{0}-runtime'.format(self.__version),
'llvm-toolset-{0}-libomp'.format(self.__version),
'llvm-toolset-{0}-compiler-rt'.format(self.__version)]
self.__distro()
def __init__(self, **kwargs):
"""Initialize building block"""
super(hpcx, self).__init__(**kwargs)
self.__arch = hpccm.config.get_cpu_architecture()
self.__baseurl = kwargs.get(
'baseurl', 'http://www.mellanox.com/downloads/hpc/hpc-x')
self.__bashrc = '' # Filled in by __distro()
self.__hpcxinit = kwargs.get('hpcxinit', True)
self.__inbox = kwargs.get('inbox', False)
self.__mlnx_ofed = kwargs.get('mlnx_ofed', '4.7-1.0.0.1')
self.__multi_thread = kwargs.get('multi_thread', False)
self.__oslabel = kwargs.get('oslabel', '') # Filled in by __distro()
self.__ospackages = kwargs.get('ospackages',
[]) # Filled in by _distro()
self.__packages = kwargs.get('packages', [])
self.__prefix = kwargs.get('prefix', '/usr/local/hpcx')
self.__version = kwargs.get('version', '2.5.0')
self.__commands = [] # Filled in by __setup()
self.__wd = '/var/tmp' # working directory
# Output toolchain
self.toolchain = toolchain(CC='mpicc',
CXX='mpicxx',
F77='mpif77',
F90='mpif90',
FC='mpifort')
# Set the Linux distribution specific parameters
self.__distro()
# Construct the series of steps to execute
self.__setup()
# Fill in container instructions
self.__instructions()
def __init__(self, **kwargs):
"""Initialize building block"""
super(cgns, self).__init__(**kwargs)
self.__baseurl = kwargs.pop('baseurl', 'https://github.com/CGNS/CGNS/archive')
self.__check = kwargs.pop('check', False)
self.__configure_opts = kwargs.pop('configure_opts',
['--with-hdf5=/usr/local/hdf5',
'--with-zlib'])
self.__ospackages = kwargs.pop('ospackages', [])
self.__prefix = kwargs.pop('prefix', '/usr/local/cgns')
self.__toolchain = kwargs.pop('toolchain', toolchain())
self.__version = kwargs.pop('version', '4.1.2')
# Set the configuration options
self.__configure()
# Set the Linux distribution specific parameters
self.__distro()
# Setup build configuration
self.__bb = generic_autotools(
annotations={'version': self.__version},
base_annotation=self.__class__.__name__,
check=self.__check,
comment=False,
configure_opts=self.__configure_opts,
directory=posixpath.join('CGNS-{}'.format(self.__version), 'src'),
prefix=self.__prefix,
toolchain=self.__toolchain,
url='{0}/v{1}.tar.gz'.format(self.__baseurl, self.__version),
**kwargs)
# Container instructions
self += comment('CGNS version {}'.format(self.__version))
self += packages(ospackages=self.__ospackages)
self += self.__bb
def __init__(self, **kwargs):
"""Initialize building block"""
super(llvm, self).__init__(**kwargs)
# Current LLVM trunk version
self.__trunk_version = '15'
self.__apt_keys = [] # Filled in below
self.__apt_repositories = [] # Filled in below
self.__commands = [] # Filled in below
self.__compiler_debs = [] # Filled in below
self.__compiler_rpms = [] # Filled in below
self.__extra_tools = kwargs.get('extra_tools', False)
self.__openmp = kwargs.get('openmp', True)
self.__ospackages = kwargs.get('ospackages', []) # Filled in below
self.__runtime_debs = [] # Filled in below
self.__runtime_ospackages = [] # Filled in below
self.__runtime_rpms = [] # Filled in below
self.__toolset = kwargs.get('toolset', False)
self.__upstream = kwargs.get('upstream', False)
self.__version = kwargs.get('version', None)
# Output toolchain
self.toolchain = toolchain()
self.toolchain.CC = 'clang'
self.toolchain.CFLAGS = hpccm.config.get_cpu_optimization_flags(
'clang')
self.toolchain.CXX = 'clang++'
self.toolchain.CXXFLAGS = hpccm.config.get_cpu_optimization_flags(
'clang')
# Set the packages to install based on the Linux distribution
# and CPU architecture
self.__setup()
# Fill in container instructions
self.__instructions()
def test_toolchain(self):
"""Toolchain specified"""
cm = CMakeBuild()
tc = toolchain(CC='mycc',
CXX='mycxx',
FC='myfc',
F77='myf77',
F90='myf90',
CFLAGS='-g -O3',
CPPFLAGS='-DFOO -DBAR',
CXXFLAGS='-g -O3',
FCFLAGS='-g -O3',
FFLAGS='-g -O3',
FLIBS='-ldl',
LD_LIBRARY_PATH='/opt/mysw/lib:/opt/yoursw/lib',
LDFLAGS='-Wl,--start-group foo.o bar.o -Wl,--endgroup',
LIBS='-ldl -lpthread')
configure = cm.configure_step(directory='/tmp/src', toolchain=tc)
self.assertEqual(
configure,
'''mkdir -p /tmp/src/build && cd /tmp/src/build && CC=mycc CFLAGS='-g -O3' CPPFLAGS='-DFOO -DBAR' CXX=mycxx CXXFLAGS='-g -O3' F77=myf77 F90=myf90 FC=myfc FCFLAGS='-g -O3' FFLAGS='-g -O3' FLIBS=-ldl LD_LIBRARY_PATH=/opt/mysw/lib:/opt/yoursw/lib LDFLAGS='-Wl,--start-group foo.o bar.o -Wl,--endgroup' LIBS='-ldl -lpthread' cmake /tmp/src'''
)
def __init__(self, **kwargs):
"""Initialize building block"""
super(slurm_pmi2, self).__init__(**kwargs)
self.__baseurl = kwargs.get('baseurl',
'https://download.schedmd.com/slurm')
self.configure_opts = kwargs.get('configure_opts', [])
self.environment = kwargs.get('environment', False)
self.__ospackages = kwargs.get(
'ospackages', ['bzip2', 'file', 'make', 'perl', 'tar', 'wget'])
self.prefix = kwargs.get('prefix', '/usr/local/slurm-pmi2')
self.__toolchain = kwargs.get('toolchain', toolchain())
self.__version = kwargs.get('version', '19.05.4')
self.__commands = [] # Filled in by __setup()
self.__wd = '/var/tmp' # working directory
# Construct the series of steps to execute
self.__setup()
# Fill in container instructions
self.__instructions()
def __init__(self, **kwargs):
"""Initialize building block"""
# Trouble getting MRO with kwargs working correctly, so just call
# the parent class constructors manually for now.
#super(gnu, self).__init__(**kwargs)
self.__cc = kwargs.get('cc', True)
self.__cxx = kwargs.get('cxx', True)
self.__fortran = kwargs.get('fortran', True)
self.__compiler_debs = [] # Filled in below
self.__compiler_rpms = [] # Filled in below
self.__runtime_debs = ['libgomp1']
self.__runtime_rpms = ['libgomp']
# Output toolchain
self.toolchain = toolchain()
if self.__cc:
self.__compiler_debs.append('gcc')
self.__compiler_rpms.append('gcc')
self.toolchain.CC = 'gcc'
if self.__cxx:
self.__compiler_debs.append('g++')
self.__compiler_rpms.append('gcc-c++')
self.toolchain.CXX = 'g++'
if self.__fortran:
self.__compiler_debs.append('gfortran')
self.__runtime_debs.append('libgfortran3')
self.__compiler_rpms.append('gcc-gfortran')
self.__runtime_rpms.append('libgfortran')
self.toolchain.F77 = 'gfortran'
self.toolchain.F90 = 'gfortran'
self.toolchain.FC = 'gfortran'
def __init__(self, **kwargs):
"""Initialize building block"""
super(generic_autotools, self).__init__(**kwargs)
self.__branch = kwargs.get('branch', None)
self.__build_directory = kwargs.get('build_directory', None)
self.__check = kwargs.get('check', False)
self.__commit = kwargs.get('commit', None)
self.configure_opts = kwargs.get('configure_opts', [])
self.__directory = kwargs.get('directory', None)
self.__environment = kwargs.get('environment', {})
self.__install = kwargs.get('install', True)
self.__make = kwargs.get('make', True)
self.__postinstall = kwargs.get('postinstall', [])
self.__preconfigure = kwargs.get('preconfigure', [])
self.__repository = kwargs.get('repository', None)
self.__toolchain = kwargs.get('toolchain', toolchain())
self.__url = kwargs.get('url', None)
self.__commands = [] # Filled in by __setup()
self.__wd = '/var/tmp' # working directory
if not self.__repository and not self.__url:
raise RuntimeError('must specify a repository or a URL')
if self.__repository and self.__url:
raise RuntimeError('cannot specify both a repository and a URL')
if self.__branch and self.__commit:
raise RuntimeError('cannot specify both a branch and a commit')
# Construct the series of steps to execute
self.__setup()
# Fill in container instructions
self.__instructions()
def __init__(self, **kwargs):
"""Initialize building block"""
super(openblas, self).__init__(**kwargs)
self.__baseurl = kwargs.pop('baseurl', 'https://github.com/xianyi/OpenBLAS/archive')
self.__make_opts = kwargs.pop('make_opts',
[]) # Filled in by __cpu_arch()
self.__ospackages = kwargs.pop('ospackages', ['make', 'perl', 'tar',
'wget'])
self.__prefix = kwargs.pop('prefix', '/usr/local/openblas')
self.__toolchain = kwargs.pop('toolchain', toolchain())
self.__version = kwargs.pop('version', '0.3.7')
# Set the make options
self.__make()
# Setup the environment variables
if not self.ldconfig:
self.environment_variables['LD_LIBRARY_PATH'] = '{}:$LD_LIBRARY_PATH'.format(posixpath.join(self.__prefix, 'lib'))
# Setup build configuration
self.__bb = generic_build(
build=['make {}'.format(' '.join(self.__make_opts))],
comment=False,
directory='OpenBLAS-{}'.format(self.__version),
devel_environment=self.environment_variables,
install=['make install PREFIX={}'.format(self.__prefix)],
prefix=self.__prefix,
runtime_environment=self.environment_variables,
url='{0}/v{1}.tar.gz'.format(self.__baseurl, self.__version),
**kwargs)
# Container instructions
self += comment('OpenBLAS version {}'.format(self.__version))
self += packages(ospackages=self.__ospackages)
self += self.__bb
def __init__(self, **kwargs):
"""Initialize building block"""
# Trouble getting MRO with kwargs working correctly, so just call
# the parent class constructors manually for now.
#super(xpmem, self).__init__(**kwargs)
ConfigureMake.__init__(self, **kwargs)
git.__init__(self, **kwargs)
tar.__init__(self, **kwargs)
rm.__init__(self, **kwargs)
self.configure_opts = kwargs.get('configure_opts',
['--disable-kernel-module'])
self.prefix = kwargs.get('prefix', '/usr/local/xpmem')
self.__branch = kwargs.get('branch', 'master')
self.__ospackages = kwargs.get('ospackages', [
'autoconf', 'automake', 'ca-certificates', 'file', 'git',
'libtool', 'make'
])
self.__repository = kwargs.get('repository',
'https://gitlab.com/hjelmn/xpmem.git')
self.__toolchain = kwargs.get('toolchain', toolchain())
self.__commands = [] # Filled in by __setup()
self.__environment_variables = {
'CPATH':
'{}:$CPATH'.format(os.path.join(self.prefix, 'include')),
'LD_LIBRARY_PATH':
'{}:$LD_LIBRARY_PATH'.format(os.path.join(self.prefix, 'lib')),
'LIBRARY_PATH':
'{}:$LIBRARY_PATH'.format(os.path.join(self.prefix, 'lib'))
}
self.__wd = '/var/tmp' # working directory
# Construct the series of steps to execute
self.__setup()
def __init__(self, **kwargs):
"""Initialize building block"""
super(ucx, self).__init__(**kwargs)
self.configure_opts = kwargs.get('configure_opts',
['--enable-optimizations',
'--disable-logging',
'--disable-debug',
'--disable-assertions',
'--disable-params-check',
'--disable-doxygen-doc'])
self.prefix = kwargs.get('prefix', '/usr/local/ucx')
self.__baseurl = kwargs.get('baseurl', 'https://github.com/openucx/ucx/releases/download')
self.__cuda = kwargs.get('cuda', True)
self.__gdrcopy = kwargs.get('gdrcopy', '')
self.__knem = kwargs.get('knem', '')
self.__ofed = kwargs.get('ofed', '')
self.__ospackages = kwargs.get('ospackages', [])
self.__runtime_ospackages = [] # Filled in by __distro()
self.__toolchain = kwargs.get('toolchain', toolchain())
self.__version = kwargs.get('version', '1.5.2')
self.__xpmem = kwargs.get('xpmem', '')
self.__commands = [] # Filled in by __setup()
self.__wd = '/var/tmp' # working directory
# Set the Linux distribution specific parameters
self.__distro()
# Construct the series of steps to execute
self.__setup()
# Fill in container instructions
self.__instructions()
def __init__(self, **kwargs):
"""Initialize building block"""
super(nvhpc, self).__init__(**kwargs)
self.__arch_directory = None # Filled in __cpu_arch()
self.__cuda_home = kwargs.get('cuda_home', False)
self.__cuda_multi = kwargs.get('cuda_multi', True)
self.__cuda_version = kwargs.get('cuda', None)
self.__commands = [] # Filled in by __setup()
# By setting this value to True, you agree to the NVIDIA HPC
# SDK End-User License Agreement
# (https://docs.nvidia.com/hpc-sdk/eula)
self.__eula = kwargs.get('eula', False)
self.__extended_environment = kwargs.get('extended_environment', False)
self.__hpcx = kwargs.get('_hpcx', False)
self.__mpi = kwargs.get('mpi', True)
self.__ospackages = kwargs.get('ospackages', [])
self.__runtime_ospackages = [] # Filled in by __distro()
self.__prefix = kwargs.get('prefix', '/opt/nvidia/hpc_sdk')
self.__redist = kwargs.get('redist', [])
self.__stdpar_cudacc = kwargs.get('stdpar_cudacc', None)
self.__url = kwargs.get('url', None)
self.__version = kwargs.get('version', '21.9')
self.__wd = kwargs.get('wd', hpccm.config.g_wd) # working directory
self.__year = '' # Filled in by __version()
self.toolchain = toolchain(CC='nvc', CXX='nvc++', F77='nvfortran',
F90='nvfortran', FC='nvfortran')
if StrictVersion(self.__version) >= StrictVersion('21.7'):
self.__cuda_version_default = '11.4'
elif StrictVersion(self.__version) >= StrictVersion('21.5'):
self.__cuda_version_default = '11.3'
elif StrictVersion(self.__version) >= StrictVersion('21.2'):
self.__cuda_version_default = '11.2'
elif StrictVersion(self.__version) >= StrictVersion('20.11'):
self.__cuda_version_default = '11.1'
else:
self.__cuda_version_default = '11.0'
# Set the CPU architecture specific parameters
self.__cpu_arch()
# Set the Linux distribution specific parameters
self.__distro()
# Figure out the version information
self.__get_version()
# Set paths used extensively
self.__basepath = posixpath.join(self.__prefix, self.__arch_directory,
self.__version)
# Construct the series of steps to execute
self.__setup()
# Fill in container instructions
self.__instructions()
def __init__(self, **kwargs):
"""Initialize building block"""
super(pnetcdf, self).__init__(**kwargs)
self.__baseurl = kwargs.get(
'baseurl', 'https://parallel-netcdf.github.io/Release')
self.__configure_opts = kwargs.pop('configure_opts',
['--enable-shared'])
self.__ospackages = kwargs.pop(
'ospackages', ['file', 'm4', 'make', 'perl', 'tar', 'wget'])
self.__prefix = kwargs.pop('prefix', '/usr/local/pnetcdf')
self.__runtime_ospackages = [] # Filled in by __distro()
self.__toolchain = kwargs.pop(
'toolchain',
toolchain(CC='mpicc',
CXX='mpicxx',
F77='mpif77',
F90='mpif90',
FC='mpifort'))
self.__url = None # Filled in by __download()
self.__version = kwargs.get('version', '1.12.1')
# Set the Linux distribution specific parameters
self.__distro()
# Set the download specific parameters
self.__download()
# Set the environment variables
self.environment_variables['CPATH'] = '{}:$CPATH'.format(
posixpath.join(self.__prefix, 'include'))
self.environment_variables['LIBRARY_PATH'] = '{}:$LIBRARY_PATH'.format(
posixpath.join(self.__prefix, 'lib'))
self.environment_variables['PATH'] = '{}:$PATH'.format(
posixpath.join(self.__prefix, 'bin'))
if not self.ldconfig:
self.environment_variables[
'LD_LIBRARY_PATH'] = '{}:$LD_LIBRARY_PATH'.format(
posixpath.join(self.__prefix, 'lib'))
# Setup build configuration
self.__bb = generic_autotools(
annotations={'version': self.__version},
base_annotation=self.__class__.__name__,
comment=False,
configure_opts=self.__configure_opts,
devel_environment=self.environment_variables,
# For some compilers, --enable-shared leads to the following error:
# GEN libpnetcdf.la
# /usr/bin/ld: .libs/libpnetcdf.lax/libf77.a/strerrnof.o: relocation R_X86_64_32 against `.data' can not be used when making a shared object; recompile with -fPIC
# .libs/libpnetcdf.lax/libf77.a/strerrnof.o: error adding symbols: Bad value
# Apply the workaround
postconfigure=[
'sed -i -e \'s#pic_flag=""#pic_flag=" -fpic -DPIC"#\' -e \'s#wl=""#wl="-Wl,"#\' libtool'
] if '--enable-shared' in self.__configure_opts else None,
prefix=self.__prefix,
runtime_environment=self.environment_variables,
toolchain=self.__toolchain,
url=self.__url,
**kwargs)
# Container instructions
self += comment('PnetCDF version {}'.format(self.__version))
self += packages(ospackages=self.__ospackages)
self += self.__bb
def __init__(self, **kwargs):
"""Initialize building block"""
super(openmpi, self).__init__(**kwargs)
self.__baseurl = kwargs.pop('baseurl',
'https://www.open-mpi.org/software/ompi')
self.__configure_opts = kwargs.pop('configure_opts',
['--disable-getpwuid',
'--enable-orterun-prefix-by-default'])
self.__cuda = kwargs.pop('cuda', True)
self.__default_repository = 'https://github.com/open-mpi/ompi.git'
self.__infiniband = kwargs.pop('infiniband', True)
self.__ospackages = kwargs.pop('ospackages', [])
self.__pmi = kwargs.pop('pmi', False)
self.__pmix = kwargs.pop('pmix', False)
self.__prefix = kwargs.pop('prefix', '/usr/local/openmpi')
self.__recursive = kwargs.pop('recursive', True)
self.__runtime_ospackages = [] # Filled in by __distro()
# Input toolchain, i.e., what to use when building
# Create a copy of the toolchain so that it can be modified
# without impacting the original
self.__toolchain = _copy(kwargs.pop('toolchain', toolchain()))
self.__version = kwargs.pop('version', '4.0.5')
self.__ucx = kwargs.pop('ucx', False)
# Output toolchain
self.toolchain = toolchain(CC='mpicc', CXX='mpicxx', F77='mpif77',
F90='mpif90', FC='mpifort')
# Set the configure options
self.__configure()
# Set the Linux distribution specific parameters
self.__distro()
# Set the download specific parameters
self.__download()
kwargs['repository'] = self.repository
kwargs['url'] = self.url
# Setup the environment variables
self.environment_variables['PATH'] = '{}:$PATH'.format(
posixpath.join(self.__prefix, 'bin'))
if not self.ldconfig:
self.environment_variables['LD_LIBRARY_PATH'] = '{}:$LD_LIBRARY_PATH'.format(posixpath.join(self.__prefix, 'lib'))
# Setup build configuration
self.__bb = generic_autotools(
annotations={'version': self.__version} if not self.repository else {},
base_annotation=self.__class__.__name__,
comment=False,
configure_opts=self.__configure_opts,
devel_environment=self.environment_variables,
preconfigure=['./autogen.pl'] if self.repository else None,
prefix=self.__prefix,
recursive=self.__recursive,
runtime_environment=self.environment_variables,
toolchain=self.__toolchain,
**kwargs)
# Container instructions
if self.repository:
if self.branch:
self += comment('OpenMPI {} {}'.format(self.repository,
self.branch))
elif self.commit:
self += comment('OpenMPI {} {}'.format(self.repository,
self.commit))
else:
self += comment('OpenMPI {}'.format(self.repository))
else:
self += comment('OpenMPI version {}'.format(self.__version))
self += packages(ospackages=self.__ospackages)
self += self.__bb
def __init__(self, **kwargs):
"""Initialize building block"""
super(mpich, self).__init__(**kwargs)
self.__baseurl = kwargs.pop('baseurl',
'https://www.mpich.org/static/downloads')
self.__check = kwargs.pop('check', False)
self.__configure_opts = kwargs.pop('configure_opts', [])
self.__ospackages = kwargs.pop('ospackages', [])
self.__prefix = kwargs.pop('prefix', '/usr/local/mpich')
self.__runtime_ospackages = [] # Filled in by __distro()
# Input toolchain, i.e., what to use when building
self.__toolchain = kwargs.pop('toolchain', toolchain())
self.__version = kwargs.pop('version', '3.3.2')
# Output toolchain
self.toolchain = toolchain(CC='mpicc',
CXX='mpicxx',
F77='mpif77',
F90='mpif90',
FC='mpifort')
# Set the configuration options
self.__configure()
# Set the Linux distribution specific parameters
self.__distro()
# Set the environment variables
self.environment_variables['PATH'] = '{}:$PATH'.format(
posixpath.join(self.__prefix, 'bin'))
if not self.ldconfig:
self.environment_variables[
'LD_LIBRARY_PATH'] = '{}:$LD_LIBRARY_PATH'.format(
posixpath.join(self.__prefix, 'lib'))
# Setup build configuration
self.__bb = generic_autotools(
annotations={'version': self.__version},
base_annotation=self.__class__.__name__,
check=self.__check,
comment=False,
configure_opts=self.__configure_opts,
devel_environment=self.environment_variables,
# Run test suite (must be after install)
postinstall=[
'cd {0}/mpich-{1}'.format(hpccm.config.g_wd, self.__version),
'RUNTESTS_SHOWPROGRESS=1 make testing'
] if self.__check else None,
prefix=self.__prefix,
runtime_environment=self.environment_variables,
toolchain=self.__toolchain,
url='{0}/{1}/mpich-{1}.tar.gz'.format(self.__baseurl,
self.__version),
**kwargs)
# Container instructions
self += comment('MPICH version {}'.format(self.__version))
self += packages(ospackages=self.__ospackages)
self += self.__bb
