Visual Studio 11开发指南（19）C++11更新-行模式库和代理库

Visual Studio 11，具备并行模式库和代理库、 更轻松地开发自然并行的多个处理器上运行的代码。

这些库的主要范式，它是根据任务 （任务） 和并发运行库和自定义的调度程序

到目前为止，处理任务的概念，我们使用task_handle ●类型 （或直接键入task_group ●），如下所示：

1.task_group task;    
 2.    int i=0;    
 3.    auto  t1=make_task([&i]()
 4.        {
 5.            
 6.            i=42;
 7.        });
 8.    int z=0;
 9.    auto t2=make_task([&z]()
 10.        {
 11.            
 12.            z=42;
 13.        });
 14. 
 15.    task.run_and_wait (t1);    
 16.    task.run_and_wait (t2);    
 17.    std::wcout << i+z << std::endl;
 18.    std::wcout << "Fini" << std::endl;

这里计算的 i + z 我们必须捕获的 lambda 表达式中引用变量 （& 我，和 & z），然后期望这两个任务完成他们的工作。

现在，使用 Visual Studio 11，我们可以直接使用的任务 ●类型和未来的概念，如下所示：

1.task<int> t1=task<int>([]()->int
 2.        {
 3.            return 42;
 4.        });
 5.    
 6.    task<int> t2=task<int>([]()->int
 7.        {
 8.            return 42;
 9.        });
 10.    
 11.    std::wcout << t1.get() +t2.get () << std::endl;

这简化了语法，更需要捕获变量的引用，并为每项任务，要等待通过调用方法wait()的每个任务并返回值角色的方法get () 。

键入任务 ●也有可能实现持续的概念。这一概念允许滑雪轮流的异步任务的遵循，即是说，不论Tn 取决于 Tn-1 任务的任务和这样的结果如果前一任务已完成他的工作，或没有。在联系日益紧密的世界中，异步操作将概括为避免冻结的用户界面，很重要的是为了简化开发过程。

若要实现这一概念的延续，任务 ●类型实现的then()方法，将会执行一次该任务已完成其工作。

1.task<int> t1=task<int>([]()->int
 2.    {
 3.        return 42;
 4.    }).then ([](int i)->int
 5.        {
 6.        
 7.            return i+42;    
 8.        });
 9. 
 10.task<int> t2=task<int>([]()->int
 11.    {
 12.        //simule une charge
 13.        std::this_thread::sleep_for (chrono::seconds (1));        
 14.        return 42;
 15.    }).then ([](int i)->int
 16.        {
 17.            
 18.            return i+42;    
 19.        });            
 20.std::wcout << t1.get() + t2.get() << std::endl;

这里的每项任务，返回值是作为参数传递，lambda 表达式中的then()方法。

在此版本中我们还加基地算法的并行算法 （parallel_for、 parallel_for_each、 parallel_invoke ）)

并行算法的尝试

parallel_sort 、 parallel_radixsort、 parallel_buffered_sort的标准如果命运它只运行并行模式中相同的方式使用这些算法。

1.vector<unsigned int> v3;
 2.   parallel_sort(begin(v3),end(v3))

虽然在大多数情况下，这是一个简单的类整数的性能足以 （示例矢量的整数 40 000 000，得到一个序列(std::sort)和parallel_sort()，它是这种情况，或允许更好地控制可能会提高性能与 711 分。）

每种算法，都来做重载，此方法允许设置的谓语的排序和要使用的分区的大小。

1.vector<unsigned int> v2;
 2.      parallel_sort(begin(v2),end(v2),[](const unsigned int& l,const unsigned int& r)->bool    
 3.   {
 4.       
 5.       return (l<r);
 6.   },4096);   

默认分区大小为 2048，对于大多数情况下就足够了。邮件可以玩到最后一个分区的大小来提高性能。不过，如果分区大小小于或等于向量的大小，它是将使用任何方法std::sort ()中。（默认情况下，如果向量的元素的数目是 < = 2048总是将使用std::sort ()版本)。

1.inline void parallel_sort(const _Random_iterator &_Begin, const _Random_iterator &_End, const _Function &_Func, const size_t _Chunk_size = 2048)
 2.{
 3.    _CONCRT_ASSERT(_Chunk_size > 0);
 4. 
 5.    // We make the guarantee that if the sort is part of a tree that has been canceled before starting, it will
 6.    // not begin at all.
 7.    if (is_current_task_group_canceling())
 8.    {
 9.        return;
 10.    }
 11. 
 12.    size_t _Size = _End - _Begin;
 13.    size_t _Core_num = Concurrency::details::_CurrentScheduler::_GetNumberOfVirtualProcessors();
 14. 
 15.    if (_Size <= _Chunk_size || _Core_num < 2)
 16.    {
 17.        return std::sort(_Begin, _End, _Func);
 18.    }
 19. 
 20.    _Parallel_quicksort_impl(_Begin, _Size, _Func, _Core_num * _MAX_NUM_TASKS_PER_CORE, _Chunk_size, 0);
 21.}

您还会注意是否系统至少不会以任何方式使用的 std::sort () 的虚拟处理器。

可用其他算法的尝试并使用需要。例如，在我们的例子中的基数排序

1.vector<unsigned int> v4;
 2.   parallel_radixsort(begin(v4),end(v4));

提供更好的结果 197.09 上 40 000 000 个项目。默认分区大小为 256 * 256

parallel_buffered_sort给 631

1. parallel_buffered_sort(begin(v5),end(v5));

减少

申请的数量，最小，最多的一组所有成员称为一般减少。应用减少并行可以或者涉及争用条件或问题的另外的浮点操作的舍入为例。

Visual Studio 2010 年时他们希望提出的减少，例如双平行的循环，循环的量的一种方法是使用concurrency::combinable <T>对象

1.combinable<double> sumReduction;    
 2.   parallel_for_each(begin(v1),end(v1),[&sumReduction](double i)
 3.   {     
 4.       sumReduction.local ()+=i;       
 5.   });
 6.   sum=sumReduction.combine (std::plus<double>());

Visual Studio 11，它是现在可以使用算法parallel_reduce()，似乎比类型的使用效率更高(concurrency::combinable)。

它的使用是相对 ， std::accumulate)

vector<double>::const_iterator deb=begin(v1);
 2.   vector<double>::const_iterator fin=end(v1);
 3.   auto identity=std::iterator_traits<vector<double>::const_iterator>::value_type();   
 4.   sum= parallel_reduce(deb,fin,identity,std::plus<double>());

转型

最后的最后的算法是加工parallel_transformation()算法

1.parallel_transform(begin(v1),end(v1),begin(v2),[](double value)->double 
2.{ 
3.    return value*2; 
4.});