comp-chem/cp2k
1
0
Fork 0
mirror of https://github.com/cp2k/cp2k.git synced 2026-07-28 06:05:29 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Toolchain: Remove reflapack

Browse source
This commit is contained in:
Ole Schütt 2021-05-21 20:19:31 +02:00 • committed by Ole Schütt
parent 849fc254a9
commit 907ab74f82
14 changed files with 39 additions and 231 deletions
Download patch file Download diff file Expand all files Collapse all files

2
arch/Linux-x86-64-gfortran.dumpast
View file

@ -12,7 +12,7 @@ DFLAGS =
FCFLAGS = -O0 -fstrict-aliasing -fbacktrace -g -fbounds-check -ffree-form -fdump-fortran-original -fopenmp $(DFLAGS)
CFLAGS = -fopenmp $(DFLAGS)
LDFLAGS = $(FCFLAGS)
LIBS = -llapack -lblas
LIBS = -lopenblas
FCLOGPIPE = > $(notdir $<).ast

2
arch/minimal.sdbg
View file

@ -9,4 +9,4 @@ LD = gfortran
CFLAGS = -fopenmp
FCFLAGS = -fopenmp -ffree-form
LDFLAGS = -fopenmp
LIBS = -llapack -lblas
LIBS = -lopenblas

16
arch/test_tsan.sdbg
View file

@ -1,16 +0,0 @@
#
# gfortran arch file, currently for testing tsan http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59286
#
# needs tsan instrumented lib gomp (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=55561#c15)
#
CC = cc
FC = gfortran
LD = gfortran
AR = ar -r
DFLAGS = -D__LIBINT
FCFLAGS = -gdwarf-3 -fPIE -pie -fsanitize=thread -fno-omit-frame-pointer -O0 -march=native -ffree-form $(DFLAGS) -I$(LIBINT_INCLUDE)
LDFLAGS = $(FCFLAGS) -L/data/vjoost/libint/sanitize/install/lib/
LIBS = -llapack -lblas -lint2 -lstdc++

1
tools/toolchain/Dockerfile.cuda_mkl
View file

@ -37,7 +37,6 @@ COPY ./install_cp2k_toolchain.sh .
RUN ./install_cp2k_toolchain.sh \
--mpi-mode=mpich \
--math-mode=mkl \
--with-reflapack=no \
--with-scalapack=no \
--libint-lmax=${LIBINT_LMAX} \
--gpu-ver=${GPU_VERSION} \

2
tools/toolchain/Dockerfile.ubuntu_nompi
View file

@ -21,7 +21,6 @@ RUN export DEBIAN_FRONTEND=noninteractive DEBCONF_NONINTERACTIVE_SEEN=true && \
gfortran-${GCC_VERSION} \
fftw3-dev \
libopenblas-dev \
liblapack-dev \
libgsl-dev \
libhdf5-dev \
&& rm -rf /var/lib/apt/lists/*
@ -41,7 +40,6 @@ RUN ./install_cp2k_toolchain.sh \
--with-cmake=system \
--with-fftw=system \
--with-openblas=system \
--with-reflapack=system \
--with-gsl=system \
--with-hdf5=system \
--with-libxc=install \

62
tools/toolchain/install_cp2k_toolchain.sh
View file

@ -93,16 +93,13 @@ OPTIONS:
options to values other than no will also switch --mpi-mode
to the respective mode.
--math-mode Selects which core math library to use. Available options
are: acml, cray, mkl, openblas and reflapack. cray
are: acml, cray, mkl, and openblas. cray
corresponds to cray libsci, and is the default for CRAY
(CLE) systems. For non-CRAY systems, if env variable MKLROOT
exists then mkl will be default, otherwise openblas is the
default option. Note that reflapack corresponds to the
reference LAPACK library, and is not really recommended for
CP2K binaries used for real simulations. Explicitly setting
default option. Explicitly setting
--with-acml, --with-mkl or --with-openblas options will
switch --math-mode to the respective modes, BUT
--with-reflapack option do not have this effect.
switch --math-mode to the respective modes.
--gpu-ver Selects the GPU architecture for which to compile. Available
options are: K20X, K40, K80, P100, V100, no. Default: no.
The script will determine the correct corresponding value for
@ -118,10 +115,6 @@ The --enable-FEATURE options follow the rules:
--enable-FEATURE The option keyword alone is equivalent to
--enable-FEATURE=yes
--enable-tsan If you are installing GCC using this script
this option enables thread sanitizer support.
This is only relevant for debugging purposes.
Default = no
--enable-gcc-master If you are installing GCC using this script
this option forces the master development version
to be installed.
@ -171,11 +164,6 @@ The --with-PKG options follow the rules:
Default = install
--with-fftw FFTW3, library for fast fourier transform
Default = install
--with-reflapack Reference (vanilla) LAPACK and BLAS linear algebra libraries.
One should use only ONE linear algebra library. This
one is really mostly used for debugging purposes as it is
non-optimised.
Default = no
--with-acml AMD core maths library, which provides LAPACK and BLAS
Default = system
--with-mkl Intel Math Kernel Library, which provides LAPACK, and BLAS.
@ -266,7 +254,7 @@ EOF
# ------------------------------------------------------------------------
tool_list="gcc cmake"
mpi_list="mpich openmpi intelmpi"
math_list="mkl acml openblas reflapack"
math_list="mkl acml openblas"
lib_list="fftw libint libxc libsmm libxsmm cosma scalapack elpa plumed \
spfft spla ptscotch superlu pexsi quip gsl spglib hdf5 libvdwxc sirius
libvori"
@ -291,19 +279,18 @@ with_libint=__INSTALL__
with_libxsmm=__INSTALL__
with_libxc=__INSTALL__
with_scalapack=__INSTALL__
# default math library settings, FAST_MATH_MODE picks the math library
# default math library settings, MATH_MODE picks the math library
# to use, and with_* defines the default method of installation if it
# is picked. For non-CRAY systems defaults to mkl if $MKLROOT is
# available, otherwise defaults to openblas
if [ "$MKLROOT" ]; then
export FAST_MATH_MODE=mkl
export MATH_MODE=mkl
else
export FAST_MATH_MODE=openblas
export MATH_MODE=openblas
fi
with_acml=__SYSTEM__
with_mkl=__SYSTEM__
with_openblas=__INSTALL__
with_reflapack=__DONTUSE__
# sirius is activated by default
with_sirius="__INSTALL__"
@ -362,7 +349,7 @@ export LIBINT_LMAX=5
# defaults for CRAY Linux Environment
if [ "$CRAY_LD_LIBRARY_PATH" ]; then
enable_cray=__TRUE__
export FAST_MATH_MODE=cray
export MATH_MODE=cray
# Default MPI used by CLE is assumed to be MPICH, in any case
# don't use the installers for the MPI libraries
with_mpich="__DONTUSE__"
@ -423,23 +410,20 @@ while [ $# -ge 1 ]; do
user_input="${1#*=}"
case "$user_input" in
cray)
export FAST_MATH_MODE=cray
export MATH_MODE=cray
;;
mkl)
export FAST_MATH_MODE=mkl
export MATH_MODE=mkl
;;
acml)
export FAST_MATH_MODE=acml
export MATH_MODE=acml
;;
openblas)
export FAST_MATH_MODE=openblas
;;
reflapack)
export FAST_MATH_MODE=reflapack
export MATH_MODE=openblas
;;
*)
report_error ${LINENO} \
"--math-mode currently only supports mkl, acml, openblas and reflapack as options"
"--math-mode currently only supports mkl, acml, and openblas as options"
;;
esac
;;
@ -547,25 +531,22 @@ while [ $# -ge 1 ]; do
--with-fftw*)
with_fftw=$(read_with $1)
;;
--with-reflapack*)
with_reflapack=$(read_with $1)
;;
--with-mkl*)
with_mkl=$(read_with $1)
if [ $with_mkl != __DONTUSE__ ]; then
export FAST_MATH_MODE=mkl
export MATH_MODE=mkl
fi
;;
--with-acml*)
with_acml=$(read_with $1)
if [ $with_acml != __DONTUSE__ ]; then
export FAST_MATH_MODE=acml
export MATH_MODE=acml
fi
;;
--with-openblas*)
with_openblas=$(read_with $1)
if [ $with_openblas != __DONTUSE__ ]; then
export FAST_MATH_MODE=openblas
export MATH_MODE=openblas
fi
;;
--with-scalapack*)
@ -649,17 +630,6 @@ export ENABLE_CRAY=$enable_cray
# Check and solve known conflicts before installations proceed
# ------------------------------------------------------------------------
# GCC thread sanitizer conflicts
if [ $ENABLE_TSAN = "__TRUE__" ]; then
if [ "$with_openblas" != "__DONTUSE__" ]; then
echo "TSAN is enabled, cannot use openblas, we will use reflapack instead"
[ "$with_reflapack" = "__DONTUSE__" ] && with_reflapack="__INSTALL__"
export FAST_MATH_MODE=reflapack
fi
echo "TSAN is enabled, cannot use libsmm"
with_libsmm="__DONTUSE__"
fi
# mpi library conflicts
if [ $MPI_MODE = no ]; then
if [ "$with_scalapack" != "__DONTUSE__" ]; then

3
tools/toolchain/scripts/common_vars.sh
View file

@ -31,11 +31,10 @@ LIB_PATHS=${LIB_PATHS:-'LD_LIBRARY_PATH LIBRARY_PATH LD_RUN_PATH SYS_LIB_PATH'}
# mode flags
ENABLE_OMP=${ENABLE_OMP:-"__TRUE__"}
ENABLE_TSAN=${ENABLE_TSAN:-"__FALSE__"}
ENABLE_CUDA=${ENABLE_CUDA:-"__FALSE__"}
ENABLE_CRAY=${ENABLE_CRAY:-"__FALSE__"}
MPI_MODE=${MPI_MODE:-openmpi}
FAST_MATH_MODE=${FAST_MATH_MODE:-openblas}
MATH_MODE=${MATH_MODE:-openblas}
# compiler flags
export CC=${CC:-gcc}

2
tools/toolchain/scripts/generate_arch_files.sh
View file

@ -36,7 +36,7 @@ FC_arch="IF_MPI(${MPIFC}|${FC})"
LD_arch="IF_MPI(${MPIFC}|${FC})"
# we always want good line information and backtraces
BASEFLAGS="-march=native -mtune=native -fno-omit-frame-pointer -g ${TSANFLAGS}"
BASEFLAGS="-march=native -mtune=native -fno-omit-frame-pointer -g"
OPT_FLAGS="-O3 -funroll-loops"
NOOPT_FLAGS="-O1"

6
tools/toolchain/scripts/stage2/install_acml.sh
View file

@ -60,9 +60,9 @@ EOF
export ACML_CFLAGS="${ACML_CFLAGS}"
export ACML_LDFLAGS="${ACML_LDFLAGS}"
export ACML_LIBS="${ACML_LIBS}"
export FAST_MATH_CFLAGS="\${FAST_MATH_CFLAGS} ${ACML_CFLAGS}"
export FAST_MATH_LDFLAGS="\${FAST_MATH_LDFLAGS} ${ACML_LDFLAGS}"
export FAST_MATH_LIBS="\${FAST_MATH_LIBS} ${ACML_LIBS}"
export MATH_CFLAGS="\${MATH_CFLAGS} ${ACML_CFLAGS}"
export MATH_LDFLAGS="\${MATH_LDFLAGS} ${ACML_LDFLAGS}"
export MATH_LIBS="\${MATH_LIBS} ${ACML_LIBS}"
EOF
fi

38
tools/toolchain/scripts/stage2/install_mathlibs.sh
View file

@ -15,21 +15,13 @@ source "${SCRIPT_DIR}"/signal_trap.sh
source "${INSTALLDIR}"/toolchain.conf
source "${INSTALLDIR}"/toolchain.env
# math core libraries, need to use reflapack for valgrind builds, as
# many fast libraries are not necessarily valgrind clean
export REF_MATH_CFLAGS=''
export REF_MATH_LDFLAGS=''
export REF_MATH_LIBS=''
export FAST_MATH_CFLAGS=''
export FAST_MATH_LDFLAGS=''
export FAST_MATH_LIBS=''
export MATH_CFLAGS=''
export MATH_LDFLAGS=''
export MATH_LIBS=''
write_toolchain_env "${INSTALLDIR}"
"${SCRIPTDIR}"/stage2/install_reflapack.sh "${with_reflapack}"
load "${BUILDDIR}/setup_reflapack"
case "$FAST_MATH_MODE" in
case "$MATH_MODE" in
mkl)
"${SCRIPTDIR}"/stage2/install_mkl.sh "${with_mkl}"
load "${BUILDDIR}/setup_mkl"
@ -45,26 +37,14 @@ case "$FAST_MATH_MODE" in
cray)
# note the space is intentional so that the variable is
# non-empty and can pass require_env checks
export FAST_MATH_LDFLAGS="${FAST_MATH_LDFLAGS} "
export FAST_MATH_LIBS="${FAST_MATH_LIBS} ${CRAY_EXTRA_LIBS}"
export MATH_LDFLAGS="${MATH_LDFLAGS} "
export MATH_LIBS="${MATH_LIBS} ${CRAY_EXTRA_LIBS}"
;;
esac
if [ "$with_reflapack" = "__DONTUSE__" ]; then
# if we don't build the refereence blas/lapack implementations,
# make sure we still link against a BLAS/LAPACK implementation in *dbg profiles
export REF_MATH_CFLAGS="${FAST_MATH_CFLAGS}"
export REF_MATH_LDFLAGS="${FAST_MATH_LDFLAGS}"
export REF_MATH_LIBS="${FAST_MATH_LIBS}"
fi
export MATH_CFLAGS="${FAST_MATH_CFLAGS}"
export MATH_LDFLAGS="${FAST_MATH_LDFLAGS}"
export MATH_LIBS="${FAST_MATH_LIBS}"
export CP_CFLAGS="${CP_CFLAGS} IF_DEBUG(${REF_MATH_CFLAGS}|IF_VALGRIND(${REF_MATH_CFLAGS}|${FAST_MATH_CFLAGS}))"
export CP_LDFLAGS="${CP_LDFLAGS} IF_DEBUG(${REF_MATH_LDFLAGS}|IF_VALGRIND(${REF_MATH_LDFLAGS}|${FAST_MATH_LDFLAGS}))"
export CP_LIBS="${CP_LIBS} IF_DEBUG(${REF_MATH_LIBS}|IF_VALGRIND(${REF_MATH_LIBS}|${FAST_MATH_LIBS}))"
export CP_CFLAGS="${CP_CFLAGS} ${MATH_CFLAGS}"
export CP_LDFLAGS="${CP_LDFLAGS} ${MATH_LDFLAGS}"
export CP_LIBS="${CP_LIBS} ${MATH_LIBS}"
write_toolchain_env "${INSTALLDIR}"

4
tools/toolchain/scripts/stage2/install_mkl.sh
View file

@ -114,8 +114,8 @@ EOF
cat << EOF >> "${BUILDDIR}/setup_mkl"
export MKL_CFLAGS="${MKL_CFLAGS}"
export MKL_LIBS="${MKL_LIBS}"
export FAST_MATH_CFLAGS="\${FAST_MATH_CFLAGS} ${MKL_CFLAGS}"
export FAST_MATH_LIBS="\${FAST_MATH_LIBS} ${MKL_LIBS}"
export MATH_CFLAGS="\${MATH_CFLAGS} ${MKL_CFLAGS}"
export MATH_LIBS="\${MATH_LIBS} ${MKL_LIBS}"
export CP_DFLAGS="\${CP_DFLAGS} -D__MKL -D__FFTW3 IF_COVERAGE(IF_MPI(|-U__FFTW3)|)"
EOF
if [ -n "${mkl_scalapack_lib}" ]; then

6
tools/toolchain/scripts/stage2/install_openblas.sh
View file

@ -137,9 +137,9 @@ export OPENBLASROOT="${pkg_install_dir}"
export OPENBLAS_CFLAGS="${OPENBLAS_CFLAGS}"
export OPENBLAS_LDFLAGS="${OPENBLAS_LDFLAGS}"
export OPENBLAS_LIBS="${OPENBLAS_LIBS}"
export FAST_MATH_CFLAGS="\${FAST_MATH_CFLAGS} ${OPENBLAS_CFLAGS}"
export FAST_MATH_LDFLAGS="\${FAST_MATH_LDFLAGS} ${OPENBLAS_LDFLAGS}"
export FAST_MATH_LIBS="\${FAST_MATH_LIBS} ${OPENBLAS_LIBS}"
export MATH_CFLAGS="\${MATH_CFLAGS} ${OPENBLAS_CFLAGS}"
export MATH_LDFLAGS="\${MATH_LDFLAGS} ${OPENBLAS_LDFLAGS}"
export MATH_LIBS="\${MATH_LIBS} ${OPENBLAS_LIBS}"
EOF
fi

122
tools/toolchain/scripts/stage2/install_reflapack.sh
View file

@ -1,122 +0,0 @@
#!/bin/bash -e
# TODO: Review and if possible fix shellcheck errors.
# shellcheck disable=SC1003,SC1035,SC1083,SC1090
# shellcheck disable=SC2001,SC2002,SC2005,SC2016,SC2091,SC2034,SC2046,SC2086,SC2089,SC2090
# shellcheck disable=SC2124,SC2129,SC2144,SC2153,SC2154,SC2155,SC2163,SC2164,SC2166
# shellcheck disable=SC2235,SC2237
[ "${BASH_SOURCE[0]}" ] && SCRIPT_NAME="${BASH_SOURCE[0]}" || SCRIPT_NAME=$0
SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_NAME")/.." && pwd -P)"
reflapack_ver="3.9.0"
reflapack_sha256="106087f1bb5f46afdfba7f569d0cbe23dacb9a07cd24733765a0e89dbe1ad573"
source "${SCRIPT_DIR}"/common_vars.sh
source "${SCRIPT_DIR}"/tool_kit.sh
source "${SCRIPT_DIR}"/signal_trap.sh
source "${INSTALLDIR}"/toolchain.conf
source "${INSTALLDIR}"/toolchain.env
[ -f "${BUILDDIR}/setup_reflapack" ] && rm "${BUILDDIR}/setup_reflapack"
REFLAPACK_CFLAGS=''
REFLAPACK_LDFLAGS=''
REFLAPACK_LIBS=''
! [ -d "${BUILDDIR}" ] && mkdir -p "${BUILDDIR}"
cd "${BUILDDIR}"
case "$with_reflapack" in
__INSTALL__)
echo "==================== Installing LAPACK ===================="
pkg_install_dir="${INSTALLDIR}/lapack-${reflapack_ver}"
install_lock_file="$pkg_install_dir/install_successful"
if verify_checksums "${install_lock_file}"; then
echo "lapack-${reflapack_ver} is already installed, skipping it."
else
if [ -f lapack-${reflapack_ver}.tgz ]; then
echo "reflapack-${reflapack_ver}.tgz is found"
else
download_pkg ${DOWNLOADER_FLAGS} ${reflapack_sha256} \
https://www.cp2k.org/static/downloads/lapack-${reflapack_ver}.tgz
fi
echo "Installing from scratch into ${pkg_install_dir}"
[ -d lapack-${reflapack_ver} ] && rm -rf lapack-${reflapack_ver}
tar -xzf lapack-${reflapack_ver}.tgz
cd lapack-${reflapack_ver}
cat << EOF > make.inc
SHELL = /bin/sh
FORTRAN = $FC
OPTS = $FFLAGS -frecursive
DRVOPTS = $FFLAGS -frecursive
NOOPT = $FFLAGS -O0 -frecursive
LOADER = $FC
LOADOPTS = $FFLAGS -Wl,--enable-new-dtags
TIMER = INT_ETIME
CC = $CC
CFLAGS = $CFLAGS
ARCH = ar
ARCHFLAGS= cr
RANLIB = ranlib
XBLASLIB =
BLASLIB = ../../libblas.a
LAPACKLIB = liblapack.a
TMGLIB = libtmglib.a
LAPACKELIB = liblapacke.a
EOF
# lapack/blas build is *not* parallel safe (updates to the archive race)
# Run first in parallel which will result most likely in an incomplete library
make -j $(get_nprocs) lib blaslib > make.log 2>&1
# Complete library in non-parallel mode
make -j 1 lib blaslib > make1.log 2>&1
# no make install, so have to do this manually
! [ -d "${pkg_install_dir}/lib" ] && mkdir -p "${pkg_install_dir}/lib"
cp libblas.a SRC/liblapack.a "${pkg_install_dir}/lib"
cd ..
write_checksums "${install_lock_file}" "${SCRIPT_DIR}/stage2/$(basename ${SCRIPT_NAME})"
fi
REFLAPACK_LDFLAGS="-L'${pkg_install_dir}/lib' -Wl,-rpath='${pkg_install_dir}/lib'"
;;
__SYSTEM__)
echo "==================== Finding LAPACK from system paths ===================="
check_lib -lblas "lapack"
check_lib -llapack "lapack"
add_lib_from_paths REFLAPACK_LDFLAGS "liblapack.*" $LIB_PATHS
;;
__DONTUSE__) ;;
*)
echo "==================== Linking LAPACK to user paths ===================="
pkg_install_dir="$with_reflapack"
check_dir "${pkg_install_dir}/lib"
REFLAPACK_LDFLAGS="-L'${pkg_install_dir}/lib' -Wl,-rpath='${pkg_install_dir}/lib'"
;;
esac
if [ "$with_reflapack" != "__DONTUSE__" ]; then
REFLAPACK_LIBS="-llapack -lblas"
if [ "$with_reflapack" != "__SYSTEM__" ]; then
cat << EOF > "${BUILDDIR}/setup_reflapack"
prepend_path LD_LIBRARY_PATH "$pkg_install_dir/lib"
prepend_path LD_RUN_PATH "$pkg_install_dir/lib"
prepend_path LIBRARY_PATH "$pkg_install_dir/lib"
EOF
cat "${BUILDDIR}/setup_reflapack" >> $SETUPFILE
fi
cat << EOF >> "${BUILDDIR}/setup_reflapack"
export REFLAPACK_LDFLAGS="${REFLAPACK_LDFLAGS}"
export REFLAPACK_LIBS="${REFLAPACK_LIBS}"
export REF_MATH_LDFLAGS="\${REF_MATH_LDFLAGS} ${REFLAPACK_LDFLAGS}"
export REF_MATH_LIBS="\${REF_MATH_LIBS} ${REFLAPACK_LIBS}"
EOF
if [ "$FAST_MATH_MODE" = reflapack ]; then
cat << EOF >> setup_reflapack
export FAST_MATH_LDFLAGS="\${FAST_MATH_LDFLAGS} ${REFLAPACK_LDFLAGS}"
export FAST_MATH_LIBS="\${FAST_MATH_LIBS} ${REFLAPACK_LIBS}"
EOF
fi
fi
load "${BUILDDIR}/setup_reflapack"
write_toolchain_env "${INSTALLDIR}"
cd "${ROOTDIR}"
report_timing "reflapack"

4
tools/toolchain/scripts/stage4/install_cosma.sh
View file

@ -49,7 +49,7 @@ case "$with_cosma" in
cd cosma-${cosma_ver}
mkdir build-cpu
cd build-cpu
case "$FAST_MATH_MODE" in
case "$MATH_MODE" in
mkl)
cmake \
-DCMAKE_INSTALL_PREFIX="${pkg_install_dir}" \
@ -80,7 +80,7 @@ case "$with_cosma" in
[ -d build-cuda ] && rm -rf "build-cuda"
mkdir build-cuda
cd build-cuda
case "$FAST_MATH_MODE" in
case "$MATH_MODE" in
mkl)
cmake \
-DCMAKE_INSTALL_PREFIX="${pkg_install_dir}" \