The workers in a parallel pool communicate with each other, so you can distribute an array among the workers. Each worker contains part of the array, and all the workers are aware of which portion of the array each worker has.
Use the distributed
function to distribute an
array among the workers:
M = magic(4) % a 4-by-4 magic square in the client workspace
MM = distributed(M)
Now MM
is a distributed array, equivalent
to M
, and you can manipulate or access its elements
in the same way as any other array.
M2 = 2*MM; % M2 is also distributed, calculation performed on workers x = M2(1,1) % x on the client is set to first element of M2
The single program multiple data (spmd
) construct
lets you define a block of code that runs in parallel on all the workers
in a parallel pool. The spmd
block can run on some
or all the workers in the pool.
spmd % By default creates pool and uses all workers R = rand(4); end
This code creates an individual 4-by-4 matrix, R
,
of random numbers on each worker in the pool.
Following an spmd
statement, in the client
context, the values from the block are accessible, even though the
data is actually stored on the workers. On the client, these variables
are called Composite objects. Each element of
a composite is a symbol referencing the value (data) on a worker in
the pool. Note that because a variable might not be defined on every
worker, a Composite might have undefined elements.
Continuing with the example from above, on the client, the Composite R
has
one element for each worker:
X = R{3}; % Set X to the value of R from worker 3.
The line above retrieves the data from worker 3 to assign the
value of X
. The following code sends data to worker
3:
X = X + 2;
R{3} = X; % Send the value of X from the client to worker 3.
If the parallel pool remains open between spmd
statements
and the same workers are used, the data on each worker persists from
one spmd
statement to another.
spmd R = R + labindex % Use values of R from previous spmd. end
A typical use for spmd
is to run the same
code on a number of workers, each of which accesses a different set
of data. For example:
spmd INP = load(['somedatafile' num2str(labindex) '.mat']); RES = somefun(INP) end
Then the values of RES
on the workers are
accessible from the client as RES{1}
from worker
1, RES{2}
from worker 2, etc.
There are two forms of indexing a Composite, comparable to indexing a cell array:
AA{n}
returns the values of AA
from
worker n
.
AA(n)
returns a cell array of the
content of AA
from worker n
.
Although data persists on the workers from one spmd
block
to another as long as the parallel pool remains open, data does not
persist from one instance of a parallel pool to another. That is,
if the pool is deleted and a new one created, all data from the first
pool is lost.
For more information about using distributed arrays, spmd
,
and Composites, see Distributed Arrays.