Getting Started

Page Content

Supported Releases of MATLAB and MATLAB Compiler Runtime

MATLAB Release (Patch level)

MATLAB Compiler Runtime

In order to list available modules or load the Matlab and MCR modules listed here, you must first load the following Spack module. This makes the latest software stack available.

> module switch spack/23.1.0
List available
modules
> module avail matlab
> module avail matlab-mcr
 

R2024a
(Update 4)

> module remove intel-mpi
> module load intel-mpi/2018.4.274
> module load matlab/R2024a_Update4-generic
> module remove intel-mpi
> module load intel-mpi/2018.4.274
> module load matlab-mcr/R2024a
R2024a
R2023b
(Update 7)
> module remove intel-mpi
> module load intel-mpi/2018.4.274
> module load matlab/R2023b_Update7-generic
> module remove intel-mpi
> module load intel-mpi/2018.4.274
> module load matlab-mcr/R2023b_Update7
R2023b
(Update 7)
Availability

Linux Cluster (CoolMUC-2)

Linux Cluster (CoolMUC-2)

SuperMUC-NG

 

Using the default Intel-MPI module (Version 2019 or newer versions), unintended crashes of parallel MATLAB jobs might occur. Please switch to Intel MPI 2018.

Useful MATLAB Command-line Options

Run MATLAB via the "matlab" command only or add command-line arguments. Please consider: All MATLAB command-line arguments are case-sensitive!

> matlab arg_1 ... arg_N
Command-line argumentMeaning
no argumentStart MATLAB GUI.
-nodesktop
Start MATLAB without desktop but allow GUI and graphics output (figures).
-nodisplay
Start MATLAB without any GUI support. Graphics output (figures) is also not possible.
-singleCompThread

Many intrinsic MATLAB functions automatically exploit multithreading. MATLAB can be forced to disable this feature. Use this option for any work on the login nodes! 

-r myfunc
Run a MATLAB script or function, e. g. myfunc.m.

Further information:

Interactive MATLAB Jobs

LRZ policies for using MATLAB on Login Nodes

MATLAB is a very resource-hungry application with respect to both memory and CPU resources! Please run MATLAB on login nodes with care!

Especially, involving multiple threads (many MATLAB functions/operators use multithreading by default) or multiple processes might cause a high load on the login node and handicapping other users!

MATLAB applications, which handicap other users or have a negative impact on the general operation of the login nodes, will be terminated by system administrators!

Our rules using MATLAB on the login nodes:

  • Only run a maximum of one MATLAB instance!
  • Disable any kind of parallelization, i.e. multithreading (see command-line options above) or the Parallel Computing Toolbox!
  • Check the load and memory consumption of your own MATLAB session. Usually, you can do this via the "top" command, e.g.:
    top -u $USER
  • We recommend NOT to use the graphical user interface (GUI) of MATLAB, as this unnecessarily increases the load (resource consumption). Furthermore, using GUI decreases the overall performance of MATLAB.
    • If the MATLAB GUI is needed, then you may run MATLAB via a VNC session (VNC Server on Login-Nodes) to increase the performance and responsiveness of the GUI!
    • If the MATLAB GUI is not needed, it is better to run MATLAB via an interactive Slurm job (see next section). This job runs on a compute node. Parallelization is explicitly allowed here!
  • Repeated violation of the above mentioned restrictions on login nodes might result in a ban of the affected user account and notification to the responsible master user or PI.

Interactive MATLAB Jobs via Slurm Job

Usecases

Depending on the purpose, there are different possibilities to use MATLAB interactively:

  • MATLAB computations with focus on visualisation: We recommend to use our Remote Visualisation System.
  • Pure MATLAB computations: Interactive MATLAB sessions may be started on compute nodes of CoolMUC-2 or CoolMUC-3 by employing interactive Slurm jobs (see Slurm documentation).

Constraints

  • Interactive jobs depend on the availability of compute resources. Matlab may not start immediately.
  • Matlab will run on 1 compute node.
  • The time limit is set to 2 hours (= maximum time for interactive Slurm sessions).

How to Use it - the Convenient Way

  1. Load desired MATLAB module.

  2. For convenience, load the interactive-MATLAB module in order to use the loaded MATLAB version:

    > # use CoolMUC-2:
> module load matlab-tools/coolmuc-2
> 
> # use CoolMUC-3:
> module load matlab-tools/coolmuc-3

  3. Start interactive MATLAB session. This command will implicitly submit an interactive Slurm job. Probably you have to wait if the interactive partition is fully occupied.

    > matlab-inter
  4. Exiting MATLAB session will automatically finish the Slurm job.

Common Batch Jobs

Batch jobs are used for all MATLAB production runs. Usually, the resources, consumed by MATLAB applications, are limited to a single CPU core (pure serial job) or a single compute node (parallel job involving either multithreading or the Parallel Computing Toolbox [PCT]). Following table lists job examples for various cases which can be used on CoolMUC-2.


Slurm job scriptMatlab script

Serial batch job

No parallelization at all, MATLAB is intended to run on a single core.
Please use the "serial" cluster of the Linux Cluster!

#!/bin/bash
#SBATCH -o ./out/%x.%j.%N.out
#SBATCH -e ./out/%x.%j.%N.err
#SBATCH -D ./
#SBATCH -J matlab_serial_batch_job
#SBATCH --get-user-env
#SBATCH --export=NONE
#SBATCH --clusters=serial
#SBATCH --partition=serial_std
#SBATCH --nodes=1
#SBATCH --tasks-per-node=1
#SBATCH --cpus-per-task=1
#SBATCH --mem=10000M
#SBATCH --time=0:30:00
# As needed, remove/adjust memory requirement "--mem" in MB
 
module load slurm_setup
module switch spack/23.1.0
module load matlab/R2023b_Update4-generic
 
# Example: matrix-matrix multiplication C = A*B
#          with A of size NROWA x NCOLA and
#          B of size NROWB x NCOLB
NROWA=1000
NCOLA=2000
NROWB=2000
NCOLB=5000
 
# Run MATLAB
# => Using option -r don't add file extension .m to the function call!
# => MATLAB commandline arguments are case-sensitive!
matlab -nodisplay -singleCompThread \
       -r "matmul_serial([$NROWA $NCOLA], [$NROWB $NCOLB]);"


function [C, comptime] = matmul_serial(size_A, size_B)
 
%===============================================================================
% MATLAB EXAMPLE: SERIAL HELLO WORLD
%                 -> matrix-matrix multiplication C = A*B
%
% INPUT
%   size_A, size_B ... 2-element row vectors defining sizes of A and B
% OUTPUT
%   C ................ result
%   comptime ......... computation time (matrix product only)
%===============================================================================
 
%===============================================================================
% Check input
%===============================================================================
if nargin~=2
    error('Invalid number of input arguments!');
end
if size_A(2)~=size_B(1)
    error(sprintf('Dimension mismatch of A (%d columns) and B (%d rows)!',...
                  size_A(2), size_B(1)));
end
 
%===============================================================================
% Work
%===============================================================================
% Hello message from compute node
fprintf('Hello from MATLAB process PID=%d running on node %s!\n',...
        feature('getpid'),...
        strtrim(evalc('system(''hostname'');')));
 
% generate well-defined matrices
NA = prod(size_A);
NB = prod(size_B);
A = reshape( linspace( 1,NA, NA), size_A );
B = reshape( linspace(NB, 1, NB), size_B );
 
% compute
tic;
C = A*B;
comptime = toc;
fprintf('serial computation of matrix-matrix product:\n');
fprintf('\ttime = %.2f s\n', comptime);

Parallel job using multithreading

MATLAB will run on a single compute node.
Please use the partition "cm2_tiny" in cluster "cm2_tiny"!

#!/bin/bash
#SBATCH -o ./out/%x.%j.%N.out
#SBATCH -e ./out/%x.%j.%N.err
#SBATCH -D ./
#SBATCH -J matlab_threading_batch_job
#SBATCH --get-user-env
#SBATCH --export=NONE
#SBATCH --clusters=cm2_tiny
#SBATCH --partition=cm2_tiny
#SBATCH --nodes=1
#SBATCH --tasks-per-node=1
#SBATCH --cpus-per-task=14
#SBATCH --time=00:30:00
 
module load slurm_setup
module switch spack/23.1.0
module load matlab/R2023b_Update4-generic
 
# Example: matrix-matrix multiplication C = A*B
#          with A of size NROWA x NCOLA and
#          B of size NROWB x NCOLB
NROWA=1000
NCOLA=2000
NROWB=2000
NCOLB=5000
 
# Run MATLAB
# => Using option -r don't add file extension .m to the function call!
# => MATLAB commandline arguments are case-sensitive!
matlab -nodisplay \
       -r "matmul_mthread([$NROWA $NCOLA], [$NROWB $NCOLB]);"


function [C, comptime] = parallel_mthread(size_A, size_B)
 
%===============================================================================
% MATLAB EXAMPLE: PARALLEL HELLO WORLD USING MULTITHREADING
%                 -> matrix-matrix multiplication C = A*B
%
% INPUT
%   size_A, size_B ... 2-element row vectors defining sizes of A and B
% OUTPUT
%   C ................ result
%   comptime ......... computation time (matrix product only)
%===============================================================================
 
%===============================================================================
% Check input
%===============================================================================
if nargin~=2
    error('Invalid number of input arguments!');
end
if size_A(2)~=size_B(1)
    error(sprintf('Dimension mismatch of A (%d columns) and B (%d rows)!',...
                  size_A(2), size_B(1)));
end
 
%===============================================================================
% Manage multithreading
%===============================================================================
% Get number of threads depending on job type (batch job or interactive job).
% In batch jobs 1 MATLAB task will use "nw" threads.
%
% obtain number of threads from Slurm environment variables
cluster = getenv('SLURM_CLUSTER_NAME');
if strcmp(cluster, 'inter')
    % interactive job
    nw = str2num(getenv('SLURM_JOB_CPUS_PER_NODE'));
elseif strcmp(cluster, 'cm2_tiny') || ...
       strcmp(cluster, 'mpp3') || ...
       strcmp(cluster, 'ivymuc')
    % batch job
    nw = str2num(getenv('SLURM_CPUS_PER_TASK'));
else
    % default
    nw = 1;
end
% set threads
maxNumCompThreads(nw);
 
%===============================================================================
% Work
%===============================================================================
fprintf('Hello from MATLAB process PID=%d running on node %s!\n',...
        feature('getpid'),...
        strtrim(evalc('system(''hostname'');')));
 
% generate well-defined matrices
NA = prod(size_A);
NB = prod(size_B);
A = reshape( linspace( 1,NA, NA), size_A );
B = reshape( linspace(NB, 1, NB), size_B );
 
% compute
tic;
C = A*B;
comptime = toc;
fprintf('parallel computation (multithreading) of matrix-matrix product:\n');
fprintf('\tnumber of threads = %d\n', nw);
fprintf('\ttime = %.2f s\n', comptime);

Parallel batch job using Parallel Computing Toolbox (PCT)

MATLAB will run on a single compute node.
Please use the partition "cm2_tiny" in cluster "cm2_tiny"!

#!/bin/bash
#SBATCH -o ./out/%x.%j.%N.out
#SBATCH -e ./out/%x.%j.%N.err
#SBATCH -D ./
#SBATCH -J matlab_pct_batch_job
#SBATCH --get-user-env
#SBATCH --export=NONE
#SBATCH --clusters=cm2_tiny
#SBATCH --partition=cm2_tiny
#SBATCH --nodes=1
#SBATCH --tasks-per-node=4
#SBATCH --cpus-per-task=1
#SBATCH --time=00:30:00

module load slurm_setup
module switch spack/23.1.0

# IMPORTANT
# Default settings of Intel MPI module may disrupt
# functionality of Parallel-Computing-Toolbox!
# Do one of the following solutions:
# (1) Unload Intel MPI module:
module rm intel-mpi
module rm mpi.intel
# (2) If Intel MPI module is mandatory, uncomment next 2 lines
module load intel-mpi/2018.4.274
export KMP_AFFINITY=granularity=thread,none

module load matlab/R2021a-generic

# Example: matrix-matrix multiplication C = A*B
#          with A of size NROWA x NCOLA and
#          B of size NROWB x NCOLB
NROWA=1000
NCOLA=2000
NROWB=2000
NCOLB=5000

# Run MATLAB
# => Using option -r don't add file extension .m to the function call!
# => MATLAB commandline arguments are case-sensitive!
matlab -nodisplay -singleCompThread \
       -r "matmul_pct([$NROWA $NCOLA], [$NROWB $NCOLB]);"



function [Cglob, comptime] = matmul_pct(size_A, size_B)
 
%===============================================================================
% MATLAB EXAMPLE: PARALLEL HELLO WORLD USING PCT TOOLBOX
%                 -> matrix-matrix multiplication C = A*B
%
% INPUT
%   size_A, size_B ... 2-element row vectors defining sizes of A and B
% OUTPUT
%   C ................ result
%   comptime ......... computation time (matrix product only)
%===============================================================================
 
%===============================================================================
% Check input
%===============================================================================
if nargin~=2
    error('Invalid number of input arguments!');
end
if size_A(2)~=size_B(1)
    error(sprintf('Dimension mismatch of A (%d columns) and B (%d rows)!',...
                  size_A(2), size_B(1)));
end
 
%===============================================================================
% Verify that no parallel pool is initialized by creating/deleting a dummy pool
%===============================================================================
if ~isempty(gcp('nocreate'))
    poolobj = gcp('nocreate');
    delete(poolobj);
end
 
%===============================================================================
% Start parallel pool
%===============================================================================
% Get number of workers depending on job type. Start parallel pool via "local"
% cluster object.
%
% obtain number of tasks from Slurm environment variables
cluster = getenv('SLURM_CLUSTER_NAME');
if strcmp(cluster, 'inter')
    % interactive job
    nw = str2num(getenv('SLURM_JOB_CPUS_PER_NODE'));
elseif strcmp(cluster, 'cm2_tiny') || ...
       strcmp(cluster, 'serial') || ...
       strcmp(cluster, 'mpp3') || ...
       strcmp(cluster, 'ivymuc')
    % batch job
    nw = str2num(getenv('SLURM_NTASKS'));
else
    % default
    nw = 1;
end
 
% disallow Threading
if maxNumCompThreads > 1
    maxNumCompThreads(1);
    warning('MultiThreading: number of threads has been set to 1!');
end
 
% create a local cluster object
pc = parcluster('local');
% set number of workers
pc.NumWorkers = nw;
% set the JobStorageLocation to SCRATCH (default: HOME -> not recommended)
pc.JobStorageLocation = strcat(getenv('SCRATCH'));
% start the parallel pool
poolobj = parpool(pc, nw);
 
%===============================================================================
% Work
%===============================================================================
spmd
    fprintf('Hello from MATLAB process PID=%d running on node %s!\n',...
            feature('getpid'),...
            getenv('HOSTNAME'));
end
 
% generate well-defined matrices
NA = prod(size_A);
NB = prod(size_B);
A = reshape( linspace( 1,NA, NA), size_A );
B = reshape( linspace(NB, 1, NB), size_B );
 
% distribute data to workers and do parallel computation
spmd
    Aloc = codistributed(A, codistributor2dbc([nw 1]));
    Bloc = codistributed(B, codistributor2dbc([1 nw]));
    tic;
    Cloc = Aloc*Bloc;
    t = toc;
end
 
comptime = max(cell2mat(t(:)));
fprintf('parallel computation (MPI) of matrix-matrix product:\n');
fprintf('\tnumber of tasks (MATLAB workers) = %d\n', nw);
fprintf('\ttime = %.2f s\n', comptime);
 
Cglob = gather(Cloc);
 
%===============================================================================
% Close parallel pool
%===============================================================================
delete(poolobj);