1. Introductionto top

1.1. Document Scope and Assumptions

This document provides an overview and introduction to the use of the HPE SGI 8600, Gaffney, located at the Navy DSRC, along with a description of the specific computing environment on Gaffney. The intent of this guide is to provide information that will enable the average user to perform computational tasks on the system. To receive the most benefit from the information provided here, you should be proficient in the following areas:

1.2. Policies to Review

Users are expected to be aware of the following policies for working on Gaffney.

1.2.1. Login Node Abuse Policy

The login nodes provide login access for Gaffney and support such activities as compiling, editing, and general interactive use by all users. Consequently, memory- or CPU-intensive programs running on the login nodes can significantly affect all users of the system. Therefore, only small serial applications requiring less than 15 minutes of compute time and less than 8 GB of memory are allowed on the login nodes. Any jobs running on the login nodes that exceed these limits will be terminated.

1.2.2. Workspace Purge Policy

Close management of space in the /p/work1 file system is a high priority. Files in the /p/work1 file system that have not been accessed in 21 days are subject to the purge cycle. If available space becomes critically low, a manual purge may be run, and all files in /p/work1 are eligible for deletion. Using the touch command (or similar commands) to prevent files from being purged is prohibited. Users are expected to keep up with file archival and removal within the normal purge cycles.

Note! If it is determined as part of the normal purge cycle that files in your $WORKDIR directory must be deleted, you WILL NOT be notified prior to deletion. You are responsible to monitor your workspace to prevent data loss.

1.3. Obtaining an Account

The process of getting an account on the HPC systems at any of the DSRCs begins with getting an account on the HPCMP Portal to the Information Environment, commonly called a "pIE User Account." If you do not yet have a pIE User Account, please visit HPC Centers: Obtaining an Account and follow the instructions there. If you need assistance with any part of this process, please contact the HPC Help Desk at accounts@helpdesk.hpc.mil.

1.4. Requesting Assistance

The HPC Help Desk is available to help users with unclassified problems, issues, or questions. Analysts are on duty 8:00 a.m. - 8:00 p.m. Eastern, Monday - Friday (excluding Federal holidays).

You can contact the Navy DSRC in any of the following ways for after-hours support and for support services not provided by the HPC Help Desk :

For more detailed contact information, please see our Contact Page.

2. System Configurationto top

2.1. System Summary

Gaffney is an HPE SGI 8600 system. The login and compute nodes are populated with Intel Xeon Platinum 8168 (Skylake) processors clocked at 2.7 GHz. Gaffney uses the Intel Omni-Path interconnect in a Non-Blocking Fat Tree as its high-speed network for MPI messages and I/O traffic. Gaffney uses Lustre to manage its parallel file system that targets the disk RAID arrays.

Gaffney has 752 compute nodes that share memory only on the node; memory is not shared across the nodes.

Each standard compute node has two 24-core processors (48 cores) sharing 192 GB of DDR4 memory, with no user-accessible swap space.

Each large-memory compute node has two 24-core processors (48 cores) sharing 768 GB of DDR4 memory, with no user-accessible swap space.

Each GPU compute node has two 24-core processors (48 cores) and one NVIDA Tesla P100 GPU with its own Red Hat Enterprise Linux operating system, sharing 384 GB of DDR4 memory, with no user-accessible swap space.

As of October 2019, 16 recently expanded GPGPU nodes (17-32) are similar in configuration to the existing GPGPU nodes, with the exception of one key differentiator; the availability of 500+ GB of local NVMe scratch space (available at /tmp/scratch on the nodes). This space will allow users to load data locally on the node(s) for faster processing and I/O.

Gaffney is rated at 3.29 peak PFLOPS and has 5.5 PB (formatted) of parallel disk storage.

Gaffney is intended to be used as a batch-scheduled HPC system. Its login nodes are not to be used for large computational (e.g., memory, I/O, long executions) work. All executions that require large amounts of system resources must be sent to the compute nodes by batch job submission.

2.2. Processors

Gaffney uses the 2.7-GHz Intel Skylake Xeon processors (XSPF 8168) on its login, standard-memory and large-memory compute nodes. There are two processors per node with 24 cores, for a total of 48 cores per node. Each processor has a 33-MB L3 cache.

GPU nodes use the 2.7-GHz Intel Skylake Xeon processors (XSPF 8168). There are two processors per node with 24 cores, for a total of 48 cores per node. Each processor has a 33-MB L3 cache. Each GPU node has an NVIDIA Tesla P100 GPU with 3,584 cores.

2.3. Memory

Gaffney uses both shared- and distributed-memory models. Memory is shared among all the cores on a node, but is not shared among the nodes across the cluster.

Each login node contains 384 GB of main memory. All memory and cores on the node are shared among all users who are logged in. Therefore, users should not use more than 8 GB of memory at any one time.

Each standard compute node contains 180 GB of user-accessible shared memory.

Each large-memory compute node, available exclusively via the bigmem queue, contains 744 GB of user-accessible shared memory.

Each GPU node, available exclusively via the gpu queue, contains 372 GB of user-accessible shared memory on the standard compute portion of the node and approximately 16 GB on the NVIDIA Tesla P100 portion of the node.

2.4. Operating System

The operating system on Gaffney is RedHat Linux.

2.5. File Systems

Gaffney has the following file systems available for user storage:

2.5.1. /p/home/

This file system is locally mounted from Gaffney's Lustre file system and has a formatted capacity of 346 TB. All users have a home directory located on this file system which can be referenced by the environment variable $HOME.

2.5.2. /p/work1/

This file system is locally mounted from Gaffney's Lustre file system and is tuned for parallel I/O. It has a formatted capacity of 5.5 PB. All users have a work directory located on this file system which can be referenced by the environment variable $WORKDIR. This file system is not backed up. Users are responsible for making backups of their files to the archive server or to some other local system.

2.5.3. /p/work2/

This file system is locally mounted from Gaffney's Lustre file system that is tuned for parallel I/O operations. It has a formatted capacity of 111 TB. Users need to request special access to make use of work2, given the constraints on number of overwrites of the solid state devices that comprise work2.

2.5.4. /p/work3/

This file system is a locally mounted Lustre file system comprised of NVMe SSDs targeted for data intensive (artificial intelligence, machine learning, or data analytics), metadata or IOPS-bound workloads (thousands or millions of small files being read or written). The /p/work3 Lustre file system has a formatted capacity of 350 TB, and can provide up to 1.5 million input/output operations per second (IOPS) for certain workloads. Users need to request special access to make use of work3, given the constraints on number of overwrites of the solid state devices that comprise work3.

2.5.5. /p/cwfs/

This path is directed to the Center-Wide File System (CWFS) which is meant for short-term storage (no longer than 180 days). All users have a directory defined in this file system which can be referenced by the environment variable $CENTER. It is accessible from the HPC system login nodes and the HPC Portal. The CWFS has a formatted capacity of 3300 TB and is managed by IBM's Spectrum Scale (formerly GPFS).

2.6. Peak Performance

Gaffney is rated at 3.29 peak PFLOPS.

3. Accessing the Systemto top

3.1. Kerberos

A Kerberos client kit must be installed on your desktop to enable you to get a Kerberos ticket. Kerberos is a network authentication tool that provides secure communication by using secret cryptographic keys. Only users with a valid HPCMP Kerberos authentication can gain access to Gaffney. More information about installing Kerberos clients on your desktop can be found at HPC Centers: Kerberos & Authentication.

3.2. Logging In

The system host name for the Gaffney cluster is gaffney.navydsrc.hpc.mil, which will redirect the user to one of six login nodes. Hostnames and IP addresses to these nodes are available upon request from the HPC Help Desk.

3.3. File Transfers

File transfers to DSRC systems (except those to the local archive system) must be performed using Kerberized versions of the following tools: scp, mpscp, sftp, and kftp. Before using any Kerberized tool, you must use a Kerberos client to obtain a Kerberos ticket. Information about installing and using a Kerberos client can be found at HPC Centers: Kerberos & Authentication.

The command below uses secure copy (scp) to copy a single local file into a destination directory on a Gaffney login node. The mpscp command is similar to the scp command, but has a different underlying means of data transfer, and may enable greater transfer rate. The mpscp command has the same syntax as scp.

Both scp and mpscp can be used to send multiple files. This command transfers all files with the .txt extension to the same destination directory.

The example below uses the secure file transfer protocol (sftp) to connect to Gaffney, then uses the sftp "cd" and "put" commands to change to the destination directory and copy a local file there. The sftp "quit" command ends the sftp session. Use the sftp "help" command to see a list of all sftp commands.

The Kerberized file transfer protocol (kftp) command differs from sftp in that your username is not specified on the command line, but given later when prompted. The kftp command may not be available in all environments.

Windows users may use a graphical file transfer protocol (ftp) client such as FileZilla.

4. User Environmentto top

4.1. User Directories

The following user directories are provided for all users on Gaffney.

4.1.1. Home Directory

When you log on to Gaffney, you will be placed in your home directory, /p/home/username. The environment variable $HOME is automatically set for you and refers to this directory. $HOME is visible to both the login and compute nodes, and may be used to store small user files. It has an initial quota of 200 GB. $HOME is not intended as permanent storage, but files stored in $HOME are not subject to being purged.

4.1.2. Work Directory

Gaffney has one large file system, /p/work1, for the temporary storage of data files needed for executing programs. You may access your personal working directory by using the $WORKDIR environment variable, which is set for you upon login. Your $WORKDIR directory has an initial quota of 20 TB. Your $WORKDIR and the /p/work1 file system will fill up as jobs run. Please review the Purge Policy and be mindful of your disk usage.

REMEMBER: /p/work1 is a "scratch" file system and is not backed up. You are responsible for managing files in your $WORKDIR by backing up files to the archive server and deleting unneeded files when your jobs end. See the section below on Archive Usage for details.

All of your jobs should execute from your $WORKDIR directory, not $HOME. While not technically forbidden, jobs that are run from $HOME are subject to smaller disk space quotas and have a much greater chance of failing if problems occur with that resource.

To avoid unusual errors that can arise from two jobs using the same scratch directory, a common technique is to create a unique subdirectory for each batch job by including the following lines in your batch script:

TMPD=${WORKDIR}/${PBS_JOBID}
mkdir -p ${TMPD}

4.1.3. Center Directory

The Center-Wide File System (CWFS) provides file storage that is accessible from Gaffney's login nodes. The CWFS allows file transfers and other file and directory operations from Gaffney using simple Linux commands. Each user has their own directory in the CWFS. The name of your CWFS directory may vary between machines and between centers, but the environment variable $CENTER will always refer to this directory.

The example below shows how to copy a file from your work directory on Gaffney to the CWFS ($CENTER). While logged into Gaffney, copy your file from your Gaffney work directory to the CWFS.

% cp $WORKDIR/filename $CENTER

4.2. Shells

The following shells are available on Gaffney: csh, bash, ksh, tcsh, zsh, and sh. To change your default shell, please email a request to require@hpc.mil. Your preferred shell will become your default shell on the Gaffney cluster within 1-2 working days.

4.3. Environment Variables

A number of environment variables are provided by default on all HPCMP HPC systems. We encourage you to use these variables in your scripts where possible. Doing so will help to simplify your scripts and reduce portability issues if you ever need to run those scripts on other systems.

4.3.1. Login Environment Variables

The following environment variables are common to both the login and batch environments:

4.3.2. Batch-Only Environment Variables

In addition to the variables listed above, the following variables are automatically set only in your batch environment. That is, your batch scripts will be able to see them when they run. These variables are supplied for your convenience and are intended for use inside your batch scripts.

4.4. Modules

Software modules are a convenient way to set needed environment variables and include necessary directories in your path so that commands for particular applications can be found. Gaffney uses "modules" to initialize your environment with COTS application software, system commands and libraries, compiler suites, environment variables, and PBS batch system commands.

A number of modules are loaded automatically as soon as you log in. To see the modules which are currently loaded, use the "module list" command. To see the entire list of available modules, use "module avail". You can modify the configuration of your environment by loading and unloading modules. For complete information on how to do this, see the Modules User Guide.

4.5. Archive Usage

All of our HPC systems have access to an online archival mass storage system that provides long-term storage for users' files on a petascale archival storage system that resides on a robotic tape library system. A 60-TB disk cache frontends the tape file system and temporarily holds files while they are being transferred to or from tape.

Tape file systems have very slow access times. The tapes must be robotically pulled from the tape library, mounted in one of the limited number of tape drives, and wound into position for file archival or retrieval. For this reason, users should always tar up their small files in a large tarball when archiving a significant number of files. A good maximum target size for tarballs is about 200 GB or less. At that size, the time required for file transfer and tape I/O is reasonable. Files larger than 1 TB may span more than one tape, which will greatly increase the time required for both archival and retrieval.

The environment variables $ARCHIVE_HOST and $ARCHIVE_HOME are automatically set for you. $ARCHIVE_HOST can be used to reference the archive server, and $ARCHIVE_HOME can be used to reference your archive directory on the server. These variables can be used when transferring files to/from archive.

4.5.1. Archival Command Synopsis

A synopsis of the main archival utilities is listed below. For information on additional capabilities, see the Archive User Guide or read the online man pages that are available on each system. These commands are non-Kerberized and can be used in batch submission scripts if desired.

• Copy one or more files from the archive server
  rcp ${ARCHIVE_HOST}:${ARCHIVE_HOME}/file_name ${WORKDIR}/proj1

• List files and directory contents on the archive server
  rsh ${ARCHIVE_HOST} ls [lsopts] [file/dir ...]

• Create directories on the archive server
  rsh ${ARCHIVE_HOST} mkdir [-p] [-s] dir1 [dir2 ...]

• Copy one or more files to the archive server
  rcp ${WORKDIR}/proj1/file_name ${ARCHIVE_HOST}:${ARCHIVE_HOME}/proj1

5. Program Developmentto top

5.1. Programming Models

Gaffney supports two parallel programming models: Message Passing Interface (MPI) and Open Multi-Processing (OpenMP). A Hybrid MPI/OpenMP programming model is also supported. MPI is an example of the message- or data-passing models, while OpenMP uses only shared memory on a node by spawning threads. And, the hybrid model combines both models.

5.1.1. Message Passing Interface (MPI)

Gaffney has MPI libraries from HPE SGI and Intel. SGI's Message Passing Toolkit (MPT) and Intel's MPI support the MPI 3.0 standard, as documented by the MPI Forum. The Message Passing Interface (MPI) is part of the software support for parallel programming across a network of computer systems through a technique known as message passing. MPI establishes a practical, portable, efficient, and flexible standard for message passing that makes use of the most attractive features of a number of existing message-passing systems, rather than selecting one of them and adopting it as the standard. See "man intro_mpi" for additional information.

When creating an MPI program on Gaffney, ensure the following:

• That either the Message Passing Toolkit (module mpt) or Intel MPI (module compiler/intelmpi) has been loaded. To check this, run the "module list" command. If neither module is listed, use one of the following commands:

  module load mpt

  or

  module load compiler/intelmpi

• That the source code includes one of the following lines:

  INCLUDE "mpif.h"        ## for Fortran, or
  #include <mpi.h>        ## for C/C++

Using the HPE SGI MPI Library

To compile an MPI program, use the following examples:

For C Codes:

icc -o mpi_program mpi_program.c –lmpi	## Intel
gcc -o mpi_program mpi_program.c –lmpi	## GNU
pgcc –o mpi_program mpi_program.c –lmpi	## PGI
        

For Fortran Codes:

ifort -o mpi_program mpi_program.f –lmpi	## Intel
gfortran -o mpi_program mpi_program.f –lmpi	## GNU
pgf77 –o mpi_program mpi_program.f –lmpi	## PGI
pgf90 –o mpi_program mpi_program.f90 –lmpi	## PGI
        

To run an MPI program within a batch script, use the following command:

mpiexec_mpt -np mpi_procs mpi_program [user_arguments]

where mpi_procs is the number of MPI processes being started. For example:

#### Starts 96 MPI processes; 48 on each node, one per core
## request 2 nodes, each with 48 cores and 48 processes per node
#PBS -l select=2:ncpus=48:mpiprocs=48
mpiexec_mpt -np 96 ./a.out

The mpiexec_mpt command launches executables across a set of compute nodes allocated to your job and, by default, utilizes all cores and nodes available to your job. When each member of the parallel application has exited, mpiexec_mpt exits.

A common concern for MPI users is the need for more memory for each process. By default, one MPI process is started on each core of a node. This means that on Gaffney, the available memory on the node is split 48 ways. To allow an individual process to use more of the node's memory, you need to start fewer processes on that node. To accomplish this, the user must request more nodes from PBS, but only run on a certain number of them. For example, the following select statement requests 8 nodes, with 48 cores per node, but only uses 12 of those cores for MPI processes:

#### Starts 48 MPI processes; only 12 on each node
## request 8 nodes, each with 48 cores and 12 processes per node
#PBS -l select=8:ncpus=48:mpiprocs=12
mpiexec_mpt -np 96 ./a.out

For more information about mpiexec_mpt, type "man mpiexec_mpt".

Using the Intel MPI Library

When compiling with the Intel MPI library on Gaffney, swap the default HPE SGI MPI module for an Intel MPI module, as follows:

module swap mpt compiler/intelmpi

To compile using the Intel MPI library, use one of the following examples:

mpiicc –o mpi_program mpi_program.c	## for C
mpiicpc –o mpi_program mpi_program.C	## for C++
mpiifort –o mpi_program mpi_program.f	## for Fortran

To run your program within a batch script, source the module init script that matches your script shell, swap to the Intel MPI library that you compiled with, and then use the Intel launch command, mpirun. For example:

source $MODULESHOME/modules.csh	## for csh and tcsh shell batch scripts

or

. $MODULESHOME/modules.sh	## for bash, ksh, and sh shell batch scripts

module swap mpt compiler/intelmpi
mpirun -np mpi_procs ./mpi_program

where mpi_procs is the number of processes being started. For example:

#### Starts 64 MPI processes; 8 on each node
## Request 8 nodes, each with 48 cores
#PBS -l select=8:ncpus=48:mpiprocs=8
mpirun -np 64 ./mpi_program

For more information about mpirun, type "man mpirun".

5.1.2. Open Multi-Processing (OpenMP)

OpenMP is a portable, scalable model that gives programmers a simple and flexible interface for developing parallel applications. It supports shared-memory multiprocessing programming in C, C++, and Fortran, and consists of a set of compiler directives, library routines, and environment variables that influence compilation and run-time behavior.

When creating an OpenMP program on Gaffney, ensure the following:

• If using OpenMP functions (for example, omp_get_wtime), that the source code includes one of the following lines:

  INCLUDE 'omp.h'      ## for Fortran

  or

  #include <omp.h>    ## for C/C++

  Or, if the code is written in Fortran 90 or later, the following line may be used instead:

  USE omp_lib

• That the compile command includes an option to reference the OpenMP library. The Intel, PGI, and GNU compilers support OpenMP, and each one uses a different option.

To compile an OpenMP program, use the following examples:

For C codes:

icc –openmp -o OpenMP_program OpenMP_program.c	      ## Intel
pgcc –mp-nonuma –o OpenMP_program OpenMP_program.c    ## PGI
gcc –fopenmp -o OpenMP_program OpenMP_program.c	      ## GNU 

For C++ codes:

icpc –openmp -o OpenMP_program OpenMP_program.c	      ## Intel
pgcc –mp-nonuma -o OpenMP_program OpenMP_program.c    ## PGI
g++ –fopenmp -o OpenMP_program OpenMP_program.c	      ## GNU

For Fortran codes:

ifort –openmp -o OpenMP_program OpenMP_program.f      ## Intel 
pgf77 –openmp -o OpenMP_program OpenMP_program.f      ## PGI
gfortran –fopenmp -o OpenMP_program OpenMP_program.f  ## GNU

See section 5.2 for additional information on available compilers.

When running OpenMP applications, the $OMP_NUM_THREADS environment variable must be used to specify the number of threads. For example:

export OMP_NUM_THREADS=48
./OpenMP_program [user_arguments]

In the example above, the application starts the OpenMP_program on one node and spawns a total of 48 threads. Since Gaffney has 48 cores per compute node, this yields 1 thread per core.

5.1.3. Hybrid Processing (MPI/OpenMP)

An application built with the hybrid model of parallel programming can run on Gaffney using both OpenMP and Message Passing Interface (MPI). In hybrid applications, OpenMP threads can be spawned by MPI processes, but MPI calls should not be issued from OpenMP parallel regions or by an OpenMP thread.

When creating a hybrid (MPI/OpenMP) program on Gaffney, follow the instructions in the MPI and OpenMP sections above for creating your program. Then use the compilation instructions for OpenMP.

To run a hybrid program within a batch script, set $OMP_NUM_THREADS equal to the number of threads in the team. Then launch your program using mpiexec_mpt as follows:

####  MPI/OpenMP on 4 nodes, 8 MPI processes total with 6 threads each
## request 4 nodes, each with 48 cores and 2 processes per node
#PBS -l select=4:ncpus=48:mpiprocs=2:ompthreads=6
## assign 8 MPI processes with 2 MPI processes per node
export OMP_NUM_THREADS=48
mpiexec_mpt –np 8 omplace ./mpi_program

5.2. Available Compilers

Gaffney has three programming environment suites.

• Intel
• Portland Group (PGI)
• GNU

Gaffney has two MPI suites.

• SGI MPT
• Intel MPI

All versions of MPI share a common base set of compilers that are available on both the login and compute nodes.

SGI MPT codes are built using the above compiler commands with addition of "-lmpi" option on the link line. The following additional compiler wrapper scripts are used for building intelMPI codes:

To select one of these compilers for use, load its associated module. See Relevant Modules (below) to learn how.

5.2.1. Intel Compiler Environment

The following table lists some of the more common options that you may use:

Detailed information about these and other compiler options is available in the Intel compiler (ifort, icc, and icpc) man pages on Gaffney.

5.2.2. Portland Group (PGI) Compiler Suite

The PGI Programming Environment provides a large number of options that are the same for all compilers in the suite. The following table lists some of the more common options that you may use:

Detailed information about these and other compiler options is available in the PGI compiler (pgf95, pgcc, and pgCC) man pages on Gaffney.

5.2.3. GNU Compiler Collection

The GNU Programming Environment provides a large number of options that are the same for all compilers in the suite. The following table lists some of the more common options that you may use:

Detailed information about these and other compiler options is available in the GNU compiler (gfortran, gcc, and g++) man pages on Gaffney.

5.3. Relevant Modules

By default, Gaffney loads the Intel compiler and SGI MPT environments for you. For more information on using modules, see the Modules User Guide.

5.4. Libraries

5.4.1. Intel Math Kernel Library (MKL)

Gaffney provides the Intel Math Kernel Library (Intel MKL), a set of numerical routines tuned specifically for Intel platform processors and optimized for math, scientific, and engineering applications. The routines, which are available via both FORTRAN and C interfaces, include:

• LAPACK plus BLAS (Levels 1, 2, and 3)
• ScaLAPACK plus PBLAS (Levels 1, 2, and 3)
• Fast Fourier Transform (FFT) routines for single-precision, double-precision, single-precision complex, and double-precision complex data types
• Discrete Fourier Transforms (DFTs)
• Fast Math and Fast Vector Library
• Vector Statistical Library Functions (VSL)
• Vector Transcendental Math Functions (VML)

The MKL routines are part of the Intel Programming Environment as Intel's MKL is bundled with the Intel Compiler Suite.

Linking to the Intel Math Kernel Libraries can be complex and is beyond the scope of this introductory guide. Documentation explaining the full feature set along with instructions for linking can be found at the Intel Math Kernel Library documentation page.

Intel also makes a link advisor available to assist users with selecting proper linker and compiler options: http://software.intel.com/sites/products/mkl.

5.4.2. Additional Math Libraries

There is also an extensive set of Math libraries available in the $PET_HOME/MATH directory on Gaffney. Information about these libraries can be found on the Baseline Configuration website at BC policy FY13-01.

5.5. Debuggers

Gaffney provides the DDT and GNU Project Debugger (gdb) debuggers to assist users in debugging their code.

5.5.1. Forge DDT

DDT supports threads, MPI, OpenMP, C/C++, Fortran, Co-Array Fortran, UPC, and CUDA. Memory debugging and data visualization are supported for large-scale parallel applications. The Parallel Stack Viewer is a unique way to see the program state of all processes and threads at a glance.

DDT is a graphical debugger; therefore, you must be able to display it via a UNIX X-Windows interface. There are several ways to do this including SSH X11 Forwarding, HPC Portal, or SRD. Follow the steps below to use DDT via X11 Forwarding or Portal.

1. Choose a remote display method: X11 Forwarding, HPC Portal, or SRD. X11 Forwarding is easier but typically very slow. HPC Portal requires no extra clients and is typically fast. SRD requires an extra client but is typically fast and may be a good option if doing a significant amount of X11 Forwarding.
   1. To use X11 Forwarding:
      1. Ensure an X server is running on your local system. Linux users will likely have this by default, but MS Windows users need to install a third-party X Windows solution. There are various options available.
      2. For Linux users, connect to Gaffney using ssh -Y. Windows users need to use PuTTY with X11 forwarding enabled (Connection->SSH->X11->Enable X11 forwarding).
   2. Or to use HPC Portal:
      1. Navigate to https://centers.hpc.mil/portal.
      2. Select HPC Portal at Navy.
      3. Select XTerm -> Navy -> Gaffney.
   3. Or, for information on using SRD, see the SRD User Guide.
2. Compile your program with the -g option.

3. Submit an interactive job:

   qsub -l select=1:ncpus=48:mpiprocs=48 -A Project_ID -l walltime=00:30:00 -q debug -l application=Application_Name -X -I

4. Load the Forge DDT module:

   module load forge

5. Start program execution:

   ddt -n 4 ./my_mpi_program arg1 arg2 ...

   (Example for 4 MPI ranks)
6. The DDT window will pop up. Verify the application name and number of MPI processes. Click "Run".

An example of using DDT can be found in $SAMPLES_HOME/Programming/DDT_Example on Gaffney.

5.5.2. GDB

The GNU Project Debugger (gdb) is a source-level debugger that can be invoked either with a program for execution or a running process id. To launch your program under gdb for debugging, use the following command:

gdb a.out corefile

To attach gdb to a program that is already executing on a node, use the following command:

gdb a.out pid

For more information, the GDB manual can be found at http://www.gnu.org/software/gdb.

5.6. Code Profiling and Optimization

Profiling is the process of analyzing the execution flow and characteristics of your program to identify sections of code that are likely candidates for optimization, which increases the performance of a program by modifying certain aspects for increased efficiency.

We provide two profiling tools: gprof and codecov to assist you in the profiling process. In addition, a basic overview of optimization methods with information about how they may improve the performance of your code can be found in Performance Optimization Methods (below).

5.6.1. gprof

The GNU Project Profiler (gprof) is a profiler that shows how your program is spending its time and which function calls are made. To profile code using gprof, use the "-pg" option during compilation.

5.6.2. Codecov

The Intel Code Coverage Tool (codecov) can be used in numerous ways to improve code efficiency and increase application performance. The tool leverages Profile-Guided optimization technology (discussed below). Coverage can be specified in the tool as file-level, function-level or block-level. Another benefit to this tool is the ability to compare the profiles of two application runs to find where the optimizations are making a difference.

5.6.3. Additional Profiling Tools

There is also a set of profiling tools available in the $PET_HOME/pkgs directory on Gaffney. Information about these tools may be found on the Baseline Configuration Web site at BC policy FY13-01.

5.6.4. Program Development Reminders

If an application is not programmed for distributed memory, then only the cores on a single node can be used. This is limited to 48 cores on Gaffney.

Keep the system architecture in mind during code development. For instance, if your program requires more memory than is available on a single node, then you will need to parallelize your code so that it can function across multiple nodes.

5.6.5. Compiler Optimization Options

The "-Olevel" option enables code optimization when compiling. The level that you choose (0-4) will determine how aggressive the optimization will be. Increasing levels of optimization may increase performance significantly, but you should note that a loss of precision may also occur. There are also additional options that may enable further optimizations. The following table contains the most commonly used options.

5.6.6. Performance Optimization Methods

Optimization generally increases compilation time and executable size, and may make debugging difficult. However, it usually produces code that runs significantly faster. The optimizations that you can use will vary depending on your code and the system on which you are running.

Note: Before considering optimization, you should always ensure that your code runs correctly and produces valid output.

In general, there are four main categories of optimization:

Global Optimization

A technique that looks at the program as a whole and may perform any of the following actions:

Loop Optimization

A technique that focuses on loops (for, while, etc.,) in your code and looks for ways to reduce loop iterations or parallelize the loop operations. The following types of actions may be performed:

Interprocedural Analysis and Optimization (IPA)

A technique that allows the use of information across function call boundaries to perform optimizations that would otherwise be unavailable.

Function Inlining

A technique that seeks to reduce function call and return overhead. It:

6. Batch Schedulingto top

6.1. Scheduler

The Portable Batch System (PBS) is currently running on Gaffney. It schedules jobs and manages resources and job queues, and can be accessed through the interactive batch environment or by submitting a batch request. PBS is able to manage both single-processor and multiprocessor jobs. The PBS module is automatically loaded for you when you log in.

6.2. Queue Information

The following table describes the PBS queues available on Gaffney:

Queue Descriptions and Limits on Gaffney

Priority	Queue Name	Max Wall Clock Time	Max Cores Per Job	Description
Highest	urgent	24 Hours	768	Jobs belonging to DoD HPCMP Urgent Projects
	debug	30 Minutes	2,400	Time/resource-limited for user testing and debug purposes
	HIE	24 Hours	384	Rapid response for interactive work. For more information see the HPC Interactive Environment (HIE) User Guide.
	high	168 Hours	15,840	Jobs belonging to DoD HPCMP High Priority Projects
	frontier	168 Hours	14,400	Jobs belonging to DoD HPCMP Frontier Projects
	standard	168 Hours	8,160	Standard jobs
	gpu	24 Hours	384	GPU-accelerated jobs
	serial	168 Hours	1	Serial jobs
	bigmem	96 Hours	720	Large-memory jobs
	transfer	48 Hours	N/A	Data transfer for user jobs. See the Navy DSRC Archive Guide, section 5.2.
Lowest	background	4 Hours	1,200	User jobs that are not charged against the project allocation

6.3. Interactive Logins

When you log in to Gaffney, you will be running in an interactive shell on a login node. The login nodes provide login access for Gaffney and support such activities as compiling, editing, and general interactive use by all users. Please note the Login Node Abuse policy. The preferred method to run resource intensive executions is to use an interactive batch session.

6.4. Interactive Batch Sessions

An interactive session on a compute node is possible using the PBS qsub command with the "-I" option from a login node. Once PBS has scheduled your request to the specified queue, you will be directly logged into a compute node, and this session can last as long as your requested wall time. For example:

You must specify the number of nodes requested (N1), the number of processes per node (N2), the desired maximum walltime, your project ID, and a job queue. Valid values for N2 are between 1 and 48.

Your interactive batch sessions will be scheduled just as normal batch jobs are scheduled depending on the other queued batch jobs, so it may take quite a while. Once your interactive batch shell starts, you can run or debug interactive applications, post-process data, etc.

At this point, you can launch parallel applications on your assigned set of compute nodes by using the mpiexec_mpt command. You can also run interactive commands or scripts on this node.

6.5. Batch Request Submission

PBS batch jobs are submitted via the qsub command. The format of this command is:

qsub [ options ] batch_script_file

qsub options may be specified on the command line or embedded in the batch script file by lines beginning with "#PBS".

For a more thorough discussion of PBS batch submission on Gaffney, see the Gaffney PBS Guide.

6.6. Batch Resource Directives

Batch resource directives allow you to specify to PBS how your batch jobs should be run and what resources your job requires. Although PBS has many directives, you only need to know a few to run most jobs.

The basic syntax of PBS directives is as follows:

#PBS option[[=]value]

where some options may require values to be included. For example, to start a 24-process job, you would request one node of 48 cores and specify that you will be running 24 processes per node:

#PBS -l select=1:ncpus=48:mpiprocs=24

If you wanted to specify just to run on GPU nodes (17-32) that have access to high-performance NVMe SSD storage the following is an example:

#PBS –l select=1:ncpus=48:ngpu=1:nvme=1

The following directives are required for all jobs:

A more complete listing of batch resource directives is available in the Gaffney PBS Guide.

6.7. Launch Commands

There are different commands for launching MPI executables from within a batch job depending on which MPI implementation your script uses.

To launch an SGI MPT executable, mpiexec_mpt command as follows:

mpiexec_mpt -n #_of_MPI_tasks ./mpijob.exe

To launch an IntelMPI executable, use the mpirun command as follows:

mpirun ./mpijob.exe

For OpenMP executables, no launch command is needed.

6.8. Sample Scripts

While it is possible to include all PBS directives at the qsub command line, the preferred method is to embed the PBS directives within the batch request script using "#PBS". The following script is a basic example and contains all of the required directives, some frequently used optional directives, and common script components. It starts 96 processes on 2 nodes of 48 cores each, with one MPI process per core. More thorough examples are available in the Gaffney PBS Guide and in the Sample Code Repository ($SAMPLES_HOME) on Gaffney.

The following example is a good starting template for a batch script to run a serial job for one hour:

#!/bin/bash ## Specify your shell
#
# Specify name of the job
#PBS -N serialjob
#
# Append std output to file serialjob.out 
#PBS -o serialjob.out
#
# Append std error to file serialjob.err
#PBS -e serialjob.err
#
# Specify Project ID to be charged (Required)
#PBS -A Project_ID
#
# Request wall clock time of 1 hour (Required)
#PBS -l walltime=01:00:00
#
# Specify queue name (Required)
#PBS -q standard
#
# Specify the number cores (Required)
#PBS -l select=1:ncpus=1
#
#PBS -S /bin/bash
# Change to the specified directory
cd $WORKDIR
#
# Execute the serial executable on 1 core
./serial_fort.exe
# End of batch job

The first few lines tell PBS to save the standard output and error output to the given files, and to give the job a name. Skipping ahead, we estimate the run-time to be about one hour and know that this is acceptable for the standard batch queue. We need one core in total, so we request one core.

The following example is a good starting template for a batch script to run a parallel (MPI) job for two hours:

#!/bin/bash
## The first line (above) specifies the shell to use for parsing 
## the remaining lines of the batch script.
#
## Required PBS Directives --------------------------------------
#PBS -A Project_ID
#PBS -q standard
#PBS -l select=2:ncpus=48:mpiprocs=48
#PBS -l walltime=02:00:00
#
## Optional PBS Directives --------------------------------------
#PBS -N Test_Run_1
#PBS -j oe
#PBS -V
#PBS -S /bin/bash
#
## Execution Block ----------------------------------------------
# Environment Setup
# cd to your personal directory in the scratch file system
cd $WORKDIR
#
# create a job-specific subdirectory based on JOBID and cd to it
JOBID=`echo $PBS_JOBID | cut -d '.' -f 1`
if [ ! -d $JOBID ]; then
  mkdir -p $JOBID
fi
cd $JOBID
#
# Launching
# copy executable from $HOME and submit it
cp $HOME/mympiprog.exe .
mpiexec_mpt -n 96 ./mympiprog.exe > mympiprog.out
#
# Clean up
# archive your results
# Using the "here document" syntax, create a job script
# for archiving your data.
cd $WORKDIR
rm -f archive_job
cat > archive_job << END
#!/bin/bash
#PBS -l walltime=06:00:00
#PBS -q transfer
#PBS -A Project_ID
#PBS -l select=1:ncpus=1
#PBS -j oe
#PBS -S /bin/bash
cd $WORKDIR
rsh $ARCHIVE_HOST mkdir $ARCHIVE_HOME/$JOBID
rcp -r $JOBID $ARCHIVE_HOST:$ARCHIVE_HOME/
rsh $ARCHIVE_HOST ls -l $ARCHIVE_HOME/$JOBID
# Remove scratch directory from the file system.
rm -rf $JOBID
END
#
# Submit the archive job script.
qsub archive_job
# End of batch job

The first few lines tell PBS to save the standard output and error output to the given files, and to give the job a name. Skipping ahead, we estimate the run-time to be about 2 hours and know that this is acceptable for the standard batch queue. The next couple of lines set the total number of cores and the number of cores per node for the job. This job is requesting 96 total cores and 48 cores per node allowing the job to run on 2 nodes. The default value for number of cores per node is 48.

Additional examples are available in the Gaffney PBS Guide and in the Sample Code Repository ($SAMPLES_HOME) on Gaffney.

6.9. PBS Commands

The following commands provide the basic functionality for using the PBS batch system:

qsub: Used to submit jobs for batch processing.
qsub [ qsub_options ] my_job_script

qstat: Used to check the status of submitted jobs.
qstat PBS_JOBID ## check one job
qstat -u my_user_name ## check all of user's jobs

qdel: Used to kill queued or running jobs.
qdel PBS_JOBID

A more complete list of PBS commands is available in the Gaffney PBS Guide.

6.10. Determining Time Remaining in a Batch Job

In batch jobs, knowing the time remaining before the workload management system will kill the job enables the user to write restart files or even prepare input for the next job submission. However, adding such capability to an existing source code requires knowledge to query the workload management system as well as parsing the resulting output to determine the amount of remaining time.

The DoD HPCMP allocated systems now have the library, WLM_TIME, as an easy way to provide the remaining time in the batch job to C, C++, and Fortran programs. The library can be added to your job using the following:

For C:

#include <wlm_time.h>
void wlm_time_left(long int *seconds_left)

For Fortran:

SUBROUTINE WLM_TIME_LEFT(seconds_left)
INTEGER seconds_left

For C++:

extern "C" {
#include <wlm_time.h>
}
void wlm_time_left(long int *seconds_left)

For simplicity, wall-clock-time remaining is returned as an integer value of seconds.

To simplify usage, a module file defines the process environment, and a pkg-config metadata file defines the necessary compiler linker options:

For C:

module load wlm_time
$(CC) ctest.c `pkg-config --cflags --libs wlm_time`

For Fortran:

module load wlm_time
$(F90) test.f90 `pkg-config --cflags-only-I --libs wlm_time`

For C++:

module load wlm_time
$(CXX) Ctest.C `pkg-config --cflags --libs wlm_time`

WLM_TIME works currently with PBS. The developers expect that WLM_TIME will continue to provide a uniform interface encapsulating the underlying aspects of the workload management system.

6.11. Advance Reservations

An Advance Reservation Service (ARS) is available on Gaffney for reserving cores for use, starting at a specific date/time, and lasting for a specific number of hours. The ARS is accessible via most modern web browsers at https://reservation.hpc.mil. Authenticated access is required. The ARS User Guide is available on HPC Centers.

7. Software Resourcesto top

7.1. Application Software

A complete listing with installed versions can be found on our software page. The general rule for all COTS software packages is that the two latest versions will be maintained on our systems. For convenience, modules are also available for most COTS software packages.

7.2. Useful Utilities

The following utilities are available on Gaffney. For command-line syntax and examples of usage, please see each utility's online man page.

7.3. Sample Code Repository

The Sample Code Repository is a directory that contains examples for COTS batch scripts, building and using serial and parallel programs, data management, and accessing and using serial and parallel math libraries. The $SAMPLES_HOME environment variable contains the path to this area, and is automatically defined in your login environment. Below is a listing of the examples p rovided in the Sample Code Repository on Gaffney.

8. Links to Vendor Documentationto top

8.1. HPE SGI Links

HPE Home: http://www.hpe.com

8.2. RedHat Links

RedHat Home: http://www.redhat.com

8.3. GNU Links

GNU Home: http://www.gnu.org
GNU Compiler: http://gcc.gnu.org/onlinedocs

8.4. Portland Group (PGI) Links

PGI Home: http://www.pgroup.com
Portland Group Resources Page: http://www.pgroup.com/resources
Portland Group User's Guide: http://www.pgroup.com/doc/pgiug.pdf

8.5. Intel Links

Intel Home: http://www.intel.com
Intel Documentation: http://software.intel.com/en-us/intel-software-technical-documentation
Intel Compiler List: http://software.intel.com/en-us/intel-compilers

8.6. Debugger Links

DDT Tutorials: http://www.allinea.com/tutorials