Define and share a function:

When called from each subkernel, the definition of getPID is evaluated on the master kernel:

Without the shared function, the values in the subkernels are returned:

Define a shared function to manipulate the local variable results on the master kernel:

Call the function from the subkernels:

The variable on the master has been modified:

Define and share a function:

When called from each subkernel, the function updates next on the master kernel:

Set up a shared function with a default rule:

Make additional definitions on the subkernels:

Since the function is shared, the master kernel knows about the additional rules:

Maintain indexed shared variables with a default value:

A delayed definition for a shared function made on the master kernel:

Such definitions are always evaluated on the master kernel, whichever kernel evaluates it:

A definition for a shared function made on one of the parallel kernels:

Such definitions are always evaluated on the kernel that asks for the value:

Shared functions can be used for synchronization:

Less efficient is the use of a shared variable and critical section:

A constructor for a simple queue data type:

Create two shared queues:

Fill the input queue:

Work on the elements of the input queue in parallel and put results into the output queue:

Use a single shared function to communicate both input and result:

Set up a search and display its progress until it is manually aborted:

The results found so far—a list of the number of factors of :

Use a shared append function for a local variable to collect results:

Using AppendTo on a shared variable has the same effect:

Make fs be a (global) shared function:

Each subkernel makes a definition for the same shared variable:

Without sharing, each subkernel has its own (local) copy of the function:

Shared functions are listed in $SharedFunctions:

A shared function is inefficient for mere code distribution and leads to sequential evaluation:

Simply distribute the definitions of any function needed on the parallel kernels:

Separate read and write operations on a shared variable are not thread-safe:

Use a shared function to synchronize access to an (unshared) variable:

Alternatively, use CriticalSection to make a whole code section atomic:

Parallel dynamic programming:

A parallel version of Sow: