Question

This is in relation to my previous question: D concurrent writing to buffer

Say you have a piece of code that consists of 2 consecutive code blocks A and B, where B depends on A. This is very common in programming. Both A and B consist of a loop, where each iteration can be run in parallel:

double[] array = [ ... ]; // has N elements

// A
for (int i = 0; i < N; i++)
{
    job1(array[i]); // new task
}

// wait for all job1's to be done

// B
for (int i = 0; i < N; i++)
{
    job2(array[i]); // new task
}

B can only be executed when A is finished. How do I wait till all tasks of A are finished before executing B?

Answer 1

I assume you’re using std.parallelism? I wrote std.parallelism, so I’ll let you in on a design decision. There was actually a join function in some of the betas of std.parallelism. It waited until all tasks were finished and then shut down the task pool. I removed it because I realized it was useless.

The reason is that if you’re manually creating a set of O(N) task objects to iterate over some range, you’re misusing the library. You should be using a parallel foreach loop instead, which automatically joins before it releases control back to the calling thread. Your example would become:

foreach(ref elem; parallel(array)) {
    job1(elem); 
}

foreach(ref elem; parallel(array)) {
    job2(elem);
}

In this case job1 and job2 should not start a new task because the parallel foreach loop is already using enough tasks to fully utilize all CPU cores.