CUDA编程之环境配置

VS2015+CUDA8.0环境配置

Anyway，在这里记录下正确的配置方式：

1、首先，上官网下载对应vs版本的CUDA toolkit：

https://developer.nvidia.com/cuda-toolkit-50-archive

（记住vs2010对应CUDA5.0,vs2013对应CUDA7.5，vs2015对应CUDA8.0）

2、接着，直接安装，记得在安装过程中如果你不想换你原有的显卡驱动的话，就选择自定义不安装driver；否则如果你直接选“精简”又不安装驱动，则CUDA安装无法成功。

3、安装完成之后，进入C:Program FilesNVIDIA GPU Computing ToolkitCUDAv8.0 之后可以看到有好几个文件夹：bin、lib 、include等等，这就表明安装成功了

4、接下来，看看如何创建一个利用cuda编程的项目，打开vs创建项目时，你可以看到有了新的项目类型：

但是我们这里教你如何在一个空项目中编译cu文件，所以我们还是 创建一个vc++的空项目，接着创建一个新的cpp文件和cu文件

test.cpp代码如下：

[cpp] view plain copy
 
  1. #include <time.h>  
  2. #include <stdlib.h>  
  3. #include <stdio.h>  
  4.   
  5. //这里不要忘了加引用声明  
  6. extern "C" void MatrixMultiplication_CUDA(const float* M, const float* N, float* P, int Width);  
  7.   
  8. //构造函数...  
  9. //析构函数...  
  10.   
  11. // 产生矩阵,矩阵中元素0~1  
  12. void matgen(float* a, int Width)  
  13. {  
  14.     int i, j;  
  15.     for (i = 0; i < Width; i++)  
  16.     {  
  17.         for (j = 0; j < Width; j++)  
  18.         {  
  19.             a[i * Width + j] = (float)rand() / RAND_MAX + (float)rand() / (RAND_MAX*RAND_MAX);  
  20.         }  
  21.     }  
  22. }  
  23.   
  24. //矩阵乘法(CPU验证)  
  25. void MatrixMultiplication(const float* M, const float* N, float* P, int Width)  
  26. {  
  27.     int i, j, k;  
  28.     for (i = 0; i < Width; i++)  
  29.     {  
  30.         for (j = 0; j < Width; j++)  
  31.         {  
  32.             float sum = 0;  
  33.             for (k = 0; k < Width; k++)  
  34.             {  
  35.                 sum += M[i * Width + k] * N[k * Width + j];  
  36.             }  
  37.             P[i * Width + j] = sum;  
  38.         }  
  39.     }  
  40. }  
  41.   
  42. double MatrixMul_GPU()  
  43. {  
  44.     float *M, *N, *Pg;  
  45.     int Width = 1024;   //1024×1024矩阵乘法  
  46.     M = (float*)malloc(sizeof(float)* Width * Width);  
  47.     N = (float*)malloc(sizeof(float)* Width * Width);  
  48.     Pg = (float*)malloc(sizeof(float)* Width * Width); //保存GPU计算结果  
  49.   
  50.     srand(0);  
  51.   
  52.     matgen(M, Width);           //产生矩阵M  
  53.     matgen(N, Width);           //产生矩阵N  
  54.   
  55.     double timeStart, timeEnd;  //定义时间，求时间差用  
  56.     timeStart = clock();  
  57.     MatrixMultiplication_CUDA(M, N, Pg, Width);         //GPU上计算  
  58.     timeEnd = clock();  
  59.   
  60.     free(M);  
  61.     free(N);  
  62.     free(Pg);  
  63.     return timeEnd - timeStart;  
  64. }  
  65.   
  66. double MatrixMul_CPU()  
  67. {  
  68.     float *M, *N, *Pc;  
  69.     int Width = 1024;   //1024×1024矩阵乘法  
  70.     M = (float*)malloc(sizeof(float)* Width * Width);  
  71.     N = (float*)malloc(sizeof(float)* Width * Width);  
  72.     Pc = (float*)malloc(sizeof(float)* Width * Width);  //保存CPU计算结果  
  73.   
  74.     srand(0);  
  75.   
  76.     matgen(M, Width);           //产生矩阵M  
  77.     matgen(N, Width);           //产生矩阵N  
  78.   
  79.     double timeStart, timeEnd; //定义时间，求时间差用  
  80.     timeStart = clock();  
  81.     MatrixMultiplication(M, N, Pc, Width);              //CPU上计算  
  82.     timeEnd = clock();  
  83.   
  84.     free(M);  
  85.     free(N);  
  86.     free(Pc);  
  87.     return timeEnd - timeStart;  
  88. }  
  89.   
  90. //////////////////////////////////////////////////////////////////////////  
  91. int main()  
  92. {  
  93.     printf("CPU use time %g ", MatrixMul_CPU());  
  94.     printf("GPU use time %g ", MatrixMul_GPU());  
  95.     system("pause");  
  96.     return 0;  
  97. }  
 

test.cu代码如下：

[cpp] view plain copy
 
  1. ////CUDAtest.cu  
  2.   
  3. #include "cuda_runtime.h"    
  4. #include "device_launch_parameters.h"  
  5.   
  6. #define TILE_WIDTH 16  
  7.   
  8. // 核函数  
  9. // __global__ static void MatrixMulKernel(const float* Md,const float* Nd,float* Pd,int Width)  
  10. __global__ void MatrixMulKernel(const float* Md, const float* Nd, float* Pd, int Width)  
  11. {  
  12.     //计算Pd和Md中元素的行索引  
  13.     int Row = blockIdx.y * TILE_WIDTH + threadIdx.y; //行  
  14.     int Col = blockIdx.x * TILE_WIDTH + threadIdx.x; //列  
  15.   
  16.     float Pvalue = 0.0;  
  17.     for (int k = 0; k < Width; k++)  
  18.     {  
  19.         Pvalue += Md[Row * Width + k] * Nd[k * Width + Col];  
  20.     }  
  21.     //每个线程负责计算P中的一个元素  
  22.     Pd[Row * Width + Col] = Pvalue;  
  23. }  
  24.   
  25. // 矩阵乘法(CUDA中)  
  26. // 在外部调用，使用extern  
  27. extern "C" void MatrixMultiplication_CUDA(const float* M, const float* N, float* P, int Width)  
  28. {  
  29.     cudaSetDevice(0);  //设置目标GPU   
  30.   
  31.     float *Md, *Nd, *Pd;  
  32.     int size = Width * Width * sizeof(float);//字节长度  
  33.   
  34.     cudaMalloc((void**)&Md, size);  
  35.     cudaMalloc((void**)&Nd, size);  
  36.     cudaMalloc((void**)&Pd, size);  
  37.   
  38.     //Copies a matrix from the memory* area pointed to by src to the memory area pointed to by dst  
  39.     cudaMemcpy(Md, M, size, cudaMemcpyHostToDevice);  
  40.     cudaMemcpy(Nd, N, size, cudaMemcpyHostToDevice);  
  41.   
  42.     //  
  43.     dim3 dimGrid(Width / TILE_WIDTH, Width / TILE_WIDTH);   //网格的维度  
  44.     dim3 dimBlock(TILE_WIDTH, TILE_WIDTH);                  //块的维度  
  45.     MatrixMulKernel <<< dimGrid, dimBlock >>>(Md, Nd, Pd, Width);  
  46.   
  47.     cudaMemcpy(P, Pd, size, cudaMemcpyDeviceToHost);  
  48.     //释放设备上的矩阵  
  49.     cudaFree(Md);  
  50.     cudaFree(Nd);  
  51.     cudaFree(Pd);  
  52. }  


接下来就是第三方库的链接了，首先呢，你得右击项目，打开项目属性

分别在可执行文件目录下输入：C:Program FilesNVIDIA GPU Computing ToolkitCUDAv8.0in

在包含目录下输入：C:Program FilesNVIDIA GPU Computing ToolkitCUDAv8.0include

在库目录下输入：C:Program FilesNVIDIA GPU Computing ToolkitCUDAv8.0libWin32

之后在链接器/输入/附加依赖项中输入：C:Program FilesNVIDIA GPU Computing ToolkitCUDAv8.0libWin32目录下的所有lib文件的文件名

这时，如果你急于立马编译的话，你就会发现报错了：大致的意思是extern修饰的函数被应用，无法解析的外部命令

因为这时其实编译器没有编译cu文件，所以cpp文件中无法引用cu文件里的函数。

最关键的一步来了：

右击项目，点击生成依赖 项，选择“生成自定义”，然后勾选cuda


之后右击test.cu文件打开属性，修改“项目类型”如下：


大功告成，愉快的调试吧

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/lyx2018/p/7840325.html