CUDA多个流的使用

CUDA中使用多个流并行执行数据复制和核函数运算可以进一步提高计算性能。以下程序使用2个流执行运算：

[cpp]  view plain  copy

1. #include "cuda_runtime.h"      
2. #include <iostream>    
3. #include <stdio.h>      
4. #include <math.h>      
5.   
6. #define N (1024*1024)      
7. #define FULL_DATA_SIZE N*20      
8.   
9. __global__ void kernel(int* a, int *b, int*c)  
10. {  
11.     int threadID = blockIdx.x * blockDim.x + threadIdx.x;  
12.   
13.     if (threadID < N)  
14.     {  
15.         c[threadID] = (a[threadID] + b[threadID]) / 2;  
16.     }  
17. }  
18.   
19. int main()  
20. {  
21.     //获取设备属性    
22.     cudaDeviceProp prop;  
23.     int deviceID;  
24.     cudaGetDevice(&deviceID);  
25.     cudaGetDeviceProperties(&prop, deviceID);  
26.   
27.     //检查设备是否支持重叠功能    
28.     if (!prop.deviceOverlap)  
29.     {  
30.         printf("No device will handle overlaps. so no speed up from stream.\n");  
31.         return 0;  
32.     }  
33.   
34.     //启动计时器    
35.     cudaEvent_t start, stop;  
36.     float elapsedTime;  
37.     cudaEventCreate(&start);  
38.     cudaEventCreate(&stop);  
39.     cudaEventRecord(start, 0);  
40.   
41.     //创建两个CUDA流    
42.     cudaStream_t stream, stream1;  
43.     cudaStreamCreate(&stream);  
44.     cudaStreamCreate(&stream1);  
45.   
46.     int *host_a, *host_b, *host_c;  
47.     int *dev_a, *dev_b, *dev_c;  
48.     int *dev_a1, *dev_b1, *dev_c1;  
49.   
50.     //在GPU上分配内存    
51.     cudaMalloc((void**)&dev_a, N * sizeof(int));  
52.     cudaMalloc((void**)&dev_b, N * sizeof(int));  
53.     cudaMalloc((void**)&dev_c, N * sizeof(int));  
54.   
55.     cudaMalloc((void**)&dev_a1, N * sizeof(int));  
56.     cudaMalloc((void**)&dev_b1, N * sizeof(int));  
57.     cudaMalloc((void**)&dev_c1, N * sizeof(int));  
58.   
59.     //在CPU上分配页锁定内存    
60.     cudaHostAlloc((void**)&host_a, FULL_DATA_SIZE * sizeof(int), cudaHostAllocDefault);  
61.     cudaHostAlloc((void**)&host_b, FULL_DATA_SIZE * sizeof(int), cudaHostAllocDefault);  
62.     cudaHostAlloc((void**)&host_c, FULL_DATA_SIZE * sizeof(int), cudaHostAllocDefault);  
63.   
64.     //主机上的内存赋值    
65.     for (int i = 0; i < FULL_DATA_SIZE; i++)  
66.     {  
67.         host_a[i] = i;  
68.         host_b[i] = FULL_DATA_SIZE - i;  
69.     }  
70.   
71.     for (int i = 0; i < FULL_DATA_SIZE; i += 2 * N)  
72.     {  
73.         cudaMemcpyAsync(dev_a, host_a + i, N * sizeof(int), cudaMemcpyHostToDevice, stream);  
74.         cudaMemcpyAsync(dev_b, host_b + i, N * sizeof(int), cudaMemcpyHostToDevice, stream);  
75.   
76.         cudaMemcpyAsync(dev_a1, host_a + i + N, N * sizeof(int), cudaMemcpyHostToDevice, stream1);  
77.         cudaMemcpyAsync(dev_b1, host_b + i + N, N * sizeof(int), cudaMemcpyHostToDevice, stream1);  
78.   
79.         kernel << <N / 1024, 1024, 0, stream >> > (dev_a, dev_b, dev_c);  
80.         kernel << <N / 1024, 1024, 0, stream1 >> > (dev_a, dev_b, dev_c1);  
81.   
82.         cudaMemcpyAsync(host_c + i, dev_c, N * sizeof(int), cudaMemcpyDeviceToHost, stream);  
83.         cudaMemcpyAsync(host_c + i + N, dev_c1, N * sizeof(int), cudaMemcpyDeviceToHost, stream1);  
84.     }  
85.   
86.     // 等待Stream流执行完成  
87.     cudaStreamSynchronize(stream);  
88.     cudaStreamSynchronize(stream1);  
89.   
90.     cudaEventRecord(stop, 0);  
91.     cudaEventSynchronize(stop);  
92.     cudaEventElapsedTime(&elapsedTime, start, stop);  
93.   
94.     std::cout << "消耗时间： " << elapsedTime << std::endl;  
95.   
96.     //输出前10个结果    
97.     for (int i = 0; i < 10; i++)  
98.     {  
99.         std::cout << host_c[i] << std::endl;  
100.     }  
101.   
102.     getchar();  
103.   
104.     // free stream and mem      
105.     cudaFreeHost(host_a);  
106.     cudaFreeHost(host_b);  
107.     cudaFreeHost(host_c);  
108.   
109.     cudaFree(dev_a);  
110.     cudaFree(dev_b);  
111.     cudaFree(dev_c);  
112.   
113.     cudaFree(dev_a1);  
114.     cudaFree(dev_b1);  
115.     cudaFree(dev_c1);  
116.   
117.     cudaStreamDestroy(stream);  
118.     cudaStreamDestroy(stream1);  
119.     return 0;  
120. }  

使用2个流，执行时间16ms，基本上是使用一个流消耗时间的二分之一。