几年之前,CPU的性能还主要取决于CPU的主频,经过超摩尔定律的发展后,没过多长时间CPU的主频速度就已接近“极限”,使得单单靠提高CPU的主频来提升性能变得非常困难。
目前,Intel、AMD等CPU生产商都转而采用了多核技术来提升CPU性能,甚至提出了群核CPU的概念。这意味着,要充分发挥多核CPU的性能,程序就必须采用多线程并发计算的方式,传统的串行程序将会极大地浪费多核CPU的运算能力!
C++是上世纪80年代诞生的语言,它的前身是同样风靡全球的C语言。一直以来它都以代码效率卓越著称,进入多核时代后,因为C++标准库没有提供多线程支持,要用C++开发出充分利用多核CPU的程序将面临很大挑战。
于是,在C++社区出现了不少优秀的库以支持并行编程,如各种跨平台的线程库,OpenMP,Clik++等。另一方面,微软也从Win2K开始不断地加入线程池API(如QueueUserWorkItem),C++09标准也明确地表示要加入多线程的支持。
使用线程库编写并行程序的优点是可以精确调度各个线程,并且可以在所有C++编译器里使用。不过要充分发挥多核CPU的性能,还要考虑很多因素,主要难点有:
- 死锁 编写多线程必然会遇到同步问题,如果同步控制出现问题,就可能出现死锁或脏数据。
- 线程之间通信 使用何种机制在多个线程之间通信?即要保证通信数据同步又要保证效率。
- 负载平衡 分配到每个线程的工作量要尽量平衡,避免一个线程忙一个线程闲的情形发生。
- 资源匹配 程序应该使用多少个线程?过少的线程不能充分利用CPU的多核优势,而过多的线程会造成线程调度过于频繁同样会降低效率。
OpenMP是目前比较流行的C++并行编程方式,它通过在代码中插入专用的pragma编译指令来指示编译器把串行代码编译成并行程序。
它的优点是易于使用,几乎不用修改原代码就可对老程序进行并发支持的改造。问题是它必须要有编译器的支持,尽管目前不少编译器都提供了OpenMP的支持,但它毕竟不是C++的一部分,甚至它都不是真正意义上的C++库。使用OpenMP的C++代码看上去总是有些怪异(个人观点^_^)。
现在,我们又有了一个新选择:Intel Thread BuildingBlocks(TBB,线程构建模块)。TBB是一个开源的C++模板库,能够运行在Windows、Linux、Macintosh以及UNIX等系统上,只要是标准的C++编译器都可以使用它。
TBB的功能和优势
功能 | 优势 |
---|---|
基于任务的并行化 | 在逻辑任务而非物理线程的角度来指定线程功能
|
并行算法 | 从库中选择高效并行算法模板,即可快速地获得多核处理器带来的优势。
|
跨平台支持 | 编写一次应用就可以部署到多个操作系统中。
|
程序库级解决方案 | 只需花费很小的精力就可得到高优化的并行功能。
|
高并发容器 | 优化处理器的能力实现任务并发
|
示例:
用TBB写并行transform代替原std::transform
- #include <iostream>
- #include <algorithm>
- #include <vector>
- #include <list>
- #include <math.h>
- #include <tbb/task_scheduler_init.h>
- #include <tbb/blocked_range.h>
- #include <tbb/parallel_for.h>
- #include <tbb/pipeline.h>
- #include <tbb/tick_count.h>
- //-----------------随机存取迭代器版本-------------------------------------
- //both_random_helper,作用:测试两个模板是否都是random_access_iterator_tag
- //是则Iter_cat返回random_access_iterator_tag
- //否则返回forward_iterator_tag
- template<class _Cat1, class _Cat2>
- struct both_random_helper{
- typedef std::forward_iterator_tag Iter_cat;
- };
- template<>
- struct both_random_helper<
- std::random_access_iterator_tag,
- std::random_access_iterator_tag>{
- typedef std::random_access_iterator_tag Iter_cat;
- };
- // 用于存放一对迭代器
- template<class _InIt, class _OutIt>
- struct Iter_pair{
- _InIt m_in;
- _OutIt m_out;
- Iter_pair(_InIt _in, _OutIt _out)
- :m_in(_in),m_out(_out){}
- //支持blocked_range拆分
- Iter_pair operator+(size_t off) const
- {
- return Iter_pair(m_in+off, m_out+off);
- }
- size_t operator-(Iter_pair rhs) const
- {
- return m_in-rhs.m_in;
- }
- bool operator<(Iter_pair rhs) const
- {
- return m_in<rhs.m_in;
- }
- };
- // 随机存取迭代器版本
- template<class _InIt, class _OutIt, class _Fn1>
- struct op_parallel_transform{
- op_parallel_transform(_Fn1 _Func)
- :m_Func(_Func){}
- void operator()(const tbb::blocked_range<Iter_pair<_InIt,_OutIt> > &r) const
- {
- std::transform(r.begin().m_in, r.end().m_in, r.begin().m_out, m_Func);
- }
- private:
- _Fn1 m_Func;
- };
- template<class _InIt, class _OutIt, class _Fn1>
- _OutIt _parallel_transform(_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func, std::random_access_iterator_tag)
- {
- // 使用parallel_for来处理
- typedef typename Iter_pair<_InIt,_OutIt> iter_pair_type;
- _OutIt LastDest = _Dest + (_Last - _First);
- iter_pair_type begin(_First, _Dest);
- iter_pair_type end(_Last, LastDest);
- tbb::blocked_range<iter_pair_type> x(begin, end);
- tbb::parallel_for(x, op_parallel_transform<_InIt,_OutIt,_Fn1>(_Func), tbb::auto_partitioner());
- return LastDest;
- }
- //-----------------顺序存取迭代器版本-------------------------------------
- template<class _InIt>
- struct filter_in : tbb::filter{
- filter_in(_InIt _First, _InIt _Last)
- :tbb::filter(true),m_First(_First), m_Last(_Last){}
- void* operator()(void*)
- {
- if(m_First==m_Last) return NULL;
- void* p = &(*m_First);
- ++m_First;
- return p;
- }
- private:
- _InIt m_First, m_Last;
- };
- template<class _Fn1>
- struct filter_process : tbb::filter{
- typedef typename _Fn1::result_type r_type;
- typedef typename _Fn1::argument_type a_type;
- filter_process(_Fn1 _Func)
- :tbb::filter(false),m_Func(_Func){}
- void* operator()(void* data)
- {
- a_type &at = *(a_type*)data;
- m_r = m_Func( at );
- return &m_r;
- }
- private:
- _Fn1 m_Func;
- r_type m_r;
- };
- template<class _OutIt, class _DataType>
- struct filter_out : tbb::filter{
- filter_out(_OutIt _Dest)
- :tbb::filter(true),m_Dest(_Dest){}
- void* operator()(void* data)
- {
- _DataType *p = (_DataType*) data;
- *m_Dest = *p;
- ++m_Dest;
- return NULL;
- }
- private:
- _OutIt m_Dest;
- };
- template<class _InIt, class _OutIt, class _Fn1>
- _OutIt _parallel_transform(_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func, std::forward_iterator_tag)
- {
- // 使用管线pipeline来处理
- tbb::pipeline pipeline;
- filter_in<_InIt> f1(_First, _Last);
- filter_process<_Fn1> f2(_Func);
- filter_out<_OutIt, _Fn1::result_type> f3(_Dest);
- pipeline.add_filter(f1);
- pipeline.add_filter(f2);
- pipeline.add_filter(f3);
- pipeline.run(3);
- return _Dest;
- }
- //----------------------parallel_transform----------------------------
- template<class _InIt, class _OutIt, class _Fn1>
- inline
- _OutIt parallel_transform(_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)
- {
- typedef typename std::iterator_traits<_InIt>::iterator_category cat1;
- typedef typename std::iterator_traits<_OutIt>::iterator_category cat2;
- return _parallel_transform(_First, _Last, _Dest, _Func, both_random_helper<cat1,cat2>::Iter_cat());
- }
- // 测试代码
- struct SinFunctor
- :std::unary_function<double, double>{
- double operator()(double &d) const
- {
- // 高强度运算
- double sum = 0;
- for(int i=0; i<10000; i++) sum += sin(i*d);
- return sum;
- }
- };
- int main()
- {
- // 随机存取迭代
- std::vector<double> a(10000,1.5);
- // 顺序存取迭代
- std::list<double> b(10000,1.5);
- tbb::task_scheduler_init init;
- tbb::tick_count t0,t1;
- t0 = tbb::tick_count::now();
- parallel_transform(a.begin(), a.end(), a.begin(), SinFunctor());
- t1 = tbb::tick_count::now();
- std::cout << "并行(随机迭代)" << (t1 - t0).seconds() << std::endl;
- t0 = tbb::tick_count::now();
- std::transform(a.begin(), a.end(), a.begin(), SinFunctor());
- t1 = tbb::tick_count::now();
- std::cout << "原版(随机迭代)" << (t1 - t0).seconds() << std::endl;
- t0 = tbb::tick_count::now();
- parallel_transform(b.begin(), b.end(), b.begin(), SinFunctor());
- t1 = tbb::tick_count::now();
- std::cout << "并行(顺序迭代)" << (t1 - t0).seconds() << std::endl;
- t0 = tbb::tick_count::now();
- std::transform(b.begin(), b.end(), b.begin(), SinFunctor());
- t1 = tbb::tick_count::now();
- std::cout << "原版(顺序迭代)"<< (t1 - t0).seconds() << std::endl;
- std::cin.get();
- return 0;
- }
在我的双核Centrino电脑上测试结果如下:
并行(随机迭代)3.17299 原版(随机迭代)5.41531 并行(顺序迭代)3.13054 原版(顺序迭代)5.33182
在顺序存取迭代器版本的_parallel_transform中,因为迭代器不能随意跳转,所以使用了tbb::pipeline加三个filter分别执行顺序读取,处理和写入。其中的处理是可以并行处理的。从上面的结果可以看出,pipeline的性能甚至不亚于parallel_for循环。关于pipeline的使用说明,请参考文章:TBB流水线
这里写的parallel_transform可以直接替换大家原有代码中的std::transform,当然如果有兴趣的话完全可以把标准库中的算法全用TBB改写成并行算法。不过要注意的一点是并不是任何地方都适合使用并行运算的,象这个例子中测试用的处理算子是“for(int i=0; i<10000; i++) sum += sin(i*d);”这样的需要耗时较长的运算,如果把它改成“return sin(d);”。那么考虑到线程调度以及TBB的任务调度,并行算法的效率可能还不如串行算法。
TBB库可以从这里下载:http://www.threadingbuildingblocks.org/download.php
另外再推荐几篇TBB入门文章:
Intel Threading Building Blocks 之 并行循环
Intel Threading Building Blocks 之 并发容器
Intel Threading Building Blocks 基于任务编程
相信度过了自己的20岁生日之后的C++,在多核时候将再创辉煌!