MATLAB

Set-up

Running MATLAB

matlab -nodisplay 

Batch Usage

sinteractive -A <project-account> -N 1 -n 28 -t 00:20:00

Set-up

Running MATLAB

The following command will start an interactive, command line version of MATLAB:

matlab -nodisplay 

The commands listed above will run MATLAB on the login node you are connected to. As the login node is a shared resource, running scripts that require significant computational resources will impact the usability of the cluster for others. As such, you should not use interactive MATLAB sessions on the login node for any significant computation. If your MATLAB script requires significant time, CPU power, or memory, you should run your code via the batch system.

Batch Usage

sinteractive -A <project-account> -N 1 -n 40 -t 00:20:00

MATLAB supports implicit multithreading on a single node, as well as MPI accross multiple nodes via MatLab Parallel Server's built-in implementation of MPI.  

Multithreading

Multithreading allows some functions in MATLAB to distribute the work load between cores of the node that your job is running on. By default, all of the current versions of MATLAB available on the OSC clusters have multithreading enabled. 

The system will run as many threads as there are cores on the nodes requested.

Multithreading increases the speed of some linear algebra routines, but if you would like to disable multithreading you may include the option " -singleCompThread" when running MATLAB. An example is given below:

#!/bin/bash
#SBATCH --job-name disable_multithreading
#SBATCH --time=00:10:00
#SBATCH --nodes=1 --ntasks-per-node=40
#SBATCH --account=<project-account>

module load matlab
matlab -singleCompThread -nodisplay -nodesktop < hello.m
# end of example file

Single node parallelization with 'parpool'

To parallelize MatLab processes across a single node, we will write a MatLab script that uses "parcluster" and "parpool" to setup a pool of workers.  Here is an example "Hello World" code for illustration:

% specify timezone to prevent warnings about timezone ambiguity

setenv('TZ', 'America/New_York')

% open the local cluster profile for a single node job
  p = parcluster('local');

  % open the parallel pool, recording the time it takes
  tic;
  parpool(p, 40); % open the pool using 40 workers
  fprintf('Opening the parallel pool took %g seconds.\n', toc)

  % "single program multiple data"
  spmd
    fprintf('Worker %d says Hello World!\n', labindex)
  end

  delete(gcp); % close the parallel pool
  exit

Since we will only be using a single  node, we will use the "local" cluster profile and set the parpool size to be equal to the number of cores on the compute node we'll be running on.  

Let's save this MatLab script as "helloworld.m" and then write a Slurm batch script to execute it:

#!/usr/bin/env bash

#SBATCH -N 1
#SBATCH --ntasks-per-node=40
#SBATCH --job-name=matlab_helloworld
#SBATCH --output=MatLabHello40.log

# load a MatLab module
module load matlab/r2020a

# create a variable for the basename of the script to be run
BASE_MFILE_NAME=helloworld

# execute code without a GUI
cd $SLURM_SUBMIT_DIR
matlab -nodisplay -r $BASE_MFILE_NAME

In the above batch script, we load a MatLab module, create a variable to specify the basename of Hello World script, and then execute the script with the "-nodisplay" flag to prevent the GUI from trying to load. The script uses 40 workers since Pitzer nodes have 40 or 48 cores.

Next, let's save this file as "helloworld.slurm" and submit the job script to the Slurm scheduler with "sbatch helloworld.slurm."

The output will be found in the log file "MatLabHello40.log":

                          < M A T L A B (R) >
                  Copyright 1984-2022 The MathWorks, Inc.
             R2020a Update 5 (9.10.0.1739362) 64-bit (glnxa64)
                               April 18, 2022

To get started, type doc.
For product information, visit www.mathworks.com.

Starting parallel pool (parpool) using the 'local' profile ...
Connected to the parallel pool (number of workers: 40).
Opening the parallel pool took 24.7213 seconds.
Lab  1:
  Worker 1 says Hello World!
....
Lab 40:
  Worker 40 says Hello World!
Parallel pool using the 'local' profile is shutting down.

We can see from the above that there is a "Hello World" statement from each of the 40 workers.

Multi-Node Processing

It's also possible to use multiple nodes to run MatLab code  via MatLab Parallel Server's built-in implementation of MPI, but this process requires a bit of intial setup:

1. First we need to load the matlab module and run the matlab executable in GUI mode:

module load matlab/r2020a
matlab

2. Next, within the matlab GUI, navigate to HOME->Environment->Parallel->Create and Manage Clusters:

3. Next, we create a new cluster profile by navigating to "Add Cluster Profile" and choosing the Slurm scheduler:

4. Finally, we edit the cluster profile to suite the needs of the job we will be running. Most of the settings can be left as default, though the following should be set:
Resource arguments for job submission  - these are the SBATCH flags used to control the job's behavior and resources utilized.  At a minimum, the "--account" flag should be set to a valid account name.

Finally, after editing the Slurm cluster profile to specify the resources neeed for your job, we can launch the job with by executing a MatLab script at the command line (note that this can also be done within the MatLab GUI):

% specify timezone to prevent warnings about timezone ambiguity

setenv('TZ', 'America/New_York')

% open the desired Slurm cluster profile
  p = parcluster('SlurmProfile1');

  % open the parallel pool, recording the time it takes
  tic;
  parpool(p, 80); % open the pool using 80 workers which will be spread across 2 nodes
  fprintf('Opening the parallel pool took %g seconds.\n', toc)

  % "single program multiple data"
  spmd
    fprintf('Worker %d says Hello World!\n', labindex)
  end

  delete(gcp); % close the parallel pool
  exit

This time, we've specified the 'SlurmProfile1' profile to the parcluster command. In addition, since the cluster profile is set to use 2 nodes on Pitzer, when we open the parallel pool we set the worker count to 80 workers. 

Let's save this file as 'helloworld_slurm.m' and execute it:

matlab -nodisplay -r helloworld_slurm > helloworld_slurm.log

This will use MatLab's Slurm cluster profile to submit the code to the scheduler. The job may sit in the queue if the cluster is busy, but once it has run, we see a Hello World statement printed from 80 different workers printed in the log file:

...
Lab 45:
  Worker 45 says Hello World!
Lab 46:
  Worker 46 says Hello World!
Lab 47:
  Worker 47 says Hello World!
...

Multi-node Slurm MatLab jobs can also be submitted using a specific Slurm MatLab plugin, which may offer more scriptable flexibility.  To learn more about that option, please see here.