
Dispatching Evaluations to Remote KernelsParallelDispatch[h[e_{1},e_{2},...,e_{n}],{k_{1},k_{2},...,k_{m}}] 
 evaluatese_{i}on kernel k_{i} and returns h[ r_{1}, r_{2}, ... r_{n}],wherer_{i}is the result of evaluatinge_{i}. The default list of kernels is $Slaves 
ParallelEvaluate[h[e_{1},e_{2},...,e_{n}],f,comb] 
 evaluates f[h[e_{1},e_{2},...,e_{n}]] in parallel by distributing chunks f[h[e_{i},e_{i+1},...,e_{i+k}]] to all kernels and combining the results with comb[]. 
ParallelEvaluate[h[e_{1},e_{2},...,e_{n}],f] 
 the default combiner comb is h, if h has attribute Flat, and Join otherwise 
ParallelEvaluate[h[e_{1},e_{2},...,e_{n}]] 
Basic parallel dispatch of evaluations. In ParallelDispatch[h [e _{1},e _{2},...,e _{n}],{k _{1},k _{2},...,k _{m}}], the number m of kernels must be at least as large as the number n of expressions. ParallelDispatch has the attribute HoldFirst so that h [e _{1},e _{2},...,e _{n}] is not evaluated on the master kernel before the parallelization. ParallelDispatch[{e _{1},e _{2},...,e _{n}},{k _{1},k _{2},...,k _{n}}] is equivalent to Receive[Inner[Send,{k _{1},k _{2},...,k _{n}},{e _{1},e _{2},...,e _{n}}]]. ParallelEvaluate[h [e _{1},e _{2},...,e _{n}],f,comb] breaks h [e _{1},e _{2},...,e _{n}] into as many pieces h [e _{i},e _{i+1},...,e _{i+k}] as there are remote kernels, evaluates f[h [e _{i},e _{i+1},...,e _{i+k}]] in parallel (using ParallelDispatch[]), then combines the results r _{i} using comb[r _{1},r _{2},...,r _{m}]. ParallelEvaluate has the attribute HoldFirst so that h [e _{1},e _{2},...,e _{n}] is not evaluated on the master kernel before the parallelization. The size of the pieces of the input expression is chosen to be proportional to the remote processor speed estimates for optimal load balancing. ParallelEvaluateParallelEvaluate is a general and powerful command with default values for its arguments that are suitable for evaluating elements of containers such as lists and associative functions. Evaluating Listlike ContainersIf the result of applying the function f to a list is again a list, ParallelEvaluate[{e _{1},e _{2},...,e _{n}},f] simply applies f to pieces of the input list and joins the partial results together. Out[2]=  
The result is the same as that of Prime[{1,2,3,4,5,6,7,8,9}], but the computation is done in parallel. The default function is Identity, therefore, ParallelEvaluate[{e _{1},e _{2},...,e _{n}}] simply evaluates the elements e_{i} in parallel. Out[3]=  
If the result of applying the function f to a list is not a list, a custom combiner has to be chosen. The function Function[li,Count[li,_?OddQ] counts the number of odd elements in a list. To find the total number of odd elements, add the partial results together. Out[4]=  
Evaluating Associative OperationsIf the operation h in h [e _{1},e _{2},...,e _{n}] is associative (has attribute Flat), the identity holds; with the default combiner being h itself, the operation is parallelized in a natural way. Here all numbers are added in parallel. Out[5]=  
Out[6]=  
Automatic ParallelizationParallelEvaluate[cmd[list,arguments...]] recognizes if cmd is a Mathematica function that operates on a list or other long expression in a way that can be easily parallelized and performs the parallelization automatically. You do not need to figure out suitable f and comb for ParallelEvaluate[list,f,comb]. The list of commands that can be parallelized is kept in the variable $ParallelCommands. Out[5]=  
Out[6]=  
Out[7]=  
Out[8]=  
Not all uses of these commands can be parallelized. A message is generated and the evaluation is performed sequentially on the master kernel if necessary. Out[9]=  
