Create or change your PSC password

If you do not already have an active PSC account, you must create a PSC password (also called a PSC Kerberos password) before you can connect to Bridges. Your PSC password is the same on all PSC systems, so if you have an active account on another PSC system, you do not need to reset it before connecting to Bridges.

Your PSC password is separate from your XSEDE Portal password. Resetting one password does not change the other password.

Setting your initial PSC password

To set your initial PSC password, use the web-based PSC password change utility.

See PSC password policies.

Changing your PSC password

There are two ways to change or reset your PSC password:

• Use the "kpasswd" command when logged into a PSC system. (Do not use the "passwd" command.)

When you change your PSC password, whether you do it via the online utility or via the "kpasswd" command on one PSC system, you change it on all PSC systems.

Connect to Bridges

When you connect to Bridges, you are connecting to one of its login nodes. The login nodes are used for managing files, submitting batch jobs and launching interactive sessions. They are not suited for production computing.

See the Running Jobs section of this User Guide for information on production computing on Bridges.

There are several methods you can use to connect to Bridges.

1. You can access Bridges through a web browser by using the OnDemand software. You will still need to understand Bridges' partition structure and the options which specify job limits like time and memory use, but OnDemand provides a more modern, graphical interface to Bridges.

   See the OnDemand section of this User Guide for more information.

2. You can connect to a traditional command line interface by logging in via one of these:

   • ssh, using either XSEDE or PSC credentials. If you are registered with XSEDE for DUO Multi-Factor Authentication (MFA), you can use this security feature in connecting to Bridges.
     See the XSEDE instructions to set up DUO for MFA.
   • gsissh, if you have the Globus toolkit installed
   • XSEDE Single Sign On Hub, including using Multi-Factor authentication if you are an XSEDE user

SSH

You can use an SSH client from your local machine to connect to Bridges using either your PSC or XSEDE credentials.

SSH is a program that enables secure logins over an unsecure network. It encrypts the data passing both ways so that if it is intercepted it cannot be read.

SSH is client-server software, which means that both the user's local computer and the remote computer must have it installed. SSH server software is installed on all the PSC machines. You must install SSH client software on your local machine.

Read more about SSH in the Getting Started with HPC document.

Once you have an SSH client installed, you can use either your PSC credentials or XSEDE credentials (optionally with DUO MFA) to connect to Bridges. Note that you must have created your PSC password before you can use SSH to connect to Bridges.

Use ssh to connect to Bridges using XSEDE credentials and (optionally) DUO MFA

1. Using your SSH client, connect to hostname bridges.psc.xsede.org or bridges.psc.edu using port 2222.
   Either hostname will connect you to Bridges, but you must specify port 2222.
2. Enter your XSEDE username and password when prompted.
3. (Optional) If you are registered with XSEDE DUO, you will receive a prompt on your phone. Once you have answered it, you will be logged in.

Use ssh to connect to Bridges using PSC credentials

1. Using your SSH client, connect to hostname bridges.psc.xsede.org or bridges.psc.edu using the default port (22).
   Either hostname will connect you to Bridges. You do not have to specify the port.
2. Enter your PSC username and password when prompted.

Read more about using SSH to connect to PSC systems.

gsissh

If you have installed the Globus toolkit you can use gsissh to connect to Bridges. GsiSSH is a version of SSH which uses certificate authentication. Use the "myproxy-logon" command to get a suitable certificate. The Globus toolkit includes a man page for myproxy-logon.

See more information on the Globus Toolkit website.

Public-private keys

You can also use public-private key pairs to connect to Bridges. To do so, you must first fill out this form to register your keys with PSC.

XSEDE Single Sign On

XSEDE users can use their XSEDE usernames and passwords in the XSEDE User Portal Single Sign On Login Hub (SSO Hub) to access bridges.psc.xsede.org or bridges.psc.edu.

You must use DUO Multi-Factor Authentication in the SSO Hub.

See the XSEDE instructions to set up DUO for Multi-Factor Authentication.

Charging for Bridges use

Charges for using Bridges depend on the type of node you use, which is determined by the type of allocation you have: "Bridges regular", for Bridges' RSM (128GB) nodes; "Bridges GPU", for Bridges' GPU nodes; or "Bridges large", for Bridges LSM and ESM (3TB and 12TB) nodes.

Bridges regular

The RSM nodes are allocated as "Bridges regular". This does not include Bridges' GPU nodes. Service Units are defined in terms of compute resources:

1 SU = 1 core-hour

Bridges GPU

Bridges contains two kinds of GPU nodes: NVIDIA Tesla K80s and NVIDIA Tesla P100s. Because of the difference in node performance, the charges are different for the two types of nodes.

K80 nodes

The K80 nodes hold 4 GPU units each, which can be allocated separately. Service units (SUs) are defined in terms of GPU-hours:

1 GPU-hour = 1 SU

Note that the use of an entire K80 GPU node for one hour would be charged 4 SUs.

P100 nodes

The P100 nodes hold 2 GPU units each, which can be allocated separately. Service units (SUs) are defined in terms of GPU-hours:

1 GPU-hour = 2.5 SUs

Note that the use of an entire P100 node for one hour would be charged 5 SUs.

Bridges large

The LSM and ESM nodes are allocated as "Bridges large". Service Units are defined in terms of memory requested:

1 SU = 1 TB-hour 

Managing multiple grants

If you have more than one grant, be sure to charge your usage to the correct one. Usage is tracked by group name.

Find your group names

To find your group names, use the "id" command.

id -Gn

will list all the groups you belong to.

Find your current group

id -gn

will list the group you associated with your current session.

Charge to a (non-default) group

Batch jobs and interactive sessions are charged to your primary group by default. To charge your usage to a different group, you must specify the appropriate group with the -A groupname option to the Slurm "sbatch" command. See the Running Jobs section of this Guide for more information on batch jobs, interactive sessions and Slurm.

Note that any files created during a job are owned by your primary group, no matter which group is charged for the job.

Change your group for a login session

To change the group which will be charged for usage during a login session, use the "newgrp" command.

newgrp groupname

Until you logout (or issue another newgrp command), groupname is charged for all usage. All files created during this time will belong to groupname, and their storage is charged against the quota for groupname.

On the next login, your default group is back in effect, and will be charged for usage.

Change your default group permanently

Your primary group is charged with all usage by default. To change your primary group, the group to which your Slurm jobs are charged by default, use the "change_primary_group" command. Type:

change_primary_group -l

to see all your groups. Then type:

change_primary_group groupname

to set groupname as your default group.

Tracking your usage

There are several methods you can use to track your Bridges usage. The "xdusage" command is available on Bridges. There is a man page for xdusage. The "projects" command will also help you keep tabs on your usage. It shows grant information, including usage and the pylon directory associated with the grant.

Type:

projects

For more detailed accounting data you can use the Grant Management System You can also track your usage through the XSEDE User Portal. The xdusage and projects commands and the XSEDE Portal accurately reflect the impact of a Grant Renewal but the Grant Management System currently does not.

Managing your XSEDE allocation

Most account management functions for your XSEDE grant are handled through the XSEDE User Portal. You can search the Knowledge Base to get help. Some common questions:

• How do I add a user to my grant?
• How can I transfer SUs from Bridges Large to Bridges Regular (or vice versa)?
• How can I request more SUs or storage space on Bridges?

Change your default shell

The "change_shell" command allows you to change your default shell. This command is only available on the login nodes.

To see which shells are available, type:

login1$ change_shell -l

To change your default shell, type:

login1$ change_shell newshell

where newshell is one of the choices output by the "change_shell" command. You must use the entire path output by change_shell, e.g. /usr/psc/shells/bash. You must log out and back in again for the new shell to take effect.

File expiration

Three months after your grant expires all of your Bridges files associated with that grant will be deleted, no matter which file space they are in. You will be able to login during this 3-month period to transfer files, but you will not be able to run jobs or create new files.

File permissions

Access to files in any Bridges space is governed by Unix file permissions which you control. If your data has additional security or compliance requirements, please contact compliance@psc.edu.

Home ($HOME)

This is your Bridges home directory. It is the usual location for your batch scripts, source code and parameter files. Its path is /home/username, where username is your PSC userid. You can refer to your home directory with the environment variable $HOME. Your home directory is visible to all of the Bridges nodes.

Your home directory is backed up daily, although it is still a good idea to store copies of your important files in another location, such as the pylon5 file system or on a local file system at your site. If you need to recover a home directory file from backup send email to remarks@psc.edu. The process of recovery will take 3 to 4 days.

$HOME quota

Your home directory has a 10GB quota. You can check your home directory usage using the "quota" command or the command "du -sh". To improve the access speed to your home directory files you should stay as far below your home directory quota as you can.

Grant expiration

Three months after a grant expires, the files in your home directory associated with that grant will be deleted.

pylon5 ($SCRATCH)

Pylon5 is a Lustre file system shared across all of Bridges' nodes. It is available on Bridges compute nodes as $SCRATCH.

The pylon5 file system is persistent storage, and can be used as working space for your running jobs. It provides fast access for data read or written by running jobs. I/O to pylon5 is much faster than to your home directory.

Files on pylon5 are not backed up, so you should store copies of important pylon5 files in another location.

pylon5 directories

The path of your pylon5 home directory is /pylon5/groupname/username, where groupname is the name for the PSC group associated with your grant. Use the "id" command to find your group name.

The command "id -Gn" will list all the groups you belong to.

The command "id -gn" will list the group associated with your current session.

If you have more than one grant, you will have a pylon5 directory for each grant. Be sure to use the appropriate directory when working with multiple grants.

pylon5 quota

Your usage quota for each of your grants is the Pylon storage allocation you received when your proposal was approved. If your total use in pylon5 exceeds this quota your access to the partitions on Bridges will be shut off until you are under quota.

Use the "du -sh" or "projects" command to check your total pylon usage (pylon5 plus pylon2). You can also check your usage on the XSEDE User Portal.

If you have multiple grants, it is very important that you store your files in the correct pylon5 directory.

Sharing files on pylon5

Unix file permissions can be used to share pylon5 files among members of your group. To do this you need to give each directory from your top-level pylon5 directory down your directory hierarchy to the directory that contains the files you want to share a file protection of 750 with the "chmod" command. Then you need to give you each file you want to share a protection of 740 with the chmod command.

If you want more fine-grained control than this–if you want to give only certain members of a group access to a file, but not all members–then you need to use Access Control Lists (ACLs). Suppose, for example, that you want to give janeuser access to a file in a directory, but no one else in the group. Then issue a command similar to the following:

setfacl -m user:janeuser:rx directoryname

for each directory from your top-level pylon5 directory down your directory hierarchy to the directory that contains the file you want to share with janeuser. Then give janeuser access to a specific file with a command similar to:

setfacl -m user:janeuser:r filename

User janeuser will now be able to read this file, but no one else in the group will have access to it.

There are man pages for chmod, setfacl and getfacl.

Grant expiration

Three months after a grant expires, the files in any pylon5 directories associated with that grant will be deleted.

Node-local ($LOCAL)

Each Bridges node has a local file system attached to it. This local file system is only visible to the node to which it is attached. The local file system provides fast access to local storage.

This file space is available on all nodes as $LOCAL.

If your application performs a lot of small reads and writes, then you could benefit from using $LOCAL. Many genomics applications are of this type.

$LOCAL is only available when your job is running, and can only be used as working space for a running job. Once your job finishes your local files are inaccessible and deleted. To use local space, copy files to $LOCAL at the beginning of your job and back out to a persistent file space before your job ends.

If a node crashes all the $LOCAL files are lost. Therefore, you should checkpoint your $LOCAL files by copying them to pylon5 during long runs.

Multi-node jobs

If you are running a multi-node job the variable $LOCAL points to the local file space on your node that is running your rank 0 process.

You can use the "srun" command to copy files between $LOCAL on the nodes in a multi-node job. See the MPI job script in the Running Jobs section of this User Guide for details.

$LOCAL size

The maximum amount of local space varies by node type. The RSM (128GB) nodes have a maximum of 3.7TB. The LSM (3TB) nodes have a maximum of 14TB and the ESM (12TB) nodes have a maximum of 49TB.

To check on your local file space usage type:

du -sh

There is no charge for the use of $LOCAL.

Using $LOCAL

To use $LOCAL you must first copy your files to $LOCAL at the beginning of your script, before your executable runs. The following script is an example of how to do this:

RC=1
n=0
while [[ $RC -ne 0 && $n -lt 20 ]]; do
    rsync -aP $sourcedir $LOCAL/
    RC=$?
    let n = n + 1
    sleep 10
done

Set $sourcedir to point to the directory that contains the files to be copied before you execute your program. This code will try at most 20 times to copy your files. If it succeeds, the loop will exit. If an invocation of rsync was unsuccessful, the loop will try again and pick up where it left off.

At the end of your job you must copy your results back from $LOCAL or they will be lost. The following script will do this:

mkdir $SCRATCH/results
RC=1
n=0
while [[ $RC -ne 0 && $n -lt 20 ]]; do
    rsync -aP $LOCAL/ $SCRATCH/results
    RC=$?
    let n = n + 1
    sleep 10
done

This code fragment copies your files to a directory in your pylon5 file space named results, which you must have created previously with the "mkdir" command. Again it will loop at most 20 times and stop if it is successful.

Memory files ($RAMDISK)

You can also use the memory allocated for your job for I/O rather than using disk space. This will offer the fastest I/O on Bridges.

In a running job the environment variable $RAMDISK will refer to the memory associated with the nodes in use.

The amount of memory space available to you depends on the size of the memory on the nodes and the number of nodes you are using. You can only perform I/O to the memory of nodes assigned to your job.

If you do not use all of the cores on a node, you are allocated memory in proportion to the number of cores you are using. Note that you cannot use 100% of a node's memory for I/O; some is needed for program and data usage.

$RAMDISK is only available to you while your job is running, and can only be used as working space for a running job. Once your job ends this space is inaccessible. To use memory files, copy files to $RAMDISK at the beginning of your job and back out to a permanent space before your job ends. If your job terminates abnormally your memory files are lost.

Within your job you can cd to $RAMDISK, copy files to and from it, and use it to open files. Use the command "du -sh" to see how much space you are using.

If you are running a multi-node job the $RAMDISK variable points to the memory space on your node that is running your rank 0 process.

Paths for Bridges file spaces

For all file transfer methods other than cp, you must always use the full path for your Bridges files. The start of the full paths for your Bridges directories are:

Home directory /home/username
Pylon5 directory /pylon5/groupname/username

The command "id -Gn" will show all of your valid groupnames. You have a pylon2 and pylon5 directory for each grant you have.

Transfers into your Bridges home directory

Your Bridges home directory quota is 10GB, so large files cannot be stored there; they should be copied into one of your pylon file spaces instead. Exceeding your home directory quota will prevent you from writing more data into your home directory and will adversely impact other operations you might want to perform.

rsync

You can use the "rsync" command to copy files to and from Bridges. A sample rsync command to copy to a Bridges directory is

rsync -rltpDvp -e 'ssh -l joeuser' source_directory data.bridges.psc.edu:target_directory

Substitute your userid for ‘joeuser'. Make sure you use the correct group name in your target directory. By default, rsync will not copy older files with the same name in place of newer files in the target directory. It will overwrite older files.

We recommend the rsync options -rltDvp. See the rsync man page for information on these options and other you options you might want to use. We also recommend the option

-oMACS=umac-64@openssh.com

If you use this option your transfer will use a faster data validation algorithm.

You may to want to put your rsync command in a loop to insure that it completes. A sample loop is

RC=1
n=0
while [[ $RC -ne 0 && $n -lt 20 ]] do
    rsync ...
    RC = $?
    let n = n + 1
    sleep 10
done

This loop will try your rsync command 20 times. If it succeeds it will exit. If an rsync invocation is unsuccessful the system will try again and pick up where it left off. It will copy only those files that have not already been transferred. You can put this loop, with your rsync command, into a batch script and run it with sbatch.

Globus

Globus can be used for any file transfer to Bridges. It tracks the progress of the transfer and retries when there is a failure; this makes it especially useful for transfers involving large files or many files. This includes transfers between the pylon2 and pylon5 filesystems and file transfers between the Data Supercell and pylon2 or pylon5.

To use Globus to transfer files you must authenticate either via a Globus account or with InCommon credentials.

Globus account

You can set up a Globus account at the Globus site.

InCommon credentials

If you wish to use InCommon credentials to transfer files to/from Bridges, you must first provide your CILogon Certificate Subject information to PSC. Follow these steps:

1. Find your Certificate Subject string
   1. Navigate your web browser to https://cilogon.org.
   2. Select your institution from the ‘Select an Identity Provider' list.
   3. Click the ‘Log On' button. You will be taken to the web login page for your institution.
   4. Login with your username and password for your institution.
      1. If your institution has an additional login requirement (e.g., Duo), authenticate to that as well. After successfully authenticating to your institution's web login interface, you will be returned to the CILogon webpage. Note the boxed section near the top that lists a field named ‘Certificate Subject'.
2. Send your Certificate Subject string to PSC
   1. In the CILogon webpage, select and copy the Certificate Subject text. Take care to get the entire text string if it is broken up onto multiple lines.
   2. Send email to support@psc.edu. Paste your Certificate Subject field into the message, asking that it be mapped to your PSC username.

Your CILogon Certificate Subject information will be added within one business day, and you will be able to begin transferring files to and from Bridges.

Globus endpoints

Once you have the proper authentication you can initiate file transfers from the Globus site. A Globus transfer requires a Globus endpoint, a file path and a file name for both the source and destination. The endpoints for Bridges are:

• psc#bridges-xsede if you are using an XSEDE User Portal account for authentication
• psc#bridges-cilogon if you are using InCommon for authentication

These endpoints are owned by psc@globusid.org. If you use DUO MFA for your XSEDE authentication, you do not need to because you cannot use it with Globus. You must always specify a full path for the Bridges file systems. See Paths for Bridges file spaces for details.

Globus-url-copy

The globus-url-copy command can be used if you have access to Globus client software. Both the globus-url-copy and myproxy-logon commands are available on Bridges, and can be used for file transfers internal to the PSC.

To use globus-url-copy you must have a current user proxy certificate. The command "grid-proxy-info" will tell you if you have current user proxy certificate and if so, what the remaining life of your certificate is.

Use the "myproxy-logon" command to get a valid user proxy certificate if any one of these applies:

• you get an error from the grid-proxy-info command
• you do not have a current user proxy certificate
• the remaining life of your certificate is not sufficient for your planned file transfer

When prompted for your MyProxy passphrase enter your XSEDE Portal password.

To use globus-url-copy for transfers to a machine, you must know the Grid FTP server address. The Grid FTP server address for Bridges is

gsiftp://gridftp.bridges.psc.edu

The use of globus-url-copy always requires full paths. See Paths for Bridges file spaces for details.

scp

To use scp for a file transfer, you must specify a source and destination for your transfer. The format for either source or destination is

username@machine-name:path/filename

For transfers involving Bridges, username is your PSC username. The machine-name should be given as data.bridges.psc.edu. This is the name for a high-speed data connector at PSC. We recommend using it for all file transfers using scp involving Bridges. Using it prevents file transfers from disrupting interactive use on Bridges login nodes. File transfers using scp must specify full paths for Bridges file systems. See Paths for Bridges file spaces for details.

sftp

To use sftp, first connect to the remote machine:

sftp username@machine-name

When Bridges is the remote machine, use your PSC userid as username. The Bridges machine-name should be specified as data.bridges.psc.edu. This is the name for a high-speed data connector at PSC. We recommend using it for all file transfers using sftp involving Bridges. Using it prevents file transfers from disrupting interactive use on Bridges login nodes.

You will be prompted for your password on the remote machine. If Bridges is the remote machine enter your PSC password.

You can then enter "sftp" subcommands, like put to copy a file from the local system to the remote system, or get to copy a file from the remote system to the local system.

To copy files into Bridges you must either cd to the proper directory or use full pathnames in your file transfer commands. See Paths for Bridges file spaces for details.

Two-factor Authentication

If you are required to use two-factor authentication (TFA) to access Bridges filesystems, you must enroll in XSEDE DUO. Once that is complete, use scp or sftp to transfer files to/from Bridges.

TFA users must use port 2222 and XSEDE Portal usernames and passwords. The machine name for these transfers is data.bridges.psc.edu.

In the examples below, myfile is the local filename, XSEDE-username is your XSEDE Portal username and /path/to/file is the full path to the file on a Bridges filesystem. Note that -P (capital P) is necessary.

scp

Transfer a file from a local machine to Bridges:

scp -P 2222 myfile XSEDE-username@data.bridges.psc.edu:/path/to/file

Transfer a file from Bridges to a local machine:

scp -P 2222 XSEDE-username@data.bridges.psc.edu:/path/to/file myfile

sftp

Use sftp interactively:

sftp -P 2222 XSEDE-username@data.bridges.psc.edu

Then use the "put" command to copy a file from the local machine to Bridges, or the "get" command to transfer a file from Bridges to the local machine.

Graphical SSH client

If you are using a graphical SSH client, configure it to connect to data.bridges.psc.edu on port 2222/TCP. Login using your XSEDE Portal username and password.

Transfer rates

PSC maintains a Web page at http://speedpage.psc.edu that lists average data transfer rates between all XSEDE resources. If your data transfer rates are lower than these average rates or you believe that your file transfer performance is subpar, send email to bridges@psc.edu. We will examine approaches for improving your file transfer performance.

C, C++ and Fortran

Intel, Gnu and PGI compilers for C, C++ and Fortan are available on Bridges. The compilers are:

OpenMP programming

To compile OpenMP programs you must add an option to your compile command:

MPI programming

Three types of MPI are supported on Bridges: MVAPICH2, OpenMPI and Intel MPI.

There are two steps to compile an MPI program:

1. Load the correct module for the compiler and MPI type you want to use, unless you are using Intel MPI. The Intel MPI module is loaded for you on login.
2. Issue the appropriate MPI wrapper command to compile your program

The three MPI types may perform differently on different problems or in different programming environments. If you are having trouble with one type of MPI, please try using another type. Contact bridges@psc.edu for more help.

INTEL COMPILERS

For proper Intel MPI behavior, you must set the environment variable I_MPI_JOB_RESPECT_PROCESS_PLACEMENT to 0. Otherwise the mpirun task placement settings you give will be ignored. For example:

BASH

export I_MPI_JOB_RESPECT_PROCESS_PLACEMENT=0

CSH:

setenv I_MPI_JOB_RESPECT_PROCESS_PLACEMENT 0

GNU COMPILERS

PGI COMPILERS

Other languages

Other languages, including Java, Python, R, and MATLAB, are available. See the software section for information.

Debugging and performance analysis

DDT

DDT is a debugging tool for C, C++ and Fortran 90 threaded and parallel codes. It is client-server software. Install the client on your local machine and then you can access the GUI on Bridges to debug your code.

See the PSC DDT page for more information.

VTune

VTune is a performance analysis tool from Intel for serial, multithreaded and MPI applications. Install the client on your local machine and then you can access the GUI on Bridges. See the PSC VTune page for more information.

The Module package

The environment management package Module is essential for running software on most PSC systems. Be sure to check if there is a module for the software you want to use by typing module avail software-name.

The module help software-name command lists any additional modules that must also be loaded. Note that in some cases the order in which these additional modules are loaded matters. See documentation on the module command for more information.

PSC provides an up-to-date list of available software.

You may request that additional software be installed by sending email to remarks@psc.edu.

Interactive sessions

You can do your production work interactively on Bridges, typing commands on the command line, and getting responses back in real time. But you must be allocated the use of one or more Bridges' compute nodes by Slurm to work interactively on Bridges. You cannot use the Bridges login nodes for your work.

You can run an interactive session in any of the Slurm partitions. You will need to specify which partition you want, so that the proper resources are allocated for your use.

If all of the resources set aside for interactive use are in use, your request will wait until the resources you need are available. Using a shared partition (RM-shared, GPU-shared) will probably allow your job to start sooner.

interact -options

$ interact

[bridgesuser@br006 ~]$ interact

A command prompt will appear when your session begins
"Ctrl+d" or "exit" will end your session

[bridgesuser@r004 ~]$

See also:

• Bridges partitions
• How to determine your valid groups and change your default group, in the Account adminstration section of the Bridges User Guide
• Managing charging with multiple accounts
• The srun command, for more complex control over your interactive job

Batch jobs

To run a batch job, you must first create a batch (or job) script, and then submit the script using the sbatch command.

A batch script is a file that consists of SBATCH directives, executable commands, and comments.

SBATCH directives specify your resource requests and other job options in your batch script. You can also specify resource requests and options on the sbatch command line. Any options on the command line take precedence over those given in the batch script. The SBATCH directives must start with "#SBATCH" as the first text on a line, with no leading spaces.

Comments begin with a ‘#' character.

The first line of any batch script must indicate the shell to use for your batch job.

Sample script for OpenMP #!/bin/bash #SBATCH -N 1 #SBATCH -p RM #SBATCH --ntasks-per-node 28 #SBATCH -t 5:00:00 # echo commands to stdout set -x # move to your appropriate pylon5 directory # this job assumes: # - all input data is stored in this directory # - all output should be stored in this directory cd /pylon5/groupname/username/path-to-directory # run OpenMP program export OMP_NUM_THREADS=28 ./myopenmp Notes: The "--ntasks-per-node" option indicates that you will use all 28 cores. For groupname, username, and path-to-directory you must substitute your group, username, and appropriate directory path.

Sample script for MPI #!/bin/bash #SBATCH -p RM #SBATCH -t 5:00:00 #SBATCH -N 2 #SBATCH --ntasks-per-node 28 #echo commands to stdout set -x #move to your appropriate pylon5 directory cd /pylon5/groupname/username/path-to-directory #set variable so that task placement works as expected export I_MPI_JOB_RESPECT_PROCESS_PLACEMENT=0 #copy input files to `$LOCAL` file storage srun -N $SLURM_JOB_NUM_NODES --ntasks-per-node=1 \ sh -c 'cp path-to-directory/input.${SLURM_PROCID} $LOCAL' #run MPI program mpirun -np $SLURM_NTASKS ./mympi # Copy output files to pylon5 srun -N $SLURM_JOB_NUM_NODES --ntasks-per-node=1 \ sh -c 'cp $LOCAL/output.* /pylon5/groupname/username/path-to-directory' Notes: The variable $SLURM_NTASKS gives the total number of cores requested in a job. In this example $SLURM_NTASKS will be 56 because the "-N" option requested 2 nodes and the "--ntasks-per-node" option requested all 28 cores on each node. The export command sets "I_MPI_JOB_RESPECT_PROCESS_PLACEMENT" so that your task placement settings are effective. Otherwise, the SLURM defaults are in effect. The srun commands are used to copy files between pylon5 and the $LOCAL file systems on each of your nodes. The first srun command assumes you have two files named input.0 and input.1 in your pylon5 file space. It will copy input.0 and input.1 to, respectively, the $LOCAL file systems on the first and second nodes allocated to your job. The second srun command will copy files named "output.*" back from your $LOCAL file systems to your pylon5 file space before your job ends. In this command '*' functions as the usual Unix wildcard. For groupname, username, and path-to-directory you must substitute your group, username, and appropriate directory path.

Sample script for hybrid OpenMP-MPI #!/bin/bash #SBATCH --nodes=2 #SBATCH --ntasks=4 #SBATCH --cpus-per-task=14 #SBATCH --time=00:10:00 #SBATCH --job-name=hybrid cd $SLURM_SUBMIT_DIR mpiifort -xHOST -O3 -qopenmp -mt_mpi hello_hybrid.f90 -o hello_hybrid.exe # set variable so task placement works as expected export I_MPI_JOB_RESPECT_PROCESS_PLACEMENT=0 mpirun -print-rank-map -n $SLURM_NTASKS -genv \ OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK -genv I_MPI_PIN_DOMAIN=omp \ ./hello_hybrid.exe Notes: This example asks for 2 nodes, 4 MPI tasks and 14 OpenMP threads per MPI task. The export command sets I_MPI_JOB_RESPECT_PROCESS_PLACEMENT so that your task placement settings are effective. Otherwise, the SLURM defaults are in effect.

Sample script for Job Array #!/bin/bash #SBATCH -t 05:00:00 #SBATCH -p RM-shared #SBATCH -N 1 #SBATCH --ntasks-per-node 5 #SBATCH --array=1-5 set -x ./myexecutable $SLURM_ARRAY_TASK_ID Notes: The above job will generate five jobs that will each run on a separate core on the same node. The value of the variable SLURM_ARRAY_TASK_ID is the core number, which, in this example, will range from 1 to 5. Good candidates for job array jobs are jobs that can use only this core index to determine the different processing path for each job. For more information about job array jobs see the sbatch man page and the online SLURM documentation.

Sample script for bundling single-core jobs #!/bin/bash #SBATCH -N 1 #SBATCH -p RM-shared #SBATCH -t 05:00:00 #SBATCH --ntasks-per-node 14 echo SLURM NTASKS: $SLURM_NTASK i=0 while [ $i -lt $SLURM_NTASKS ] do numactl -C +$i ./run.sh & let i=i+1 done wait # IMPORTANT: wait for all to finish or get killed Notes: Bundling or packing multiple jobs in a single job can improve your turnaround and improve the performance of the SLURM scheduler.

Sample script for bundling multi-core jobs #!/bin/bash #SBATCH -N 1 #SBATCH -p RM-shared #SBATCH -t 05:00:00 #SBATCH --ntasks-per-node 14 #SBATCH --cpus-per-task 2 echo SLURM NTASKS: $SLURM_NTASKS i=0 while [ $i -lt $SLURM_NTASKS ] do numactl -C +$i ./run.sh & let i=i+1 done wait # IMPORTANT: wait for all to finish or get killed Notes: Bundling or packing multiple jobs in a single job can improve your turnaround and improve the performance of the SLURM scheduler.

The sbatch command

To submit a batch job, use the sbatch command. The format is

sbatch -options batch-script

The options to sbatch can either be in your batch script or on the sbatch command line. Options in the command line override those in the batch script.

Note:

• Be sure to charge your job to the correct group if you have more than one grant. See the -A option for sbatch to change the charging group for a job. Information on how to determine your valid groups and change your default group is in the Account adminstration section of the Bridges User Guide.
• In some cases, the options for sbatch differ from the options for interact or srun.
• By default, sbatch submits jobs to the RM partition. Use the -p option for sbatch to direct your job to a different partition.

Managing Charging with Multiple Grants

If you have more than one grant, be sure to use the correct one when running jobs.

See "Managing multiple grants" in the Account adminstration section of the Bridges User Guide to see how to find your groups and determine or change which is your default.

See the -A option to the sbatch or interact commands to set the grant that is charged for a job.

Note that any files created by a job are owned by the grant in effect when the job is submitted, which is not necessarily the grant charged for the job. See the newgrp command in the Account Administration section of the Bridges User Guide to see how to change the group currently in effect.

Bridges Partitions

Each Slurm partition manages a subset of Bridges' resources. Each partition allocates resources to interactive sessions, batch jobs, and OnDemand sessions that request resources from it.

Know which partitions are open to you: Your Bridges allocations determine which partitions you can submit jobs to.

• A "Bridges regular memory" allocation allows you to use Bridges' RSM (128GB) nodes. Partitions available to "Bridges regular memory" allocations are
  
  • RM, for jobs that will run on Bridges' RSM (128GB) nodes, and use one or more full nodes
  • RM-shared, for jobs that will run on Bridges' RSM (128GB) nodes, but share a node with other jobs
  • RM-small, for short jobs needing 2 full nodes or less, that will run on Bridges RSM (128GB) nodes
• A "Bridges GPU" allocation allows you to use Bridges' GPU nodes. Partitions available to "Bridges GPU" allocations are:
  • GPU, for jobs that will run on Bridges' GPU nodes, and use one or more full nodes
  • GPU-shared, for jobs that will run on Bridges' GPU nodes, but share a node with other jobs
  • GPU-small, for jobs that will use only one of Bridges' GPU nodes and 8 hours or less of wall time.
• A "Bridges large memory" allocation allows you to use Bridges LSM and ESM (3TB and 12TB) nodes. There is one partition available to "Bridges large memory" allocations:
  • LM, for jobs that will run on Bridges' LSM and ESM (3TB and 12TB) nodes

All the partitions use FIFO scheduling. If the top job in the partition will not fit, Slurm will try to schedule the next job in the partition. The scheduler follows policies to ensure that one user does not dominate the machine. There are also limits to the number of nodes and cores a user can simultaneously use. Scheduling policies are always under review to ensure best turnaround for users.

Partitions for "Bridges regular memory" allocations

Use your allocation wisely: To make the most of your allocation, use the shared partitions whenever possible. Jobs in the RM partition are charged for the use of all cores on a node. Jobs in the RM-shared partition share nodes, and are only charged for the cores they are allocated. The RM partition is the default for the sbatch command, while RM-small is the default for the interact command. See the discussion of the interact and sbatch commands in this document for more information.

Charge your jobs to the correct group: If you have more than one Bridges grant, be sure to charge your usage to the correct one. See "Managing charging for multiple grants".

For information on requesting resources and submitting jobs see the discussion of the interact or sbatch commands.

interact -p RM -N 2 -t 30:00

sbatch -p RM -t 5:00:00 -N 1 myscript.job

interact -p RM-shared --ntasks-per-node=4 -t 1:00:00

sbatch -p RM-shared --ntasks-per-node 2 -t 5:00:00 myscript.job

#!/bin/bash
#SBATCH -N 1
#SBATCH -p RM-shared
#SBATCH -t 5:00:00
#SBATCH --ntasks-per-node 2

#echo commands to stdout
set -x

# move to working directory
# this job assumes:
# - all input data is stored in this directory 
# - all output should be stored in this directory

cd /pylon5/groupname/username/path-to-directory

#run OpenMP program
export OMP_NUM_THREADS 2
./myopenmp

interact -p RM-small -N 1 --ntasks-per-node=8 -t 45:00

sbatch -p RM-small -N 2 -t 6:00:00 myscript.job

Partitions for "Bridges GPU" allocations

Use your allocation wisely: To make the most of your allocation, use the shared partitions whenever possible. Jobs in the GPU partition are charged for the use of all cores on a node. Jobs in the GPU-shared partition share nodes, and are only charged for the cores they are allocated.

Charge your jobs to the correct group: If you have more than one Bridges grant, be sure to charge your usage to the correct one. See "Managing charging for multiple grants".

For information on requesting resources and submitting jobs see the interact or sbatch commands.

 interact -p GPU --gres=gpu:p100:2 -N 4 -t 30:00

sbatch -p GPU --gres=gpu:k80:4 -N 1 -t 45:00 myscript.job

#!/bin/bash
#SBATCH -N 2
#SBATCH -p GPU
#SBATCH --ntasks-per-node 28
#SBATCH -t 5:00:00
#SBATCH --gres=gpu:p100:2

#echo commands to stdout
set -x

#move to working directory
# this job assumes:
# - all input data is stored in this directory 
# - all output should be stored in this directory 
cd /pylon5/groupname/username/path-to-directory


#run GPU program
./mygpu

interact -p GPU-shared --gres=gpu:k80:4 -t 8:00:00

sbatch -p GPU-shared --gres=gpu:P100:2 -t 1:00:00 myscript.job

#!/bin/bash
#SBATCH -N 1
#SBATCH -p GPU-shared
#SBATCH --ntasks-per-node 7
#SBATCH --gres=gpu:p100:1
#SBATCH -t 5:00:00

#echo commands to stdout
set -x

#move to working directory
# this job assumes:
# - all input data is stored in this directory 
# - all output should be stored in this directory 
cd /pylon5/groupname/username/path-to-directory

#run GPU program
./mygpu

interact -p GPU-small --gres=gpu:p100:2 -t 2:00:00

sbatch -p GPU-small --gres=gpu:p100:2 -t 1:00:00 myscript.job

Partitions for "Bridges large memory" allocations

There is one partition available for Bridges large memory allocations.

Charge your jobs to the correct group: If you have more than one Bridges grant, be sure to charge your usage to the correct one. See "Managing charging for multiple grants".

For information on requesting resources and submitting jobs see the interact or sbatch commands.

interact -p LM --mem=2000GB

sbatch -p LM - t 10:00:00 --mem 6000GB myscript.job

Node, partition, and job status information

scancel

The scancel command is used to kill a job in a partition, whether it is running or still waiting to run. Specify the jobid for the job you want to kill. For example,

scancel 12345

kills job # 12345.

See also: scancel man page

sacct

The sacct command can be used to display detailed information about jobs. It is especially useful in investigating why one of your jobs failed. The general format of the command is

sacct -X -j nnnnnn -S MMDDYY --format parameter1,parameter2, ...

• For ‘nnnnnn' substitute the jobid of the job you are investigating.
• The date given for the -S option is the date at which sacct begins searching for information about your job.
• The commas between the parameters in the –format option cannot be followed by spaces.

The –format option determines what information to display about a job. Useful parameters are

• JobID
• Partition
• Account - the account charged
• ExitCode - useful in determining why a job failed
• State - useful in determining why a job failed
• Start, End, Elapsed - start, end and elapsed time of the job
• NodeList - list of nodes used in the job
• NNodes - how many nodes the job was allocated
• MaxRSS - how much memory the job used
• AllocCPUs - how many cores the job was allocated

See also: sacct man page

Monitoring memory usage

It can be useful to find the memory usage of your jobs. For example, you may want to find out if memory usage was a reason a job failed.

You can determine a job's memory usage whether it is still running or has finished. To determine if your job is still running, use the squeue command.

squeue -j nnnnnn -O state

where nnnnnn is the jobid.

For running jobs: srun and top or sstat

You can use the srun and top commands to determine the amount of memory being used.

srun --jobid=nnnnnn top -b -n 1 | grep userid

For nnnnnn substitute the jobid of your job. For ‘userid' substitute your userid. The RES field in the output from top shows the actual amount of memory used by a process. The top man page can be used to identify the fields in the output of the top command.

• See the man pages for srun and top for more information.

You can also use the sstat command to determine the amount of memory being used in a running job

sstat -j nnnnnn.batch --format=JobID,MaxRss

where nnnnnn is your jobid.

• See the man page for sstat for more information.

For jobs that are finished: sacct or job_info

If you are checking within a day or two after your job has finished you can issue the command

sacct -j nnnnnn --format=JobID,MaxRss

If this command no longer shows a value for MaxRss, use the job_info command

job_info nnnnnn | grep max_rss

Substitute your jobid for nnnnnn in both of these commands.

• See the man page for sacct for more information.

See also: Online documentation for Slurm, including man pages for all the Slurm commands

Start OnDemand

To connect via OnDemand, point your browser to https://ondemand.bridges.psc.edu.

• You will be prompted for a username and password. Enter your PSC username and password.
• The OnDemand Dashboard will open. From this page, you can use the menus across the top of the page to manage files and submit jobs to Bridges.

To end your OnDemand session, choose Log Out at the top right of the Dashboard window and close your browser.

Manage files

To create, edit or move files, click on the Files menu from the Dashboard window. A dropdown menu will appear, listing all your file spaces on Bridges: your home directory and the pylon directories for each of your Bridges' grants.

Choosing one of the file spaces opens the File Explorer in a new browser tab. The files in the selected directory are listed. No matter which directory you are in, your home directory is displayed in a panel on the left.

There are two sets of buttons in the File Explorer.

Buttons on the top left just below the name of the current directory allow you to View, Edit, Rename, Download, Copy or Paste (after you have moved to a different directory) a file, or you can toggle the file selection with (Un)Select All.

Buttons on the top of the window on the right perform these functions:

• Go To Navigate to another directory or file system
• Open in Terminal Open a terminal window on Bridges in a new browser tab
• New File Creates a new empty file
• New Dir Create a new subdirectory
• Upload Copies a file from your local machine to Bridges
• Show Dotfiles Toggles the display of dotfiles
• Show Owner/Mode Toggles the display of owner and permisson settings

Create and edit jobs

You can create new job scripts and edit existing scripts, and submit those scripts to Bridges through OnDemand.

From the top menus in the Dashboard window, choose Jobs > Job Composer. A Job Composer window will open.

There are two tabs at the top: Jobs and Templates.

In the Jobs tab, a listing of your jobs is gven.

Create a new job script

To create a new job script:

1. Select a template to begin with
2. Edit the job script
3. Edit the job options

Select a template

1. Go to the Jobs tab in the Jobs Composer window. You have been given a default template, named Simple Sequential Job.
2. To create a new job script, click the blue New Job > From Default Template button in the upper left. You will see a green message at the top of the window, "Job was successfully created".

At the right of the Jobs window, you will see the Job Details, including the location of the script and the script name (by default, main_job.sh). Under that, you will see the contents of the job script in a section titled Submit Script.

Edit the job script

Edit the job script so that it has the commands and workflow that you need.

If you do not want the default settings for a job, you must include options to change them in the job script. For example, you may need more time or more than one node. For the GPU partitions, you must specify the type and number of GPUs you want. For the LM partition, you must specify how much memory you need. Use an SBATCH directive in the job script to set these options.

• See the default settings for all partitions
• See how to use SBATCH directives

You can edit the script in several ways.

• Click the blue Edit Files button at the top of the Jobs tab in the Jobs Composer window
• In the Jobs tab in the Jobs Composer window, find the Submit Script section at the bottom right. Click the blue Open Editor button.

After you save the file, the editor window remains open, but if you return to the Jobs Composer window, you will see that the content of your script has changed.

Edit the job options

In the Jobs tab in the Jobs Composer window, click the blue Job Options button. The options for the selected job such as name, the job script to run, and the account it will be charged to are displayed and can be edited. Click Save or Cancel to return to the job listing.

Submit jobs to Bridges

Select a job in the Jobs tab in the Jobs Composer window. Click the green Submit button to submit the selected job. A message at the top of the window shows whether the job submission was successful or not. If it is not, you can edit the job script or options and resubmit. When the job submits successfully, the status of the job in the Jobs Composer window will change to Queued or Running. When the job completes, the status will change to Completed.

JupyterHub and IJulia

You can run JupyterHub, and IJulia notebooks, through OnDemand. You must do some setup before the first time you run IJulia through OnDemand.

Setup IJulia for OnDemand use

Note: You only need to do this once.

While logged in to Bridges, request an interactive session by typing interact. Once the sesstion starts, type these commands:

module load anaconda3
module load julia
julia

When Julia starts, type

Pkg.add("IJulia")

When you see the message that IJulia has been installed, you can end your interactive session.

1. Select Interactive Apps > Jupyter Notebooks from the top menu in the Dashboard window.
2. In the screen that opens, specify the timelimit, number of nodes, and partition to use. You can also designate the account to charge this usage to if you have more than one grant on Bridges. If you will use the LM or one of the GPU partitions, you must add a flag in the Extra Args field for the amount of memory or the number and type of GPUs you want:

   --mem=numberGB

   --gres=gpu:type:number

   See the Running jobs section of this User Guide for more information on Bridges' partitions and the options available.
3. Click the blue Launch button to start your JupyterHub session. You may have to wait in the queue for resources to be available.

4. When your session starts, click the blue Connect to Jupyter button. The Dashboard window now displays information about your JupyterHub session including which node it is running on, when it began, and how much time remains.

   A new window running JupyterHub also opens. Note the three tabs: Files, Running and Clusters.

   Files

   By default you are in the Files tab, and it displays the contents of your Bridges home directory. You can navigate through your home directory tree. To start up a Jupyter notebook, click on its name. A new window running the notebook opens.
   Running
   Under the Running tab, you will see listed any notebooks or terminal sessions that you are currently running.

5. Now you can start a Jupyter or IJulia notebook:

   1. To start a Jupyter notebook which is stored in your home directory space, in the Files tab, click on its name. A new window running the notebook opens.

   2. To start a Jupyter notebook which is stored in your pylon5 directory, you must first create a symbolic link to it from your home directory. While in your home directory, use a command like:

      ln -s /pylon5/yourgroup/youruserid PYLONDIR

      When you enter JuypterHub, you will see the entry PYLONDIR in your list of files under the Files tab. Click on this to be moved to your pylon5 directory.
   3. To start IJulia, in the Files tab, click on the New button at the top right of the file listing. Choose IJulia from the drop down.

Errors

If you get an "Internal Server Error" when starting a JupyterHub session, you may be over your home directory quota. Check the Details section of the error for a line like:

ActionView::Template::Error: Disk quota exceeded @ dir_s_mkdir ...

You can confirm that you are over quota by opening a Bridges shell access window and typing:

du -sh

This command shows the amount of storage in your home directory. Home directory quotas are 10GB. If du -sh shows you are near 10GB, you should delete or move some files out of your home directory. You can do this in OnDemand in the File Explorer window or in a shell access window.

When you are under quota, you can try starting a JupyterHub session again.

Stopping your JupyterHub session

In the Dashboard window, click the red Delete button.

RStudio

You can run RStudio through OnDemand.

1. Select Interactive Apps > RStudio Server from the top menu in the Dashboard window.

2. In the screen that opens, specify the timelimit, number of nodes, and partition to use. You can also designate the account to charge this usage to if you have more than one grant on Bridges.
   If you will use the LM or one of the GPU partitions, you must add a flag in the Extra Args field for the amount of memory or the number and type of GPUs you want:
   

   --mem=numberGB

   --gres=gpu:type:number

   See the Running jobs section of this User Guide for more information on Bridges' partitions and the options available.
3. Click the blue Launch button to start your RStudio session. You may have to wait in the queue for resources to be available.
4. When your session starts, click the blue Connect to RStudio Server button. A new window opens with the RStudio interface.

Errors

If you exceed the timelimit you requested when setting up your RStudio session, you will see this error:

Error: Status code 503 returned

To continue using RStudio, go to Interactive Apps > RStudio from the top menu in the Dashboard window and start a new session.

Stopping your RStudio session

To end your RStudio session, either select File > Quit Session or click the red icon in the upper right of your RStudio window. NOTE that this only closes your RStudio session; it does not close your interactive Bridges session. You are still being charged for the Bridges session. If you like, you can start another RStudio session.

To end your interactive Bridges session so that you are no longer being charged, return to the Dashboard window and click the red Delete button.

Shell access

You can get shell access to Bridges by choosing Clusters >> Bridges Shell Access from the top menus in the Dashboard window. In the window that opens, you are logged in to one of Bridges' login nodes as if you used ssh to connect to Bridges.

Miscellaneous

Accessing Bridges documentation

In the Dashboard window, under the Help menu, choose Online Documentation to be taken to the Bridges User Guide.

Change your PSC password

In the Dashboard window, under the Help menu, choose Change HPC Password to be taken to the PSC password change utility.

GPU Nodes

There are two types of GPU nodes on Bridges: 16 nodes with NVIDIA K80 GPUs and 32 nodes with NVIDIA P100 GPUs.

K80 Nodes

The 16 K80 GPU nodes each contain 2 NVIDIA K80 GPU cards, and each card contains two GPUs that can be individually scheduled. Ideally, the GPUs are shared in a single application to ensure that the expected amount of on-board memory is available and that the GPUs are used to their maximum capacity. This makes the K80 GPU nodes optimal for applications that scale effectively to 2, 4 or more GPUs. Some examples are GROMACS, NAMD and VASP. Applications using a multiple of 4 K80 GPUs will maximize system throughput.

The nodes are HPE Apollo 2000s, each with 2 Intel Xeon E5-2695 v3 CPUs (14 cores per CPU) and 128GB RAM.

Each Bridges Phase 1 RSM GPU node contains:

• 2 NVIDIA K80 GPUs
• 2 Intel Xeon E5-2695 v3 CPUs, each with
  • 14 cores, 2.3 GHz base frequency, 3.3 GHz max turbo frequency
  • 35MB LLC
• 128GB RAM, DDR4 @ 2133 MHz

P100 Nodes

The 32 P100 GPU nodes contain 2 NVIDIA P100 GPU cards, and each card holds one very powerful GPU, optimally suited for single-GPU applications that require maximum acceleration. The most prominent example of this is deep learning training using frameworks that do not use multiple GPUs.

The nodes are HPE Apollo 2000s, each with 2 Intel Xeon E5-2683 v4 CPUs (16 cores per CPU) and 128GB RAM.

Each Bridges Phase 2 RSM GPU node contains:

• 2 NVIDIA P100 GPUs
• 2 Intel Xeon E5-2683 v4 CPUs, each with
  • 16 cores, 2.1 GHz base frequency, 3.0 GHz max turbo frequency
  • 40MB cache
• 128GB RAM, DDR4 @ 2400 MHz

File Systems

The /home and pylon5 file systems are available on all of these nodes. See the File Spaces section of the User Guide for more information on these file systems.

Compiling and Running Jobs

Use the GPU queue, either in batch or interactively, to compile your code and run your jobs. See the Running Jobs section of the User Guide for more information on Bridges queues and how to run jobs.

CUDA

To use CUDA, first you must load the CUDA module. To see all versions of CUDA that are available, type: module avail cuda

Then choose the version that you need and load the module for it. module load cuda

loads the default CUDA. To load a different version, use the full module name. module load cuda/8.0

CUDA 8 codes should run on both types of Bridges GPU nodes with no issues. CUDA 7 should only be used on the K80 GPUs (Phase 1). Performance may suffer with CUDA 7 on the P100 nodes (Phase 2).

OpenACC

Our primary GPU programming environment is OpenACC.

The PGI compilers are available on all GPU nodes. To set up the appropriate environment for the PGI compilers, use the module command: module load pgi

Read more about the module command at PSC

If you will be using these compilers often, it will be useful to add this command to your shell initialization script.

There are many options available with these compilers. See the online man pages

• man pgf90
• man pgcc
• man pgCC

for detailed information.

You may find these basic OpenACC options a good place to start: pgcc -acc yourcode.c pgf90 -acc yourcode.f90

P100 node users should add the -ta=tesla,cuda8.0 option to the compile command, for example: pgcc -acc -ta=tesla,cuda8.0 yourcode.c

Adding the -Minfo=accel flag to the compile command (whether pgf90, pgcc or pgCC) will provide useful feedback regarding compiler errors or success with your OpenACC commands. pgf90 -acc yourcode.f90 -Minfo=accel

Hybrid MPI/GPU Jobs

To run a hybrid MPI/GPU job, use the following commands for compiling your program: module load cuda module load mpi/pgi_openmpi mpicc -acc yourcode.c

When you execute your program you must first issue the above two module load commands.

Profiling and Debugging

The environment variables PGI_ACC_TIME, PGI_ACC_NOTIFY and PGI_ACC_DEBUG can provide profiling and debugging information for your job. Specific commands depend on the shell you are using.

A Unix shell is a command-line interpreter that provides a traditional user interface for Unix and Unix-like systems.

The two major shell types are the Bourne shell and the C shell. Each type has its own commands and syntax.

The default shell on Bridges is bash, a Bourne-type shell. Other shells, including some C-type shells, are available for you to use if you prefer.

Send email to bridges@psc.edu to request that additional CUDA-oriented debugging tools be installed.

Performance profiling

Enable runtime GPU performance profiling by setting the PGI_ACC_TIME environment variable.

export PGI_ACC_TIME=1 [bash]
setenv PGI_ACC_TIME 1 [csh]

Debugging

Basic debugging can be accomplished by setting the PGI_ACC_NOTIFY environment variable. For more detail, set PGI_ACC_NOTIFY to 3.

export PGI_ACC_NOTIFY=1 [bash]
setenv PGI_ACC_NOTIFY 1 [csh]

A further level of debugging is available with the PGI_ACC_DEBUG environment variable.

export PGI_ACC_DEBUG=1 [bash]
setenv PGI_ACC_DEBUG 1 [csh]

File Systems

/home

The /home file system, which contains your home directory, is available on all Bridges Hadoop nodes.

HDFS

The Hadoop filesystem, HDFS, is available from all Hadoop nodes. There is no explicit quota for the HDFS, but it uses your $SCRATCH disk space. Please delete any files you don't need when your job has ended.

Files must reside in HDFS to be used in Hadoop jobs. Putting files into HDFS requires these steps:

1. Transfer the files to the namenode with scp or sftp
2. Format them for ingestion into HDFS
3. Use the hadoop fs -put command to copy the files into HDFS. This command distributes your data files across the cluster's datanodes.

The hadoop fs command should be in your command path by default.

Documentation for the hadoop fs command lists other options. These options can be used to list your files in HDFS, delete HDFS files, copy files out of HDFS and other file operations.

To request the installation of data ingestion tools on the Hadoop cluster send email to bridges@psc.edu.

Accessing the Hadoop/Spark cluster

To start using Hadoop and Spark with Yarn and HDFS on Bridges, connect to the login node and issue the following commands:

interact -N 3 # you will need to wait until resources are allocated to you before continuing
module load hadoop
start-hadoop.sh

Your cluster will be set up and you'll be able to run hadoop and spark jobs. The cluster requires a minimum of three nodes (-N 3). Larger jobs may require a reservation. Please contact bridges@psc.edu if you would like to use more than 8 nodes or run for longer than 8 hours.

Please note that when your job ends, your HDFS will be unavailable so be sure to retrieve any data you need before your job finishes.

Web interfaces are currently not available for interactive jobs but can be made available for reservations.

Spark

The Spark data framework is available on Bridges. Spark, built on the HDFS filesystem, extends the Hadoop MapReduce paradigm in several directions. It supports a wider variety of workflows than MapReduce. Most importantly, it allows you to process some or all of your data in memory if you choose. This enables very fast parallel processing of your data.

Python, Java and Scala are available for Spark applications. The pyspark interpreter is especially effective for interactive, exploratory tasks in Spark. To use Spark you must first load your data into Spark's highly efficient file structure called Resilient Distributed Dataset (RDD).

Extensive online documentation is available at the Spark website. If you have questions about or encounter problems using Spark, send email to bridges@psc.edu.

Spark example using Yarn

Here is an example command to run a Spark job using yarn. This example calculates pi using 10 iterations.

spark-submit --class org.apache.spark.examples.SparkPi --master yarn \
    --deploy-mode cluster $SPARK_HOME/examples/jars/spark-examples_2.11-2.1.0.jar 10

To view the full output:

yarn logs -applicationId yarnapplicationId

where yarnapplicationId is the yarn applicationId assigned by the cluster.

A Simple Hadoop Example

This section demonstrates how to run a MapReduce Java program on the Hadoop cluster. This is the standard paradigm for Hadoop jobs. If you want to run jobs using another framework or in other languages besides Java send email to bridges@psc.edu for assistance.

Follow these steps to run a job on the Hadoop cluster. All the commands listed below should be in your command path by default. The variable HADOOP_HOME should be set for you also.

1. Compile your Java MapReduce program with a command similar to:

   hadoop com.sun.tools.javac.Main WordCount WordCount.java

   where:

   • WordCount is the name of the output directory where you want your class file to be put
   • WordCount.java is the name of your source file
2. Create a jar file out of your class file with a command similar to:

   jar -cvf WordCount.jar -C WordCount/ .

   where:

   • WordCount.jar is the name of your output jar file
   • WordCount is the name of the directory which contains your class file
3. Launch your Hadoop job with the "hadoop" command

   Once you have your jar file you can run the hadoop command to launch your Hadoop job. Your hadoop command will be similar to

   hadoop jar WordCount.jar org.myorg.WordCount \/datasets/compleat.txt $MYOUTPUT

   where:

   • Wordcount.jar is the name of your jar file
   • org.myorg.WordCount specifies the folder hierarchy inside your jar file. Substitute the appropriate hierarchy for your jar file.
   • /datasets/compleat.txt is the path to your input file in the HDFS file system. This file must already exist in HDFS.
   • $MYOUTPUT is the path to your output file, which will be saved in the HDFS file system. You must set this variable to the output file path before you issue the hadoop command.

After you issue the hadoop command your job is controlled by the Hadoop scheduler to run on the datanodes. The scheduler is currently a stricty FIFO scheduler. If your job turnaround is not meeting your needs send email to bridges@psc.edu.

When your job finishes, the hadoop command will end and you will be returned to the system prompt.

Other Hadoop Technologies

An entire ecosystem of technologies has grown up around Hadoop, such as HBase and Hive. To request the installation of a different package send email to bridges@psc.edu.

Do I need a container?

If you need a very specialized computing environment, you can create a container as your work space on Bridges. Currently, Singularity is the only type of container supported on Bridges. Docker is not supported.

However, in most cases, Bridges has all the software you will need. Before creating a container for your work, check the extensive list of software that has been installed on Bridges. While logged in to Bridges, you can also get a list of installed packages by typing

module avail

If you need a package that is not available on Bridges, you can request that it be installed by emailing bridges@psc.edu. You can also install software packages in your own file spaces and, in some cases, we can provide assistance if you encounter difficulties.

How would I use a container on Bridges?

Singularity is the only container software supported on Bridges. You can create a Singularity container, copy it to Bridges and then execute your container on Bridges, where it can use Bridges's compute nodes and filesystems. In your container you can use any software required by your application: a different version of CentOS, a different Unix operating system, any software in any specific version needed. You can set up your Singularity container without any intervention from PSC staff.

A Singularity container is a single file. Thus, it can easily be copied to Bridges and also to other systems so you can insure that you are running a reproducible environment no matter where or when you compute.

See the PSC documentation on Singularity for more details on its usage on Bridges.

Why use a VM?

If you need a persistent environment you need to use a virtual machine (VM). Examples of a need for a persistent environment are a Web server with a database backend or just a persistent database.

If you can use a Singularity container rather than a VM you should use the container. You can set up your Singularity container yourself without any intervention by PSC staff. Also, a VM is charged for usage the entire time the VM is set up, whether or not it is being actively used. Containers are only charged for the time during which they are executing, because they are not persistent computing environments. A Singularity environment only exists while you are executing it. Thus, VMs are much more expensive in terms of SUs used than Singularity containers.

A VM provides you with control over your environment, but you will have access to the computing power, memory capacity and file spaces of Bridges.

Common uses of VMs include hosting database and web servers. These servers can be restricted just to you or you can open them up to outside user communities to share your work. You can also connect your database and web servers and other processing components in a complex workflow.

VMs provide several other benefits. Since the computing power behind the VM is a supercomputer, sufficient resources are available to support multiple users. Since each VM acts like an independent machine, user security is heightened. No outside users can violate the security of your independent VM. However, you can allow other users to access your VM if you choose.

A VM can be customized to meet your requirements. PSC will set up the VM and give you access to your database and web server at a level that matches your requirements.

To discuss whether a VM would be appropriate for your research project, send email to bridges@psc.edu.

Downtime

VMs are affected by system downtime, and will not be available during an outage. Scheduled downtimes are announced in advance.

Data backups

It is your responsiblity to backup any important data to another location outside of the VM. PSC will make infrequent snapshots of VMs for recovery from system failure, but cannot be responsible for managing your data.

Grant expiration

When your grant expires, your VM will be suspended. You have a 3-month grace period to request via email to bridges@psc.edu that it be reactivated so that you can move data from the VM. Three months after your grant expires, the VM will be removed. Please notify bridges@psc.edu if you need help moving your data during the grace period.

You can request a VM by submitting the Virtual Machine Request Form.

Publicly available datasets

Some data collections are available to anyone with a Bridges account. They include:

ImageNet

ImageNet is an image dataset organized according to WordNet hierarchy. See the ImageNet website for complete information.

Available on Bridges at /pylon5/datasets/community/imagenet

Natural Languge Tool Kit Data

NLTK comes with many corpora, toy grammars, trained models, etc. A complete list of the available data is posted at: https://www.nltk.org/nltk_data/

NLTK is available on Bridges at /pylon2/datasets/community/nltk.

MNIST

Dataset of handwritten digits used to train image processing systems.

Available on Bridges at /pylon5/datasets/community/mnist

Genomics Data

Several genomics datasets are publicly available.

BLAST

The BLAST databases can be accessed through the environment variable $BLASTDB after loading the BLAST module.

CAMI

CAMI (Critical Assessment of Metagenome Interpretation) is a community-led initiative designed to help tackle challenges in metagenome assembly and analysis by aiming for an independent, comprehensive and bias-free evaluation of methods. Data from the first CAMI challenge is available at /pylon5/datasets/community/genomics/cami.

RepBase

UCSC

The University of California Santa Cruz reference genomes are available at /pylon5/datasets/community/genomics/UCSC. The collection includes human, mouse and drosophila genomes.

Other genomics datasets

Other available datasets are typically used with a particular genomics package. These include:

XSEDE supported research on Bridges

We ask that you use the following text:

This work used the Extreme Science and Engineering Discovery Environment (XSEDE), which is supported by National Science Foundation grant number ACI-1548562. Specifically, it used the Bridges system, which is supported by NSF award number ACI-1445606, at the Pittsburgh Supercomputing Center (PSC).

Please include these citations:

Towns, J., Cockerill, T., Dahan, M., Foster, I., Gaither, K., Grimshaw, A., Hazlewood, V., Lathrop, S., Lifka, D., Peterson, G.D., Roskies, R., Scott, J.R. and Wilkens-Diehr, N. 2014. XSEDE: Accelerating Scientific Discovery. Computing in Science & Engineering. 16(5):62-74. IEEE Computer Society.

Nystrom, N. A., Levine, M. J., Roskies, R. Z., and Scott, J. R. 2015. Bridges: A Uniquely Flexible HPC Resource for New Communities and Data Analytics. In Proceedings of the 2015 Annual Conference on Extreme Science and Engineering Discovery Environment (St. Louis, MO, July 26-30, 2015). XSEDE15. ACM, New York, NY, USA. ACM Digital Library.

Download Bibtex entry

Download EndNote entry

Additional Support

Please also acknowledge support provided through XSEDE's Extended Collaborative Support Services (ECSS) and/or by PSC staff.

Other research on Bridges

For research on Bridges supported by programs other than XSEDE, such as PRCI, we ask that you use the following text:

This work used the Bridges system, which is supported by NSF award number ACI-1445606, at the Pittsburgh Supercomputing Center (PSC).

Please include this citation:

Nystrom, N. A., Levine, M. J., Roskies, R. Z., and Scott, J. R. 2015. Bridges: A Uniquely Flexible HPC Resource for New Communities and Data Analytics. In Proceedings of the 2015 Annual Conference on Extreme Science and Engineering Discovery Environment (St. Louis, MO, July 26-30, 2015). XSEDE15. ACM, New York, NY, USA. ACM Digital Library.

Download Bibtex entry

Download EndNote entry

Additional support

Please also acknowledge any support provided by PSC staff.

ECSS Support

To acknowledge support provided through XSEDE's Extended Collaborative Support Services (ECSS), please use this text:

We thank [consultant name(s)] for [his/her/their] assistance with [describe tasks such as porting, optimization, visualization, etc.], which was made possible through the XSEDE Extended Collaborative Support Service (ECSS) program.

Please include this citation:

Wilkins-Diehr, N and S Sanielevici, J Alameda, J Cazes, L Crosby, M Pierce, R Roskies. High Performance Computer Applications 6th International Conference, ISUM 2015, Mexico City, Mexico, March 9-13, 2015, Revised Selected Papers Gitler, Isidoro, Klapp, Jaime (Eds.) Springer International Publishing. ISBN 978-3-319-32243-8, 3-13, 2016. 10.1007/978-3-319-32243-8.

PSC Support

If PSC staff contributed substantially to software development, optimization, or other aspects of the research, they should be considered as coauthors.

When PSC staff contributions do not warrant coauthorship, please acknowledge their support with the following text:

We thank consultant name(s) for his/her/their assistance with describe tasks such as porting, optimization, visualization, etc.

Security Measures

Security is very important to PSC. These policies are intended to ensure that our machines are not misused and that your data is secure.

What You Can Do

You play a significant role in security! To keep your account and PSC resources secure, please:

• Be aware of and comply with PSC policies on security, use and privacy found in this document
• Choose strong passwords and don't share them between accounts or with others. More information can be found in the PSC password policies.
• Utilize your local security team for advice and assistance
• Take the online XSEDE Cybersecurity Tutorial. Go to Online Training and click on "XSEDE Cybersecurity (CI-Tutor)"
• Keep your computer properly patched and protected
• Report any security concerns to the PSC help desk ASAP by calling the PSC hotline at: 412-268-6350 or email remarks@psc.edu

What We Will Never Do

• PSC will never send you unsolicited emails requesting confidential information.
• We will also never ask you for your password via an unsolicited email or phone call.

Remember that the PSC help desk is always a phone call away to confirm any correspondence at 412-267-6350.

If you have replied to an email appearing to be from PSC and supplied your password or other sensitive information, please contact the help desk immediately.

What You Can Expect

• We will send you email when we need to communicate with you about service outages, new HPC resources, and the like.
• We will send you email when your password is about to expire and ask you to change it by using the web-based PSC password change utility.

Other Security Policies

• PSC password policies
• Users must connect to PSC machines using ssh in order to avoid remote logins with clear text passwords
• We vigilantly monitor our computer systems and network connections for security violations
• We are in close contact with the CERT Coordination Project with regard to possible Internet security violations

Reporting Security Incidents

To report a security incident you should contact our Hotline at 412-268-6350. To report non-emergency security incidents you can send email to remarks@psc.edu.

PSC resource abuse policy

The Pittsburgh Supercomputing Center's computing resources are vital to the scientific community, and we have a responsibility to ensure that these resources are utilized in a responsible manner. The term computing resources in this case refers to all computers owned or operated by PSC and all hardware, data, software, storage systems and communications networks associated with these computers. Improper use of PSC systems is generally referred to as resource abuse.

Users of PSC's systems are subject to applicable Commonwealth of Pennsylvania and federal laws. Abuse of resources will be referred to the PSC User Services manager and/or the appropriate local, state and federal authorities, at PSC's discretion. Furthermore, PSC may terminate or restrict any user's access to its systems, without prior notice, if such action is necessary to maintain computing availability and security for other users of the systems.

Resource abuse includes, but is not limited to:

• using, or attempting to use, the center's computing resources without prior authorization or for unauthorized purposes
• tampering with or obstructing the operation of the computing resources, or attempting to do so
• inspecting, modifying, distributing, or copying privileged data or software without proper authorization, or attempting to do so
• supplying, or attempting to supply, false or misleading information or identification in order to access PSC's computing resources.

If there is any doubt regarding the legitimacy or authorization of any action, contact PSC User Services.

Privacy

Pittsburgh Supercomputing Center is committed to preserving your privacy. This privacy policy explains exactly what information is collected when you visit our site and how it is used.

This policy may be modified as new features are added to the site. Any changes to the policy will be posted on this page.

• Any data automatically collected from our site visitors - domain name, browser types, etc. - are used only in aggregate to help us better meet site visitors' needs.
• There is no identification of individuals from our aggregate data. Therefore, unless you choose otherwise, you are totally anonymous when visiting our site.
• We do not share data with anyone for commercial purposes.
• If you choose to submit personally identifiable information to us electronically via the PSC feedback page, email, etc., we will treat it with the same respect for privacy afforded to mailed submissions. Submission of such information is always optional.

PSC respects individual privacy and takes great effort in supporting web site privacy policy outlined above. Please be aware, however, that we publish URLs of other sites on our web site that may not adhere to the same policy.