Thanks Yair for the great series on multi-threading.

I usually spawn a new Matlab process and then use sockets to communicate between the Matlab processes (with the ^[27], which serializes Matlab objects so they can be sent via the socket). I have used this approach successfully for running experiments, where one Matlab process does the data collection (e.g. from a motion capture device), while the other does the graphics.

Another useful socket tool that enables communicating between two matlab processes is found in the file exchange at

^[28]

I’ve used it fairly successfully in communicating between many independent matlab instances. I settled on this method after attempting to use file sharing, and several other methods – but upon reading this series of Yair’s, I will probably try a different approach next time I have to do a similar task.

Thanks for the kind words, Yair. Everybody involved really appreciated hearing your kudos. Just as importantly, thanks for getting in touch with me so that we could address these issues before they impacted many more users!

Yair,
As always, thank you for the great info… I’ve got a quick question for you. I’m trying to achieve a poor-man’s parfor. I’ve written a function which I’ve compiled into a standalone executable, and it does have a GUI component (basically a graph showing progress). Right now I’m working with using the java.lang.Runtime approach to launch the standalone, and I can launch multiple instances. But, as soon as the second instance starts, it appears to halt the execution of the first. I don’t see any case where the two instances would be using the same file resources or anything. Is this something to do with the use of the java calling implementation? Any suggestions on a better way to achieve my goal?

Thanks,
Dan

Yair,
Just wanted to edit my earlier question… It turns out that the issue was that there was an embedded command that gave feedback to the command window, so the various solvers were competing for access to writing responses to a command window that doesn’t exist.

Dan

@Dan – I’m glad this blog provided you with the necessary inspiration to solve your problem… 🙂

Yair,
One more question on this topic. I’ve been using the runtime.exec approach to launch my background processes. Do you know how to launch the new process at lower priority? I’m trying to do the equivalent of start /low "C:\MATLAB\myprog.exe" "{PathToDataFile}

Thanks,
Dan

@Dan – you cannot do this using java.lang.Runtime.exec(), but you can start the process directly via Matlab’s system command:

system('start /low "C:\MATLAB\myprog.exe" "C:\Path\To\Data\File"')

The drawback is that you would not be able to monitor or stop the process asynchronously unless we use the OS’s ps command (Linux and Mac) or the tasklist / wmic commands (Windows), as explained in the post above.

An alternative is to use Java’s ^[29] class rather than java.lang.Runtime.exec(). Usage examples (that should be Matlabized) can be found ^[30] (Linux) and ^[31] (Windows).

Yair,
Thanks for the feedback…. First with response to your suggestion of using the system command: that was the first thing I tried. I don’t understand why but somehow the start command would pull the last entry and open the .mat file by launching Matlab! I tried several different variations on that and couldn’t get it to work. Actually I did find a workaround solution after some more searching. I use the Runtime.exec() to launch the process and then run:

setPriorityCmd = 'wmic process where name="ping_fitter_exe.exe" CALL setpriority "low"';
runtime.exec(setPriorityCmd);

Even this is a bit of a workaround for what I’m really trying to achieve. What I’m trying to do is to run a batch of this executable without bogging down the workstation. What I really wanted to achieve was to query the total processor % load and decide whether or not to launch another sub-process based on that. Unfortunately the only ways I could find to access the total processor load (wmic and typeperf) are slow (at least a second to execute), so I don’t want to drop those in the checking loop. I suspect there’s a sexy way to achieve this using a timer object that runs in the background, but I wasn’t going to spend the time chasing it down.

Thanks,
Dan

Yair, and everyone

Yair, another great post. You mentioned data files as a method for interprocess communication, but didn’t give an example of this, so I thought I’d advertise my own utility :), batch_job:
^[32]
It spawns extra MATLAB instances and uses the filesystem to communicate between them, as well as sharing memory using memory mapped files. Like the IP-based approaches, this approach can be extended to sharing work across CPUs that don’t share a memory address space. They only need access to a common filesystem, e.g. CPUs on different computers with a networked file server. Using the filesystem might seem slow, but if your computation is quite long compared to the amount of data it produces, then the write times are not significant.

Best wishes,
Oliver

@Oliver hi – I was aware of your batch_job utility but for some reason I simply forgot to add the reference in the main text, so thanks for plugging-in!

Dear Yair,
many thanks for your tutorial on multi-threading in matlab, which helped me substancially in solving my process control problem for live data analysis. I needed to launch a matlab function (with parameters) in a second matlab instance. Since “system” doesn’t give me a handle to later stop the spawned process, java Runtime was an option. The java runTime exec solution however blocks on IO when matlab is called without desktop (i.e. the good old stdin/out/err problem on background processes). I wish to point you to Brian Lau’s processManager toolbox ( ^[33]) with which you have full control over the spawned processes, including IO redirection.

Best wishes,
Michael Scholz

Great post Yair.

To anyone exploring using the “Spawning external processes” approach with Matlab scripts/functions, let me add some advice. First off, this approach should be considered LAST RESORT. Here are some points that may make it feasible for you to use

1. Use the matlab program switches to your advantage!
The list of interesting ones are:
-nosplash (disables the Logo window when Matlab starts up, including a small idle delay)
-nodesktop (disables the Matlab desktop environment, giving a minimalistic interface. All Java and editor functionalities still intact)
-nojvm (disables the java virtual machine, giving access to only the core Matlab computational engine. All Java functions disappear, but Matlab starts up in less than a second)

Without this, it is almost outright unusable. Switches you will probably ALWAYS add are -nosplash and -nodesktop. This will make your code look something like this:

 
system('matlab -nosplash -nodesktop –r "myFile.m" ');

Most likely, you would like to paralellize your tasks so that the new instances of Matlab you start up, do not require any Java machine. The -nojvm switch makes the memory overhead of Matlab tiny, and starts up a new instance in less than a second.

2. End your script or function with

 
quit force

3. Communicate with the rest of your program by writing to data files.
Fancier ways exist, but this is the easiest, and the gain you get from fancier ways are insignificant to what you loose in overhead by starting new matlab instances anyway. (even with -nojvm).

4. learn from your experience with this approach, and never suggest anyone else to do it 🙂

Consider replacing calls such as:

start(timer('StartDelay',0.5, 'TimerFcn',@utilityFcn));

with this:

start(timer('StartDelay',0.5, 'TimerFcn',@utilityFcn, 'StopFcn', @(obj,~) delete(obj)));

If not, repeated calls will lock the available timers for your system, until such a point as the timer function will stop working.

Hi Yair,

Thanks for sharing your immense knowledge of MATLAB.

I was bitten recently by one behavior of timer callbacks that I haven’t seen documented anywhere. Suppose a long processing task is initiated by a UI callback, but has frequently-occurring drawnow or pause(0.01) commands. In this case, a periodic timer callback can run at those opportunities.

Now suppose that same long processing task is initiated via a single-shot timer (similar to the example you provided in this article). In this case the task is running in the timer callback rather than the UI event callback. It turns out that the other periodic timer is completely blocked until the long task launched by the single-shot timer has entirely finished. Even long pause commands don’t allow the periodic timer task to run. This “serialization” of asynchronous tasks was a surprise to me.

It turns out that a timer task, even if sleeping, also blocks the main MATLAB processing thread. This is R2012b, by the way; perhaps this behavior has since been changed.

I’d be interested to know if there’s a way to launch a task asynchronously (e.g. from a timer callback) so that the new task (assuming it contains pauses) is itself interruptible.

Keep up the great work,
Mark

I’ve had similar problems. I believe it is hardware specific, in that it is how the Java engine is working on different machines. Maybe someone can tell us more?

To solve issues like this, I currently do something like this, which is ugly:

In my timer callback, (our little friend that contains lots of pauses and drawnows), I do the following:

 
start(timer('StartDelay',asLongAsItTakes, ...
            'TimerFcn', {@(~,~,p) TaskToRun(p), SomeExtraDataToSend}, ... 
            'StopFcn' ,  @(obj,~) delete(obj))); 

TaskToRun is your task, and “asLongAsItTakes” is to wait for the subsystem that handles these things (I guess some part of the java machine) to be able to handle it properly.

on the systems it has worked for me, I have never had to put asLongAsItTakes to longer than a second. Would love a better solution…

good luck

Just to add to clarity of my previous reply. I am running with Matlab 2013a.

Most of the time you can replace my ugly code, from previous reply, with just:

 
     TaskToRun(SomeExtraDataToSend);

… and “TaskToRun” will be interuptible. There are some rare occasions when TaskToRun is not interuptible, notably when being invoked from a timer callback that experiences lots of interuptions itself. The problem can appear as other timers being blocked, or as user-interface callbacks that wont be executed (all depending on your application)

In these rare occasions, you can try my ugly approach which has worked for me. Hopefully someone will post a better solution.

@Stefan – thanks. For clarification, I believe that in your second comment you meant this:

start(timer('StartDelay', asLongAsItTakes, ...
            'TimerFcn', @(~,~) TaskToRun(SomeExtraDataToSend), ...
            'StopFcn',  @(obj,~) delete(obj)));

Actually, you may be out of luck, Mark:

^[34]

Hi Yair,

The use of anonomous functions together with the timer function interface callbacks make the code look…. funky.

If both works equally well, then ofc, shorter code wins.

@Stefan – Good find on the matlabcentral post. That will save me from more time pursuing unlikely prospects. Thanks all.

Hi Yair,
Thank you for the brilliant article on multi-threading.
I am having an issue compiling an m-file (Main.m) which uses the batch function (parallel computing toolbox) to start a Matlab worker to asynchronously write to a mapped memory (without blocking the EDT). This works okay in MATLAB 2015aSP1. However when I compile Main.m using the Matlab Application compiler, the resulting executable doesnt launch a new worker as instructed by the batch command (though the home GUI screen does launch).
Is there a special way to compile scripts which use Parallel computing toolbox functions.
Many thanks

Hi Yair,

I was wondering if batch workers (parallel computing toolbox) have their own timers that we can use. Or are these disabled (much in the same way as GUI objects).

Many thanks for your help.

@MU – I think you should ask MathWorks support about this – perhaps it’s a bug in the Matlab Compiler.

Thanks Yair for this interesting series!
I found the ability of having more control over the external calls appealing. Do you know if there is a command for checking if a process is completed.
I would like to terminate the process if it takes too much time:

runtime = java.lang.Runtime.getRuntime();
process = runtime.exec('runsim.bat');
process_start = tic;
while(true)
	pause(CompletionCheckInterval)
 	if process.isCompleted()  %I would like a command like this!
  		break;
 	elseif toc(process_start) > TimeLimit
		process.destroy();
		break;
	end %if
end %while

@Knut – you can use the tasklist command on Windows. For example:

>> procId = feature('getPID');  % Matlab's own process ID
>> str = evalc('system([''tasklist /v /fi "PID eq '' num2str(procId) ''" /FO LIST'']);')
str = 
Image Name:   MATLAB.exe 
PID:          15212 
Session Name: Console 
Session#:     1 
Mem Usage:    1,314,408 K 
Status:       Running 
User Name:    Thinkpad-E530\BMPA 
CPU Time:     0:11:52 
Window Title: MATLAB R2016b 

Alternately, you can use ^[35] to determine whether a process is running or not, and if it is then you can also retrieve some process properties from the returned data object:

try
   procObject = System.Diagnostics.Process.GetProcessById(procId);
   processName = char(procObject.ProcessName);  % procObj can be queried 
   isRunning = true;
catch
   isRunning = false;
end

For Linux/MacOS, see ^[36] or simply use the ps (rather than tasklist) command with system.

Thanks for the quick reply Yair!
I didn’t get how you identify the process ID of the called process though…? Perhaps something very easy I’m missing?
But, I found a solution in the spirit of your last code example, which seems to be working:

function [out, tlimexceeded] = runscript(script, settings)
out = 0;
tlimexceeded = 0;
runtime = java.lang.Runtime.getRuntime();
process = runtime.exec(script);
process_start = tic;

while(1) %Check for completion
    pause(settings.CompletionCheckInterval)
    try
        out = process.exitValue(); %Throws IllegalThreadStateException if process not completed
        break;
    catch
        %Process still running
    end %try-catch
    
    if (toc(process_start) > settings.TimeLimit)
        process.destroy();
        fprintf('Time limit exceeded\n');
        tlimexceeded = 1;
        out = 0;
    end
end %while

[…] Yair Altman posted a trick on Undocumented Matlab. He uses a timer to call another function asynchronously. […]

Hello Yair,
Thanks for the brilliant article. Will I be able to call Java extensions from S Functions from Simulink. A very small example would help a lot.

Best Regards
Sharavan

@Sharavan – yes, as long as you place the code in a ^[37]. The syntax should be the same as that shown on this blog.