Version 3 (modified by fuji, 3 years ago) ( diff )

Submitting Jobs from MATLAB Command Window

This document provides the steps to configure MATLAB to submit jobs to Cypress, retrieve results, and debug errors. There are two ways to do this, one is submitting MATLAB jobs from MATLAB running on Cypress, another is submitting MATLAB jobs from your laptop/desktop.

MATLAB client on Cypress

With this method, you can submit MATLAB jobs from MATLAB running on an interactive session. See how to run MATLAB interactively here.


Login to Cypress and start an interactive session and then start MATLAB (see here) Configure MATLAB to run parallel jobs on your cluster by calling configCluster, which only needs to be called once per version of MATLAB. Please be aware that running configCluster more than once per version will reset your cluster profile back to default settings and erase any saved modifications to the profile.

>> configCluster

Jobs will now default to the cluster rather than submit to the current node.

When you encounter an error Unrecognized function or variable 'configCluster'. , try

>> rehash toolboxcache

MATLAB client on your local computer

With this method, you can submit MATLAB jobs to Cypress from your local computer.


  • You need to have MATLAB installed on your laptop/desktop that must be the same version of MATLAB on Cypress (r2020a or later).
  • You must have the Matlab Parallel Computing Toolbox installed. To see what toolboxes are installed, type the ver command in the Matlab command window. You should see Parallel Computing Toolbox listed.
  • Make sure you have an account on Cypress and can ssh to Cypress from your local laptop/desktop.

Installation and Configuration

In order to submit MATLAB jobs to Cypress from your laptop/desktop, you need to install a custom Matlab plugin scripts that are configured to interact with the Slurm job scheduler on Cypress. Use the link below to download the script package to your laptop/desktop.

Download the archive file and start MATLAB. The archive file should be unzipped in the location returned by calling

>> userpath

See here to view or change default user work folder on MATLAB.

Run the configCluster.m Script to Create a Cluster Profile

Configure MATLAB to run parallel jobs on your cluster by calling configCluster. This only needs to be called once per version of MATLAB.

>> configCluster

Submission to the Cypress requires SSH credentials. You will be prompted for your ssh username and password or identity file (private key). The username and location of the private key will be stored in MATLAB for future sessions.

Configuring Jobs

Prior to submitting the job, we can specify various parameters to pass to our jobs, such as queue, e-mail, walltime, etc.

>> % Get a handle to the cluster
>> c = parcluster;


>> % Specify an account to use for MATLAB jobs
>> c.AdditionalProperties.AccountName = 'account-name';
>> % Specify e-mail address to receive notifications about your job
>> c.AdditionalProperties.EmailAddress = '';
>> % Specify Debug mode 
>> c.AdditionalProperties.EnableDebug = 'false';
>> % Specify memory to use for MATLAB jobs, per core (MB)
>> c.AdditionalProperties.MemUsage = '4000';
>> % Specify processors per node
>> c.AdditionalProperties.ProcsPerNode = '2';
>> % Specify Quality of Service
>> c.AdditionalProperties.QoS = 'qos-value';
>> % Specify a queue to use for MATLAB jobs				
>> c.AdditionalProperties.QueueName = 'queue-name';
>> % Specify the walltime (e.g. 5 hours)
>> c.AdditionalProperties.WallTime = '05:00:00';

Save changes after modifying AdditionalProperties for the above changes to persist between MATLAB sessions.

>> c.saveProfile

To see the values of the current configuration options, display AdditionalProperties.

>> % To view current properties
>> c.AdditionalProperties

Unset a value when no longer needed.

>> % Turn off email notifications 
>> c.AdditionalProperties.EmailAddress = '';
>> c.saveProfile


To run an interactive pool job on the cluster, continue to use parpool as you’ve done before.

>> % Get a handle to the cluster
>> c = parcluster;
>> % Open a pool of 64 workers on the cluster
>> p = c.parpool(64);

Rather than running local on the local machine, the pool can now run across multiple nodes on the cluster.

>> % Run a parfor over 1000 iterations
>> parfor idx = 1:1000
      a(idx) = …

Once we’re done with the pool, delete it.

>> % Delete the pool
>> p.delete


Use the batch command to submit asynchronous jobs to the cluster. The batch command will return a job object which is used to access the output of the submitted job. See the MATLAB documentation for more help on batch.

>> % Get a handle to the cluster
>> c = parcluster;
>> % Submit job to query where MATLAB is running on the cluster
>> j = c.batch(@pwd, 1, {}, …
       'CurrentFolder','.', 'AutoAddClientPath',false);
>> % Query job for state
>> j.State
>> % If state is finished, fetch the results
>> j.fetchOutputs{:}
>> % Delete the job after results are no longer needed
>> j.delete

To retrieve a list of currently running or completed jobs, call parcluster to retrieve the cluster object. The cluster object stores an array of jobs that were run, are running, or are queued to run. This allows us to fetch the results of completed jobs. Retrieve and view the list of jobs as shown below.

>> c = parcluster;
>> jobs = c.Jobs;

Once we’ve identified the job we want, we can retrieve the results as we’ve done previously. fetchOutputs is used to retrieve function output arguments; if calling batch with a script, use load instead. Data that has been written to files on the cluster needs be retrieved directly from the file system (e.g. via ftp). To view results of a previously completed job:

>> % Get a handle to the job with ID 2
>> j2 = c.Jobs(2);

NOTE: You can view a list of your jobs, as well as their IDs, using the above c.Jobs command.

>> % Fetch results for job with ID 2
>> j2.fetchOutputs{:}


Users can also submit parallel workflows with the batch command. Let’s use the following example for a parallel job, which is saved as parallel_example.m.

function t = parallel_example(iter)

if nargin==0, iter = 8; end

disp('Start sim')

t0 = tic;
parfor idx = 1:iter
     A(idx) = idx;
t = toc(t0);

disp('Sim Completed')

This time when we use the batch command, to run a parallel job, we’ll also specify a MATLAB Pool.

>> % Get a handle to the cluster
>> c = parcluster;
>> % Submit a batch pool job using 4 workers for 16 simulations
>> j = c.batch(@parallel_example, 1, {16}, 'Pool',4, …
       'CurrentFolder','.', 'AutoAddClientPath',false);
>> % View current job status
>> j.State
>> % Fetch the results after a finished state is retrieved
>> j.fetchOutputs{:}
ans = 

The job ran in 8.89 seconds using four workers. Note that these jobs will always request N+1 CPU cores, since one worker is required to manage the batch job and pool of workers. For example, a job that needs eight workers will consume nine CPU cores. We’ll run the same simulation but increase the Pool size. This time, to retrieve the results later, we’ll keep track of the job ID. NOTE: For some applications, there will be a diminishing return when allocating too many workers, as the overhead may exceed computation time.

>> % Get a handle to the cluster
>> c = parcluster;
>> % Submit a batch pool job using 8 workers for 16 simulations
>> j = c.batch(@parallel_example, 1, {16}, 'Pool', 8, …
       'CurrentFolder','.', 'AutoAddClientPath',false);
>> % Get the job ID
>> id = j.ID
id =
>> % Clear j from workspace (as though we quit MATLAB)
>> clear j

Once we have a handle to the cluster, we’ll call the findJob method to search for the job with the specified job ID.

>> % Get a handle to the cluster
>> c = parcluster;
>> % Find the old job
>> j = c.findJob('ID', 4);
>> % Retrieve the state of the job
>> j.State
ans = 
>> % Fetch the results
>> j.fetchOutputs{:};
ans = 

The job now runs in 4.73 seconds using eight workers. Run code with different number of workers to determine the ideal number to use. Alternatively, to retrieve job results via a graphical user interface, use the Job Monitor (Parallel > Monitor Jobs).


If a serial job produces an error, call the getDebugLog method to view the error log file. When submitting independent jobs, with multiple tasks, specify the task number.

>> c.getDebugLog(j.Tasks(3))

For Pool jobs, only specify the job object.

>> c.getDebugLog(j)

When troubleshooting a job, the cluster admin may request the scheduler ID of the job. This can be derived by calling schedID

>> schedID(j)
ans = 


To learn more about the MATLAB Parallel Computing Toolbox, check out these resources:

Attachments (1)

Download all attachments as: .zip

Note: See TracWiki for help on using the wiki.