Skip to content
CP2K_Build_README.txt 7.89 KiB
Newer Older
Valeriu Codreanu's avatar
Valeriu Codreanu committed
Build instructions for CP2K.
Valeriu Codreanu's avatar
Valeriu Codreanu committed

===== 1. Get the code =====

Download a CP2K release from or follow instructions at to check out the relevant branch of the CP2K SVN repository. These
build instructions and the accompanying benchmark run instructions have been tested with release

===== 2. Prerequisites & Libraries =====

GNU make and Python 2.x are required for the build process, as are a Fortran 2003 compiler and
matching C compiler, e.g. gcc/gfortran (gcc >=4.6 works, later version is recommended).

CP2K can benefit from a number of external libraries for improved performance. It is advised to use
vendor-optimized versions of these libraries. If these are not available on your machine, there
exist freely available implementations of these libraries including but not limited to those listed


The minimum set of libraries required to build a CP2K executable that will run the UEABS benchmarks

1. LAPACK & BLAS, as provided by, for example:
	netlib 		   : &
	MKL	           : part of your Intel MKL installation, if available
	LibSci    	   : installed on Cray platforms
	ATLAS              :
	OpenBLAS	   :
	clBLAS		   :

2. SCALAPACK & BLACS, as provided by, for example:
	netlib		   :
	MKL		   : part of your Intel MKL installation, if available
	LibSci        	   : installed on Cray platforms	
3. LIBINT, available from
   (see build instructions in section 2.1 below)


The following libraries are optional but give a significant performance benefit:

4. FFTW3, available from or provided as an interface by MKL
5. ELPA, available from
6. libgrid, available from inside the distribution at cp2k/tools/autotune_grid
7. libxsmm, available from

More information can be found in the INSTALL file in the CP2K distribution.

2.1 Building LIBINT

The following commands will uncompress and install the LIBINT library required for the UEABS

  tar xzf libint-1.1.4
  cd libint-1.1.4
  ./configure CC=cc CXX=CC --prefix=some_path_other_than_this_directory
  make install
The environment variables CC and CXX are optional and can be used to specify the C and C++ compilers
to use for the build (the example above is configured to use the compiler wrappers cc and CC used on
Cray systems). By default the build process only creates static libraries (ending in .a). If you
want to be able to link dynamically to LIBINT when building CP2K you can pass the flag
--enable-shared to ./configure in order to produce shared libraries (ending in .so). In that case
you will need to ensure that the library is located in place that is accessible at runtime and that
the LD_LIBRARY_PATH environment variable includes the LIBINT installation directory.

For more build options see ./configure --help.

===== 3. Building CP2K =====

If you have downloaded a tarball of the release, uncompress the file by running

   tar xf cp2k-4.1.tar.bz2.

If necessary you can find additional information about building CP2K in the INSTALL file located in
the root directory of the CP2K distribution.

==== 3.1 Create or choose an arch file ====

Before compiling the choice of compilers, the library locations and compilation and linker flags
need to be specified. This is done in an arch (architecture) file. Example arch files for a number
of common architecture examples can be found inside cp2k/arch. The names of these files match the
pattern architecture.version (e.g., Linux-x86-64-gfortran.sopt). The case "version=psmp" corresponds
to the hybrid MPI + OpenMP version that you should build to run the UEABS benchmarks.

In most cases you need to create a custom arch file, either from scratch or by modifying an existing
one that roughly fits the cpu type, compiler, and installation paths of libraries on your
system. You can also consult, which provides sample arch files as part of
the testing reports for some platforms (click on the status field for a platform, and search for
'ARCH-file' in the resulting output).

As a guided example, the following should be included in your arch file if you are compiling with
GNU compilers:

(a) Specification of which compiler and linker commands to use:

    		  CC = gcc
		  FC = mpif90
		  LD = mpif90

    CP2K is primarily a Fortran code, so only the Fortran compiler needs to be MPI-enabled.

(b) Specification of the DFLAGS variable, which should include:
	-D__parallel (to build parallel CP2K executable)
	-D__SCALAPACK (to link to ScaLAPACK)
	-D__LIBINT (to link to LIBINT)
	-D__MKL (if relying on MKL to provide ScaLAPACK and/or an FFTW interface)
	-D__HAS_NO_SHARED_GLIBC (for convenience on HPC systems, see INSTALL file)

    Additional DFLAGS needed to link to performance libraries, such as -D__FFTW3 to link to FFTW3,
    are listed in the INSTALL file. 

(c) Specification of compiler flags:

    		  Required (for gfortran):
	       	    FCFLAGS = $(DFLAGS) -ffree-form -fopenmp

		  Recommended additional flags (for gfortran):
	      	    FCFLAGS += -O3 -ffast-math -funroll-loops
    If you want to link any libraries containing header files you should pass the path to the
    directory containing these to FCFLAGS in the format -I/path_to_include_dir.

(d) Specification of linker flags:

    		  LDFLAGS = $(FCFLAGS)

(e) Specification of libraries to link to:

    		  Required (LIBINT):
		    -L/home/z01/z01/UEABS/CP2K/libint/1.1.4/lib -lderiv -lint

    If you use MKL to provide ScaLAPACK and/or an FFTW interface the LIBS variable should be used
    to pass the relevant flags provided by the MKL Link Line Advisor (,
    which you should use carefully in order to generate the right options for your system.

(f) AR = ar -r

As an example, a simple arch file is shown below for ARCHER (, a Cray system
that uses compiler wrappers cc and ftn to compile C and Fortran code respectively, and which has
LIBINT installed in /home/z01/z01/user/cp2k/libs/libint/1.1.4. On Cray systems the compiler wrappers
automatically link in Cray's LibSci library which provides ScaLAPACK, hence there is no need for
explicit specification of the library location and library names in LIBS or relevant include paths
in FCFLAGS. This would not be the case if MKL was used instead.

# Ensure the following environment modules are loaded before starting the build:
# PrgEnv-gnu
# cray-libsci

CC       = cc
CPP      =
FC       = ftn
LD       = ftn
Valeriu Codreanu's avatar
Valeriu Codreanu committed
AR       = ar -r
Valeriu Codreanu's avatar
Valeriu Codreanu committed

DFLAGS   = -D__parallel \
           -D__SCALAPACK \
           -D__LIBINT \


FCFLAGS  = $(DFLAGS) -ffree-form -fopenmp

FCFLAGS  += -O3 -ffast-math -funroll-loops


LIBS     = -L/home/z01/z01/user/cp2k/libint/1.1.4/lib -lderiv -lint


==== 3.2 Compile ===

Change directory to cp2k-4.1/makefiles

There is no configure stage. If the arch file for your machine is called
SomeArchitecture_SomeCompiler.psmp, then issue the following command to compile:

	  make ARCH=SomeArchitecture_SomeCompiler VERSION=psmp

or, if you are able to run in parallel with N threads:

       	  make -j N ARCH=SomeArchitecture_SomeCompiler VERSION=psmp

There is also no "make install" stage. If everything goes fine, you'll find the executable cp2k.psmp
in the directory cp2k-4.1/exe/SomeArchitecture_SomeCompiler