0_Simple__simpleCooperativeGroups

▶ 协作组，CUDA9.0 的新特性

▶ 源代码，如何获得协作组的编号？

 #include <stdio.h>

 #include "cuda_runtime.h"

 #include "device_launch_parameters.h"

 #include <cooperative_groups.h>

 #define THREAD_PER_BLOCK 64

 using namespace cooperative_groups;                             // 注意使用命名空间

 __device__ int sumReduction(thread_group g, int *x, int val)    // 规约设备函数，要求共享内存 int *x 要够放得下 g.size() 个参加规约的元素

 {

     int lane = g.thread_rank();                                 // 线程在协作组中的编号，教程中名字就叫 line ID

     for (int i = g.size() / ; i > ; i /= )

     {

         x[lane] = val;                                          // 第一次迭代该步相当于初始化，以后迭代该步相当于存储上一次迭代的结果

         g.sync();                                               // 协作组同步

         if (lane < i)

             val += x[lane + i];                                 // 利用每个线程局部变量 val 记录当前结果

         g.sync();

     }

     if (g.thread_rank() == )                                   // 零号线程返回计算结果

         return val;

     else

         return -;

 }

 __global__ void cgkernel()

 {

     extern __shared__ int workspace[];

     thread_block group = this_thread_block();                   // 将线程块内所有线程打包为一个协作组

     int groupSize = group.size();                               // 获得协作组大小（线程个数）

     int input = group.thread_rank();                            // 获得线程在协作组内的编号，并作为计算输入

     int output = sumReduction(group, workspace, input);         // 规约计算，注意直接使用共享内存作为工作空间

     int expectedOutput = (groupSize - )*groupSize / ;         // 预期计算结果，0 + 1 + 2 +...+ 63 = 2016

     if (group.thread_rank() == )                               // 0 号线程报告计算结果，宣布开始新的 4 个协作组的计算任务

     {

         printf("\n\tSum of thread 0 ~ %d in group is %d (expected %d)\n", group.size() - , output, expectedOutput);

         printf("\n\tNow creating %d groups, each of size 16 threads:\n", group.size() / );

     }

     group.sync();                                               // 协作组同步

     thread_block_tile<> group16 = tiled_partition<>(group); // 每16个线程分割为一个协作组（只能使用 2 的整数次幂）

     int offset = group.thread_rank() - group16.thread_rank();   // 各协作组使用的共享内存的地址偏移量

     printf("%d -> thread_rank = %d, group16.thread_rank = %d， offset = %d\n", threadIdx.x, group.thread_rank(), group16.thread_rank(), offset);

     // dim3 group.group_index() 打印出来全是 (0, 0, 0)，dim3 group.thread_index() 打印出来跟 group.thread_rank() 一样 

     input = group16.thread_rank();                              // 获得线程在新协作组中的编号，并作为计算输入

     output = sumReduction(group16, workspace + offset, input);  // 规约计算，注意工作空间的地址偏移

     expectedOutput =  *  / ;                               // 预期计算结果，0 + 1 + 2 +...+ 16 = 120

     if (group16.thread_rank() == )                             // 各协作组零号线程报告计算结果

         printf("\n\tSum of all ranks 0..15 in group16 is %d (expected %d)\n", output, expectedOutput);

     return;

 }

 int main()

 {

     printf("\n\tStart with %d threads.\n", THREAD_PER_BLOCK);

     cgkernel << <, THREAD_PER_BLOCK, THREAD_PER_BLOCK * sizeof(int) >> > ();

     cudaDeviceSynchronize();

     printf("\n\tFinish.\n");

     getchar();

     return ;

 }

● 输出结果

        Start with  threads.

        Sum of thread  ~  in group is  (expected )

        Now creating  groups, each of size  threads:

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset =

 -> thread_rank = , group16.thread_rank = ， offset = 

        Sum of all ranks .. in group16 is  (expected )

        Sum of all ranks .. in group16 is  (expected )

        Sum of all ranks .. in group16 is  (expected )

        Sum of all ranks .. in group16 is  (expected )

        Finish.

▶ 涨姿势：

● 相关定义

 // cooperative_groups_helper.h

 # if !defined(_CG_QUALIFIER)

 #  define _CG_QUALIFIER __forceinline__ __device__

 # endif

 # define die() assert();

 // cooperative_groups.h（调整顺序）

 class thread_group                      // 通用线程组类型

 {

     friend _CG_QUALIFIER thread_group this_thread();

     friend _CG_QUALIFIER thread_group tiled_partition(const thread_group& parent, unsigned int tilesz);

     friend class thread_block;

 protected:

     union __align__()

     {

         unsigned int type : ;

         struct

         {

             unsigned int type : ;

             unsigned int size : ;

             unsigned int mask;

         } coalesced;

         struct

         {

             void* ptr[];

         } buffer;

     } _data;

     _CG_QUALIFIER thread_group operator=(const thread_group& src);

     _CG_QUALIFIER thread_group(__internal::groupType type)

     {

         _data.type = type;

     }

 #if __cplusplus >= 201103L

     static_assert(sizeof(_data) == , "Failed size check");

 #endif

 public:

     _CG_QUALIFIER unsigned int size() const;

     _CG_QUALIFIER unsigned int thread_rank() const;

     _CG_QUALIFIER void sync() const;

 };

 class thread_block : public thread_group

 {

     friend _CG_QUALIFIER thread_block this_thread_block();

     friend _CG_QUALIFIER thread_group tiled_partition(const thread_group& parent, unsigned int tilesz);

     friend _CG_QUALIFIER thread_group tiled_partition(const thread_block& parent, unsigned int tilesz);

     _CG_QUALIFIER thread_block() : thread_group(__internal::ThreadBlock) {}

     _CG_QUALIFIER thread_group _get_tiled_threads(unsigned int tilesz) const

     {

         const bool pow2_tilesz = ((tilesz & (tilesz - )) == );

         if (tilesz ==  || (tilesz > ) || !pow2_tilesz)

         {

             die();

             return (thread_block());

         }

         unsigned int mask;

         unsigned int base_offset = thread_rank() & (~(tilesz - ));

         unsigned int masklength = min(size() - base_offset, tilesz);

         mask = (unsigned int)(-) >> ( - masklength);

         mask <<= (__internal::laneid() & ~(tilesz - ));

         thread_group tile = thread_group(__internal::CoalescedTile);

         tile._data.coalesced.mask = mask;

         tile._data.coalesced.size = __popc(mask);

         return (tile);

     }

 public:

     _CG_QUALIFIER void sync() const { __internal::cta::sync(); }

     _CG_QUALIFIER unsigned int size() const { return (__internal::cta::size()); }

     _CG_QUALIFIER unsigned int thread_rank() const { return (__internal::cta::thread_rank()); }

     _CG_QUALIFIER dim3 group_index() const { return (__internal::cta::group_index()); }

     _CG_QUALIFIER dim3 thread_index() const { return (__internal::cta::thread_index()); }

 };

 _CG_QUALIFIER thread_block this_thread_block()// 范例代码中用到的，实际是调用了 thread_block 的构造函数

 {

     return (thread_block());

 }

 template <unsigned int Size>

 class thread_block_tile;

 template <> class thread_block_tile<> : public __thread_block_tile_base<> { };

 template <> class thread_block_tile<> : public __thread_block_tile_base<> { };

 template <> class thread_block_tile<> : public __thread_block_tile_base<> { };

 template <> class thread_block_tile<> : public __thread_block_tile_base<> { };

 template <> class thread_block_tile<> : public __thread_block_tile_base<> { };

 template <> class thread_block_tile<> : public __thread_block_tile_base<> { };

 template <unsigned int Size>

 class __thread_block_tile_base : public thread_group

 {

     static const unsigned int numThreads = Size;

     _CG_QUALIFIER unsigned int build_mask() const

     {

         unsigned int mask;

         if (numThreads == )

             mask = 0xFFFFFFFF;

         else

         {

             mask = (unsigned int)(-) >> ( - numThreads);

             mask <<= (__internal::laneid() & (~(numThreads - )));

         }

         return (mask);

     }

 protected:

     _CG_QUALIFIER __thread_block_tile_base() : thread_group(__internal::CoalescedTile)

     {

         _data.coalesced.mask = build_mask();

         _data.coalesced.size = numThreads;

     }

 public:

     _CG_QUALIFIER void sync() const { __syncwarp(build_mask()); }

     _CG_QUALIFIER unsigned int thread_rank() const { return (threadIdx.x & (numThreads - )); }

     _CG_QUALIFIER unsigned int size() const { return (numThreads); }

     // PTX supported collectives

     _CG_QUALIFIER int shfl(int var, int srcRank) const { return (__shfl_sync(build_mask(), var, srcRank, numThreads)); }

     ...

 #ifdef _CG_HAS_FP16_COLLECTIVE

     _CG_QUALIFIER __half shfl(__half var, int srcRank) const { return (__shfl_sync(build_mask(), var, srcRank, numThreads)); }

     ...

 #endif

 #ifdef _CG_HAS_MATCH_COLLECTIVE

     _CG_QUALIFIER unsigned int match_any(int val) const

     {

         unsigned int lane_match = build_mask() & __match_any_sync(build_mask(), val);

         return (lane_match >> (__internal::laneid() & (~(numThreads - ))));

     }

     ...

 #endif

 };

● 用到的线程协作相关函数

 thread_block threadBlockGroup = this_thread_block();    // 将当前线程块分配为一个协作组

 thread_block_tile<> tiledPartition16 = tiled_partition<>(threadBlockGroup); // 协作组分组

 int in = tiledPartition16.thread_rank();                // 协作组中线程的编号

 tiledPartition16.sync();                            // 协作组同步

0_Simple__simpleCooperativeGroups的更多相关文章

随机推荐

LOJ2540. 「PKUWC2018」随机算法【概率期望DP+状压DP】
LINK 思路首先在加入几个点之后所有的点都只有三种状态一个是在独立集中,一个是和独立集联通,还有一个是没有被访问过然后前两个状态是可以压缩起来的因为我们只需要记录下当前独立集大小和是否被访问 ...
Xcode7（ linker command failed with exit code 1）
”Build Settings”->”Enable Bitcode”设置为NO ,因为有些SDK不支持Bitcode
Python开源应用系统
1.股票量化系统 https://github.com/moyuanz/DevilYuan 2.基于Echarts和Tushare的股票视觉化应用 https://github.com/Seedarc ...
<ul><li>
☆ <ul><li> 1. li是不能单独使用,必须在于ul之中的. 2. ul是块级元素,能直接定义宽高,而li是行级元素,不能直接定义高. 3. li组只能写在ul之中 ...
【liunx】端口号的占用情况查看
Linux如何查看端口 1.lsof -i:端口号用于查看某一端口的占用情况,比如查看8000端口使用情况,lsof -i:8000 # lsof -i:8000 COMMAND PID USER ...
sql server 表变量存储临时查询数据
对于使用sql server 编写存储过程或者类似的sql 查询的时候我们使用表变量进行临时数据的存储,可以方便我们进行下来的数据处理表变量的使用类似如下: declare @userinfo ta ...
oracle for in 学习
oracle for in 是对于进行循环的数据处理时比较方便的因为我们平时的操作经常会碰到进行循环的数据操作以下为建立的例子 1. begin for item in 2..10 loop d ...
oracle 以及 sql server mysql 空值默认值修改
在SQL Server Oracle MySQL当数据库中查出某值为NULL怎么办? 1.MSSQL: ISNULL() 语法 ISNULL ( check_expression , replacem ...
gridview 合并单元格并原样导出数据
使用的方式都是比较简单的,asp.net 如何进行数据的导出有好多种方法,大家可以在网上找到, 一下提供一些合并并原样输出的一个简单的代码: public void ToExcel(System.We ...
linux 的dmesg命令
dmesg命令参考博客 http://www.linuxso.com/command/dmesg.html dmesg用来显示内核环缓冲区(kernel-ring buffer)内容,内核将各种消息存 ...

0_Simple__simpleCooperativeGroups

0_Simple__simpleCooperativeGroups的更多相关文章

随机推荐

热门专题