Fra Robin

(Forskjeller mellom versjoner)
Gå til: navigasjon, søk
Linje 54: Linje 54:
Now, <code>ssh hpc-robin</code> should directly establish a connection to the server (commands like <code>scp</code> should also work in the same way).
Now, <code>ssh hpc-robin</code> should directly establish a connection to the server (commands like <code>scp</code> should also work in the same way).
== Access ==
== Access ==  
To apply for access to robins project, send an e-mail to robin-engineer at Please include who your supervisor is and deadline for your thesis. 
Apply for access using this link: More information on how to get access is then given via e-mail.
Apply for access using this link: More information on how to get access is then given via e-mail.
== SLURM ==
== SLURM ==

Nåværende revisjon fra 18. mai 2022 kl. 08:59


Hardware and network configuration

The robin-hpc is a shared resource for robins researchers and Master students. The strength of the machine is the amount of CPU cores and RAM. Unforunatly, there's no GPU available in this service.


login node 2 cores/4 vCPU 16GB
worker node 120 cores/240 vCPU 460GB CentOS


The storage on the nodes consists of one 1TB disk where 100GB is reserved for software and 900GB is reserved for the users of the node. However, each user has a soft limit of 20 GB and a hard limit of 100 GB with a grace period of 14 days.

It's important to note that there is no backup of the disk, so do not use the robin-hpc as a cloud storage service. We suggest using rsync/scp to your home area on


rsync --progress <file>.tar.gz <username><path>/<to>/<wherever>

It is also a possibility to mount your UiO home directory to the robin-hpc.


For security reasons, the robin-hpc is only accessable from ifis-networks. If you use a desktop machine at ifi, you can access the robin-hpc directly. However, from your own laptop you are required to login to ifi's login cluster, namely, before you can access

URL for the robin-hpc login node is:

SSH from outside UiOs networks

To access the machine from outside UiOs networks, see Configure SSH. To make SSH slightly more pleasant to work with we can create a configuration file at ~/.ssh/config which can contain additional information about remote machines. The following is a possible configuration for the Robin-hpc (see here for more info). Indiviual key paths can be added with IdentityFile ~/.ssh/<key_on_jump_host>.

Host uio-login
 User <my-username>
 Hostname <my-uio-hostname>
Host hpc-robin
 ProxyJump uio-login
 User <my-username>

Now, ssh hpc-robin should directly establish a connection to the server (commands like scp should also work in the same way).


Apply for access using this link: More information on how to get access is then given via e-mail.


Ropin-hpc uses slurm for job scheduling.

To start a job on robin-hpc you will need to use a job script specifying the resources you want to use. The job is started with the following command:


(Note: Please do not run your program on the login node, test your implementation before copying the files to robin-hpc. You can easily copy the files needed to run your program to your home area on robin-hpc with scp.)

Below you will find a template for the job script, followed by some convenient commands.

For more information about slurm please visit

SLURM job script template


# This is a template for a slurm job script.
# To start a job on robin-hpc please use the command "sbatch".                                                                                                                            

# Job name                                                                                                                                                                                                  
#SBATCH --job-name=nameofmyjob                                                                                                                                                                              

# Wall clock time limit (hh:mm:ss). 
# (Note: The program will be killed when the time limit is reached.)                                                                                                         
#SBATCH --time=01:00:00                                                                                                                                                                                     

# Number of tasks to start in parallel from this script.                                                                                                                                                    
# (i.e. below will be started ntasks times)                                                                                                                                                    
#SBATCH --ntasks=1                                                                                                                                                                                          

# CPUs allocated per task                                                                                                                                                                                   
#SBATCH --cpus-per-task=16                                                                                                                                                                                  

# Memory allocated per cpu                                                                                                                                                                                  
#SBATCH --mem-per-cpu=1G                                                                                                                                                                                    

# Set exit on errors                                                                                                                                                                                        
set -o errexit
set -o nounset

# Load your environment                                                                                                                                                                                     
source myenv/bin/activate

# Run your program with "srun yourcommand"                                                                                                                                                                  
# stdout and stderr will be written to a file "slurm-jobid.out".                                                                                                                                            
# (warning: all tasks will write to the same slurm.out file)                                                                                                                                                
srun python3

Additional options

To run multiple tasks in sequence you can also use the --array option of the sbatch command. You can add the following to the script. You can then get the job array number with SLURM_ARRAY_TASK_ID. The following example would run 900 jobs:

#SBATCH --array=0-899

Convenient commands

View the status of all jobs:


View the status of your own jobs:

squeue -u yourusername  

Cancel all your jobs:

scancel -u yourusername

Cancel all jobs with name "job_name":

scancel -n job_name



Setting up the SLURM job script

#SBATCH --job-name=matlab_job
#SBATCH --ntasks=1
#SBATCH --cpus-per-task 16

srun matlab -batch "addpath(genpath('/path/to/your/matlab/folder'));run('myScript.m')"

Running Matlab in batch mode is the most safe option for running MATLAB on a HPC. (From Mathworks documentation)[1]:

-batch statement

  • Starts without the desktop

  • Does not display the splash screen

  • Executes statement

  • Disables changes to preferences

  • Disables toolbox caching

  • Logs text to stdout and stderr

  • Does not display modal dialog boxes

  • Exits automatically with exit code 0 if script executes successfully. Otherwise, MATLAB terminates with a non-zero exit code.

The addpath(genpath('/path/to/your/matlab/folder')) part adds all files in the specified directory to the MATLAB search path. Afterwards we run the main script of your program with run('myScript.m').

Utilizing parallel computing in your MATLAB Script

When the SLURM worker node is setting up your job, a number of environment variables is set. We can use the environment variable SLURM_CPUS_ON_NODE to get the number of CPU cores available in our MATLAB script. In fact, we can use that variable to dynamically select the number of workers in the MATLAB parallel pool, so that your script works both on your own computer and on the HPC.


% Delete parallel pool from earlier runs

if isempty(SLURM_CPUS_STR) 
    % Run on personal computer (with however many cores your CPU has)
    % Run on SLURM-scheduled HPC


After initializing Anaconda (see Deep Learning Workstations), it is possible to start a job on robin-hpc by using the command above and the following template:

SLURM Anaconda template


 #SBATCH --job-name=<test_name>
 #SBATCH --output=log.txt
 #SBATCH --ntasks=1
 #SBATCH --time=01:00:00
 #SBATCH --mem-per-cpu=100

 # load anaconda and your environment
 source ~/.bashrc
 conda activate <your_environment>

 # Run your program with "srun your_command"     
 srun python3 <script_name>.py

The output is written to "log.txt" and can be traced via "tail -f log.txt".

Running containers

singularity is installed on robin-hpc. Read more about singularity on . Alternativly you can use podman:

alias docker=podman
Personlige verktøy