<liclass="toctree-l2"><aclass="reference internal"href="Section_accelerate.html#comparison-of-various-accelerator-packages">5.4. Comparison of various accelerator packages</a></li>
<p><aclass="reference internal"href="Section_accelerate.html"><spanclass="doc">Return to Section accelerate overview</span></a></p>
<divclass="section"id="gpu-package">
<h1>5.3.1. GPU package</h1>
<p>The GPU package was developed by Mike Brown at ORNL and his
collaborators, particularly Trung Nguyen (ORNL). It provides GPU
versions of many pair styles, including the 3-body Stillinger-Weber
pair style, and for <aclass="reference internal"href="kspace_style.html"><spanclass="doc">kspace_style pppm</span></a> for
long-range Coulombics. It has the following general features:</p>
<ulclass="simple">
<li>It is designed to exploit common GPU hardware configurations where one
or more GPUs are coupled to many cores of one or more multi-core CPUs,
e.g. within a node of a parallel machine.</li>
<li>Atom-based data (e.g. coordinates, forces) moves back-and-forth
between the CPU(s) and GPU every timestep.</li>
<li>Neighbor lists can be built on the CPU or on the GPU</li>
<li>The charge assignment and force interpolation portions of PPPM can be
run on the GPU. The FFT portion, which requires MPI communication
between processors, runs on the CPU.</li>
<li>Asynchronous force computations can be performed simultaneously on the
CPU(s) and GPU.</li>
<li>It allows for GPU computations to be performed in single or double
precision, or in mixed-mode precision, where pairwise forces are
computed in single precision, but accumulated into double-precision
force vectors.</li>
<li>LAMMPS-specific code is in the GPU package. It makes calls to a
generic GPU library in the lib/gpu directory. This library provides
NVIDIA support as well as more general OpenCL support, so that the
same functionality can eventually be supported on a variety of GPU
hardware.</li>
</ul>
<p>Here is a quick overview of how to enable and use the GPU package:</p>
<ulclass="simple">
<li>build the library in lib/gpu for your GPU hardware with the desired precision settings</li>
<li>install the GPU package and build LAMMPS as usual</li>
<li>use the mpirun command to set the number of MPI tasks/node which determines the number of MPI tasks/GPU</li>
<li>specify the # of GPUs per node</li>
<li>use GPU styles in your input script</li>
</ul>
<p>The latter two steps can be done using the “-pk gpu” and “-sf gpu”
<aclass="reference internal"href="Section_start.html#start-7"><spanclass="std std-ref">command-line switches</span></a> respectively. Or
the effect of the “-pk” or “-sf” switches can be duplicated by adding
the <aclass="reference internal"href="package.html"><spanclass="doc">package gpu</span></a> or <aclass="reference internal"href="suffix.html"><spanclass="doc">suffix gpu</span></a> commands
<p>Note that if the “-sf gpu” switch is used, it also issues a default
<aclass="reference internal"href="package.html"><spanclass="doc">package gpu 1</span></a> command, which sets the number of
GPUs/node to 1.</p>
<p>Using the “-pk” switch explicitly allows for setting of the number of
GPUs/node to use and additional options. Its syntax is the same as
same as the “package gpu” command. See the <aclass="reference internal"href="package.html"><spanclass="doc">package</span></a>
command doc page for details, including the default values used for
all its options if it is not specified.</p>
<p>Note that the default for the <aclass="reference internal"href="package.html"><spanclass="doc">package gpu</span></a> command is to
set the Newton flag to “off” pairwise interactions. It does not
affect the setting for bonded interactions (LAMMPS default is “on”).
The “off” setting for pairwise interaction is currently required for
GPU package pair styles.</p>
<p><strong>Or run with the GPU package by editing an input script:</strong></p>
<p>The discussion above for the mpirun/mpiexec command, MPI tasks/node,
and use of multiple MPI tasks/GPU is the same.</p>
<p>Use the <aclass="reference internal"href="suffix.html"><spanclass="doc">suffix gpu</span></a> command, or you can explicitly add an
“gpu” suffix to individual styles in your input script, e.g.</p>
<preclass="literal-block">
pair_style lj/cut/gpu 2.5
</pre>
<p>You must also use the <aclass="reference internal"href="package.html"><spanclass="doc">package gpu</span></a> command to enable the
GPU package, unless the “-sf gpu” or “-pk gpu”<aclass="reference internal"href="Section_start.html#start-7"><spanclass="std std-ref">command-line switches</span></a> were used. It specifies the
number of GPUs/node to use, as well as other options.</p>
<p><strong>Speed-ups to expect:</strong></p>
<p>The performance of a GPU versus a multi-core CPU is a function of your
hardware, which pair style is used, the number of atoms/GPU, and the
precision used on the GPU (double, single, mixed).</p>
<p>See the <aclass="reference external"href="http://lammps.sandia.gov/bench.html">Benchmark page</a> of the
LAMMPS web site for performance of the GPU package on various
hardware, including the Titan HPC platform at ORNL.</p>
<p>You should also experiment with how many MPI tasks per GPU to use to
give the best performance for your problem and machine. This is also
a function of the problem size and the pair style being using.
Likewise, you should experiment with the precision setting for the GPU
library to see if single or mixed precision will give accurate
results, since they will typically be faster.</p>
<p><strong>Guidelines for best performance:</strong></p>
<ulclass="simple">
<li>Using multiple MPI tasks per GPU will often give the best performance,
as allowed my most multi-core CPU/GPU configurations.</li>
<li>If the number of particles per MPI task is small (e.g. 100s of
particles), it can be more efficient to run with fewer MPI tasks per
GPU, even if you do not use all the cores on the compute node.</li>
<li>The <aclass="reference internal"href="package.html"><spanclass="doc">package gpu</span></a> command has several options for tuning
performance. Neighbor lists can be built on the GPU or CPU. Force
calculations can be dynamically balanced across the CPU cores and
GPUs. GPU-specific settings can be made which can be optimized
for different hardware. See the <aclass="reference internal"href="package.html"><spanclass="doc">packakge</span></a> command
doc page for details.</li>
<li>As described by the <aclass="reference internal"href="package.html"><spanclass="doc">package gpu</span></a> command, GPU
accelerated pair styles can perform computations asynchronously with
CPU computations. The “Pair” time reported by LAMMPS will be the
maximum of the time required to complete the CPU pair style
computations and the time required to complete the GPU pair style
computations. Any time spent for GPU-enabled pair styles for
computations that run simultaneously with <aclass="reference internal"href="bond_style.html"><spanclass="doc">bond</span></a>,
<aclass="reference internal"href="improper_style.html"><spanclass="doc">improper</span></a>, and <aclass="reference internal"href="kspace_style.html"><spanclass="doc">long-range</span></a>
calculations will not be included in the “Pair” time.</li>
<li>When the <em>mode</em> setting for the package gpu command is force/neigh,
the time for neighbor list calculations on the GPU will be added into
the “Pair” time, not the “Neigh” time. An additional breakdown of the
times required for various tasks on the GPU (data copy, neighbor
calculations, force computations, etc) are output only with the LAMMPS
screen output (not in the log file) at the end of each run. These
timings represent total time spent on the GPU for each routine,
regardless of asynchronous CPU calculations.</li>
<li>The output section “GPU Time Info (average)” reports “Max Mem / Proc”.
This is the maximum memory used at one time on the GPU for data
Built with <ahref="http://sphinx-doc.org/">Sphinx</a> using a <ahref="https://github.com/snide/sphinx_rtd_theme">theme</a> provided by <ahref="https://readthedocs.org">Read the Docs</a>.