parallelization - Efficient way to utilise Parallel features to make use of many cores

Let's say I have 100 cores/kernels as my disposal and want to compute a function of two variables f[x,y] over {x,1,10}, {y,0,59}. So in total 600 data points. Ideally I would like to utilize all 100 cores giving each core 6 data points to compute. How can I achieve this?

ParallelTable[f[x, y], {y, 0, 59 }, {x, 1, 10 }]

Would only parallelize on the first 60 cores and give each core a workload of 10 points and

ParallelTable[f[x, y], {x, 1, 10 }, {y, 0, 59 }]

would do even worse- parallelizing on the first 10 cores and giving each a workload of 60 points.

I think doing

ParallelTable[f[x, y], {y, 0, 59 }, {x, 1, 3 }];
ParallelTable[f[x, y], {y, 0, 59 }, {x, 4, 6 }];
ParallelTable[f[x, y], {y, 0, 59 }, {x, 7, 10}];

Would only evaluate the three calls sequentially when the previous ParallelTable had finished so would also do not better?

Is there a way around this?

Answer

I usually work around this by first generating all argument combinations, then using ParallelMap:

ParallelMap[f, Tuples[{Range[0,59], Range[1,10]}]]

You'll need to define your function so that it takes the form f[{x,y}], not f[x,y].

Often it is more practical to use the form

ParallelTable[{arg, f[arg]}, {arg, Tuples[{Range[0,59], Range[1,10]}]}]

as this will save both the result and the arguments in the output.

Note that this method gives you a flat 1D list, not a 2D one like a Table with two iterators would. If you do need a 2D table, use Partition or ArrayReshape (v9) on the result.