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

zhczzm

已于 2025-04-30 15:43:10 修改

阅读量413

点赞数 14

分类专栏： TBB库使用教程文章标签： tbb blocked_range parallel_for

于 2025-04-30 15:29:22 首次发布

本文链接：https://blog.csdn.net/zhanghuaichao/article/details/147633012

版权

TBB库使用教程专栏收录该内容

2 篇文章

订阅专栏

在上一篇博客中介绍了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_argument
    else if (last > first) {
        // Above "else" avoids "potential divide by zero" warning on some platforms
        Index 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

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

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

N=10000、grainsize=1000：

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