|Installed||(orig Feb 2013), Oct 2018|
|Operating System||Linux (Centos 7.4)|
|Number of Nodes||42|
|Login/Devel Node||teach01 (from teach.scinet)|
SciNet has assembled some older compute hardware into a small cluster provided primarily for teaching purposes. It is configured similarly to the production Niagara system, however uses repurposed hardware. This system should not be used for production work as such the queuing policies are designed to provide fast job turnover and limit the amount of resources one person can use at a time. Questions about its use or problems should be sent to firstname.lastname@example.org.
The cluster consists of 42 repurposed x86_64 nodes each with 16 cores (from two octal core Intel XeonSandybridge E5-2650 CPUs) running at 2.0GHz with 64GB of RAM per node. The nodes are interconnected with 2.6:1 blocking QDR Infiniband for MPI communications and disk I/O to the SciNet Niagara filesystems. In total this cluster contains 672 cores.
Teach runs CentOS 7, which is a type of Linux. You will need to be somewhat familiar with Linux systems to work on Teach. If you are not, it will be worth your time to review our Introduction to Linux Shell class.
ssh -Y USERNAME@teach.scinet.utoronto.ca
This will bring directly to the command line of teach01 the gateway/devel node for this cluster. From teach01 you can compile, do short tests, and submit your jobs to the queue. The first time you login to Teach cluster, please make sure to check if the login node ssh key fingerprint matches. See here how.
The login node teach01 is shared between students of a number of different courses. Use this node to develop and compile code, to run short tests, and to submit computations to the scheduler (see below).
Other than essentials, all installed software is made available using module commands. These modules set environment variables (PATH, etc.), allowing multiple, conflicting versions of a given package to be available. A detailed explanation of the module system can be found on the modules page.
Common module subcommands are:
module load <module-name>: load the default version of a particular software.
module load <module-name>/<module-version>: load a specific version of a particular software.
module purge: unload all currently loaded modules.
module spider <module-name>): list available software packages.
module avail: list loadable software packages.
module list: list loaded modules.
For example, to make the GNU compilers (gcc, g++ and gfortran) available, you should type
module load gcc
while the Intel compilers (icc, icpc and ifort) can be loaded by
module load intel
Along with modifying common environment variables, such as PATH, and LD_LIBRARY_PATH, these modules also create a SCINET_MODULENAME_ROOT environment variable, which can be used to access commonly needed software directories, such as /include and /lib.
There are handy abbreviations for the module commands.
ml is the same as
module list, and
ml <module-name> is the same as
module load <module-name>.
A list of available software modules can be found below.
For a interactive sessions on a compute node of the teach cluster that give access to non-shared resources, use the 'debugjob' command.
teach01:~$ debugjob -n C
where C is the number of cores. An interactive session defaults to four hours when using at most one node (C<=16), and becomes 60 minutes when using four nodes (i.e., 48<C<=64), which the maximum number of nodes allowed for an interactive session by debugjob.
For a short interactive sessions on a dedicated compute node of the teach cluster, use the 'debugjob' command as follows:
teach01:~$ debugjob N
where N is the number of nodes. On the Teach cluster, this is equivalent to debugjob -n 16*N . The positive integer number N can at most be 4.
If no arguments are given to debugjob, it allocates a single core on a Teach compute node.
There are limits on the resources you can get with a debugjob, and how long you can get them. No debugjob can run longer than four hours or use more than 64 cores, and each user can only run one at a time. For longer computations, jobs must be submitted to the scheduler.
Submit a Job
Teach uses SLURM as its job scheduler. More-advanced details of how to interact with the scheduler can be found on the Slurm page.
You submit jobs from a login node by passing a script to the sbatch command:
teach01:~scratch$ sbatch jobscript.sh
This puts the job in the queue. It will run on the compute nodes in due course.
It is worth mentioning some differences between the Niagara and Teach clusters:
- On the Teach cluster, $HOME is writable on the compute nodes. On Niagara, $HOME is read-only on the compute nodes, so in most cases, you will want to submit from your $SCRATCH directory.
- Each teach cluster node has two CPUs with 8 cores each, a total of 16 cores per node (there is no hyperthreading). Make sure to adjust accordingly the flags --ntasks-per-node or --ntasks together with --nodes for the examples found at Slurm page.
- The current slurm configuration of the teach cluster allocates compute resources by core as opposed to by node. That means your tasks might land on nodes that have other jobs running, i.e. they might share the node. If you want to avoid that, make sure to add the following directive in your submitting script: #SBATCH --exclusive. This forces your job to use the compute nodes exclusively.
- The maximum walltime is currently set to 4 hours.
- There are 2 queues available: Compute queue and debug queue. Their usage limits are listed on the table below.
- 7 of the teach computing nodes have more memory than the 64GB default memory size. 5 of them have 128GB and 2 of them, 256GB. To run a big memory job on these nodes you need to add the following directive to your submitting script: #SBATCH --constraint=m128G. Replace m128G for m256G if you want your job to run exclusively on the 256GB nodes.
There are limits to the size and duration of your jobs, the number of jobs you can run and the number of jobs you can have queued. It also matters in which 'partition' the jobs runs. 'Partitions' are SLURM-speak for use cases. You specify the partition with the -p parameter to sbatch or salloc, but if you do not specify one, your job will run in the compute partition, which is the most common case.
|Usage||Partition||Running jobs||Submitted jobs (incl. running)||Min. size of jobs||Max. size of jobs||Min. walltime||Max. walltime|
|Interactive testing or troubleshooting||debug||1||1||1 core||4 nodes (64 cores)||N/A||4 hours|
|Compute jobs||compute||6||12||1 core||8 nodes (128 cores)||15 minutes||4 hours|
Within these limits, jobs may still have to wait in the queue. Although there are no allocations on the teach cluster, the waiting time still depends on many factors, such as the number of nodes and the walltime, how many other jobs are waiting in the queue, and whether a job can fill an otherwise unused spot in the schedule.
Some courses, like the Summer School, use Jupyter notebooks. In those cases, some (or all) of the large memory compute nodes are dedicated as jupyterhub nodes.
To connect to these, you must first set up an ssh tunnel from your local computer to the jupyterhub node in the SciNet datacenter. On a local terminal on your computer (i.e., not logged into SciNet), use the following command:
ssh -L8888:jupyterhub7:8000 teach.scinet.utoronto.ca -N
Instead of jupyterhub7, you can also choose jupyterhub1, jupyterhub2, jupyterhub3, jupyterhub4, jupyterhub5, or jupyterhub 6.
Note: It turns out that for many computers, in particular for Macs, this ssh command should be the first ssh to teach.scinet.utoronto.ca, i.e, you cannot already have another ssh session to teach running on your computer.
Also Note that this command will seem to 'hang' there, but the tunnel will have been established.
Next, open your browser and go to https://localhost:8888 and you can login to the jupyterhub.
Note: You will likely have to tell your browser to trust this site.
Built to complement the rich, open source Python community, the Anaconda platform provides an enterprise-ready data analytics platform that empowers companies to adopt a modern open data science analytics architecture
R is a free software environment for statistical computing and graphics
ASTRAL is a tool for estimating an unrooted species tree given a set of unrooted gene trees
SAMtools is a suite of programs for interacting with high-throughput sequencing data
The BEDTools utilities allow one to address common genomics tasks such as finding feature overlaps and computing coverage
Basic Local Alignment Search Tool, or BLAST, is an algorithm for comparing primary biological sequence information, such as the amino-acid sequences of different proteins or the nucleotides of DNA sequences
|boost||1.67.0 1.66.0|| |
Boost provides free peer-reviewed portable C++ source libraries
Bowtie 2 is an ultrafast and memory-efficient tool for aligning sequencing reads to long reference sequences
Burrows-Wheeler Aligner (BWA) is an efficient program that aligns relatively short nucleotide sequences against a long reference sequence such as the human genome
Fast and accurate alignment of BS-Seq reads
CMake, the cross-platform, open-source build system
Cutadapt finds and removes adapter sequences, primers, poly-A tails and other types of unwanted sequence from your high-throughput sequencing reads
deepTools is a suite of python tools particularly developed for the efficient analysis of high-throughput sequencing data, such as ChIP-seq, RNA-seq or MNase-seq
Inference of differential exon usage in RNA sequencing
FastQC is a quality control application for high throughput sequence data
FFTW is a C subroutine library for computing the discrete Fourier transform (DFT) in one or more dimensions, of arbitrary input size, and of both real and complex data
The GNU Compiler Collection for C, C++, and Fortran
The GNU Project Debugger
git-annex allows managing files with git, without checking the file contents into git
GMP is a free library for arbitrary precision arithmetic, operating on signed integers, rational numbers, and floating point numbers
GNU parallel is a shell tool for executing (usually serial) jobs in parallel
Portable interactive, function plotting utility
The GNU Scientific Library (GSL) is a numerical library for C and C++
|hdf5||1.8.20 1.10.4|| |
HDF5 is a data model, library, and file format for storing and managing data
HISAT2 is a fast and sensitive alignment program for mapping next-generation sequencing reads (both DNA and RNA) against the general human population (as well as against a single reference genome)
|htseq||0.11.1-anaconda2 0.11.1|| |
A framework to process and analyze data from high-throughput sequencing (HTS) assays
A C library for reading/writing high-throughput sequencing data
Intel compilers suite for C, C++, and Fortran, including the MKL, TBB, IPP, DAAL, and PSTL libraries
Intel MPI library with compiler wrappers for C, C++, and Fortran
Java Platform, Standard Edition (Java SE) lets you develop and deploy Java applications on desktops and servers
OpenLDAP's Lightning Memory-Mapped Database (LMDB) library
A (mostly) universal methylation extractor for BS-seq experiments
Fast and sensitive detection of differential DNA methylation
A probabilistic framework that quantitates the expression level of alternatively spliced genes from RNA-Seq data, and identifies differentially regulated isoforms or exons across samples
Intel Math Kernel Library
NetCDF (network Common Data Form) is a set of software libraries and machine-independent data formats that support the creation, access, and sharing of array-oriented scientific data
The Open MPI Project is an open source MPI-2 implementation
OProfile is a system-wide profiler for Linux systems, capable of profiling all running code at low overhead
Program for identifying orthologous protein sequence families
Graphics subroutine library for C/C++ and Fortran
A bioinformatics tool to PRe-process and show INformation of SEQuence data
Python is a programming language that lets you work more quickly and integrate your systems more effectively
|r||3.5.1 3.5.0|| |
R is a free software environment for statistical computing and graphics
Library for runtime multi-dimensional arrays in C++
RAxML search algorithm for maximum likelihood based inference of phylogenetic trees
SAM Tools provide various utilities for manipulating alignments in the SAM format, including sorting, merging, indexing and generating alignments in a per-position format
Singularity is a portable application stack packaging and runtime utility.
SQLite: SQL Database Engine in a C Library
StringTie is a fast and highly efficient assembler of RNA-Seq alignments into potential transcripts
Intel(R) Threading Building Blocks (Intel(R) TBB) lets you easily write parallel C++ programs that take full advantage of multicore performance, that are portable, composable and have future-proof scalability
Function A wrapper tool around Cutadapt and FastQC to consistently apply quality and adapter trimming to FastQ files, with some extra functionality for MspI-digested RRBS-type (Reduced Representation Bisufite-Seq) libraries
R implementation of the UpSet set visualization technique published by Lex, Gehlenborg, et al
Valgrind provides debugging and profiling tools