tbb parallel_for 使用教程2之 tbb::blocked_range

在上一篇博客中介绍了tbb parallel_for 的使用例子

tbb parallel_for 使用教程1-CSDN博客

源码进行深度挖掘，看下底层的源码实现

//! Parallel iteration over a range of integers with a default step value and default partitioner
template <typename Index, typename Function>
void parallel_for(Index first, Index last, const Function& f) {parallel_for_impl<Index,Function,const auto_partitioner>(first, last, static_cast<Index>(1), f, auto_partitioner());
}

//! Implementation of parallel iteration over stepped range of integers with explicit step and partitioner
template <typename Index, typename Function, typename Partitioner>
void parallel_for_impl(Index first, Index last, Index step, const Function& f, Partitioner& partitioner) {if (step <= 0 )internal::throw_exception(internal::eid_nonpositive_step); // throws std::invalid_argumentelse if (last > first) {// Above "else" avoids "potential divide by zero" warning on some platformsIndex end = (last - first - Index(1)) / step + Index(1);tbb::blocked_range<Index> range(static_cast<Index>(0), end);internal::parallel_for_body<Function, Index> body(f, first, step);tbb::parallel_for(range, body, partitioner);}
}

可以看到经过一些列的转化，最终还是生成了一个 tbb::blocked_range<Index> range(static_cast<Index>(0), end); 

然后再继续调用 tbb::parallel_for(range, body, partitioner);

tbb::blocked_range的使用

#include <iostream>
#include <vector>
#include <tbb/parallel_for.h>
#include <tbb/blocked_range.h>
#include <tbb/concurrent_vector.h>
#include <tbb/global_control.h>int main() {// 生成测试数据:tbb::global_control gc(tbb::global_control::max_allowed_parallelism, 10);const int N = 10000;std::vector<int> numbers(N);for (int i = 0; i < N; ++i) {numbers[i] = i;}// 存储结果的线程安全容器tbb::concurrent_vector<std::pair<int, unsigned long >> results;// 并行计算平方 ,tbb::simple_partitioner()tbb::parallel_for(tbb::blocked_range<size_t>(0, N, 1000),  // 范围0~N，每个块至少1000个元素[&](const tbb::blocked_range<size_t>& range) {thread_local int a = 100;for (size_t i = range.begin(); i != range.end(); ++i) {// 为了方便打印日志，保证每个线程只是打印一次.if(a == 100){std::cout<< std::endl << range.begin() << std::endl;}a++;           int num = numbers[i];results.push_back({num, num * num});}},tbb::simple_partitioner());// 打印结果（顺序可能乱序）for (const auto& [num, square] : results) {// std::cout << num << "^2 = " << square << std::endl;}return 0;
}

我们来看下，tbb::blocked_range的代码构造，都有哪些参数：

    //! Construct range over half-open interval [begin,end), with the given grainsize.blocked_range( Value begin_, Value end_, size_type grainsize_=1 ) :my_end(end_), my_begin(begin_), my_grainsize(grainsize_){__TBB_ASSERT( my_grainsize>0, "grainsize must be positive" );}

我们看下默认的颗粒度是1，这个颗粒度 grainsize 代表着给我们的任务分组，比方说我们上面的例子有10000个数，需要进行并行处理，则分成多少个组呢，那要看每个组里要多少个数据，一个组是在一个线程上执行，这个颗粒度  grainsize 就代表了每个组里最少有这么多的数据，注意是至少，但是也不绝对，可能小于这个数，一般tbb会在底层进行一个递归分隔，然后与你的并行度也会有关系。

我们先来看下代码的输出：

g++ -std=c++17 tbb.cpp -I /opt/voy-sdk/include/ -L /opt/voy-sdk/lib  -o test -ltbb

./test0500075002500625037506875875031259375

看下我们的输出，就是理论上每个分组里的数据大于等于1000.但是在实际的递归过程中可能小于1000，但是不会差太多，主要是递归的一个过程，然后我们的并行度是10.(同时启动10个线程)

它大致的分隔过程如下所示：

N=10000、grainsize=1000：

1. ​​初始区间​​：[0, 10000)，大小 10000。
2. ​​第一次分割​​：[0,5000) 和 [5000,10000)，每个大小 5000（均 >=1000）。
3. ​​递归分割左半部分​​：[0,2500) 和 [2500,5000)。
4. ​​继续分割​​：[2500,3750)、[3750,5000)，直到子区间大小接近 1000。
5. ​​右半部分同理​​：[5000,7500)、[7500,10000)，继续分割为 [7500,8750) 和 [8750,10000)。
6. ​​问题出现​​：[8750,10000) 的大小为 1250，仍然 >=1000，继续分割为：
   • [8750,9375)（大小 625，<1000，但无法再分割为两个 >=1000 的子区间）
   • [9375,10000)（大小 625，同理）