9 Introduction to building |Gromacs|
10 ==================================
12 These instructions pertain to building |Gromacs|
13 |version|. You might also want to check the `up-to-date installation instructions`_.
15 Quick and dirty installation
16 ----------------------------
17 1. Get the latest version of your C and C++ compilers.
18 2. Check that you have CMake version |CMAKE_MINIMUM_REQUIRED_VERSION| or later.
19 3. Get and unpack the latest version of the |Gromacs| tarball.
20 4. Make a separate build directory and change to it.
21 5. Run ``cmake`` with the path to the source as an argument
22 6. Run ``make``, ``make check``, and ``make install``
23 7. Source ``GMXRC`` to get access to |Gromacs|
25 Or, as a sequence of commands to execute:
29 tar xfz gromacs-|version|.tar.gz
33 cmake .. -DGMX_BUILD_OWN_FFTW=ON -DREGRESSIONTEST_DOWNLOAD=ON
37 source /usr/local/gromacs/bin/GMXRC
39 This will download and build first the prerequisite FFT library
40 followed by |Gromacs|. If you already have FFTW installed, you can
41 remove that argument to ``cmake``. Overall, this build of |Gromacs|
42 will be correct and reasonably fast on the machine upon which
43 ``cmake`` ran. On another machine, it may not run, or may not run
44 fast. If you want to get the maximum value for your hardware with
45 |Gromacs|, you will have to read further. Sadly, the interactions of
46 hardware, libraries, and compilers are only going to continue to get
49 Quick and dirty cluster installation
50 ------------------------------------
52 On a cluster where users are expected to be running across multiple
53 nodes using MPI, make one installation similar to the above, and
54 another using an MPI wrapper compiler and which is `building only
55 mdrun`_, because that is the only component of |Gromacs| that uses
60 As above, and with further details below, but you should consider
61 using the following `CMake options`_ with the
62 appropriate value instead of ``xxx`` :
64 * ``-DCMAKE_C_COMPILER=xxx`` equal to the name of the C99 `Compiler`_ you wish to use (or the environment variable ``CC``)
65 * ``-DCMAKE_CXX_COMPILER=xxx`` equal to the name of the C++98 `compiler`_ you wish to use (or the environment variable ``CXX``)
66 * ``-DGMX_MPI=on`` to build using `MPI support`_ (generally good to combine with `building only mdrun`_)
67 * ``-DGMX_GPU=on`` to build using nvcc to run using NVIDIA `CUDA GPU acceleration`_ or an OpenCL_ GPU
68 * ``-DGMX_USE_OPENCL=on`` to build with OpenCL_ support enabled. ``GMX_GPU`` must also be set.
69 * ``-DGMX_SIMD=xxx`` to specify the level of `SIMD support`_ of the node on which |Gromacs| will run
70 * ``-DGMX_BUILD_MDRUN_ONLY=on`` for `building only mdrun`_, e.g. for compute cluster back-end nodes
71 * ``-DGMX_DOUBLE=on`` to build |Gromacs| in double precision (slower, and not normally useful)
72 * ``-DCMAKE_PREFIX_PATH=xxx`` to add a non-standard location for CMake to `search for libraries, headers or programs`_
73 * ``-DCMAKE_INSTALL_PREFIX=xxx`` to install |Gromacs| to a `non-standard location`_ (default ``/usr/local/gromacs``)
74 * ``-DBUILD_SHARED_LIBS=off`` to turn off the building of shared libraries to help with `static linking`_
75 * ``-DGMX_FFT_LIBRARY=xxx`` to select whether to use ``fftw``, ``mkl`` or ``fftpack`` libraries for `FFT support`_
76 * ``-DCMAKE_BUILD_TYPE=Debug`` to build |Gromacs| in debug mode
78 Building older versions
79 -----------------------
80 Installation instructions for old |Gromacs| versions can be found at
81 the |Gromacs| `documentation page
82 <http://manual.gromacs.org/documentation>`_.
88 |Gromacs| can be compiled for many operating systems and
89 architectures. These include any distribution of Linux, Mac OS X or
90 Windows, and architectures including x86, AMD64/x86-64, several
91 PowerPC including POWER8, ARM v7, ARM v8, and SPARC VIII.
96 |Gromacs| can be compiled on any platform with ANSI C99 and C++11
97 compilers, and their respective standard C/C++ libraries. Good
98 performance on an OS and architecture requires choosing a good
99 compiler. We recommend gcc, because it is free, widely available and
100 frequently provides the best performance.
102 You should strive to use the most recent version of your
103 compiler. Since we require full C++11 support the minimum supported
104 compiler versions are
109 * Microsoft (MSVC) 2015
111 Other compilers may work (Cray, Pathscale, older clang) but do
112 not offer competitive performance. We recommend against PGI because
113 the performance with C++ is very bad.
115 You may also need the most recent version of other compiler toolchain
116 components beside the compiler itself (e.g. assembler or linker);
117 these are often shipped by your OS distribution's binutils package.
119 C++11 support requires adequate support in both the compiler and the
120 C++ library. The gcc and MSVC compilers include their own standard
121 libraries and require no further configuration. For configuration of
122 other compilers, read on.
124 On Linux, both the Intel and clang compiler use the libstdc++ which
125 comes with gcc as the default C++ library. For |Gromacs|, we require
126 the compiler to support libstc++ version 4.8.1 or higher. To select a
127 particular libstdc++ library, use:
129 * For Intel: ``-DGMX_STDLIB_CXX_FLAGS=-gcc-name=/path/to/gcc/binary``
130 or make sure that the correct gcc version is first in path (e.g. by
131 loading the gcc module). It can also be useful to add
132 ``-DCMAKE_CXX_LINK_FLAGS="-Wl,-rpath,/path/to/gcc/lib64
133 -L/path/to/gcc/lib64"`` to ensure linking works correctly.
135 ``-DCMAKE_CXX_FLAGS=--gcc-toolchain=/path/to/gcc/folder``. This
136 folder should contain ``include/c++``.
138 On Windows with the Intel compiler, the MSVC standard library is used,
139 and at least MSVC 2015 is required. Load the enviroment variables with
142 To build with any compiler and clang's libcxx standard library, use
143 ``-DGMX_STDLIB_CXX_FLAGS=-stdlib=libc++
144 -DGMX_STDLIB_LIBRARIES='-lc++abi -lc++'``.
146 If you are running on Mac OS X, the best option is the Intel
147 compiler. Both clang and gcc will work, but they produce lower
148 performance and each have some shortcomings. clang 3.8 now offers
149 support for OpenMP, and so may provide decent performance.
151 For all non-x86 platforms, your best option is typically to use gcc or
152 the vendor's default or recommended compiler, and check for
153 specialized information below.
155 For updated versions of gcc to add to your Linux OS, see
157 * Ubuntu: `Ubuntu toolchain ppa page`_
158 * RHEL/CentOS: `EPEL page`_ or the RedHat Developer Toolset
160 Compiling with parallelization options
161 --------------------------------------
163 For maximum performance you will need to examine how you will use
164 |Gromacs| and what hardware you plan to run on. Often OpenMP_
165 parallelism is an advantage for |Gromacs|, but support for this is
166 generally built into your compiler and detected automatically.
170 |Gromacs| has excellent support for NVIDIA GPUs supported via CUDA.
171 On Linux with gcc, NVIDIA's CUDA_ version |REQUIRED_CUDA_VERSION|
172 software development kit is required, and the latest
173 version is strongly encouraged. Using Intel or Microsoft compilers
174 requires version 7.0 and 8.0, respectively. NVIDIA GPUs with at
175 least NVIDIA compute capability |REQUIRED_CUDA_COMPUTE_CAPABILITY| are
176 required, e.g. Fermi, Kepler, Maxwell or Pascal cards. You are strongly recommended to
177 get the latest CUDA version and driver supported by your hardware, but
178 beware of possible performance regressions in newer CUDA versions on
179 older hardware. Note that while some CUDA compilers (nvcc) might not
180 officially support recent versions of gcc as the back-end compiler, we
181 still recommend that you at least use a gcc version recent enough to
182 get the best SIMD support for your CPU, since |Gromacs| always runs some
183 code on the CPU. It is most reliable to use the same C++ compiler
184 version for |Gromacs| code as used as the back-end compiler for nvcc,
185 but it could be faster to mix compiler versions to suit particular
188 To make it possible to use other accelerators, |Gromacs| also includes
189 OpenCL_ support. The minimum OpenCL version required is
190 |REQUIRED_OPENCL_MIN_VERSION|. The current version is recommended for
191 use with GCN-based AMD GPUs. It does work with NVIDIA GPUs, but using
192 the latest NVIDIA driver (which includes the NVIDIA OpenCL runtime) is
193 recommended. Additionally, there are known limitations when using
194 recent versions of the AMD APPSDK (details are found in the |Gromacs|
195 user guide). It is not possible to configure both CUDA and OpenCL
196 support in the same version of |Gromacs|.
198 Please note that MSVC 2015 is the earliest version of MSVC supported
199 by |Gromacs|, but that requires at least CUDA 8 for an officially
200 supported CUDA build. This will likely not occur before |Gromacs| 2016
208 |Gromacs| can run in parallel on multiple cores of a single
209 workstation using its built-in thread-MPI. No user action is required
210 in order to enable this.
212 If you wish to run in parallel on multiple machines across a network,
213 you will need to have
215 * an MPI library installed that supports the MPI 1.3
217 * wrapper compilers that will compile code using that library.
219 The |Gromacs| team recommends OpenMPI_ version
220 1.6 (or higher), MPICH_ version 1.4.1 (or
221 higher), or your hardware vendor's MPI installation. The most recent
222 version of either of these is likely to be the best. More specialized
223 networks might depend on accelerations only available in the vendor's
224 library. LAM-MPI_ might work, but since it has
225 been deprecated for years, it is not supported.
230 |Gromacs| builds with the CMake build system, requiring at least
231 version |CMAKE_MINIMUM_REQUIRED_VERSION|. You can check whether
232 CMake is installed, and what version it is, with ``cmake
233 --version``. If you need to install CMake, then first check whether
234 your platform's package management system provides a suitable version,
235 or visit the `CMake installation page`_ for pre-compiled binaries,
236 source code and installation instructions. The |Gromacs| team
237 recommends you install the most recent version of CMake you can.
241 Fast Fourier Transform library
242 ------------------------------
244 Many simulations in |Gromacs| make extensive use of fast Fourier
245 transforms, and a software library to perform these is always
246 required. We recommend FFTW_ (version 3 or higher only) or Intel
247 MKL_. The choice of library can be set with ``cmake
248 -DGMX_FFT_LIBRARY=<name>``, where ``<name>`` is one of ``fftw``,
249 ``mkl``, or ``fftpack``. FFTPACK is bundled with |Gromacs| as a
250 fallback, and is acceptable if simulation performance is not a
251 priority. When choosing MKL, |Gromacs| will also use MKL for BLAS and
252 LAPACK (see `linear algebra libraries`_). Generally, there is no
253 advantage in using MKL with |Gromacs|, and FFTW is often faster.
257 FFTW_ is likely to be available for your platform via its package
258 management system, but there can be compatibility and significant
259 performance issues associated with these packages. In particular,
260 |Gromacs| simulations are normally run in "mixed" floating-point
261 precision, which is suited for the use of single precision in
262 FFTW. The default FFTW package is normally in double
263 precision, and good compiler options to use for FFTW when linked to
264 |Gromacs| may not have been used. Accordingly, the |Gromacs| team
267 * that you permit the |Gromacs| installation to download and
268 build FFTW from source automatically for you (use
269 ``cmake -DGMX_BUILD_OWN_FFTW=ON``), or
270 * that you build FFTW from the source code.
272 If you build FFTW from source yourself, get the most recent version
273 and follow the `FFTW installation guide`_. Choose the precision for
274 FFTW (i.e. single/float vs. double) to match whether you will later
275 use mixed or double precision for |Gromacs|. There is no need to
276 compile FFTW with threading or MPI support, but it does no harm. On
277 x86 hardware, compile with *both* ``--enable-sse2`` and
278 ``--enable-avx`` for FFTW-3.3.4 and earlier. From FFTW-3.3.5, you
279 should also add ``--enable-avx2`` also. On Intel chipsets supporting
280 512-wide AVX, including KNL, add ``--enable-avx512`` also. FFTW will
281 create a fat library with codelets for all different instruction sets,
282 and pick the fastest supported one at runtime. On IBM Power8, you
283 definitely want FFTW-3.3.5 and to compile it with ``--enable-vsx`` for
284 SIMD support. If you are using a Cray, there is a special modified
285 (commercial) version of FFTs using the FFTW interface which can be
290 Use MKL bundled with Intel compilers by setting up the compiler
291 environment, e.g., through ``source /path/to/compilervars.sh intel64``
292 or similar before running CMake including setting
293 ``-DGMX_FFT_LIBRARY=mkl``.
295 If you need to customize this further, use
299 cmake -DGMX_FFT_LIBRARY=mkl \
300 -DMKL_LIBRARIES="/full/path/to/libone.so;/full/path/to/libtwo.so" \
301 -DMKL_INCLUDE_DIR="/full/path/to/mkl/include"
303 The full list and order(!) of libraries you require are found in Intel's MKL documentation for your system.
305 Other optional build components
306 -------------------------------
307 * Run-time detection of hardware capabilities can be improved by
308 linking with hwloc, which is automatically enabled if detected.
309 * Hardware-optimized BLAS and LAPACK libraries are useful
310 for a few of the |Gromacs| utilities focused on normal modes and
311 matrix manipulation, but they do not provide any benefits for normal
312 simulations. Configuring these is discussed at
313 `linear algebra libraries`_.
314 * The built-in |Gromacs| trajectory viewer ``gmx view`` requires X11 and
315 Motif/Lesstif libraries and header files. You may prefer to use
316 third-party software for visualization, such as VMD_ or PyMol_.
317 * An external TNG library for trajectory-file handling can be used
318 by setting ``-DGMX_EXTERNAL_TNG=yes``, but TNG
319 |GMX_TNG_MINIMUM_REQUIRED_VERSION| is bundled in the |Gromacs|
321 * An external lmfit library for Levenberg-Marquardt curve fitting
322 can be used by setting ``-DGMX_EXTERNAL_LMFIT=yes``, but lmfit
323 |GMX_LMFIT_MINIMUM_REQUIRED_VERSION| is bundled in the |Gromacs|
325 * zlib is used by TNG for compressing some kinds of trajectory data
326 * Building the |Gromacs| documentation is optional, and requires
327 ImageMagick, pdflatex, bibtex, doxygen, python 2.7, sphinx 1.2.4,
329 * The |Gromacs| utility programs often write data files in formats
330 suitable for the Grace plotting tool, but it is straightforward to
331 use these files in other plotting programs, too.
333 Doing a build of |Gromacs|
334 ==========================
335 This section will cover a general build of |Gromacs| with CMake_, but it
336 is not an exhaustive discussion of how to use CMake. There are many
337 resources available on the web, which we suggest you search for when
338 you encounter problems not covered here. The material below applies
339 specifically to builds on Unix-like systems, including Linux, and Mac
340 OS X. For other platforms, see the specialist instructions below.
342 Configuring with CMake
343 ----------------------
344 CMake will run many tests on your system and do its best to work out
345 how to build |Gromacs| for you. If your build machine is the same as
346 your target machine, then you can be sure that the defaults and
347 detection will be pretty good. However, if you want to control aspects
348 of the build, or you are compiling on a cluster head node for back-end
349 nodes with a different architecture, there are a few things you
350 should consider specifying.
352 The best way to use CMake to configure |Gromacs| is to do an
353 "out-of-source" build, by making another directory from which you will
354 run CMake. This can be outside the source directory, or a subdirectory
355 of it. It also means you can never corrupt your source code by trying
356 to build it! So, the only required argument on the CMake command line
357 is the name of the directory containing the ``CMakeLists.txt`` file of
358 the code you want to build. For example, download the source tarball
363 tar xfz gromacs-|version|.tgz
369 You will see ``cmake`` report a sequence of results of tests and
370 detections done by the |Gromacs| build system. These are written to the
371 ``cmake`` cache, kept in ``CMakeCache.txt``. You can edit this file by
372 hand, but this is not recommended because you could make a mistake.
373 You should not attempt to move or copy this file to do another build,
374 because file paths are hard-coded within it. If you mess things up,
375 just delete this file and start again with ``cmake``.
377 If there is a serious problem detected at this stage, then you will see
378 a fatal error and some suggestions for how to overcome it. If you are
379 not sure how to deal with that, please start by searching on the web
380 (most computer problems already have known solutions!) and then
381 consult the gmx-users mailing list. There are also informational
382 warnings that you might like to take on board or not. Piping the
383 output of ``cmake`` through ``less`` or ``tee`` can be
386 Once ``cmake`` returns, you can see all the settings that were chosen
387 and information about them by using e.g. the curses interface
393 You can actually use ``ccmake`` (available on most Unix platforms)
394 directly in the first step, but then
395 most of the status messages will merely blink in the lower part
396 of the terminal rather than be written to standard output. Most platforms
397 including Linux, Windows, and Mac OS X even have native graphical user interfaces for
398 ``cmake``, and it can create project files for almost any build environment
399 you want (including Visual Studio or Xcode).
400 Check out `running CMake`_ for
401 general advice on what you are seeing and how to navigate and change
402 things. The settings you might normally want to change are already
403 presented. You may make changes, then re-configure (using ``c``), so that it
404 gets a chance to make changes that depend on yours and perform more
405 checking. It may take several configuration passes to reach the desired
406 configuration, in particular if you need to resolve errors.
408 When you have reached the desired configuration with ``ccmake``, the
409 build system can be generated by pressing ``g``. This requires that the previous
410 configuration pass did not reveal any additional settings (if it did, you need
411 to configure once more with ``c``). With ``cmake``, the build system is generated
412 after each pass that does not produce errors.
414 You cannot attempt to change compilers after the initial run of
415 ``cmake``. If you need to change, clean up, and start again.
417 .. _non-standard location:
419 Where to install |Gromacs|
420 ^^^^^^^^^^^^^^^^^^^^^^^^^^
422 |Gromacs| is installed in the directory to which
423 ``CMAKE_INSTALL_PREFIX`` points. It may not be the source directory or
424 the build directory. You require write permissions to this
425 directory. Thus, without super-user privileges,
426 ``CMAKE_INSTALL_PREFIX`` will have to be within your home directory.
427 Even if you do have super-user privileges, you should use them only
428 for the installation phase, and never for configuring, building, or
433 Using CMake command-line options
434 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
435 Once you become comfortable with setting and changing options, you may
436 know in advance how you will configure |Gromacs|. If so, you can speed
437 things up by invoking ``cmake`` and passing the various options at once
438 on the command line. This can be done by setting cache variable at the
439 cmake invocation using ``-DOPTION=VALUE``. Note that some
440 environment variables are also taken into account, in particular
441 variables like ``CC`` and ``CXX``.
443 For example, the following command line
447 cmake .. -DGMX_GPU=ON -DGMX_MPI=ON -DCMAKE_INSTALL_PREFIX=/home/marydoe/programs
449 can be used to build with CUDA GPUs, MPI and install in a custom
450 location. You can even save that in a shell script to make it even
451 easier next time. You can also do this kind of thing with ``ccmake``,
452 but you should avoid this, because the options set with ``-D`` will not
453 be able to be changed interactively in that run of ``ccmake``.
457 |Gromacs| has extensive support for detecting and using the SIMD
458 capabilities of many modern HPC CPU architectures. If you are building
459 |Gromacs| on the same hardware you will run it on, then you don't need
460 to read more about this, unless you are getting configuration warnings
461 you do not understand. By default, the |Gromacs| build system will
462 detect the SIMD instruction set supported by the CPU architecture (on
463 which the configuring is done), and thus pick the best
464 available SIMD parallelization supported by |Gromacs|. The build system
465 will also check that the compiler and linker used also support the
466 selected SIMD instruction set and issue a fatal error if they
469 Valid values are listed below, and the applicable value with the
470 largest number in the list is generally the one you should choose.
471 In most cases, choosing an inappropriate higher number will lead
472 to compiling a binary that will not run.
474 1. ``None`` For use only on an architecture either lacking SIMD,
475 or to which |Gromacs| has not yet been ported and none of the
476 options below are applicable.
477 2. ``SSE2`` This SIMD instruction set was introduced in Intel
478 processors in 2001, and AMD in 2003. Essentially all x86
479 machines in existence have this, so it might be a good choice if
480 you need to support dinosaur x86 computers too.
481 3. ``SSE4.1`` Present in all Intel core processors since 2007,
482 but notably not in AMD Magny-Cours. Still, almost all recent
483 processors support this, so this can also be considered a good
484 baseline if you are content with slow simulations and prefer
485 portability between reasonably modern processors.
486 4. ``AVX_128_FMA`` AMD bulldozer processors (2011) have this.
487 5. ``AVX_256`` Intel processors since Sandy Bridge (2011). While this
488 code will work on recent AMD processors, it is significantly less
489 efficient than the ``AVX_128_FMA`` choice above - do not be fooled
490 to assume that 256 is better than 128 in this case.
491 6. ``AVX2_256`` Present on Intel Haswell (and later) processors (2013),
492 and it will also enable Intel 3-way fused multiply-add instructions.
493 7. ``AVX_512`` Skylake-EP Xeon processors (2017)
494 8. ``AVX_512_KNL`` Knights Landing Xeon Phi processors
495 9. ``IBM_QPX`` BlueGene/Q A2 cores have this.
496 10. ``Sparc64_HPC_ACE`` Fujitsu machines like the K computer have this.
497 11. ``IBM_VMX`` Power6 and similar Altivec processors have this.
498 12. ``IBM_VSX`` Power7 and Power8 have this.
499 13. ``ARM_NEON`` 32-bit ARMv7 with NEON support.
500 14. ``ARM_NEON_ASIMD`` 64-bit ARMv8 and later.
502 The CMake configure system will check that the compiler you have
503 chosen can target the architecture you have chosen. mdrun will check
504 further at runtime, so if in doubt, choose the lowest number you
505 think might work, and see what mdrun says. The configure system also
506 works around many known issues in many versions of common HPC
509 A further ``GMX_SIMD=Reference`` option exists, which is a special
510 SIMD-like implementation written in plain C that developers can use
511 when developing support in |Gromacs| for new SIMD architectures. It is
512 not designed for use in production simulations, but if you are using
513 an architecture with SIMD support to which |Gromacs| has not yet been
514 ported, you may wish to try this option instead of the default
515 ``GMX_SIMD=None``, as it can often out-perform this when the
516 auto-vectorization in your compiler does a good job. And post on the
517 |Gromacs| mailing lists, because |Gromacs| can probably be ported for new
518 SIMD architectures in a few days.
520 CMake advanced options
521 ^^^^^^^^^^^^^^^^^^^^^^
522 The options that are displayed in the default view of ``ccmake`` are
523 ones that we think a reasonable number of users might want to consider
524 changing. There are a lot more options available, which you can see by
525 toggling the advanced mode in ``ccmake`` on and off with ``t``. Even
526 there, most of the variables that you might want to change have a
527 ``CMAKE_`` or ``GMX_`` prefix. There are also some options that will be
528 visible or not according to whether their preconditions are satisfied.
530 .. _search for libraries, headers or programs:
532 Helping CMake find the right libraries, headers, or programs
533 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
534 If libraries are installed in non-default locations their location can
535 be specified using the following variables:
537 * ``CMAKE_INCLUDE_PATH`` for header files
538 * ``CMAKE_LIBRARY_PATH`` for libraries
539 * ``CMAKE_PREFIX_PATH`` for header, libraries and binaries
540 (e.g. ``/usr/local``).
542 The respective ``include``, ``lib``, or ``bin`` is
543 appended to the path. For each of these variables, a list of paths can
544 be specified (on Unix, separated with ":"). These can be set as
545 enviroment variables like:
549 CMAKE_PREFIX_PATH=/opt/fftw:/opt/cuda cmake ..
551 (assuming ``bash`` shell). Alternatively, these variables are also
552 ``cmake`` options, so they can be set like
553 ``-DCMAKE_PREFIX_PATH=/opt/fftw:/opt/cuda``.
555 The ``CC`` and ``CXX`` environment variables are also useful
556 for indicating to ``cmake`` which compilers to use. Similarly,
557 ``CFLAGS``/``CXXFLAGS`` can be used to pass compiler
558 options, but note that these will be appended to those set by
559 |Gromacs| for your build platform and build type. You can customize
560 some of this with advanced CMake options such as ``CMAKE_C_FLAGS``
563 See also the page on `CMake environment variables`_.
565 .. _CUDA GPU acceleration:
567 CUDA GPU acceleration
568 ^^^^^^^^^^^^^^^^^^^^^
569 If you have the CUDA_ Toolkit installed, you can use ``cmake`` with:
573 cmake .. -DGMX_GPU=ON -DCUDA_TOOLKIT_ROOT_DIR=/usr/local/cuda
575 (or whichever path has your installation). In some cases, you might
576 need to specify manually which of your C++ compilers should be used,
577 e.g. with the advanced option ``CUDA_HOST_COMPILER``.
580 possible to get best performance from NVIDIA Tesla and Quadro GPUs,
581 you should install the `GPU Deployment Kit
582 <https://developer.nvidia.com/gpu-deployment-kit>`_ and configure
583 |Gromacs| to use it by setting the CMake variable
584 ``-DGPU_DEPLOYMENT_KIT_ROOT_DIR=/path/to/your/kit``. The NVML support
586 ``nvidia-smi --applications-clocks-permission=UNRESTRICTED`` is run
587 (as root). When application clocks permissions are unrestricted, the
588 GPU clock speed can be increased automatically, which increases the
589 GPU kernel performance roughly proportional to the clock
590 increase. When using |Gromacs| on suitable GPUs under restricted
591 permissions, clocks cannot be changed, and in that case informative
592 log file messages will be produced. Background details can be found at
593 this `NVIDIA blog post
594 <http://devblogs.nvidia.com/parallelforall/increase-performance-gpu-boost-k80-autoboost/>`_.
595 NVML support is only available if detected, and may be disabled by
596 turning off the ``GMX_USE_NVML`` CMake advanced option.
598 By default, optimized code will be generated for CUDA architectures
599 supported by the nvcc compiler (and the |Gromacs| build system).
600 However, it can be beneficial to manually pick the specific CUDA architecture(s)
601 to generate code for either to reduce compilation time (and binary size) or to
602 target a new architecture not yet supported by the |Gromacs| build system.
603 Setting the desired CUDA architecture(s) and virtual architecture(s)
604 can be done using the ``GMX_CUDA_TARGET_SM`` and ``GMX_CUDA_TARGET_COMPUTE``
605 variables, respectively. These take a semicolon delimited string with
606 the two digit suffixes of CUDA (virtual) architectures names
607 (for details see the "Options for steering GPU code generation" section of the
608 nvcc man / help or Chapter 6. of the nvcc manual).
610 The GPU acceleration has been tested on AMD64/x86-64 platforms with
611 Linux, Mac OS X and Windows operating systems, but Linux is the
612 best-tested and supported of these. Linux running on POWER 8, ARM v7 and v8
613 CPUs also works well.
615 OpenCL GPU acceleration
616 ^^^^^^^^^^^^^^^^^^^^^^^
618 The primary target of the |Gromacs| OpenCL support is accelerating simulations
619 on AMD hardware, both discrete GPUs and APUs (integrated CPU+GPU chips).
620 The |Gromacs| OpenCL on NVIDIA GPUs works, but performance
621 and other limitations make it less practical (for details see the user guide).
623 To build |Gromacs| with OpenCL_ support enabled, two components are
624 required: the OpenCL_ headers and the wrapper library that acts
625 as a client driver loader (so-called ICD loader).
626 The additional, runtime-only dependency is the vendor-specific GPU driver
627 for the device targeted. This also contains the OpenCL_ compiler.
628 As the GPU compute kernels are compiled on-demand at run time,
629 this vendor-specific compiler and driver is not needed for building |Gromacs|.
630 The former, compile-time dependencies are standard components,
631 hence stock versions can be obtained from most Linux distribution
632 repositories (e.g. ``opencl-headers`` and ``ocl-icd-libopencl1`` on Debian/Ubuntu).
633 Only the compatibility with the required OpenCL_ version |REQUIRED_OPENCL_MIN_VERSION|
635 Alternatively, the headers and library can also be obtained from vendor SDKs
636 (e.g. `from AMD <http://developer.amd.com/appsdk>`_),
637 which must be installed in a path found in ``CMAKE_PREFIX_PATH`` (or via the environment
638 variables ``AMDAPPSDKROOT`` or ``CUDA_PATH``).
640 To trigger an OpenCL_ build the following CMake flags must be set
644 cmake .. -DGMX_GPU=ON -DGMX_USE_OPENCL=ON
646 On Mac OS, an AMD GPU can be used only with OS version 10.10.4 and
647 higher; earlier OS versions are known to run incorrectly.
651 Dynamic linking of the |Gromacs| executables will lead to a
652 smaller disk footprint when installed, and so is the default on
653 platforms where we believe it has been tested repeatedly and found to work.
654 In general, this includes Linux, Windows, Mac OS X and BSD systems.
655 Static binaries take more space, but on some hardware and/or under
656 some conditions they are necessary, most commonly when you are running a parallel
657 simulation using MPI libraries (e.g. BlueGene, Cray).
659 * To link |Gromacs| binaries statically against the internal |Gromacs|
660 libraries, set ``-DBUILD_SHARED_LIBS=OFF``.
661 * To link statically against external (non-system) libraries as well,
662 set ``-DGMX_PREFER_STATIC_LIBS=ON``. Note, that in
663 general ``cmake`` picks up whatever is available, so this option only
664 instructs ``cmake`` to prefer static libraries when both static and
665 shared are available. If no static version of an external library is
666 available, even when the aforementioned option is ``ON``, the shared
667 library will be used. Also note that the resulting binaries will
668 still be dynamically linked against system libraries on platforms
669 where that is the default. To use static system libraries,
670 additional compiler/linker flags are necessary, e.g. ``-static-libgcc
672 * To attempt to link a fully static binary set
673 ``-DGMX_BUILD_SHARED_EXE=OFF``. This will prevent CMake from explicitly
674 setting any dynamic linking flags. This option also sets
675 ``-DBUILD_SHARED_LIBS=OFF`` and ``-DGMX_PREFER_STATIC_LIBS=ON`` by
676 default, but the above caveats apply. For compilers which don't
677 default to static linking, the required flags have to be specified. On
678 Linux, this is usually ``CFLAGS=-static CXXFLAGS=-static``.
682 A |Gromacs| build will normally not be portable, not even across
683 hardware with the same base instruction set, like x86. Non-portable
684 hardware-specific optimizations are selected at configure-time, such
685 as the SIMD instruction set used in the compute kernels. This
686 selection will be done by the build system based on the capabilities
687 of the build host machine or otherwise specified to ``cmake`` during
690 Often it is possible to ensure portability by choosing the least
691 common denominator of SIMD support, e.g. SSE2 for x86, and ensuring
692 the you use ``cmake -DGMX_USE_RDTSCP=off`` if any of the target CPU
693 architectures does not support the ``RDTSCP`` instruction. However, we
694 discourage attempts to use a single |Gromacs| installation when the
695 execution environment is heterogeneous, such as a mix of AVX and
696 earlier hardware, because this will lead to programs (especially
697 mdrun) that run slowly on the new hardware. Building two full
698 installations and locally managing how to call the correct one
699 (e.g. using a module system) is the recommended
700 approach. Alternatively, as at the moment the |Gromacs| tools do not
701 make strong use of SIMD acceleration, it can be convenient to create
702 an installation with tools portable across different x86 machines, but
703 with separate mdrun binaries for each architecture. To achieve this,
704 one can first build a full installation with the
705 least-common-denominator SIMD instruction set, e.g. ``-DGMX_SIMD=SSE2``,
706 then build separate mdrun binaries for each architecture present in
707 the heterogeneous environment. By using custom binary and library
708 suffixes for the mdrun-only builds, these can be installed to the
709 same location as the "generic" tools installation.
710 `Building just the mdrun binary`_ is possible by setting the
711 ``-DGMX_BUILD_MDRUN_ONLY=ON`` option.
713 Linear algebra libraries
714 ^^^^^^^^^^^^^^^^^^^^^^^^
715 As mentioned above, sometimes vendor BLAS and LAPACK libraries
716 can provide performance enhancements for |Gromacs| when doing
717 normal-mode analysis or covariance analysis. For simplicity, the text
718 below will refer only to BLAS, but the same options are available
719 for LAPACK. By default, CMake will search for BLAS, use it if it
720 is found, and otherwise fall back on a version of BLAS internal to
721 |Gromacs|. The ``cmake`` option ``-DGMX_EXTERNAL_BLAS=on`` will be set
722 accordingly. The internal versions are fine for normal use. If you
723 need to specify a non-standard path to search, use
724 ``-DCMAKE_PREFIX_PATH=/path/to/search``. If you need to specify a
725 library with a non-standard name (e.g. ESSL on AIX or BlueGene), then
726 set ``-DGMX_BLAS_USER=/path/to/reach/lib/libwhatever.a``.
728 If you are using Intel MKL_ for FFT, then the BLAS and
729 LAPACK it provides are used automatically. This could be
730 over-ridden with ``GMX_BLAS_USER``, etc.
732 On Apple platforms where the Accelerate Framework is available, these
733 will be automatically used for BLAS and LAPACK. This could be
734 over-ridden with ``GMX_BLAS_USER``, etc.
736 Changing the names of |Gromacs| binaries and libraries
737 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
738 It is sometimes convenient to have different versions of the same
739 |Gromacs| programs installed. The most common use cases have been single
740 and double precision, and with and without MPI. This mechanism can
741 also be used to install side-by-side multiple versions of mdrun
742 optimized for different CPU architectures, as mentioned previously.
744 By default, |Gromacs| will suffix programs and libraries for such builds
745 with ``_d`` for double precision and/or ``_mpi`` for MPI (and nothing
746 otherwise). This can be controlled manually with ``GMX_DEFAULT_SUFFIX
747 (ON/OFF)``, ``GMX_BINARY_SUFFIX`` (takes a string) and ``GMX_LIBS_SUFFIX``
748 (also takes a string). For instance, to set a custom suffix for
749 programs and libraries, one might specify:
753 cmake .. -DGMX_DEFAULT_SUFFIX=OFF -DGMX_BINARY_SUFFIX=_mod -DGMX_LIBS_SUFFIX=_mod
755 Thus the names of all programs and libraries will be appended with
758 Changing installation tree structure
759 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
760 By default, a few different directories under ``CMAKE_INSTALL_PREFIX`` are used
761 when when |Gromacs| is installed. Some of these can be changed, which is mainly
762 useful for packaging |Gromacs| for various distributions. The directories are
763 listed below, with additional notes about some of them. Unless otherwise noted,
764 the directories can be renamed by editing the installation paths in the main
768 The standard location for executables and some scripts.
769 Some of the scripts hardcode the absolute installation prefix, which needs
770 to be changed if the scripts are relocated.
772 The standard location for installed headers.
774 The standard location for libraries. The default depends on the system, and
775 is determined by CMake.
776 The name of the directory can be changed using ``GMX_LIB_INSTALL_DIR`` CMake
779 Information about the installed ``libgromacs`` library for ``pkg-config`` is
780 installed here. The ``lib/`` part adapts to the installation location of the
781 libraries. The installed files contain the installation prefix as absolute
784 CMake package configuration files are installed here.
786 Various data files and some documentation go here.
787 The ``gromacs`` part can be changed using ``GMX_DATA_INSTALL_DIR``. Using this
788 CMake variable is the preferred way of changing the installation path for
789 ``share/gromacs/top/``, since the path to this directory is built into
790 ``libgromacs`` as well as some scripts, both as a relative and as an absolute
791 path (the latter as a fallback if everything else fails).
793 Installed man pages go here.
795 Compiling and linking
796 ---------------------
797 Once you have configured with ``cmake``, you can build |Gromacs| with ``make``.
798 It is expected that this will always complete successfully, and
799 give few or no warnings. The CMake-time tests |Gromacs| makes on the settings
800 you choose are pretty extensive, but there are probably a few cases we
801 have not thought of yet. Search the web first for solutions to
802 problems, but if you need help, ask on gmx-users, being sure to
803 provide as much information as possible about what you did, the system
804 you are building on, and what went wrong. This may mean scrolling back
805 a long way through the output of ``make`` to find the first error
808 If you have a multi-core or multi-CPU machine with ``N``
809 processors, then using
815 will generally speed things up by quite a bit. Other build generator systems
816 supported by ``cmake`` (e.g. ``ninja``) also work well.
818 .. _building just the mdrun binary:
823 This is now supported with the ``cmake`` option
824 ``-DGMX_BUILD_MDRUN_ONLY=ON``, which will build a different version of
825 ``libgromacs`` and the ``mdrun`` program.
826 Naturally, now ``make install`` installs only those
827 products. By default, mdrun-only builds will default to static linking
828 against |Gromacs| libraries, because this is generally a good idea for
829 the targets for which an mdrun-only build is desirable.
833 Finally, ``make install`` will install |Gromacs| in the
834 directory given in ``CMAKE_INSTALL_PREFIX``. If this is a system
835 directory, then you will need permission to write there, and you
836 should use super-user privileges only for ``make install`` and
837 not the whole procedure.
839 .. _getting access to |Gromacs|:
841 Getting access to |Gromacs| after installation
842 ----------------------------------------------
843 |Gromacs| installs the script ``GMXRC`` in the ``bin``
844 subdirectory of the installation directory
845 (e.g. ``/usr/local/gromacs/bin/GMXRC``), which you should source
850 source /your/installation/prefix/here/bin/GMXRC
852 It will detect what kind of shell you are running and set up your
853 environment for using |Gromacs|. You may wish to arrange for your
854 login scripts to do this automatically; please search the web for
855 instructions on how to do this for your shell.
857 Many of the |Gromacs| programs rely on data installed in the
858 ``share/gromacs`` subdirectory of the installation directory. By
859 default, the programs will use the environment variables set in the
860 ``GMXRC`` script, and if this is not available they will try to guess the
861 path based on their own location. This usually works well unless you
862 change the names of directories inside the install tree. If you still
863 need to do that, you might want to recompile with the new install
864 location properly set, or edit the ``GMXRC`` script.
866 Testing |Gromacs| for correctness
867 ---------------------------------
868 Since 2011, the |Gromacs| development uses an automated system where
869 every new code change is subject to regression testing on a number of
870 platforms and software combinations. While this improves
871 reliability quite a lot, not everything is tested, and since we
872 increasingly rely on cutting edge compiler features there is
873 non-negligible risk that the default compiler on your system could
874 have bugs. We have tried our best to test and refuse to use known bad
875 versions in ``cmake``, but we strongly recommend that you run through
876 the tests yourself. It only takes a few minutes, after which you can
879 The simplest way to run the checks is to build |Gromacs| with
880 ``-DREGRESSIONTEST_DOWNLOAD``, and run ``make check``.
881 |Gromacs| will automatically download and run the tests for you.
882 Alternatively, you can download and unpack the |Gromacs|
883 regression test suite |gmx-regressiontests-package| tarball yourself
884 and use the advanced ``cmake`` option ``REGRESSIONTEST_PATH`` to
885 specify the path to the unpacked tarball, which will then be used for
886 testing. If the above does not work, then please read on.
888 The regression tests are also available from the download_ section.
889 Once you have downloaded them, unpack the tarball, source
890 ``GMXRC`` as described above, and run ``./gmxtest.pl all``
891 inside the regression tests folder. You can find more options
892 (e.g. adding ``double`` when using double precision, or
893 ``-only expanded`` to run just the tests whose names match
894 "expanded") if you just execute the script without options.
896 Hopefully, you will get a report that all tests have passed. If there
897 are individual failed tests it could be a sign of a compiler bug, or
898 that a tolerance is just a tiny bit too tight. Check the output files
899 the script directs you too, and try a different or newer compiler if
900 the errors appear to be real. If you cannot get it to pass the
901 regression tests, you might try dropping a line to the gmx-users
902 mailing list, but then you should include a detailed description of
903 your hardware, and the output of ``gmx mdrun -version`` (which contains
904 valuable diagnostic information in the header).
906 A build with ``-DGMX_BUILD_MDRUN_ONLY`` cannot be tested with
907 ``make check`` from the build tree, because most of the tests
908 require a full build to run things like ``grompp``. To test such an
909 mdrun fully requires installing it to the same location as a normal
910 build of |Gromacs|, downloading the regression tests tarball manually
911 as described above, sourcing the correct ``GMXRC`` and running the
912 perl script manually. For example, from your |Gromacs| source
919 cmake .. -DCMAKE_INSTALL_PREFIX=/your/installation/prefix/here
923 mkdir build-mdrun-only
925 cmake .. -DGMX_MPI=ON -DGMX_GPU=ON -DGMX_BUILD_MDRUN_ONLY=ON -DCMAKE_INSTALL_PREFIX=/your/installation/prefix/here
928 cd /to/your/unpacked/regressiontests
929 source /your/installation/prefix/here/bin/GMXRC
930 ./gmxtest.pl all -np 2
932 If your mdrun program has been suffixed in a non-standard way, then
933 the ``./gmxtest.pl -mdrun`` option will let you specify that name to the
934 test machinery. You can use ``./gmxtest.pl -double`` to test the
935 double-precision version. You can use ``./gmxtest.pl -crosscompiling``
936 to stop the test harness attempting to check that the programs can
937 be run. You can use ``./gmxtest.pl -mpirun srun`` if your command to
938 run an MPI program is called ``srun``.
940 The ``make check`` target also runs integration-style tests that may run
941 with MPI if ``GMX_MPI=ON`` was set. To make these work with various possible
942 MPI libraries, you may need to
943 set the CMake variables ``MPIEXEC``, ``MPIEXEC_NUMPROC_FLAG``,
944 ``MPIEXEC_PREFLAGS`` and ``MPIEXEC_POSTFLAGS`` so that
945 ``mdrun-mpi-test_mpi`` would run on multiple ranks via the shell command
949 ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${NUMPROC} ${MPIEXEC_PREFLAGS} \
950 mdrun-mpi-test_mpi ${MPIEXEC_POSTFLAGS} -otherflags
952 A typical example for SLURM is
956 cmake .. -DGMX_MPI=on -DMPIEXEC=srun -DMPIEXEC_NUMPROC_FLAG=-n -DMPIEXEC_PREFLAGS= -DMPIEXEC_POSTFLAGS=
959 Testing |Gromacs| for performance
960 ---------------------------------
961 We are still working on a set of benchmark systems for testing
962 the performance of |Gromacs|. Until that is ready, we recommend that
963 you try a few different parallelization options, and experiment with
964 tools such as ``gmx tune_pme``.
968 You are not alone - this can be a complex task! If you encounter a
969 problem with installing |Gromacs|, then there are a number of
970 locations where you can find assistance. It is recommended that you
971 follow these steps to find the solution:
973 1. Read the installation instructions again, taking note that you
974 have followed each and every step correctly.
976 2. Search the |Gromacs| webpage_ and users emailing list for information
978 ``site:https://mailman-1.sys.kth.se/pipermail/gromacs.org_gmx-users``
979 to a Google search may help filter better results.
981 3. Search the internet using a search engine such as Google.
983 4. Post to the |Gromacs| users emailing list gmx-users for
984 assistance. Be sure to give a full description of what you have
985 done and why you think it did not work. Give details about the
986 system on which you are installing. Copy and paste your command
987 line and as much of the output as you think might be relevant -
988 certainly from the first indication of a problem. In particular,
989 please try to include at least the header from the mdrun logfile,
990 and preferably the entire file. People who might volunteer to help
991 you do not have time to ask you interactive detailed follow-up
992 questions, so you will get an answer faster if you provide as much
993 information as you think could possibly help. High quality bug
994 reports tend to receive rapid high quality answers.
996 Special instructions for some platforms
997 =======================================
1001 Building on Windows using native compilers is rather similar to
1002 building on Unix, so please start by reading the above. Then, download
1003 and unpack the |Gromacs| source archive. Make a folder in which to do
1004 the out-of-source build of |Gromacs|. For example, make it within the
1005 folder unpacked from the source archive, and call it ``build-gromacs``.
1007 For CMake, you can either use the graphical user interface provided on
1008 Windows, or you can use a command line shell with instructions similar
1009 to the UNIX ones above. If you open a shell from within your IDE
1010 (e.g. Microsoft Visual Studio), it will configure the environment for
1011 you, but you might need to tweak this in order to get either a 32-bit
1012 or 64-bit build environment. The latter provides the fastest
1013 executable. If you use a normal Windows command shell, then you will
1014 need to either set up the environment to find your compilers and
1015 libraries yourself, or run the ``vcvarsall.bat`` batch script provided
1016 by MSVC (just like sourcing a bash script under Unix).
1018 With the graphical user interface, you will be asked about what
1019 compilers to use at the initial configuration stage, and if you use
1020 the command line they can be set in a similar way as under UNIX.
1022 Unfortunately ``-DGMX_BUILD_OWN_FFTW=ON`` (see `Using FFTW`_) does not
1023 work on Windows, because there is no supported way to build FFTW on
1024 Windows. You can either build FFTW some other way (e.g. MinGW), or
1025 use the built-in fftpack (which may be slow), or `using MKL`_.
1027 For the build, you can either load the generated solutions file into
1028 e.g. Visual Studio, or use the command line with ``cmake --build`` so
1029 the right tools get used.
1033 |Gromacs| builds mostly out of the box on modern Cray machines, but
1034 you may need to specify the use of static binaries with
1035 ``-DGMX_BUILD_SHARED_EXE=off``, and you may need to set the F77
1036 environmental variable to ``ftn`` when compiling FFTW.
1041 The built-in |Gromacs| processor detection does not work on Solaris,
1042 so it is strongly recommended that you build |Gromacs| with
1043 ``-DGMX_HWLOC=on`` and ensure that the ``CMAKE_PREFIX_PATH`` includes
1044 the path where the hwloc headers and libraries can be found. At least
1045 version 1.11.8 of hwloc is recommended.
1047 Oracle Developer Studio is not a currently supported compiler (and
1048 does not currently compile |Gromacs| correctly, perhaps because the
1049 thread-MPI atomics are incorrectly implemented in |Gromacs|).
1051 Building on BlueGene
1052 --------------------
1056 There is currently native acceleration on this platform for the Verlet
1057 cut-off scheme. There are no plans to provide accelerated kernels for
1058 the group cut-off scheme, but the default plain C kernels will work
1061 Only the bgclang compiler is supported, because it is the only
1062 availble C++11 compiler. Only static linking is supported.
1064 Computation on BlueGene floating-point units is always done in
1065 double-precision. However, mixed-precision builds of |Gromacs| are still
1066 normal and encouraged since they use cache more efficiently.
1068 You need to arrange for FFTW to be installed correctly, following the
1069 above instructions. You may prefer to configure FFTW with
1070 ``--disable-fortran`` to avoid complications.
1072 MPI wrapper compilers should be used for compiling and linking. The
1073 MPI wrapper compilers can make it awkward to
1074 attempt to use IBM's optimized BLAS/LAPACK called ESSL (see the
1075 section on `linear algebra libraries`_. Since mdrun is the only part
1076 of |Gromacs| that should normally run on the compute nodes, and there is
1077 nearly no need for linear algebra support for mdrun, it is recommended
1078 to use the |Gromacs| built-in linear algebra routines - this is never
1079 a problem for normal simulations.
1081 The recommended configuration is to use
1085 cmake .. -DCMAKE_C_COMPILER=mpicc \
1086 -DCMAKE_CXX_COMPILER=mpicxx \
1087 -DCMAKE_TOOLCHAIN_FILE=Platform/BlueGeneQ-static-bgclang-CXX.cmake \
1088 -DCMAKE_PREFIX_PATH=/your/fftw/installation/prefix \
1090 -DGMX_BUILD_MDRUN_ONLY=ON
1094 which will build a statically-linked MPI-enabled mdrun for the compute
1095 nodes. Otherwise, |Gromacs| default configuration
1098 It is possible to configure and make the remaining |Gromacs| tools with
1099 the compute-node toolchain, but as none of those tools are MPI-aware,
1100 this would not normally
1101 be useful. Instead, users should plan to run these on the login node,
1102 and perform a separate |Gromacs| installation for that, using the login
1103 node's toolchain - not the above platform file, or any other
1104 compute-node toolchain. This may require requesting an up-to-date
1105 gcc or clang toolchain for the front end.
1107 Note that only the MPI build is available for the compute-node
1108 toolchains. The |Gromacs| thread-MPI or no-MPI builds are not useful at
1113 There is currently no SIMD support on this platform and no plans to
1114 add it. The default plain C kernels will work if there is a C++11
1115 compiler for this platform.
1119 This is the architecture of the K computer, which uses Fujitsu
1120 Sparc64VIIIfx chips. On this platform, |Gromacs| has
1121 accelerated group kernels using the HPC-ACE instructions, no
1122 accelerated Verlet kernels, and a custom build toolchain. Since this
1123 particular chip only does double precision SIMD, the default setup
1124 is to build |Gromacs| in double. Since most users only need single, we have added
1125 an option GMX_RELAXED_DOUBLE_PRECISION to accept single precision square root
1126 accuracy in the group kernels; unless you know that you really need 15 digits
1127 of accuracy in each individual force, we strongly recommend you use this. Note
1128 that all summation and other operations are still done in double.
1130 The recommended configuration is to use
1134 cmake .. -DCMAKE_TOOLCHAIN_FILE=Toolchain-Fujitsu-Sparc64-mpi.cmake \
1135 -DCMAKE_PREFIX_PATH=/your/fftw/installation/prefix \
1136 -DCMAKE_INSTALL_PREFIX=/where/gromacs/should/be/installed \
1138 -DGMX_BUILD_MDRUN_ONLY=ON \
1139 -DGMX_RELAXED_DOUBLE_PRECISION=ON
1145 |Gromacs| has preliminary support for Intel Xeon Phi. Only symmetric
1146 (aka native) mode is supported on Knights Corner, and it has so far
1147 not been optimized to the same level as other architectures. The
1148 performance depends among other factors on the system size, and for
1149 now the performance might not be faster than CPUs. Building for Xeon
1150 Phi works almost as any other Unix. See the instructions above for
1151 details. The recommended configuration is
1155 cmake .. -DCMAKE_TOOLCHAIN_FILE=Platform/XeonPhi
1161 While it is our best belief that |Gromacs| will build and run pretty
1162 much everywhere, it is important that we tell you where we really know
1163 it works because we have tested it. We do test on Linux, Windows, and
1164 Mac with a range of compilers and libraries for a range of our
1165 configuration options. Every commit in our git source code repository
1166 is currently tested on x86 with a number of gcc versions ranging from 4.8.1
1167 through 6.1, versions 16 of the Intel compiler, and Clang
1168 versions 3.4 through 3.8. For this, we use a variety of GNU/Linux
1169 flavors and versions as well as recent versions of Windows. Under
1170 Windows, we test both MSVC 2015 and version 16 of the Intel compiler.
1171 For details, you can
1172 have a look at the `continuous integration server used by GROMACS`_,
1173 which runs Jenkins_.
1175 We test irregularly on ARM v7, ARM v8, BlueGene/Q, Cray, Fujitsu
1176 PRIMEHPC, Power8, Google Native Client and other environments, and
1177 with other compilers and compiler versions, too.