• Quick recipes
  • Unix
  • macOS
  • Windows
• Basic explanation and dependencies
• Compilation targets
• Compilation options
• Portability

In the following we provide short recipes which may work out of the box on most systems. They allow one to compile sequential (standard), MPI (for distributed-memory clusters) and OpenCL (for GPU acceleration) versions of ADDA. If these recipes do not work or you want to understand all available compilation modes and options, scroll below. Before executing the recipes, download the ADDA package (source) and position yourself in its src/ directory. For instance, this may be accomplished by (if you have git installed):

git clone https://github.com/adda-team/adda.git
cd adda/src

Each recipe consists of three parts. First two lines compile sequential ADDA, while the remaining lines are optional (for MPI and OCL parts). After the recipe is finished, compiled executables are src/seq/adda, src/mpi/adda_mpi, and src/ocl/adda_ocl, respectively. You can also combine all package installations into one command, and all ADDA compilations - into a single make all.

The following is based on apt, the default package manager for Ubuntu. You can, naturally, use apt-get instead, while many other package manager on any Unix system will require only minor modifications of the package names.

sudo apt install gcc gfortran libfftw3-dev
make seq
sudo apt install libopenmpi-dev
make mpi
sudo apt install ocl-icd-opencl-dev libclfft-dev
make ocl

The following is based on Homebrew, a popular package manager for macOS. But other managers may work similarly.

brew install gcc fftw 
export CPATH=`xcrun --show-sdk-path`/usr/include
export LDFLAGS=-L`xcrun --show-sdk-path`/usr/lib
make seq OPTIONS=HOMEBREW CC=gcc-11
brew install open-mpi
make mpi OPTIONS=HOMEBREW CC=gcc-11
brew install clfft
make ocl OPTIONS=HOMEBREW CC=gcc-11

The above commands use the GCC compiler instead of the default Clang for C and C++ sources. This is required for automatic linking of standard Fortran libraries (used by GFortran included in the latest gcc package), but may slightly decrease runtime performance and require changes with each major gcc update. Alternatively, replace CC=gcc-11 by

• FORT_LIB_PATH=/opt/homebrew/Cellar/gcc/11.2.0/lib/gcc/11 (requires changes with each minor gcc update)
• or FORT_LIB_PATH=/usr/local/gfortran/lib (requires installing gfortran with standalone installer)

Compiling ADDA on Windows is harder, thus we recommend to use precompiled executables for 64-bit Windows.

If you still want to compile ADDA yourself, we provide detailed instructions for that using MinGW-w64 environment. Alternatively, you can use:

• MSYS2. It is simpler to install and use than MinGW-w64, but has some limitations (see our experience with it).
• Windows Subsystem for Linux (WSL). Then you will have Ubuntu inside Windows - just follow the instructions above. Importantly, if you obtain the source by git clone, this should be done inside the WSL. And the compiled binaries can be executed only inside the WSL. OpenCL support inside the WSL is also limited - try it at your own risk.

ADDA can be compiled on any system with GNU make (version 3.81 or higher) and C, Fortran, and C++ compilers installed. Core parts of ADDA are written in C, while Fortran and C++ are used for relatively small parts that are not always required (see below). make command should be run in the src/ directory of the ADDA repository (package) - possible targets are listed below.

The Makefile is designed to work out of the box on many systems using GNU compilers (intercompatible versions of gcc and gfortran are required). However, FFTW3 package need to be installed on your system. Moreover, MPI version of ADDA requires installed MPI implementation. Using the latter, ADDA can run both on multiprocessor systems (clusters) and on multicore processors of a single PC, as well as on heterogeneous hardware.

The OpenCL version of ADDA is designed to use graphic cards (GPUs) to accelerate computations. It requires OpenCL environment and clFFT library (alternatively, slower built-in OpenCL FFT routines can be used). The future goal is to make OpenCL version capable of running on other compatible hardware, including hybrid CPU-GPUs and Cell processors.

As mentioned above, the dependencies can usually be installed with a few command lines on Unix and macOS systems. In case of problems or Windows, see the separate wiki pages. Finally, we recommend to compile and run ADDA on a 64-bit operating system to avoid any limitations on memory usage.

Full list of possible targets (arguments to make) is the following:

The details of compilation are controlled by a number of options (described in a table below), which can be specified by three different methods. First, one may change or uncomment the corresponding lines in the Makefile, starting with name = ... or override name += , where name is the option name. These lines are accompanied by a lot of descriptive comments. Second, these options may be set as environmental variables before executing make. Third, they may be given as additional command line parameters when invoking make, for example

make COMPILER=intel OPTIONS="DEBUG FFT_TEMPERTON" ...

Note that multi-word value of OPTIONS need to be enclosed in quotes.

Although Makefile contain options for several compilers, described above, the new releases are usually tested only with GNU compilers. So the options for other compilers may be outdated. If you modify these options to successfully compile the current version of ADDA, please communicate these modifications to the discussion group, so they can be incorporated in future releases.

To use COMPILER=other one should manually add definitions of corresponding compiler flags to the Makefile, according to the pattern used for predefined compilers, after the line

ifeq ($(COMPILER),other)

If you do so, please write to the discussion group, so this compiler can be incorporated in future releases. Please also write to this group if you use one of the supported compilers with OPTIONS=DEBUG and obtain any warnings.

If compilation of MPI version does not work out-of-box, you may need to modify mpi/Makefile. This may include specifying a particular compiler wrapper (setting variable MPICC) and paths to compiler headers and libraries. For the latter uncomment and adjust lines starting with CFLAGS += -I and LFLAGS += -L accordingly. Please see comments in the file for more details.

If compilation of OpenCL version does not work out-of-box, you may need to modify ocl/Makefile to explicitly specify paths to headers and libraries. For this uncomment and adjust lines starting with CFLAGS += -I and LFLAGS += -L accordingly. Please see comments in the file for more details.

When asked to repeat compilation, make automatically determines, which source files need to be recompiled. Apart from changes in the source files themselves the logic of makefiles also considers the differences in compilation options between current and previous compilation. Thus, it is not necessary to perform any cleaning between the compilations with different options.

ADDA is intended to be portable to as wide range of platforms as possible. There are only two operating-system-dependent aspects of ADDA: precise timing and file locking. Both are optional (controlled by compilation flags, see above) and should be functional on any Windows or POSIX-compliant (Unix, macOS) operating system.

If all of the above doesn't work, one may compile all source files (with maximum possible optimizations) and link them into an executable. In that case adjusting some of compilation options is possible by uncommenting defines in corresponding header files (see comments in the Makefile).