darshan-runtime.txt

Darshan-runtime installation and usage
======================================

== Introduction

This document describes darshan-runtime, which is the instrumentation
portion of the Darshan characterization tool.  It should be installed on the
system where you intend to collect I/O characterization information.

Darshan instruments applications via either compile time wrappers for static
executables or dynamic library preloading for dynamic executables.  An
application that has been instrumented with Darshan will produce a single
log file each time it is executed.  This log summarizes the I/O access patterns
used by the application.

The darshan-runtime instrumentation only instruments MPI applications (the
application must at least call `MPI_Init()` and `MPI_Finalize()`).  However,
it captures both MPI-IO and POSIX file access.  It also captures limited
information about HDF5 and PnetCDF access.

This document provides generic installation instructions, but "recipes" for
several common HPC systems are provided at the end of the document as well.

More information about Darshan can be found at the 
http://www.mcs.anl.gov/darshan[Darshan web site].

== Requirements

* MPI C compiler
* zlib development headers and library

== Compilation

.Configure and build example
----
tar -xvzf darshan-<version-number>.tar.gz
cd darshan-<version-number>/darshan-runtime
./configure --with-mem-align=8 --with-log-path=/darshan-logs --with-jobid-env=PBS_JOBID CC=mpicc
make
make install
----

.Detecting file size and alignment
[NOTE]
====
You can also add --enable-stat-at-open option to cause the Darshan library
to issue an additional stat() system call on each file the first time that
it is opened on each process.  This allows Darshan to detect the file
alignment (and subsequent unaligned accesses).  It also allows Darshan to
detect the size of files at open time before any I/O is performed.
Unfortunately, this option can cause significant overhead at scale on file
systems such as PVFS or Lustre that must contact every server for a given
file in order to satisfy a stat request.  We therefore disable this
feature by default.
====

.Explanation of configure arguments:
* `--with-mem-align` (mandatory): This value is system-dependent and will be
used by Darshan to determine if the buffer for a read or write operation is
aligned in memory.
* `--with-log-path` (this, or `--with-log-path-by-env`, is mandatory): This
specifies the parent directory for the directory tree where darshan logs
will be placed
* `--with-jobid-env` (mandatory): this specifies the environment variable that
Darshan should check to determine the jobid of a job.  Common values are
`PBS_JOBID` or `COBALT_JOBID`.  If you are not using a scheduler (or your
scheduler does not advertise the job ID) then you can specify `NONE` here.
Darshan will fall back to using the pid of the rank 0 process if the
specified environment variable is not set.
* `CC=`: specifies the MPI C compiler to use for compilation
* `--with-log-path-by-env`: specifies an environment variable to use to
determine the log path at run time.
* `--with-log-hints=`: specifies hints to use when writing the Darshan log
file.  See `./configure --help` for details.
* `--with-zlib=`: specifies an alternate location for the zlib development
header and library.

=== Cross compilation

On some systems (notably the IBM Blue Gene series), the login nodes do not
have the same architecture or runtime environment as the compute nodes.  In
this case, you must configure darshan-runtime to be built using a cross
compiler.  The following configure arguments show an example for the BG/P system:

----
--host=powerpc-bgp-linux CC=/bgsys/drivers/ppcfloor/comm/default/bin/mpicc 
----

== Environment preparation

Once darshan-runtime has been installed, you must prepare a location
in which to store the Darshan log files and configure an instrumentation method.

=== Log directory

This step can be safely skipped if you configured darshan-runtime using the
`--with-log-path-by-env` option.  A more typical configuration uses a static
directory hierarchy for Darshan log
files.

The `darshan-mk-log-dirs.pl` utility will configure the path specified at
configure time to include
subdirectories organized by year, month, and day in which log files will be
placed. The deepest subdirectories will have sticky permissions to enable
multiple users to write to the same directory.  If the log directory is
shared system-wide across many users then the following script should be run
as root.
 
----
darshan-mk-log-dirs.pl
----

=== Instrumentation method

The instrumentation method to use depends on whether the executables
produced by your MPI compiler are statically or dynamically linked.  If you
are unsure, you can check by running `ldd <executable_name>` on an example
executable.  Dynamically-linked executables will produce a list of shared
libraries when this command is executed.

Most MPI compilers allow you to toggle dynamic or static linking via options
such as `-dynamic` or `-static`.  Please check your MPI compiler man page
for details if you intend to force one mode or the other.

== Instrumenting statically-linked applications

Statically linked executables must be instrumented at compile time.  The
simplest way to do this is to generate an MPI compiler script (e.g. `mpicc`)
that includes the link options and libraries needed by Darshan.  Once this
is done, Darshan instrumentation is transparent; you simply compile
applications using the darshan-enabled MPI compiler scripts.

For MPICH-based MPI libraries, such as MPICH1, MPICH2, or MVAPICH, these
wrapper scripts can be generated automatically.  The following example
illustrates how to produce wrappers for C, C++, and Fortran compilers:

----
darshan-gen-cc.pl `which mpicc` --output mpicc.darshan
darshan-gen-cxx.pl `which mpicxx` --output mpicxx.darshan
darshan-gen-fortran.pl `which mpif77` --output mpif77.darshan
darshan-gen-fortran.pl `which mpif90` --output mpif90.darshan
-----

Please see the Cray recipe in this document for instructions on adding
Darshan support to the Cray compiler scripts.  
For other MPI Libraries you must manually modify the MPI compiler scripts to
add the necessary link options and libraries.  Please see the
`darshan-gen-*` scripts for examples or contact the Darshan users mailing
list for help.

== Instrumenting dynamically-linked applications

For dynamically-linked executables, darshan relies on the `LD_PRELOAD`
environment variable to insert instrumentation at run time.  The executables
should be compiled using the normal, unmodified MPI compiler.

To use this mechanism, set the `LD_PRELOAD` environment variable to the full
path to the Darshan shared library, as in this example:

----
export LD_PRELOAD=/home/carns/darshan-install/lib/libdarshan.so
----

You can then run your application as usual.  Some environments may require a
special `mpirun` or `mpiexec` command line argument to propagate the
environment variable to all processes.  Other environments may require a
scheduler submission option to control this behavior.  Please check your
local site documentation for details.

=== Instrumenting dynamically-linked Fortran applications

Please follow the general steps outlined in the previous section.  For
Fortran applications compiled with MPICH you may have to take the additional
step of adding
`libfmpich.so` to your `LD_PRELOAD` environment variable. For example:

----
export LD_PRELOAD=libfmpich.so:/home/carns/darshan-install/lib/libdarshan.so
----

== Darshan installation recipes

The following recipes provide examples for prominent HPC systems.
These are intended to be used as a starting point.  You will most likely have to adjust paths and options to
reflect the specifics of your system.

=== IBM Blue Gene/P

The IBM Blue Gene/P series produces static executables by default, uses a
different architecture for login and compute nodes, and uses an MPI
environment based on MPICH.

The following example shows how to configure Darshan on a BG/P system:

----
./configure --with-mem-align=16 \
 --with-log-path=/home/carns/working/darshan/releases/logs \
 --prefix=/home/carns/working/darshan/install --with-jobid-env=COBALT_JOBID \
 --with-zlib=/soft/apps/zlib-1.2.3/ \
 --host=powerpc-bgp-linux CC=/bgsys/drivers/ppcfloor/comm/default/bin/mpicc 
----

.Rationale
[NOTE]
====
The memory alignment is set to 16 not because that is the proper alignment
for the BG/P CPU architecture, but because that is the optimal alignment for
the network transport used between compute nodes and I/O nodes in the
system.  The jobid environment variable is set to `COBALT_JOBID` in this
case for use with the Cobalt scheduler, but other BG/P systems may use
different schedulers.  The `--with-zlib` argument is used to point to a
version of zlib that has been compiled for use on the compute nodes rather
than the login node.  The `--host` argument is used to force cross-compilation
of Darshan.  The `CC` variable is set to point to a stock MPI compiler.
====

Once Darshan has been installed, use the `darshan-gen-*.pl` scripts as
described earlier in this document to produce darshan-enabled MPI compilers.
This method has been widely used and tested with both the GNU and IBM XL
compilers.

=== Cray XE6 (or similar)

The Cray programming environment produces static executables by default.
Darshan should therefore be configured to insert instrumentation at link
time by way of compiler script wrappers.  Darshan 2.2.3 supports GNU,
PGI, Cray, Pathscale, and Intel compilers.  The following documentation
describes how to modify the Cray compiler wrappers to add Darshan
capability, as well as how to install a Darshan software module that
allows users to enable or disable Darshan instrumentation.

==== Building and installing Darshan

Please set your environment to use the GNU programming environment before
configuring or compiling Darshan.  Although Darshan can be built with a
variety of compilers, the GNU compilers are recommended because it will
produce a Darshan library that is interoperable with a variety of linkers.
On most Cray systems you can enable the GNU programming environment with
a command similar to "module swap PrgEnv-pgi PrgEnv-gnu".  Please see
your site documentation for information about how to switch programming
environments.

The following example shows how to configure and build Darshan on a Cray
system using either the GNU programming environment.  Please adjust the 
--with-log-path and --prefix arguments to point to the desired log file path 
and installation path, respectively.

----
module swap PrgEnv-pgi PrgEnv-gnu
./configure --with-mem-align=8 \
 --with-log-path=/shared-file-system/darshan-logs \
 --prefix=/soft/darshan-2.2.3 \
 --with-jobid-env=PBS_JOBID --disable-cuserid CC=cc
make install
module swap PrgEnv-gnu PrgEnv-pgi
----

.Rationale
[NOTE]
====
The job ID is set to `PBS_JOBID` for use with a Torque or PBS based scheduler.
The `CC` variable is configured to point the standard MPI compiler.

The --disable-cuserid argument is used to prevent Darshan from attempting to
use the cuserid() function to retrieve the user name associated with a job.
Darshan automatically falls back to other methods if this function fails,
but on some Cray environments (notably the Beagle XE6 system as of March 2012)
the cuserid() call triggers a segmentation fault.  With this option set,
Darshan will typically use the LOGNAME environment variable to determine a
userid.
====

As in any Darshan installation, the darshan-mk-log-dirs.pl script can then be 
used to create the appropriate directory hierarchy for storing Darshan log 
files in the --with-log-path directory.

==== Compiler wrappers (system-wide installation)

.Warning
[NOTE]
====
The instructions in this section will modify the default compiler scripts
that underly the system-wide CC, ftn, and cc scripts.  Please proceed
with caution.  We recommend performing the following steps
on a copy of the scripts and then moving them to the correct location afterwards.
====

The Darshan distribution includes a patch to the Cray programming environment 
that adds Darshan capability to the compiler scripts.  It does not modify the
behavior of the scripts in any way unless the CRAY_DARSHAN_DIR environment 
variable is set by the Darshan software module.  This approach is similar to
that used by the HDF5, NetCDF, and PETSc packages on Cray XE6 systems.  Darshan
requires compiler script modifications in order to apply instrumentation
libraries and link options in the correct order relative to other libraries used
at link time.

Perform the following steps to patch the system compiler scripts.  The patch 
provided in the Darshan source tree was generated against the xt-asyncpe-5.10
environment, but it should also work on similar versions as well. 

----
cd $ASYNCPE_DIR/bin
patch -p1 --dry-run < /home/carns/darshan-2.2.3/darshan-runtime/share/cray/cray-xt-asyncpe-5.10-darshan.patch
# CONFIRM THE RESULTS OF THE DRY RUN SHOWN ABOVE
patch -p1 < /home/carns/darshan-2.2.3/darshan-runtime/share/cray/cray-xt-asyncpe-5.10-darshan.patch
----

The next step is to install the Darshan software module.  Note that the module
file will be found in the Darshan installation directory, as it is generated 
automatically based on configuration parameters:

----
cp -r /soft/darshan-2.2.3/share/cray/modulefiles/darshan /opt/modulefiles/
----

Users (or administrators) can now enable or disable darshan instrumentation by 
loading or unloading the "darshan" module.  Note that the module file also
includes commented-out examples that may be useful for deploying Darshan in
different configurations, including how to use LD_PRELOAD for dynamically
linked executables and how to use Darshan with a different set of compiler
scripts than those found in the normal system path.

==== Compiler wrappers (user installation)

In order to install Darshan for a single user in a Cray environment, the steps
are similar to those described above, except that the compiler script
modifications are applied to a local copy of the compiler scripts and the 
Darshan module is added locally rather than globally:

----
mkdir xt-asyncpe-darshan
cp -r $ASYNCPE_DIR/* xt-asyncpe-darshan
cd xt-asyncpe-darshan/bin
patch -p1 --dry-run < /home/carns/darshan-2.2.3/darshan-runtime/share/cray/cray-xt-asyncpe-5.10-darshan.patch
# CONFIRM THE RESULTS OF THE DRY RUN SHOWN ABOVE
patch -p1 < /home/carns/darshan-2.2.3/darshan-runtime/share/cray/cray-xt-asyncpe-5.10-darshan.patch

module use /soft/darshan-2.2.3/share/cray/modulefiles/
----

In addition to loading the "darshan" software module, in order to use the 
modified compiler script you must also set the following environment
variables:

----
setenv ASYNCPE_DIR /home/carns/xt-asyncpe-darshan
setenv PATH "/home/carns/xt-asyncpe-darshan/bin:$PATH"
----

=== Linux clusters using Intel MPI 

Most Intel MPI installations produce dynamic executables by default.  To
configure Darshan in this environment you can use the following example:

----
./configure --with-mem-align=8 --with-log-path=/darshan-logs --with-jobid-env=PBS_JOBID CC=mpicc
----

.Rationale
[NOTE]
====
There is nothing unusual in this configuration except that you should use
the underlying GNU compilers rather than the Intel ICC compilers to compile
Darshan itself.
====

You can use the `LD_PRELOAD` method described earlier in this document to
instrument executables compiled with the Intel MPI compiler scripts.  This
method has been briefly tested using both GNU and Intel compilers.

.Caveat
[NOTE]
====
Darshan is only known to work with C and C++ executables generated by the
Intel MPI suite.  Darshan will not produce instrumentation for Fortran
executables.  For more details please check this Intel forum discussion:

http://software.intel.com/en-us/forums/showthread.php?t=103447&o=a&s=lr
====

=== Linux clusters using MPICH or OpenMPI

Follow the generic instructions provided at the top of this document.  The
only modification is to make sure that the `CC` used for compilation is
based on a GNU compiler.  Once Darshan has been installed, it should be
capable of instrumenting executables built with GNU, Intel, and PGI
compilers.