HPCC Cluster Overview
The HPCC Cluster (formerly called biocluster) is a shared research computing system available at UCR. The HPCC website is available here.
What Is a Computer Cluster?
A computer cluster is an assembly of CPU units, so called computer nodes that work together to perform many computations in parallel. To achieve this, an internal network (e.g. Infiniband interconnect) connects the nodes to a larger unit, while a head node controls the load and traffic across the entire system.
Usually, users log into the head node to submit their computer requests via
srunto a queuing system provided by resource management and scheduling software, such as SGE, Slurm or TORQUE/MAUI. The queuing system distributes the processes to the computer nodes in a controlled fashion.
Because the head node controls the entire system, users should never run computing jobs on the head node directly!
For code testing purposes, one can log into one of the nodes with
srun --pty bash -land run jobs interactively. Alternatively, one can log into the test node owl via ssh.
- Over 4,500 CPU cores
- 48 AMD computer nodes, each with 64 CPU cores and 512GB RAM
- 40 Intel computer nodes, each with 32 CPU cores and 512GB RAM
- 6 high-memory nodes, each 32 CPU cores and 1024GB RAM
- 12 GPU nodes, each with 5,000 cuda cores
- FDR IB @56Gbs
- Parallel GPFS storage system with 2.1 PB usable space
- Backup of same architecture and similar amount
- Computing tasks need to be submitted via
- HPCC Cluster headnode only for login, not for computing tasks!
- Monitor cluster activity:
Log into HPCC Cluster
- Login command on OS X or Linux
ssh -XY firstname.lastname@example.org
- Host name:
- User name: …
- Password: …
- Host name:
Important Linux Commands
List content of current directory
Print current working directory
Search in files and directories
Delete files and directories
Move and rename files
Copy files from internet to
SCP command-line tool
scp file user@remotehost:/home/user/ # From local to remote scp user@remotehost:/home/user/file . # From remote to local
STD IN/OUT/ERR, Redirect & Wildcards
* to specify many files
ls output to file
ls > file
Specify file as input to command
command < myfile
Append output of command to file
command >> myfile
STDOUT of one command to another command
command1 | command2
Turn off progress info
command > /dev/null
Pipe output of
grep pattern file | wc
STDERR to file
grep pattern nonexistingfile 2 > mystderr
Homework Assignment (HW2)
See HW2 page here.
Permissions and ownership
List directories and files
The previous command shows something like this for each file/dir:
meaning of this syntax is as follows:
rwx: read, write and execute permissions, respectively
- first triplet: user permissions (u)
- second triplet: group permissions (g)
- third triplet: world permissions (o)
Example for assigning write and execute permissions to user, group and world
chmod ugo+rx my_file
+causes the permissions selected to be added
-causes them to be removed
=causes them to be the only permissions that the file has.
Syntax for changing user & group ownership
chown <user>:<group> <file or dir>
Symbolic links are short nicknames to files and directories that save typing of their full paths.
ln -s original_filename new_nickname
Software and module system
- Over 750 software tools are currently installed on HPCC Cluster
- Most common research databases used in bioinformatics are available
- Support of most common programming languages used in research computing
- A module system is used to facilitate the management of software tools. This includes any number of versions of each software.
- New software install requests can be sent to email@example.com.
- To use software manged under the module system, users need to learn using some basic commands. The most common commands are listed below.
Print available modules
Print available modules starting with R
module avail R
Load default module R
module load R
Load specific module R version
module load R/3.2.2
List loaded modules
Unload module R
module unload R
Unload specific module R
module unload R/3.2.3-dev
Big data storage
Each user account on HPCC Cluster comes only with 20GB of disk space. Much more disk space is
available in a dedicated
bigdata directory. How much space depends on the subscription
of each user group. The path of
bigdata-shared is as follows:
All lab members share the same bigdata pool. The course number
gen242 is used as
for user accounts adminstered under GEN242.
The disk usage of
bigdata can be monitored on the HPCC Cluster Dashboard.
HPCC Cluster uses
Slurm as queuing and load balancing system. To control user traffic, any
type of compute intensive jobs need to be submitted via the
srun (see below) to the computer
nodes. Much more detailed information on this topic can be found on these sites:
- UCR HPCC Manual
- Slurm Documentation
- Torque/Slurm Comparison
- Switching from Torque to Slurm
- Slurm Quick Start Tutorial
Job submission with
Print information about queues/partitions available on a cluster.
Compute jobs are submitted
sbatch via a submission script (here
The following sample submission script (
script_name.sh) executes an R script named
#!/bin/bash -l #SBATCH --nodes=1 #SBATCH --ntasks=1 #SBATCH --cpus-per-task=1 #SBATCH --mem-per-cpu=1G #SBATCH --time=1-00:15:00 # 1 day and 15 minutes #SBATCH --firstname.lastname@example.org #SBATCH --mail-type=ALL #SBATCH --job-name="some_test" #SBATCH -p batch # Choose queue/parition from: intel, batch, highmem, gpu, short Rscript my_script.R
Interactive session: logs user into node
srun --pty bash -l
Interactive session with specific resource requests
srun --x11 --partition=short --mem=2gb --cpus-per-task 4 --ntasks 1 --time 1:00:00 --pty bash -l
STDERROR of jobs will be written to files named
slurm-<jobid>.out or to custom a file specified under
#SBATCH --output in the submission script.
Monitoring jobs with
List all jobs in queue
List jobs of a specific user
squeue -u <user>
Print more detailed information about a job
scontrol show job <JOBID>
Custom command to summarize and visualize cluster activity
Deleting and altering jobs
Delete a single job
scancel -i <JOBID>
Delete all jobs of a user
scancel -u <username>
Delete all jobs of a certain name
scancel --name <myJobName>
Altering jobs with
scontrol update. The below example changes the walltime (
<NEW_TIME>) of a specific job (
scontrol update jobid=<JOBID> TimeLimit=<NEW_TIME>
Resourse limits for users can be viewed as follows.
sacctmgr show account $GROUP format=Account,User,Partition,GrpCPUs,GrpMem,GrpNodes --ass | grep $USER
Similarly, one can view the limits of the group a user belongs to.
sacctmgr show account $GROUP format=Account,User,Partition,GrpCPUs,GrpMem,GrpNodes,GrpTRES%30 --ass | head -3
The following list includes examples of several widely used code editors.
- Vi/Vim/Neovim: Non-graphical (terminal-based) editor. Vi is guaranteed to be available on any system. Vim is the improved version of vi.
- Emacs: Non-graphical or window-based editor. You still need to know keystroke commands to use it. Installed on all Linux distributions and on most other Unix systems.
- Pico: Simple terminal-based editor available on most versions of Unix. Uses keystroke commands, but they are listed in logical fashion at bottom of screen.
- Nano: A simple terminal-based editor which is default on modern Debian systems.
- Atom: Modern text editor developed by GitHub project.
Why does it matter?
To work efficiently on remote systems like a computer cluster, it is essential
to learn how to work in a pure command-line interface. GUI environments like
RStudio and similar coding environments are not suitable for this. In addition,
there is a lot of value of knowing how to work in an environment that is not
restricted to a specific programming language. Therefore, this class embraces
RStudio where it is useful, but for working on remote systems like HPCC Cluster, it
uses Vim and Tmux. Both are useful for many programming languages.
Combinded with the
vim-r plugin they also provide a powerful command-line working
environment for R. The following provides a brief introduction to this environment.
The following opens a file (here
myfile) with vim
Once you are in Vim the most important commands are:
ikey brings you into the insert mode for typing.
Esckey brings you out of the insert mode.
:key starts the command mode at the bottom of the screen.
Use the arrow keys to move your cursor in the text. Using
Fn Up/Down key allows to page through
the text quicker. In the following command overview, all commands starting with
: need to be typed in the command mode.
All other commands are typed in the normal mode after pushing the
Important modifier keys to control vim
:w: save changes to file. If you are in editing mode you have to hit
:q: quit file that has not been changed
:wq: save and quit file
:!q: quit file without saving any changes
Useful resources for learning vim
Terminal-based Working Environment for R: Vim-R-Tmux
Tmux is a terminal multiplexer that allows to split terminal windows and to detach/reattach to
existing terminal sessions. Combinded with the
vim-r plugin it provides a powerful command-line working
environment for R where users can send code from a script to the R console or command-line.
Both tmux and the
vim-r plugin need to be installed on a system. On HPCC Cluster both are configured
in each user account. A detailed user manual is available here.
The following gives a short introduction into the basic usage:
1. Start tmux session
tmux # starts a new tmux session tmux a # attaches to an existing session
2. Open R script in vim
This can be any of these file types:
3. Open vim-connected R session by pressing the
This will open an R session in a separate tmux pane. Note, in the provided
the command key binding has been reassigned from the tmux default
and the shortcut for starting R from vim has been reassigned from
F2 in the
file. The command key binding
Ctrl-a is the most important key sequence in order to move
around in tmux. For instance, the key sequence
Ctrl-a o will switch between the vim and R
Ctrl-a Ctrl-o will swap the two panes.
4. Send R code vim to the R pane
Single lines of code can be sent from vim to the R console by pressing the space bar. To send
several lines at once, one can select them in vim’s visual mode and then hit the space bar.
Please note, the default command for sending code lines in the vim-r-plugin is
\l. This key
binding has been remapped in the provided
.vimrc file to the space bar. Most other key
bindings (shortcuts) still start with the
\ as LocalLeader, e.g.
\rh opens the help for
a function/object where the curser is located in vim. More details on this are given below.
Important keybindings for vim
<F2>: opens vim-connected R session; remapped in
<spacebar>: sends code from vim to R; here remapped in
:vsplit: splits viewport (similar to pane split in tmux)
Ctrl-w-w: jumps cursor to next viewport
Ctrl-w-r: swaps viewports
Ctrl-x: freezes/unfreezes vim (some systems)
Important keybindings for tmux
Ctrl-a %: splits pane vertically
Ctrl-a ": splits pane horizontally
Ctrl-a o: jumps cursor to next pane
Ctrl-a Ctrl-o: swaps panes
Ctrl-a <space bar>: rotates pane arrangement
Ctrl-a n: switches to next tmux window
Ctrl-a Ctrl-a: switches to previous tmux window
Ctrl-a c: creates a new tmux window
Ctrl-a 1: switches to specific tmux window selected by number
Ctrl-a d: detaches from current session
Ctrl-a s: switch between available tmux sesssions
$ tmux new -s <name>: starts new session with a specific name
$ tmux ls: lists available tmux session(s)
$ tmux attach -t <id>: attaches to specific tmux session
$ tmux attach: reattaches to session
$ tmux kill-session -t <id>: kills a specific tmux session
Ctrl-a : kill-session: kills a session from tmux command mode that can be initiated with
The new Nvim-R plugin also supports the latest extension of Vim called Neovim. The main advantages of Neovim compared to Vim are its better performance and its built-in terminal emulator facilitating the communication among Neovim and interactive programming environments such as R. Since the Vim and Neovim environments are managed independently, one can run them in parallel on the same system without interfering with each other.
A short manual for Nvim-R-Tmux is available here.