滴水逆向联盟

标题: Visual Studio 11开发指南（19）C++11更新-并行模式库和代理库 [打印本页]

---

作者: 大灰狼    时间: 2014-10-23 08:11
标题: Visual Studio 11开发指南（19）C++11更新-并行模式库和代理库
Visual Studio 11，具备并行模式库和代理库、 更轻松地开发多核处理器上运行的并行代码。

这些库的主要范例是根据任务 和并发运行库，自定义的调度程序 进行处理的。

到目前为止，处理任务的的概念原型，就使用task_handle ●类型 如下所示：

• 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 表达式中引用变量 。然后这两个任务并行完成它们的工作。

使用 Visual Studio 11，可以直接使用的task类型的概念，如下所示：

• 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 ()，获取状态以便处理 。

task类的异步任务的遵循设置的运行规则，无需等待，即是说，不论Tn 取决于 Tn-1 任务的任务以及前一任务已完成或没有。

异步操作将概括为避免假死的用户界面，很重要的是为了简化开发过程，以前的VS经常卡死，加载控件的时候。

若要实现这一概念，task类实现的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()，允许更好地调控，会提高性能）

每种算法，都用来做重载，这个方法允许设置的字符串的排序和要使用的分区的大小。

• 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));  
  

减少

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

例如双平行处理的循环，循环的量的一种方法是使用concurrency::combinable <T>对象

[cpp] view plaincopy

• 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)

[cpp] view plaincopy

• 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.});   
  

---

欢迎光临 滴水逆向联盟 (http://www.dtdebug.com/)

Powered by Discuz! X3.2