【CUDA并行编程之五】计算向量的欧式距离

墨蓝 2022-08-01 12:17 270阅读 0赞

本文将介绍如何用cuda来计算两个向量之间的欧式距离，其中涉及到了如果将二维矩阵传入到核函数进行计算的问题，并且介绍两个内存分配和拷贝的API：cudaMallocPitch以及cudaMemcpy2D。

**一、需求分析**

现在我们要解决这么一个问题：计算一个D维的向量A\[D\]到二维矩阵B\[N\]\[D\]的每一行的[欧式距离][Link 1]，并且将每一组距离保存在一个向量dis\[N\]中并返回。我们还是通过串行和并行两种方式来进行实现。

**二、串行实现**

实现方法就是用一个二重循环进行相乘，然后将结果保存。上代码：

**dis\_cal\_sequence.cc:**

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#include<iostream>                                                                                                         
2.  \#include<stdio.h>  
3.  \#include<stdlib.h>  
4.  \#include<time.h>  
5.    
6.  **using** **namespace** std;  
7.    
8.  **const** **int** N = 100;  
9.  **const** **int** D = 8;  
10. **const** **int** MAX = 10;  
11.   
12. **void** cal\_dis(**int** \*\*train\_data, **int** \*test\_data, **int** \*dis)  
13. \{  
14.     **for**(**int** k=0;k<N;k++)  
15.     \{  
16.         **int** sum = 0;  
17.         **int** temp = 0;  
18.         **for**(**int** i=0;i<D;i++)  
19.         \{  
20.             temp =  \*(\*(train\_data+k)+i) - test\_data\[i\];  
21.             sum += temp \* temp;  
22.         \}  
23.         dis\[k\] = sum;  
24.     \}  
25. \}  
26.   
27. **void** print(**int** \*\*data)  
28. \{  
29.     cout<<"training data:"<<endl;  
30.     **for**(**int** i=0;i<N;i++)  
31.     \{  
32.         **for**(**int** j=0;j<D;j++)  
33.         \{  
34.             cout<<\*(\*(data+i)+j)<<" ";        
35.         \}  
36.         cout<<endl;  
37.     \}  
38. \}  
39.   
40. **void** print(**int** \*data,**int** n)  
41. \{  
42.     **for**(**int** i=0;i<n;i++)  
43.     \{  
44.         cout<<data\[i\]<<" ";  
45.     \}  
46.     cout<<endl;  
47. \}  
48.   
49. **int** main()  
50. \{  
51.     **int** \*\*h\_train\_data , \*h\_test\_data , \*distance;  
52.       
53.     //allocate space in heap for the variable  
54.     h\_train\_data = **new** **int**\*\[N\];  
55.     **for**(**int** i=0;i<N;i++)  
56.     \{  
57.         h\_train\_data\[i\] = **new** **int**\[D\];  
58.     \}  
59.     h\_test\_data = **new** **int**\[D\];  
60.     distance = **new** **int**\[N\];  
61.   
62.     //initialize training data  
63.     srand( (unsigned)time(NULL) );  
64.     **for**( **int** i=0;i<N;i++ )  
65.     \{  
66.         **for**( **int** j=0;j<D;j++)  
67.         \{  
68.             h\_train\_data\[i\]\[j\] = rand()%MAX;  
69.         \}  
70.     \}  
71.     print(h\_train\_data);  
72.   
73.     //initialize testing data  
74.     **for**( **int** j=0;j<D;j++ )  
75.     \{  
76.         h\_test\_data\[j\] = rand() % MAX;  
77.     \}  
78.     cout<<"testing data:"<<endl;  
79.     print(h\_test\_data,D);  
80.   
81.     //calculate the distance  
82.     cal\_dis( h\_train\_data,h\_test\_data,distance );  
83.   
84.     cout<<"distance data:"<<endl;  
85.     print(distance,N);  
86.   
87.     **return** 0;  
88. \}

结果：

**![SouthEast][]**

代码没有什么太多值得将的，主要讲一下C/C++中二维矩阵的传参问题。还是做一个总结吧。

**对于静态数组：**

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **void** fun( **int** array\[\]\[D\])// OK  
2.  **void** fun( **int** (\*array)\[D\])//OK  
3.  **void** fun( **int** \*\*array) //error  
4.    
5.  **int** main()  
6.  \{  
7.      **int** A\[N\]\[D\];  
8.      fun(A);  
9.  \}

对于动态数组：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **void** fun( **int** array\[\]\[D\])// Error  
2.  **void** fun( **int** (\*array)\[D\])//Error  
3.  **void** fun( **int** \*\*array) //OK  
4.    
5.  **int** main()  
6.  \{  
7.      **int** \*\*A;  
8.      A = **new** **int**\*\[N\];  
9.      **for**(**int** i=0;i<N;i++)  
10.         A\[i\] = **new** **int**\[D\];  
11.     fun(A);  
12. \}

当然在函数内部两种访问数组的方式都可以：array\[i\]\[j\]和\*( \*(array+i) + j)。

**空间复杂度O(N\*D)，时间复杂度O(N\*D)。**

**三、向CUDA内核中传递二位向量**

在介绍代码之前首先将一个如何将一个二维向量传入到核函数中进行计算的问题，被这个问题困扰很久。我们一般都是将二维矩阵转换成为一维向量进行计算，那么如果我偏偏想用二维向量计算该怎么办呢？（PS：在此吐个槽，国内网站上的技术问答有时候很难找到合适的答案，搜来搜去浪费了很多时间，但是在stackoverflow上搜很快就搜到了~）

在CUDA上分配二维数组还是有点让人困惑的，可能会犯如下两种错误：

**错误一：**

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **int** rowCount = 10;    
2.  **float**\*\* d\_array=0; // array on device    
3.  cudaMalloc(d\_array, rowCount\***sizeof**(**float**\*));    
4.  **for**(**int** i = 0 ; i < rowCount ; i++)    
5.  \{    
6.      //this results in error "Access violation writing location"    
7.      cudaMalloc((**void** \*\*)&d\_array\[i\], (i + 1) \* **sizeof**(**float**)); // column length increases with "i" here    
8.  \}

这里有点类似于二维向量的动态分配过程。这样做的问题是，cudaMalloc在内核里面一次性的获取到内存空间，一旦主线程分配完一维空间，那么就会造成当分配第二维空间的时候会抛出"Access violation writing location"的异常。

**错误二：**

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **int** rowCount = 10;    
2.  **float**\*\* d\_array =(**float**\*\*)malloc(rowCount\***sizeof**(**float**\*)); //malloc 1st dimension    
3.  **for**(**int** i = 0 ; i < rowCount ; i++)    
4.  \{    
5.  cudaMalloc(&d\_array\[i\], (i + 1) \* **sizeof**(**float**)); // cuda malloc 2nd dimension    
6.  \}

这个问题在于一维数组是在主机内存上分配的（使用了malloc），而第二维空间是在设备上分配的（使用了cudaMalloc）。这会导致内存获取失败。

那么如何来解决这个问题？我们使用两个API：cudaMallocPitch&cudaMemcpy2D。

**3.1：cudaMallocPitch()**

**cudaMallocPitch( void\*\*devPtr, size\_t\* pitch ,size\_t widthInBytes , size\_t height)**

**devPtr：**指向矩阵的内存空间的头指针。

**pitch：**分配存储器的宽度，以字节为单位

**width：**分配矩阵的列数

**height：**分配矩阵的行数

在设备上分配widthInBytes \* height字节的线性内存，并返回分配内存的指针\*devPtr。函数将确保在任何给出的行中对应的指针是连续的。pitch返回的指针\*pitch是分配的宽度。Pitch作为内存分配的一个分开的参数，用来计算2D数组中的地址。一个给定行和列的类型T的数组元素，地址等于：

**T\* pElement = (T\*)((char\*)BaseAddress + Row \* pitch) + Column;**

对于2D数组的分配，建议使用cudaMallocPitch()分配内存。由于pitch对列限制受限于硬件，特别是当应用程序从设备内存的不同区域执行一个2D的内存拷贝。

例如：要在GPU上开辟一个行数为height，列数为width的float型矩阵空间。

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **int** width = 64, height = 64;  
2.  **float**\* devPtr;  
3.  **size\_t** pitch;  
4.  cudaMallocPitch((**void**\*\*)&devPtr,&pitch, width \* **sizeof**(**float**), height)

假设GPU中 global memory 被划分为 128 Byte 的段（ 0-127 ， 128-255, 256-383,…… ），你要为内存分配 float型矩阵数据 。假设矩阵的行数为N，列数为M，在C和C++中数据是按行优先存储的。当 N\*4 是 128 倍数的时候(float型数据占4个Byte)，那么用 cudaMalloc 分配出来的内存空间也是对齐的，也就是说你一行分配的字节数刚好是 128 Bytes 的倍数的时候， cudaMalloc() 也是对齐的；

再看另一种情况，N=33，此时33\*4=132，不是128的倍数，当warp从第二行开头（从132开始读，第一行是0到131）读取global memory的时候，首地址并非global memory划分的对齐段的首地址，那么这样的访问就是非合并的，cudaMallocPitch()就是为了解决每行首地址是否是global memory对齐段的问题，如果用cudaMallocPitch()来分配N=33(即列数为33)的矩阵时，每一行大小会变成256个Bytes(0-131为我们需要使用的空间，132-255未使用)，而不是cudaMalloc中的132个Bytes，这样分配以后，每行的首地址将会是与globla memory分段地址对齐的（都是128的整数倍），warp在访问的时候就可以对齐了！

**3.2：cudaMemcpy2D**

**cudaMemcpy2D(void\* dst,size\_t dpitch,const void\* src,size\_t spitch,size\_t width,size\_t height,enum cudaMemcpyKind kind);  
dst: **目的矩阵内存头指针  
**dpitch:** dst指向的2D数组中的内存宽度，以字节为单位，是cuda为了读取方便，  
对齐过的内存宽度，可能大于一行元素占据的实际内存。  
**src：**源矩阵内存头指针  
**spitch: **src指向的2D数组中的内存宽度，以字节为单位  
**width: **src指向的2D数组中一行元素占据的实际宽度。以字节为单位，等于width\*sizeof(type)  
**height:** src指向的2D数组的行数  
**kind：**拷贝数据的方向

从src指向的内存区域拷贝数据到dst指向的内存区域。kind表示拷贝方向：cudaMemcpyHostToHost, cudaMemcpyDeviceToHost, cudaMemcpyHostToDevice,或者cudaMemcpyDeviceToDevice。  
  
  
**四、并行实现**

**方法分析：**并行的情况下让GPU的每一个线程去处理两个一维向量之间的欧式距离，那么当N个线程并行的情况下就能将所有结果计算出来，这样的时间复杂度会降到O(D)。

上代码，**dis\_cal\_parallel.cu**：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#include<iostream>                                                                                                         
2.  \#include<stdio.h>  
3.  \#include<stdlib.h>  
4.  \#include<time.h>  
5.    
6.  **using** **namespace** std;  
7.    
8.  **const** **int** N = 10;  
9.  **const** **int** D = 8;  
10. **const** **int** MAX = 10;  
11.   
12. \_\_global\_\_ **void** cal\_dis(**int** \*train\_data, **int** \*test\_data, **int** \*dis,**int** pitch)  
13. \{  
14.     **int** tid = blockIdx.x;  
15.     **if**(tid<N)  
16.     \{  
17.         **int** temp = 0;  
18.         **int** sum = 0;  
19.         **for**(**int** i=0;i<D;i++)  
20.         \{  
21.             temp = \*((**int**\*)((**char**\*)train\_data + tid \* pitch) + i) - test\_data\[i\];  
22.             sum += temp \* temp;  
23.         \}  
24.         dis\[tid\] = sum;  
25.     \}  
26. \}  
27.   
28. **void** print(**int** data\[\]\[D\])  
29. \{  
30.     cout<<"training data:"<<endl;  
31.     **for**(**int** i=0;i<N;i++)  
32.     \{  
33.         **for**(**int** j=0;j<D;j++)  
34.         \{  
35.             cout<<\*(\*(data+i)+j)<<" ";        
36.         \}  
37.         cout<<endl;  
38.     \}  
39. \}  
40.   
41. **void** print(**int** \*data,**int** n)  
42. \{  
43.     **for**(**int** i=0;i<n;i++)  
44.     \{  
45.         cout<<data\[i\]<<" ";  
46.     \}  
47.     cout<<endl;  
48. \}  
49.   
50. **int** main()  
51. \{  
52.     **int** h\_train\_data\[N\]\[D\] , h\_test\_data\[D\] , distance\[N\];  
53.   
54.     **int** \*d\_train\_data , \*d\_test\_data , \*d\_dis;  
55.   
56.     **size\_t** pitch\_d;  
57.     **size\_t** pitch\_h = D \* **sizeof**(**int**) ;  
58.   
59.     //allocate memory on GPU   
60.     cudaMallocPitch( &d\_train\_data , &pitch\_d , D \* **sizeof**(**float**) , N );   
61.     cudaMalloc( (**void**\*\*)&d\_test\_data ,  D\***sizeof**(**int**) );  
62.     cudaMalloc( (**void**\*\*)&d\_dis ,          N\***sizeof**(**int**) );  
63.   
64.     //initialize training data  
65.     srand( (unsigned)time(NULL) );  
66.     **for**( **int** i=0;i<N;i++ )  
67.     \{  
68.         **for**( **int** j=0;j<D;j++)  
69.         \{  
70.             h\_train\_data\[i\]\[j\] = rand()%MAX;  
71.         \}  
72.     \}  
73.     print(h\_train\_data);  
74.   
75.     //initialize testing data  
76.     **for**( **int** j=0;j<D;j++ )  
77.     \{  
78.         h\_test\_data\[j\] = rand() % MAX;  
79.     \}  
80.     cout<<"testing data:"<<endl;  
81.     print(h\_test\_data,D);  
82.   
83.     //copy training and testing data from host to device  
84.     cudaMemcpy2D( d\_train\_data , pitch\_d , h\_train\_data , pitch\_h , D \* **sizeof**(**int**) , N , cudaMemcpyHostToDevice );  
85.     cudaMemcpy( d\_test\_data,  h\_test\_data ,  D\***sizeof**(**int**), cudaMemcpyHostToDevice);  
86.   
87.     //calculate the distance  
88.     cal\_dis<<<N,1>>>( d\_train\_data,d\_test\_data,d\_dis,pitch\_d );  
89.   
90.     //copy distance data from device to host  
91.     cudaMemcpy( distance , d\_dis  , N\***sizeof**(**int**) , cudaMemcpyDeviceToHost);  
92.   
93.     cout<<"distance:"<<endl;;  
94.     print(distance , N);  
95.   
96.     cudaFree(d\_train\_data);  
97.     cudaFree(d\_test\_data);  
98.     cudaFree(d\_dis);  
99.   
100.     **return** 0;  
101. \}

结果：

**![SouthEast 1][]**

可以看出结果是正确的。

至于计算性能的话就不列出来了，随着计算规模的增大，GPU的计算能力表现的越明显。

在编程实现的过程中出现了一些十分DT的问题，最后还是忍住砸电脑的冲动，把问题解决了，在此记录如下：

①cuda核函数里面似乎不支持double类型，只支持float类型。

②GPU上的显存有限，当数据量比较大的情况下不能够一次性拷贝到显存上，那么就需要将数据进行分片拷贝。

**③在使用cudaMallocPitch和cudaMemcpy2D的时候，host拷贝到device的二维向量一定是静态分配的，也就是说只能使用int A\[N\]\[N\]而不是int \*\*A动态分配的空间进行数据拷贝。在堆上动态分配的内存数据拷贝到显存数据会是乱值，也是醉了。**

参考：

\+CUDA C programming guide

\+[http://blog.sina.com.cn/s/blog\_82a790120101ka1d.html][http_blog.sina.com.cn_s_blog_82a790120101ka1d.html]

\+[http://stackoverflow.com/questions/11149793/sending-2d-array-to-cuda-kernel][http_stackoverflow.com_questions_11149793_sending-2d-array-to-cuda-kernel]

\+[http://stackoverflow.com/questions/5029920/how-to-use-2d-arrays-in-cuda][http_stackoverflow.com_questions_5029920_how-to-use-2d-arrays-in-cuda]

Author：忆之独秀

Email：leaguenew@qq.com

注明出处：[http://blog.csdn.net/lavorange/article/details/42125029][http_blog.csdn.net_lavorange_article_details_42125029]

[Link 1]: http://baike.baidu.com/view/1615257.htm
[view plain]: http://blog.csdn.net/lavorange/article/details/42125029#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/563455
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/563455/fork
[SouthEast]: /images/20220731/f1caecbc7d1d4966870134adf0c4c468.png
[SouthEast 1]: /images/20220731/694fb044eb4b424180dd2ddbaf5cb221.png
[http_blog.sina.com.cn_s_blog_82a790120101ka1d.html]: http://blog.sina.com.cn/s/blog_82a790120101ka1d.html
[http_stackoverflow.com_questions_11149793_sending-2d-array-to-cuda-kernel]: http://stackoverflow.com/questions/11149793/sending-2d-array-to-cuda-kernel
[http_stackoverflow.com_questions_5029920_how-to-use-2d-arrays-in-cuda]: http://stackoverflow.com/questions/5029920/how-to-use-2d-arrays-in-cuda
[http_blog.csdn.net_lavorange_article_details_42125029]: http://blog.csdn.net/lavorange/article/details/42125029