Changes between Version 3 and Version 4 of Matlab-Slurm

Timestamp:

07/13/21 16:29:01 (3 years ago)

Author:

fuji

Comment:

—

Matlab-Slurm

@@ -71 +71 @@
 === Optional ===
 {{{
->> % 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 = 'user-id@tulane.edu';
@@ -91 +86 @@
 
 {{{
->> % Specify processors per node
->> c.AdditionalProperties.ProcsPerNode = '2';
+>> % Specify processors per node (maximum 20 on Cypress)
+>> c.AdditionalProperties.ProcsPerNode = 20;
 }}}
 
@@ -99 +94 @@
 >> c.AdditionalProperties.QoS = 'qos-value';
 }}}
-
-{{{
->> % Specify a queue to use for MATLAB jobs                             
->> c.AdditionalProperties.QueueName = 'queue-name';
-}}}
+The default is ''normal''. See [https://wiki.hpc.tulane.edu/trac/wiki/cypress/about#SLURMresourcemanager here] for other options.
 
 {{{
@@ -109 +100 @@
 >> c.AdditionalProperties.WallTime = '05:00:00';
 }}}
+See [https://wiki.hpc.tulane.edu/trac/wiki/cypress/about#SLURMresourcemanager here] for the maximum walltime.
 
 Save changes after modifying !AdditionalProperties for the above changes to persist between MATLAB sessions.
@@ -137 +129 @@
 }}}
 {{{
->> % Open a pool of 64 workers on the cluster
->> p = c.parpool(64);
+>> % Open a pool of 4 workers on the cluster (works up to 12?)
+>> p = c.parpool(4);
 }}}
 Rather than running local on the local machine, the pool can now run across multiple nodes on the cluster.
@@ -144 +136 @@
 >> % Run a parfor over 1000 iterations
 >> parfor idx = 1:1000
-      a(idx) = …
+      a(idx) = idx
    end
 }}}
@@ -154 +146 @@
 
 == INDEPENDENT BATCH JOB ==
-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{:}
-}}}
-
-== PARALLEL BATCH JOB ==
-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
-
+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 [https://www.mathworks.com/help/parallel-computing/batch.html batch].
+
+=== Running Serial Job ===
+Let’s use the following example for a serial job, which is saved as {{{serial_example.m}}}.   
+{{{
+% Serial Example
 disp('Start sim')
 
 t0 = tic;
-parfor idx = 1:iter
+for idx = 1:8
      A(idx) = idx;
      pause(2)
@@ -214 +164 @@
 }}}
 
-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;
+}}}
+
+{{{
+>> % Below, submit a batch job that calls the 'mywave.m' script.
+>> % Also set the parameter AutoAddClientPath to false so that Matlab won't complain when paths on 
+>> % your desktop don't exist on the cluster compute nodes (this is expected and can be ignored).
+
+>> myjob = batch(c,'serial_example','AutoAddClientPath',false)
+}}}
+
+{{{
+>> % Wait for the job to finish.  
+>> wait(myjob)
+}}}
+
+{{{
+>> % display the job diary (This is the Matlab standard output text, if any)
+>> diary(myjob)
+--- Start Diary ---
+Start sim
+Sim Completed
+
+--- End Diary ---
+}}}
+
+{{{
+>> % load the 'A' array (computed in serial_example) from the results of job 'myjob':
+>> load(myjob,'A');
+>> A
+
+A =
+
+     1     2     3     4     5     6     7     8
+}}}
+
+
+{{{
+>> % Query job for state
+>> myjob.State
+}}}
+
+{{{
+>> % If state is finished, fetch the results
+>> mayjob.fetchOutputs{:}
+ans = 
+
+  struct with fields:
+
+      A: [1 2 3 4 5 6 7 8]
+    ans: [1×1 struct]
+    idx: 8
+      t: 16.0127
+     t0: 1626209674755060
+}}}
+{{{
+>> % Delete the job after results are no longer needed
+>> mayjob.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{:}
+}}}
+
+=== Running Parallel Job ==
+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}}} that uses the '''parfor''' statement to parallelize the '''for''' loop
+
+{{{
+disp('Start sim')
+
+t0 = tic;
+parfor idx = 1:8
+     A(idx) = idx;
+     pause(2)
+end
+t = toc(t0);
+
+disp('Sim Completed')
+}}}
+
+In the next example, we will run a parallel job using 8 processors on a single node.
+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);
-}}}
+
+{{{
+>> % Submit a batch pool job using 8 workers for 8 iterations
+>> myjob = batch(c,'parallel_example','pool', 8, 'AutoAddClientPath',false)
+}}}
+
 {{{
 >> % View current job status
->> j.State
-}}}
+>> myjob.State
+}}}
+
 {{{
 >> % Fetch the results after a finished state is retrieved
->> j.fetchOutputs{:}
-ans = 
-        8.8872
-}}}
-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);
-}}}
+>> myjob.fetchOutputs{:}
+ans = 
+
+  struct with fields:
+
+     A: [1 2 3 4 5 6 7 8]
+     t: 2.3438
+    t0: 1626210921701584
+}}}
+
+The job ran in 2.3438 seconds using eight 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.          
+
+
+==== retrieve the results later ====
 {{{
 >> % Get the job ID
@@ -252 +305 @@
         4
 }}}
-{{{
->> % Clear j from workspace (as though we quit MATLAB)
->> clear j
+
+{{{
+>> % Clear myjob from workspace (as though we quit MATLAB)
+>> clear myjob
 }}}
 
 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;
-}}}
+
+{{{
+>> % Get a handle to the cluster
+>> c = parcluster;
+}}}
+
 {{{
 >> % Find the old job
->> j = c.findJob('ID', 4);
-}}}
+>> myjob = c.findJob('ID', 4);
+}}}
+
 {{{
 >> % Retrieve the state of the job
->> j.State
+>> myjob.State
 ans = 
 finished
 }}}
+
 {{{
 >> % Fetch the results
->> j.fetchOutputs{:};
-ans = 
-4.7270
-}}}
-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.
+>> myjob.fetchOutputs{:};
+
+ans = 
+
+  struct with fields:
+
+     A: [1 2 3 4 5 6 7 8]
+     t: 2.3438
+    t0: 1626210921701584
+}}}
+
 Alternatively, to retrieve job results via a graphical user interface, use the Job Monitor (Parallel > Monitor Jobs).