CUDA3.0的C++支持详解

最新推荐文章于 2024-08-31 13:09:03 发布
最新推荐文章于 2024-08-31 13:09:03 发布
阅读量444 收藏
点赞数
文章标签： python c/c++
CUDA3特性中最吸引人的一条就是其对C++的支持，今天兄弟就切实的尝试了一下，所有的代码都以向量相加为例子，体会分享如下：

函数重载与默认参数
允许在同一个类中出现多个同名但参数列表不同的过程或函数，运行时才确定调用函数的入口地址。记得在2.3中就已经开始支持了，但是一直都没有尝试，今天就试了一下，感觉但是不错的，呵呵！代码如下：

[Copy to clipboard] [ - ]
CODE:
#include

#define DEFAULT

#define BLOCKSIZE 256

__device__ int add(int a=0,int b=0){
        return (a+b);
}

__device__ float add(float a,float b){
        return (a+b);
}


__global__ void add(const int* __restrict__  a,const int* __restrict__ b,int* __restrict__ c,const unsigned int num){

        const unsigned int id=blockDim.x*blockIdx.x+threadIdx.x;

        if(id #ifdef DEFAULT
                c[id]=add();
#else
                c[id]=add(a[id],b[id]);
#endif
        }
}

__global__ void add(const float* __restrict__ a,const float* __restrict__ b,float* __restrict__ c,const unsigned int num){

        const unsigned int id=blockIdx.x*blockDim.x+threadIdx.x;

        if(id                 c[id]=add(a[id],b[id]);
        }
}

int test(const unsigned int num){
       
        int *a;
        int *b;
        float *af;
        float *bf;

        cudaMallocHost((void**)&a,num*sizeof(int));
        cudaMallocHost((void**)&b,num*sizeof(int));

        cudaMallocHost((void**)&af,num*sizeof(float));
        cudaMallocHost((void**)&bf,num*sizeof(float));
        for(int i=0;i                 a[i]=1;
                b[i]=2;
                af[i]=1.1f;
                bf[i]=2.2f;
        }

        int *d_a;
        cudaMalloc((void**)&d_a,num*sizeof(int));
        cudaMemcpyAsync(d_a,a,num*sizeof(int),cudaMemcpyHostToDevice,0);

        float *d_af;
        cudaMalloc((void**)&d_af,num*sizeof(float));
        cudaMemcpyAsync(d_af,af,num*sizeof(float),cudaMemcpyHostToDevice,0);

        int *d_b;
        cudaMalloc((void**)&d_b,num*sizeof(int));
        cudaMemcpyAsync(d_b,b,num*sizeof(int),cudaMemcpyHostToDevice,0);

        float *d_bf;
        cudaMalloc((void**)&d_bf,num*sizeof(float));
        cudaMemcpyAsync(d_bf,bf,num*sizeof(int),cudaMemcpyHostToDevice,0);

        int *c;
        cudaMallocHost((void**)&c,num*sizeof(int));

        float *cf;
        cudaMallocHost((void**)&cf,num*sizeof(float));

        int *d_c;
        cudaMalloc((void**)&d_c,num*sizeof(int));

        float *d_cf;
        cudaMalloc((void**)&d_cf,num*sizeof(float));

        add<<>>(d_a,d_b,d_c,num);

        cudaMemcpyAsync(c,d_c,num*sizeof(int),cudaMemcpyDeviceToHost,0);

        add<<>>(d_af,d_bf,d_cf,num);

        cudaMemcpyAsync(cf,d_cf,num*sizeof(float),cudaMemcpyDeviceToHost,0);

        for(int i=0;i                 if((i+1)%20==0)
                        printf("%d ",c[i]);
        }
       
        printf(".......................................................\n");
        for(int i=0;i                 if((i+1)%20==0)
                        printf("%f ",cf[i]);
        }

        cudaFreeHost(a);
        cudaFreeHost(b);
        cudaFreeHost(c);

        cudaFreeHost(af);
        cudaFreeHost(bf);
        cudaFreeHost(cf);

        cudaFree(d_a);
        cudaFree(d_b);
        cudaFree(d_c);

        cudaFree(d_af);
        cudaFree(d_bf);
        cudaFree(d_cf);

        return 0;
}

int main(){

        test(10000);
}

其中定义的DEFAULT用于测试默认参数；同时还试验了一下__restrict__关键字，但是有个限制，如果大家试验一下相信很容易知道，呵呵！大家试试，看看是不是能够出正确结果。

运算符重载
代码如下：

[Copy to clipboard] [ - ]
CODE:
#include

#define BLOCKSIZE 256

typedef struct __align__(8){
        int money;
        int girl;
}yyfn;

__device__ yyfn operator+ (yyfn& one,yyfn& two){
       
        yyfn temp;
        temp.money=one.money+two.money;
        temp.girl=one.girl+two.girl;

        return (temp);
}

__global__ void add(yyfn *a,yyfn *b,yyfn *c,const unsigned int num){

        const unsigned int id=blockDim.x*blockIdx.x+threadIdx.x;

        if(id                 c[id]=(a[id]+b[id]);
        }
}

int test(const unsigned int num){
       
        yyfn *a;
        yyfn *b;

        cudaMallocHost((void**)&a,num*sizeof(yyfn));
        cudaMallocHost((void**)&b,num*sizeof(yyfn));

        for(int i=0;i                 a[i].money=1;
                a[i].girl=1;
                b[i].money=2;
                b[i].girl=1;
        }

        yyfn *d_a;
        cudaMalloc((void**)&d_a,num*sizeof(yyfn));
        cudaMemcpyAsync(d_a,a,num*sizeof(yyfn),cudaMemcpyHostToDevice,0);

        yyfn *d_b;
        cudaMalloc((void**)&d_b,num*sizeof(yyfn));
        cudaMemcpyAsync(d_b,b,num*sizeof(yyfn),cudaMemcpyHostToDevice,0);

        yyfn *c;
        cudaMallocHost((void**)&c,num*sizeof(yyfn));

        yyfn *d_c;
        cudaMalloc((void**)&d_c,num*sizeof(yyfn));

        add<<>>(d_a,d_b,d_c,num);

        cudaMemcpyAsync(c,d_c,num*sizeof(yyfn),cudaMemcpyDeviceToHost,0);

        for(int i=0;i                 if((i+1)%20==0)
                        printf("money=%d,girl=%d ",c[i].money,c[i].girl);
        }

        cudaFreeHost(a);
        cudaFreeHost(b);
        cudaFreeHost(c);

        cudaFree(d_a);
        cudaFree(d_b);
        cudaFree(d_c);

        return 0;
}

int main(){

        test(10000);
}

yyfn是一个结构体，其有两个域，一个是money，一个是girl，运算符重载的使用使得程序清晰简洁了不少。但是运算符重载应当不能用于内核，因为运算符重载要返回值。

模板

CUDA很早以前就已经支持这个，所以就不详细说了，给了个例子，大家体会一下，呵呵！

[Copy to clipboard] [ - ]
CODE:
#include

#define BLOCKSIZE 256

template
__global__ void add(const T* __restrict__ a,const T* __restrict__  b,T* __restrict__ c,const unsigned int num){

        const unsigned int id=blockDim.x*blockIdx.x+threadIdx.x;

        if(id                 c[id]=(a[id]+b[id]);
        }
}

int test(const unsigned int num){
       
        int *a;
        int *b;

        cudaMallocHost((void**)&a,num*sizeof(int));
        cudaMallocHost((void**)&b,num*sizeof(int));

        for(int i=0;i                 a[i]=1;
                b[i]=2;
        }

        int *d_a;
        cudaMalloc((void**)&d_a,num*sizeof(int));
        cudaMemcpyAsync(d_a,a,num*sizeof(int),cudaMemcpyHostToDevice,0);

        int *d_b;
        cudaMalloc((void**)&d_b,num*sizeof(int));
        cudaMemcpyAsync(d_b,b,num*sizeof(int),cudaMemcpyHostToDevice,0);

        int *c;
        cudaMallocHost((void**)&c,num*sizeof(int));

        int *d_c;
        cudaMalloc((void**)&d_c,num*sizeof(int));

        add<<>>(d_a,d_b,d_c,num);

        cudaMemcpyAsync(c,d_c,num*sizeof(int),cudaMemcpyDeviceToHost,0);

        for(int i=0;i                 if((i+1)%20==0)
                        printf("%d ",c[i]);
        }

        cudaFreeHost(a);
        cudaFreeHost(b);
        cudaFreeHost(c);

        cudaFree(d_a);
        cudaFree(d_b);
        cudaFree(d_c);

        return 0;
}

int main(){

        test(10000);
}

函数对象

在C++中，函数对象广泛用于算法中，CUDA应该是为以后支持更多的算法准备的。代码如下 ：

[Copy to clipboard] [ - ]
CODE:
#include

#define BLOCKSIZE 256
class Add{
public:
template
        __device__ T operator() (T& a,T& b) const {
                return (a+b);
        }
};

__global__ void add(const int* __restrict__ a,const int* __restrict__ b,int* __restrict__ c,const unsigned int num,Add op){

        const unsigned int id=blockDim.x*blockIdx.x+threadIdx.x;

        if(id                 c[id]=op(a[id],b[id]);
        }
}

int test(const unsigned int num){
       
        int *a;
        int *b;

        cudaMallocHost((void**)&a,num*sizeof(int));
        cudaMallocHost((void**)&b,num*sizeof(int));

        for(int i=0;i                 a[i]=1;
                b[i]=2;
        }

        int *d_a;
        cudaMalloc((void**)&d_a,num*sizeof(int));
        cudaMemcpyAsync(d_a,a,num*sizeof(int),cudaMemcpyHostToDevice,0);

        int *d_b;
        cudaMalloc((void**)&d_b,num*sizeof(int));
        cudaMemcpyAsync(d_b,b,num*sizeof(int),cudaMemcpyHostToDevice,0);

        int *c;
        cudaMallocHost((void**)&c,num*sizeof(int));

        int *d_c;
        cudaMalloc((void**)&d_c,num*sizeof(int));

        add<<>>(d_a,d_b,d_c,num,Add());

        cudaMemcpyAsync(c,d_c,num*sizeof(int),cudaMemcpyDeviceToHost,0);

        for(int i=0;i                 if((i+1)%20==0)
                        printf("%d ",c[i]);
        }

        cudaFreeHost(a);
        cudaFreeHost(b);
        cudaFreeHost(c);

        cudaFree(d_a);
        cudaFree(d_b);
        cudaFree(d_c);

        return 0;
}

int main(){

        test(10000);
}

本来还想试验一下复杂的类机制，但是仔细一想，还是不打击自己了，呵呵！

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/23057064/viewspace-630474/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/23057064/viewspace-630474/

cili2562
关注
C++开源计算机视觉库OpenCV详解
dvlinker的技术专栏
07-26 147
开源计算机视觉库OpenCV详解。
开源计算机视觉库OpenCV详解
热门推荐
dvlinker的技术专栏
06-23 8万+
详细介绍开源计算机视觉库OpenCV。
CUDA C++编程接口：编译
吴建明wujianming_110117
06-04 584
CUDA C++编程接口：编译 一．概述 CUDA C++为熟悉C++编程语言的用户提供了一个简单的路径，以方便地编写程序以执行该设备。 它由一组最小的扩展到C++语言和运行库。 在编程模型中引入了核心语言扩展。它们允许程序员定义内核作为C++函数，并使用一些新的语法来指定每次调用函数时的网格和块维数。所有扩展的完整描述可以在C++语言扩展中找到。任何包含这些扩展名的源文件都必须使用nvcc编译，如使用nvcc编译中所述。 在CUDA运行时中引入了运行时。它提供了在主机上执行的C和
Nvidia CUDA 3.0 更新
OpenHero 开勇
03-23 4380
- Section 1.2     - Updated figure添加了说明图，更好的解释了CUDA不只是一个语言，而是一个平台，一个platform，可以在CUDA之上可以架构其他语言平台，或则编程环境。CUDA有自己的ISA架构，有PTX代码，所以不要简单的把CUDA理解为是编程语言，可以根据CUDA的架构开发自己的芯片，或者硬件，当然，这个得要有详细的CUDA资料才行·~至少现在
CUDA C/C++编程
最新发布
zhaoyananzyn的博客
08-31 633
在C++中直接使用CUDA进行GPU编程是CUDA最原生的支持方式。 CUDA C/C++是一种扩展了C/C++语言的编程模型，它允许开发者编写专门在NVIDIA GPU上执行的代码。 以下是一些基本的CUDA C/C++编程概念和常用指令
Cuder - 用C++11封装的CUDA类
banfan0440的博客
01-28 585
以前写cuda：初始化环境，申请显存，初始化显存，launch kernel，拷贝数据，释放显存。一个页面大部分都是这些繁杂但又必须的操作，有时还会忘掉释放部分显存。 今天用C++11封装了这些CUDA操作，然后就可以专注于写kernel代码了。.cu文件就像glsl shader文件一样简洁明了。 例如：./kernel.cu文件，里面只有一个fill函数用于填充数组A。 e...
在C++项目中集成CUDA程序加速（从环境配置讲起）
A_water_的博客
08-28 3317
因为我自己的 C++ 项目需要用到CUDA加速计算，但是又从来从来没有尝试过，所以这里记录一下整个过程。希望对大家有帮助！
使用cuda C完成矩阵相乘算法详解
sinat_38368658的博客
03-26 5199
矩阵相乘大家应该都不陌生。 设有两个矩阵M和N，假设M和N都是方阵，维度均为width × width 如果M和N均为1000 × 1000的矩阵，总共要进行1000000次点乘。其中，每次点乘有1000次乘法和1000次加法。 Matirx Multiply：CPU实现 先来看看使用普通的c代码在CPU端如何实现 void MatrixMulOnHost(float* M,float* N,...
cudnn5.1cuda8.0
10-16
1. **系统兼容性**：确保操作系统、GPU驱动和硬件设备满足CUDA 8.0的要求，特别是GPU应支持CUDA计算能力3.0或更高版本。 2. **驱动更新**：安装CUDA之前，先更新NVIDIA GPU驱动至最新版本，以确保兼容性和性能。 3...
CUDA与C++
shenlan282的笔记
11-30 2206
1.使用thrust: http://stackoverflow.com/questions/13185221/cuda-host-object-to-device http://blog.csdn.net/shenlan282/article/details/8237576 http://blog.csdn.net/shenlan282/article/details/8237586
C++_CUDA入门
cyz0202的博客
05-29 2736
NVIDIA CUDA入门blog-An Even Easier Introduction to CUDA
cuda（C++）编程简要
SKGLZ的博客
04-04 649
项目所需临时接触qt和cuda编程，仅为个人纪录。
CUDA C++ Programming Guide——编程模型
肥叔菌的博客
08-28 6834
本章通过概述CUDA编程模型在C ++中的使用方式，介绍了其主要概念。 编程接口中给出了CUDA C ++的广泛描述。本章和下章使用的向量加法示例的完整代码可以在vectorAdd CUDA示例中找到。 kernels CUDA C ++通过允许程序员定义称为内核的C ++函数来扩展C ++，这些函数在被调用时由N个不同的CUDA线程并行执行N次，而不是像常规C ++函数那样仅执行一次。使用__global__声明说明符定义内核，并使用<<< … >>>执行配置语法指定为
CUDA C++程序设计模型
吴建明wujianming_110117
06-04 570
CUDA C++程序设计模型 本章介绍了CUDA编程模型背后的主要概念，概述了它们在C++中的暴露方式。在编程接口中给出了CUDA C++的广泛描述。 使用的矢量加法示例的完整代码可以在矢量加法CUDA示例中找到。 一. 内核 CUDA C++通过允许程序员定义C++函数，称为内核，扩展了C++，当调用时，用n个不同的CUDA线程并行执行n次，而不是像常规C++函数那样只执行一次。 一个内核使用了__global__声明说明符来定义，并且使用一个新的<<<…>执行配置语法（参见C++
CUDA C++ Programming Guide——编程接口 Compilation with NVCC
肥叔菌的博客
10-08 5586
Programming Interface CUDA C ++为熟悉C ++编程语言的用户提供了一条简单的路径，可以轻松编写程序以供设备执行。它由对C ++语言的最小扩展集和运行时库组成。 核心语言扩展已在“编程模型”中引入。它们允许程序员将内核定义为C ++函数，并在每次调用该函数时使用一些新语法指定网格和块尺寸。有关所有扩展的完整说明，请参见C ++语言扩展。包含其中一些扩展名的任何源文件都必须使用nvcc进行编译，如使用NVCC进行编译中所述。运行时在CUDA运行时中引入。它提供了C和C ++函数，这
C++ 最简单的CUDA代码
蓝壳优码库
09-08 122
【代码】C++ 最简单的CUDA代码。
CUDA 3.0编程指南中文详解
CUDAC部分主要讨论了如何使用nvcc编译器进行CUDA程序的编译，包括编译流程、二进制和PTX兼容性、应用和C++兼容性等。接着，详细介绍了各种类型的存储器，如设备存储器、共享存储器、纹理存储器和分页锁定主机存储器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值