Parallelize function evaluation with different parameters

Question

How do you run the same function multiple times and at the same time, but with different parameters?

I have had a look at ParallelEvaluate[] but it is meant to run the same function multiple times but with the same parameters.

For instance: I have the following function: f[x_]: = a*x+b*x Now I would like to run this function on multiple kernels at the same time with different parameters for a and b...

pseudocode:

(*Define function in current notebook with default kernel*)    
f[x_]: = a*x+b*x

RunParallel[{ (*pseudocode*)
{a=1,b=1,f[1]}, (*send to kernel1*)
{a=2,b=2,f[1]}, (*send to kernel2*)
{a=3,b=3,f[1]}, (*send to kernel3*)
{a=4,b=4,f[1]}  (*send to kernel4*)
}]

Answer 1

One may use lists of parameters for each kernel in conjunction with $KernelID. On each kernel, $KernelID simply evaluates on a number of the kernel. So all we have to do is to design the code in a way that it depends on $KernelID. In this case, we use $KernelID in order to index into the lists of parameters (indexing with [[ ]], the short form of Part).

alist = {9, 8, 7, 6};
blist = {10, 20, 30, 40};
f[x_] := a x + b x

ParallelEvaluate[
 Block[{a = alist[[$KernelID]], b = blist[[$KernelID]]},
  f[1]
  ]
 ]

{19, 28, 37, 46}

The drawback of this method is that the outcome depends on the number of kernels...

A better approach might be to use, e.g., ParallelTable. Here an example that hopefully illuminates what is going on:

f = {x, a, b} \[Function] a x + b x;
alist = {9, 8, 7, 6};
blist = {10, 20, 30, 40};

ParallelTable[
 Row[{"Kernel ", $KernelID, " computes ", i -> f[1, alist[[i]], alist[[i]]], "."}],
 {i, 1, Length[alist]}
 ]

{Row[{"Kernel ", 4, " computes ", 1 -> 18, "."}], Row[{"Kernel ", 3, " computes ", 2 -> 16, "."}], Row[{"Kernel ", 2, " computes ", 3 -> 14, "."}], Row[{"Kernel ", 1, " computes ", 4 -> 12, "."}]}

A further, more functional oriented way could be ParallelMap:

ParallelMap[
 abpair \[Function] Row[{"Kernel ", $KernelID, " computes ",  f[1, abpair[[1]], abpair[[2]]], "."}],
 Transpose[{alist, blist}]
 ]

{Row[{"Kernel ", 4, " computes ", 19, "."}], Row[{"Kernel ", 3, " computes ", 28, "."}], Row[{"Kernel ", 2, " computes ", 37, "."}], Row[{"Kernel ", 1, " computes ", 46, "."}]}

Answer 2

I guess that you begin to discover parallel computing with Mathematica by reading the tutorial
ParallelTools/tutorial/ParallelEvaluation.

That's the way I discovered it.

The problem is that the first instruction that this tutorial introduces is ParallelEvaluate.

It's misleading : ParallelEvaluate is seldom used and, when reading the tutorial, it takes time
to understand that it is not destinated to evaluate the same function with different parameters in parallel.

Fortunely there are many other instructions to do what you want.

Here are two solutions :

Solution without risks, robust, conform to functional programming (recommended)

f[{x_,a_,b_}]=a x + b x;
ParallelMap[f,{{1,1,1},{1,2,2},{1,3,3},{1,4,4}}]  

{2, 4, 6, 8}

It's prudent to verify that the computing was really done in parallel (as opposed to a premature evaluation of the whole expression in the main kernel) :

f[{x_,a_,b_}]=a x + b x;
ParallelMap["Kernel "<>ToString[$KernelID]<>" : "<>ToString[f[#]]&,
     {{1,1,1},{1,2,2},{1,3,3},{1,4,4}}]

{"Kernel 4 : 2", "Kernel 3 : 4", "Kernel 2 : 6", "Kernel 1 : 8"}

Other solution, more close to your code

f[x_]=a x + b x;
DistributeDefinitions[a,b,f];
sub00=Table[ParallelSubmit[{params},(a=params[[1]];b=params[[2]];f[1])],
       {params,{{1,1},{2,2},{3,3},{4,4}}}]  

WaitAll[sub00]

{2, 4, 6, 8}