TBB（Intel Threading Building Blocks）

电玩女神 2022-08-31 00:47 159阅读 0赞

并行与并发是相对的，OS里讲的是并发而在[架构][Link 1]方面更多的是说并行。

并行是分多个层面的，个人认为基本上可以分为这么几个层面：

*  1、指令级的并行；即所谓的微程序、指令流水线等，现在[cp][]u的一级缓存、二级缓存都很大，所以这个cache的效果还是比较好的（基于局部性原理）
 *  2、线程级的并行；即同一个时刻多个函数在运行（现在的cpu好像都是多核的）
 *  3、服务级别的（比如一个游戏服务器中有商店服务、也有战斗服务、聊天服务等 这里的每个服务可能对应多个逻辑线程）
 *  4、节点级别的；即所谓的分布式系统，多个节点互相配合，使整个系统在逻辑上成为一个单一的系统。（google、qq等这些海量访问的服务统统是分布式的）

一般来说，第一个级别的并行直接做在硬件里面，

第二个级别的并行会有一些基础的框架，

第三和第四个级别的并行就是应用程序自己的架构的问题了。

Intel Threading Building Blocks，是为了方便程序员使用多核处理器的C++库，应该是对应上面提到的第二个级别的并行的。

##       一、TBB应该提供哪些东西？ ##

用TBB就是为了程序的并行化，那么程序员需要什么样的支持呢？最理想的情况是已有的代码不作任何修改，换一个编译器重新编译一下就OK，现在看来这个还不太现实。要有更好的效率就需要有更多的启发式信息，同时也就要求程序员要了解很多细节。

整个程序逻辑没办法自动并行化，那就针对控制流进行并行化吧，所以TBB中提供了 parallel\_for、parallel\_while、 parallel\_re[du][]ce等；

（这些是TBB给C++程序员的比较高层的接口）并行肯定是多线程，这样的话数据竞争问题就比较棘手，所以TBB提供并发容器；

如果觉得  
TBB提供的这些接口还没有办法解决性能问题，那就可以更深入的研究使用mut[ex][]、atomic、task等了；可以看出，TBB从几个层次上为程序员提供了支持。

##       二、TBB提供的接口 ##

由底层到高层，

task\_scheduler--------co[nc][]urrent\_container--------parallel\_for---pipeline

简单说，TBB帮我们调度一个个task（比OS的调度要高效），实现高效的并行算法

##       三、细节 ##

###    1、parallel\_for ###

适用场合：多个数据或请求彼此没有依赖关系，所要进行的操作是一样的（典型SPMD）  
    例子：

// 典型的c++泛型编程 blocked_range 是要处理的多个数据，3个参数依次是开始的指针（迭代器）、结束指针、每个任务分配的数据数
    // parallel_forFibBody可以简单理解为一个函数对象（c++里是用运算符重载实现的，即（）是通信的接口）
       
    
     parallel_for( blocked_range<int>( 1, my_n, 10 ), parallel_forFibBody(my_stream) );
    
       
    
     struct parallel_forFibBody {
        QueueStream &my_stream;
        //! fill functor arguments
        parallel_forFibBody(QueueStream &s) : my_stream(s) { }
        // 这里是并行的代码
        void operator()( const blocked_range<int> &range ) const {
            int i_end = range.end();
            for( int i = range.begin(); i != i_end; ++i ) {
                my_stream.Queue.push( Matrix1110 ); // push initial matrix
            }
        }
    };

###       2、parallel\_reduce ###

适合于需要汇总的情况，即各个数据的结果需要汇总回来  
  
例子：（注意分发下去和汇总回来的方法）  
    float ParallelSumFoo( const float a\[\], size\_t n ) \{  
    SumFoo sf(a);  
    parallel\_reduce(blocked\_range<size\_t>(0,n,IdealGrainSize), sf );  
    return sf.[su][]m;  
    \}  
  
    class SumFoo \{  
        float\* my\_a;  
    public:  
        float sum;  
        void operator()( const blocked\_range<size\_t>& r ) \{  
            float \*a = my\_a;  
            for( size\_t i=r.begin(); i!=r.end(); ++i )  
                sum += Foo(a\[i\]);  
        \}  
  
        SumFoo( SumFoo& x, [split][] ) : my\_a(x.my\_a), sum(0) \{\} // 分发任务，注意这个构造器要求是线程安全的  
  
        void [join][]( const SumFoo& y ) \{sum+=y.sum;\} // 收集汇总结果  
  
        SumFoo(float a\[\] ) :  
            my\_a(a), sum(0)  
        \{\}  
    \};

###    3、parallel\_while ###

有时不知道循环何时结束，即使用for的end未知，在这种情况下可以使用parallel\_while  
  
例子：注意pop\_if\_present、typedef Item\* argument\_type、operator()等部分的处理  
// 串行版本  
void SerialApplyFooToList( Item\*root ) \{  
    for( Item\* ptr=root; ptr!=NULL; ptr=ptr->next )  
        Foo(pointer->data);  
\}  
  
// 并行版本  
class ItemStream \{  
    Item\* my\_ptr;  
public:  
    bool pop\_if\_present( Item\*& item ) \{ // 用于提供下一个迭代器  
        if( my\_ptr ) \{  
            item = my\_ptr;  
            my\_ptr = my\_ptr->next;  
            return true;  
        \} e[ls][]e \{  
            return false;  
        \}  
\};  
ItemStream( Item\* root ) : my\_ptr(root) \{\}  
\}  
  
class ApplyFoo \{  
public:  
    void operator()( Item\* item ) const \{ // 要求一定是const的  
        Foo(item->data);  
    \}  
    typedef Item\* argument\_type; // 此句是必须的  
\};  
  
void ParallelApplyFooToList( Item\*root ) \{  
    // parallel\_while是个class  
    parallel\_while<ApplyFoo> w; //  先建立个对象  
    ItemStream stream;  
    ApplyFoo body;  
  
    // 第一个参数提供数据指针，第二个参数提供函数体  
    w.run( stream, body );  
\}  
  
四、并发容器  
    大部分程序都有容器类，在多线程环境下就有数据污染的问题，为了使并发的线程串行化，一般是使用加锁的办法，如果这个  
容器由程序员自己来实现，难度还是比较大的，这样就需要有线程安全的容器类。  
    1、concurrent\_hash\_map  
        hash接口与stl类似  
    2、concurrent\_vector  
        grow\_by(n) 插入n个item（动态增长）  
        grow\_to\_at\_least（）设定容器的大小  
        size()  包括正在并发增长的部分 因为有可能会同时取，所以程序员需要自己维护自己的class的线程安全性  
        [clear][]() 不是线程安全的  
    3、concurrent\_queue  
        pop\_if\_present(item) 非阻塞，  
        pop（） 阻塞，  
        concurrent\_queue::size() 负数时表示有多少个消费者在等待  
        [set][]\_capacity（）指定队列大小，会使push操作被阻塞  
在并行时，paralell\_while pipeline 的效率要高于concurrent\_queue  
  
  
五、如果觉得TBB的加锁效率不高，可以自己控制锁  
    最常用的是spin lock  
六、整个TBB引擎的核心是 Task Scheduler（基于任务图来实现）  
    提高效率的核心是threading stealing，保证cpu的效率  
  
七、小结  
    要使用TBB进行并行化，首先程序员要知道哪些是可以并行化；其次，要熟悉TBB并行化的框架（主要是泛型编程）；再次，程序员要大概知道  
并行算法的执行步骤；最后，利用TBB的组件，实现并行化的算法。总体上来说，还是不太好用的

[https://www.cnblogs.com/skiwnchiwns/p/10343944.html][https_www.cnblogs.com_skiwnchiwns_p_10343944.html]

[Link 1]: http://www.linuxso.com/architecture/
[cp]: http://www.linuxso.com/command/cp.html
[du]: http://www.linuxso.com/command/du.html
[ex]: http://www.linuxso.com/command/ex.html
[nc]: http://www.linuxso.com/command/nc.html
[su]: http://www.linuxso.com/command/su.html
[split]: http://www.linuxso.com/command/split.html
[join]: http://www.linuxso.com/command/join.html
[ls]: http://www.linuxso.com/command/ls.html
[clear]: http://www.linuxso.com/command/clear.html
[set]: http://www.linuxso.com/command/set.html
[https_www.cnblogs.com_skiwnchiwns_p_10343944.html]: https://www.cnblogs.com/skiwnchiwns/p/10343944.html