Remote Definitions
Parallel kernels do not have access to the values of variables defined in the master kernel, nor do they have access to locally defined functions.
Mathematica contains a command
DistributeDefinitions that makes it easy to transport local variables and definitions to all parallel kernels. The main advantage of this method is that the application package does not need to be installed on the remote kernels. All definitions are sent through the existing connection to the remote kernels.
Distributing Definitions
Distributing definitions.
DistributeDefinitions has the attribute
HoldAll to prevent the evaluation of the symbols.
DistributeDefinitions exports the following kinds of definitions:
OwnValues,
DownValues,
SubValues,
UpValues,
DefaultValues,
NValues.
DistributeDefinitions sets the attributes of the remote symbols equal to the locally defined attributes, except for attributes such as
Protected and
Locked.
Any old definitions existing on the remote side are cleared before the new definitions are made.
Examples
Start several parallel kernels.
| Out[24]= |  |
Define a variable with a value and a function with attributes.
The remote kernels do not know the symbol
var as demonstrated with the next evaluation.
| Out[28]= |  |
Here is a subtle point. The following remote evaluation seems to work, even though the symbols are not defined on the remote side.
| Out[29]= |  |
The reason is that the remote kernels return the unevaluated expression
func[var], because the function and variable are not defined on the remote kernel. The master kernel evaluates the returned results further, but it does so sequentially.
You can easily produce an example where the difference between remote and local evaluation becomes apparent.
On the local kernel, the symbol
var evaluates to
5, and the
Head of
5 is
Integer.
| Out[30]= |  |
On the remote kernels,
var stays a symbol, and its head is
Symbol.
| Out[31]= |  |
You can export the local definitions to the remote kernels.
Now the remote evaluation gives the same result as the local one.
| Out[33]= |  |
Automatic Distribution of Definitions
Higher-level parallel commands, such as
Parallelize,
ParallelTable,
ParallelSum,
... will automatically distribute definitions of symbols occurring in their arguments.
For this parallel table, the function
f and the iterator bound
n will evaluate on the subkernels, so their definitions need to be distributed to make it work.
| Out[3]= |  |
This automatic distribution happens for any functions and variables you define interactively, within the same notebook (technically, for all symbols in the default context). Definitions from other contexts, such as functions from packages, are not distributed automatically.
A symbol
ctx`s from a context other than the default context is not distributed automatically.
As a result the symbol is returned unevaluated from the remote kernels, and is evaluated only after the parallel computation is done, where
$KernelID is zero.
| Out[5]= |  |
| Out[7]= |  |
Distributing Contexts
DistributeDefinitions["Context`"] exports all definitions for all symbols in the given context. Thus, you can use the following to make all your interactively entered definitions known to the remote kernels.
| Out[11]= |  |
Exporting the context of a package you have loaded may not have the same effect on the remote kernels as loading the package on each remote kernel. The reason is that loading a package may perform certain initializations and it may also define auxiliary functions in other contexts (such as a private context). Also, a package may load additional auxiliary packages that establish their own contexts.
DistributeDefinitions["Context`"] is useful for exporting contexts for definitions that you have explicitly set up to be used on remote kernels. There is a separate command
ParallelNeeds for remote loading of packages.
Parallel`Developer`ClearKernels[] clears any definitions for symbols in the
Global` context on remote kernels.
Loading Packages on Remote Kernels
Loading packages.
ParallelNeeds["Context`"] is essentially equivalent to
ParallelEvaluate[Needs["Context`"]], but it is remembered and any newly launched remote kernels will be initialized as well.
Exporting the context of a package you have loaded may not have the same effect on the remote kernels as loading the package on each remote kernel with
ParallelNeeds[]. The reason is that loading a package may perform certain initializations and it may also define auxiliary functions in other contexts (such as a private context). Also, a package may load additional auxiliary packages that establish their own contexts.
The next two commands load the
Mathematica package
FiniteFields` on the master kernel and all remote kernels.
Note that
Mathematica packages available to the master kernel may not be available on remote kernels from older versions of
Mathematica.
Example: Eigenvalues of Matrices
Definitions
The parameter
prec gives the desired precision for the computation of the eigenvalues of a random
matrix.
The function
mat generates a random
matrix with numeric entries.
The function
tf measures the time it takes to find the eigenvalues.
It is enough to distribute the definition of the main function tf. Any values it depends on will be distributed automatically.
| Out[4]= |  |
A sample run
Here you measure the time it takes to find the eigenvalues of
to
matrices. Because the computations may happen on remote computers that differ in their processor speeds, the results do not necessarily form an increasing sequence.
| Out[5]= |  |
Alternatively, you can perform the same computation on each parallel processor to measure their relative speed. Here you find the speed of calculation of the eigenvalues of a 20
20 matrix on each of the parallel processors.
| Out[6]= |  |
![DistributeDefinitions[s_1, s_2, … ] distribute all definitions for symbolss_ito all remote kernels; DistributeDefinitions["Context`"] distributes definitions for all symbols in the specified context](Files/RemoteDefinitions.en/Image_1.gif "DistributeDefinitions[s_1, s_2, … ] distribute all definitions for symbolss_ito all remote kernels; DistributeDefinitions[\"Context`\"] distributes definitions for all symbols in the specified context")
![ParallelNeeds["Context`"] evaluates Needs["Context`"] on all available parallel kernels;](Files/RemoteDefinitions.en/Image_2.gif "ParallelNeeds[\"Context`\"] evaluates Needs[\"Context`\"] on all available parallel kernels;"){kind=small}
