Non-recursive split iteration of array with tbb::paralllel_for - c++

Question

I'm trying to perform a computation over a one-dimensional array A[] using Intel's TBBs. The problem is that, by default, an algorithm like tbb::parallel_for would cut the array in half recursively, sending each chunk to the task pool for the threads to steal.
However, I want all threads to "scan" the array in a linear way. For example, using 4 threads have them compute, in parallel, first A[0], A[1], A[2] and A[3] in any order. And then, compute the set A[4], A[5], A[6] and A[7], in any order.
Right now, parallel_for, after a couple of recursive splits would compute first A[0], A[2], A[4] and A[6] respectively. And then, A[1], A[3], A[5] and A[7] (or something similar).
I'm using C++14 and Intel's Threading Building Blocks. Algorithms like parallel_reduce or parallel_scan operate in a similar fashion, regarding the splitting of the iteration space, so they haven't been much of a help.
My guess is that I have do define my own iteration space object, but I can't figure out how exactly. The docs give this definition:
class R {
// True if range is empty
bool empty() const;
// True if range can be split into non-empty subranges
bool is_divisible() const;
// Splits r into subranges r and *this
R( R& r, split );
// Splits r into subranges r and *this in proportion p
R( R& r, proportional_split p );
// Allows usage of proportional splitting constructor
static const bool is_splittable_in_proportion = true;
...
};
It all boils down to this code:
#include <mutex>
#include <iostream>
#include <thread>
#include <tbb/parallel_for.h>
#include <tbb/task_scheduler_init.h>
std::mutex cout_mutex;
int main()
{
auto N = 8;
tbb::task_scheduler_init init(4);
tbb::parallel_for(tbb::blocked_range<int>(0, N),
[&](const tbb::blocked_range<int>& r)
{
for (int j = r.begin(); j < r.end(); ++j) {
// Compute A[j]
std::this_thread::sleep_for(std::chrono::seconds(1));
cout_mutex.lock();
std::cout << std::this_thread::get_id()<< ", " << j << std::endl;
cout_mutex.unlock();
}
}
);
}
The above code gives:
140455557347136, 0
140455526110976, 4
140455521912576, 2
140455530309376, 6
140455526110976, 5
140455557347136, 1
140455521912576, 3
140455530309376, 7
but I wanted something like:
140455557347136, 0
140455526110976, 1
140455521912576, 2
140455530309376, 3
140455526110976, 5
140455557347136, 4
140455521912576, 6
140455530309376, 7
Any suggestions on the iteration object or is there a better solution?

Answer 1

Consider using an external atomic, e.g. ( // !!! marks changed lines)
#include <mutex>
#include <iostream>
#include <thread>
#include <tbb/parallel_for.h>
#include <tbb/task_scheduler_init.h>
#include <atomic> // !!!
std::mutex cout_mutex;
int main()
{
auto N = 8;
tbb::task_scheduler_init init(4);
std::atomic<int> monotonic_begin{0}; // !!!
tbb::parallel_for(tbb::blocked_range<int>(0, N),
[&](const tbb::blocked_range<int>& r)
{
int s = static_cast<int>(r.size()); // !!!
int b = monotonic_begin.fetch_add(s); // !!!
int e = b + s; // !!!
for (int j = b; j < e; ++j) { // !!!
// Compute A[j]
std::this_thread::sleep_for(std::chrono::seconds(1));
cout_mutex.lock();
std::cout << std::this_thread::get_id() << ", " << j << std::endl;
cout_mutex.unlock();
}
}
);
}
The approach gives:
15084, 0
15040, 3
12400, 2
11308, 1
15084, 4
15040, 5
12400, 6
11308, 7
Why it is important to have monotonic behavior? You may want to consider parallel_pipeline or flow graph to specify calculation dependencies.