Asynchronous Parallel Programming

Evaluate functions in the background using parfeval

You can evaluate a function in the background without waiting for it to complete, using parfeval. In many cases, it can be convenient to break out of a for loop early. For example, in an optimization procedure, you can stop the loop early when the result is good enough. You can do this on one or all parallel pool workers, using parfeval or parfevalOnAll. This can be useful if you want to be able to plot intermediate results. Note that this is different from using parfor, where you have to wait for the loop to complete.

Use send and poll together to send and poll for messages or data from different workers using a data queue. You can use afterEach to add a function to call when new data is received from a data queue.

Use afterEach and afterAll to automatically invoke functions after each or after all elements of a parallel.Future array complete. This array can contain futures returned by parfeval, parfevalOnAll, afterEach or afterAll.

Topics

Evaluate Functions in the Background Using parfeval

Break out of a loop early and collect results as they become available.

Query and Cancel parfeval Futures

This example shows how to query the state of parfeval futures and cancel them.

Plot During Parameter Sweep with parfeval

This example shows how to perform a parallel parameter sweep with parfeval and send results back during computations with a DataQueue object.

Update a User Interface Asynchronously Using afterEach and afterAll

You can perform asynchronous computations on workers using parfeval and leave the user interface responsive.

Perform Webcam Image Acquisition in Parallel with Postprocessing

This example shows how to perform frame acquisition from a webcam in parallel with data postprocessing.

Perform Image Acquisition and Parallel Image Processing

This example shows how to perform image acquisition from a webcam and postprocess data in parallel.

Train Deep Learning Networks in Parallel

This example shows how to run multiple deep learning experiments on your local machine.

Use parfeval to Train Multiple Deep Learning Networks

This example shows how to use parfeval to perform a parameter sweep on the depth of the network architecture for a deep learning network and retrieve data during training.

Choose Between spmd, parfor, and parfeval

Compare and contrast spmd against other parallel computing functionality such as parfor and parfeval.

Functions

expand all

Functions and Classes

`parfeval`	Execute function asynchronously on parallel pool worker
`parfevalOnAll`	Execute function asynchronously on all workers in parallel pool
`ticBytes`	Start counting bytes transferred within parallel pool
`tocBytes`	Read how many bytes have been transferred since calling `ticBytes`
`send`	Send data from worker to client using a data queue
`poll`	Retrieve data sent from a worker
`afterEach`	Define a function to call when new data is received on a DataQueue
`afterEach`	Specify a function to invoke after each parallel.Future completes
`afterAll`	Specify a function to invoke after all parallel.Futures complete
`fetchOutputs`	Retrieve all output arguments from Future
`fetchNext`	Retrieve next available unread FevalFuture outputs
`cancel`	Cancel queued or running future
`isequal`	True if futures have same ID
`wait`	Wait for futures to complete
`parallel.Future`	Request function execution on parallel pool workers or MATLAB client
`parallel.Pool`	Parallel pool of workers
`parallel.pool.DataQueue`	Class that enables sending and listening for data between client and workers
`parallel.pool.PollableDataQueue`	Class that enables sending and polling for data between client and workers

Featured Examples

Plot During Parameter Sweep with parfeval

Perform a parallel parameter sweep with parfeval and send results back during computations with a DataQueue object. parfeval does not block MATLAB, so you can continue working while computations take place.

Open Live Script

Parfeval Blackjack

Uses Parallel Computing Toolbox™ to play the card game of blackjack, also known as 21. We simulate a number of players that are independently playing thousands of hands at a time, and display payoff statistics. This example runs the simulations asynchronously on a parallel pool of workers, using parfeval. In this way, we can update a display of the results as they become available.

Open Script

Train Deep Learning Networks in Parallel

Run multiple deep learning experiments on your local machine. Using this example as a template, you can modify the network layers and training options to suit your specific application needs. You can use this approach with a single or multiple GPUs. If you have a single GPU, the networks train one after the other in the background. The approach in this example enables you to continue using MATLAB® while deep learning experiments are in progress.