学习 Intel 线程构建块开源库

简介

我们发现了 POSIX 线程和基于 Windows 的线程的一种强大替代，即 Intel 线程构建块，该构建块是专为并行编程而设计的基于 C++ 的框架。并行编程是未来的发展趋势，但是如何实现高性能的并行编程，从而有效地利用多核 CPU 呢？使用诸如 POSIX 线程这样的线程库当然也是一种选择，不过，最初引入 POSIX 线程框架时已经考虑到了 C 语言。这是一种非常低级别的方法，例如，如果您无法访问任何并发容器，那么就不能使用任何并发算法。为此，Intel 推出了 Intel® 线程构建块 (Intel TBB)，一种用于并行编程的基于 C++ 语言的框架，它提供了大量有趣的特性，具有比线程更高程度的抽象。

#include "tbb/tbb.h"
#include <iostream>
using namespace tbb;
using namespace std;class first_task : public task { public: task* execute( ) { cout << "Hello World!\n";return NULL;}
};int main( )
{ task_scheduler_init init(task_scheduler_init::automatic);first_task& f1 = *new(tbb::task::allocate_root()) first_task( );tbb::task::spawn_root_and_wait(f1);
}

#include "tbb/tbb.h"
#include <iostream>
using namespace tbb;
using namespace std;class first_task : public task { public: task* execute( ) { cout << "Hello World!\n";task_list list1; list1.push_back( *new( allocate_child() ) first_task( ) );list1.push_back( *new( allocate_child() ) first_task( ) );set_ref_count(3); // 2 (1 per child task) + 1 (for the wait) spawn_and_wait_for_all(list1);return NULL;}
};int main( )
{ first_task& f1 = *new(tbb::task::allocate_root()) first_task( );tbb::task::spawn_root_and_wait(f1);
}

template<typename Func> void run( const Func& f )

#include "tbb/tbb.h"
#include <iostream>
using namespace tbb;
using namespace std;class say_hello( ) { const char* message;public: say_hello(const char* str) : message(str) {  }void operator( ) ( ) const { cout << message << endl;}
};int main( )
{ task_group tg;tg.run(say_hello("child 1")); // spawn task and returntg.run(say_hello("child 2")); // spawn another task and return tg.wait( ); // wait for tasks to complete
}

template<typename T, class A = cache_aligned_allocator<T> >
class concurrent_vector;

void append( concurrent_vector<char>& cv, const char* str1 ) { size_t count = strlen(str1)+1; std::copy( str1, str1+count, cv.grow_by(count) );
}

void serial_only (int* array, int size) { for (int count = 0; count < size; ++count)apply_transformation (array [count]);
}

/** \page parallel_for_body_req Requirements on parallel_for bodyClass \c Body implementing the concept of parallel_for body must define:- \code Body::Body( const Body& ); \endcode        Copy constructor- \code Body::~Body(); \endcode                             Destructor- \code void Body::operator()( Range& r ) const; \endcode   Function call operator applying the body to range \c r.
**/

#include "tbb/blocked_range.h"
using namespace tbb;class apply_transform{  int* array;  public:  apply_transform (int* a): array(a) {}  void operator()( const blocked_range& r ) const {  for (int i=r.begin(); i!=r.end(); i++ ){  apply_transformation(array[i]);  }  }
};

#include "tbb/blocked_range.h"
#include "tbb/parallel_for.h"
using namespace tbb;void do_parallel_the_tbb_way(int *array, int size) { parallel_for (blocked_range(0, size), apply_transform(array));
}

void serial_only (int* array, int size) { int sum = 0;for (int count = 0; count < size; ++count)sum += array [count]; return sum;
}

#include "tbb/blocked_range.h"
#include "tbb/parallel_reduce.h"
using namespace tbb;float sum_with_parallel_reduce(int*array, int size) {summation_helper helper (array);       parallel_reduce (blocked_range<int> (0, size, 5), helper);return helper.sum;
}

class summation_helper {int* partial_array;
public:int sum;void operator( )( const blocked_range<int>& r ) {for( int count=r.begin(); count!=r.end( ); ++count)sum += partial_array [count];}summation_helper (summation_helper & x, split): partial_array (x. partial_array), sum (0) {}summation_helper (int* array): partial_array (array), sum (0){}void join( const summation_helper & temp ) { sum += temp.sum;  // required method }
};

#include "tbb/atomic.h"
using namespace tbb;atomic<int> count;
atomic<float* > pointer_to_float;

// writing with mutex, count is declared as int count;
{// … codepthread_mutex_lock (&lock);count += 1000; pthread_mutex_unlock (&lock);// … code continues
}// writing without mutex, count declared as atomic<int> count;
{// … codecount.fetch_and_add (1000); // no explicit locking/unlocking// … code continues
}

y = x; // atomic read
x = b; // atomic write
x.fetch_and_store(y); // y = x and return the old value of x
x.fetch_and_add(y); // x += y and return the old value of x
x.compare_and_swap(y, z); // if (x == z) x = y; in either case, return old value of x

value_type operator+=( D addend ) {return fetch_and_add(addend)+addend;
}value_type operator-=( D addend ) {// Additive inverse of addend computed using binary minus,// instead of unary minus, for sake of avoiding compiler warnings.return operator+=(D(0)-addend);
}value_type operator++() {return fetch_and_add(1)+1;
}value_type operator--() {return fetch_and_add(__TBB_MINUS_ONE(D))-1;
}value_type operator++(int) {return fetch_and_add(1);}value_type operator--(int) {return fetch_and_add(__TBB_MINUS_ONE(D));}