How to use a parallel std::for_each on systems where <execution> is missing?

user_4850111 0
Viewed 979

This C++17 snippet works fine in newer versions of G++

std::for_each(std::execution::par_unseq, container.begin(), container.end(), [&](const auto& element) {
    // do something with element... or don't. whatever.
});

When you try to port that code to the current Debian (Stable) distribution for instance, which has G++ 8.3.0 (as of 12/2020), you'll find yourself reading the following error message:

fatal error: execution: File not found
     #include <execution>
              ^~~~~~~~~~~

An obvious solution relying on __has_include that involves a macro is:

#if __has_include(<execution>)
    #include <execution>
    #define PAR_UNSEQ std::execution::par_unseq,
#else
    #define PAR_UNSEQ
#endif

std::for_each(PAR_UNSEQ container.begin(), container.end(), [&](const auto& element) {
    // do something with element... or don't. whatever.
});

This compiles fine but has 2 major issues in my eyes:

  • It is not a parallel for on systems, that don't have the <execution> header and
  • that macro is not something I enjoy looking at.

So is there a better way?

Or if not is there at least a macro solution that actually does a parallel for_each?

c++17 for-loop c++
1 Answers

<execution> was added in gcc 9 (9.1 I think) but you could use the underlying library, Intel® oneAPI Threading Building Blocks or tbb for short, directly instead. It's a little cumbersome but something like the below would work in gcc 8.3 if you link with -ltbb (which you need to link with even in the newer gcc versions where <execution> is included). My example uses tbb::parallel_for which is what gcc:s std::for_each most likely also uses.

It solves, what I believe is, the most important part and that is that it's parallel on systems that don't have the <execution> header.

#if __has_include(<execution>)
    #include <execution>
#else
    #include "tbb/tbb.h"

    // define a support class for using with tbb::paralell_for
    template<typename C, typename Func>
    class ApplyFunc {
    public:
        ApplyFunc(const C& container, Func func) : c(container), f(func) {}

        // the function that will be called for each block
        void operator()(const tbb::blocked_range<size_t>& r) const {
            for(size_t i = r.begin(); i != r.end(); ++i) 
                f(c[i]); // the function you'd like to apply to each element
        }

    private:
        const C& c;
        Func f;
    };
#endif

// A function to call std::for_each or the tbb version
template<typename C, typename Func>
decltype(auto) myfor_each(const C& container, Func func) {
    #if __has_include(<execution>)
        std::for_each(std::execution::par, container.begin(), container.end(), func);
    #else
        tbb::parallel_for(tbb::blocked_range<size_t>(0, container.size()),
                          ApplyFunc(container, func));
    #endif
}

int main() {
    // example usage
    std::vector<int> container;
    myfor_each(container, [](auto& e) { do something eith e });
}
user_75822470
Related