CUDA编程-趣味小竞赛（获奖名单公布4月2日）

滑翔的蜗牛

关注一下

baopbird2005

支持一下，

joint

不会CUDA，

CUDA怎么跟BEOWULF一起运行呢？

starfuck

滚

starfuck

滚

renqingwei123

看看，并行算法。

joiky

大牛哪去了~~~

chianshin

有没有cuda入门帖啊？

Posix_man

呵呵，很少人参与啊！

我来玩玩。希望能抛砖引玉。

可惜没n家的卡，也懒得装驱动和环境，所以麻烦哪位有此环境的兄弟或姐妹，帮我把代码编译运行一次，看看有什么错误。

cuda的资料只看了一点，所以先做题目一。

1. #include <iostream>
   
2. #include <string>
   
3. #include <time.h>
   
4. 
   
5. typedef struct {
   
6. int width;
   
7. int height;
   
8. float* elements;
   
9. } myMatrix;
   
10. 
    
11. // for single device
    
12. int activeDevice=-1;
    
13. int maxBlockSize=0;
    
14. 
    
15. //for mulit device
    
16. int deviceCount=-1;
    
17. int gpuCount=0;
    
18. int blockSize=0;
    
19. 
    
20. // Forward declaration of the matrix multiplication kernel
    
21. __global__ void MatMulKernel(const Matrix, const Matrix, Matrix);
    
22. // Matrix multiplication - Host code
    
23. // Matrix dimensions are assumed to be multiples of BLOCK_SIZE
    
24. 
    
25. int main(){
    
26.        
    
27.         //iniatlize.....
    
28.         cudaDeviceProp deviceProp;
    
29.         cudaGetDeviceCount(&deviceCount);
    
30.         for (int device = 0; device < deviceCount; ++device) {               
    
31.                 cudaGetDeviceProperties(&deviceProp, device);
    
32.                 if ((device == 0)&&(deviceProp.major == 9999) &&( deviceProp.minor == 9999)){
    
33.                                 std::cout<<"There is no device supporting CUDA. See you!\n";
    
34.                                 return -1;
    
35.                 }
    
36.                 if(deviceProp.computeMode == cudaComputeModeDefault)
    
37.                         activeDevice=device;
    
38.                 else{
    
39.                         if(cudaSetDevice(device) == cudaErrorSetOnAcitveProcess)
    
40.                                 continue;
    
41.                 }
    
42. 
    
43.                 gpuCount += deviceProp.multiProcessorCount;
    
44.                 if (blockSize==0)
    
45.                         blockSize= deviceProp.maxThreadsPerBlock;
    
46.                 else
    
47.                         blockSize = deviceProp.maxThreadsPerBlock < blockSize ? deviceProp.maxThreadsPerBlock : blockSize;
    
48. 
    
49.                 activeDevice = deviceProp.maxThreadsPerBlock > maxBlockSize ? device : activeDevice;
    
50.                 maxBlockSize = deviceProp.maxThreadsPerBlock > maxBlockSize ? deviceProp.maxThreadsPerBlock : maxBlockSize;
    
51.                
    
52.         }
    
53. 
    
54.         if(activeDevice == -1){
    
55.                 std::cout << "There is no available CUDA device. See you!\n";
    
56.                 return -1;
    
57.         }
    
58. 
    
59.         //set the device on
    
60.         if(cudaSetDevice(activeDevice) == cudaErrorSetOnAcitveProcess){
    
61.                 std::cout << "There is no available CUDA device. See you!\n";
    
62.                 return -1;
    
63.         }
    
64.                
    
65.         //get inputs of matrix A and B.
    
66.         myMatrix mA,mB,mC;
    
67.         std::cout <<"\n\tPlease input the width of matrix A !";
    
68.         std::cin >> mA.width;
    
69.         std::cout <<"\n\tPlease input the height of matrix A !";
    
70.         std::cin >> mA.height;
    
71.         mA.elements= new float[mA.width * mA.height];
    
72. 
    
73.         for(int i=0;i < mA.width;i++){
    
74.                 for(int j=0; j < mA.height;j++){
    
75.                         std::cout<< "\nPlease input Matrix A ["<< i <<"][" << j << "] :";
    
76.                         std::cin >> mA.elements[i][j];
    
77.                 }
    
78.         }
    
79.     std::cout<<"Matrix A is done!\n";
    
80. 
    
81.         std::cout <<"\n\tPlease input the width of matrix B !";
    
82.         std::cin >> mB.width;
    
83.         std::cout <<"\n\tPlease input the height of matrix B !";
    
84.         std::cin >> mB.height;
    
85.         mB.elements= new float[mB.width * mB.height];
    
86. 
    
87.         for(int i=0;i < mB.width;i++){
    
88.                 for(int j=0; j < mB.height;j++){
    
89.                         std::cout<< "\nPlease input Matrix B ["<< i <<"][" << j << "] :";
    
90.                         std::cin >> mB.elements[i][j];
    
91.                 }
    
92.         }
    
93.     std::cout<<"Matrix B is done!\n";
    
94. 
    
95.         mC.width=mB.width;
    
96.         mC.height=mA.height;
    
97.         mC.elements= new float[mC.width * mC.height];
    
98. 
    
99.         clock_t t1=clock();
    
100.         MatrixMul4OneDev(mA,mB,mC);
     
101.        
     
102.         std::cout<<"This matrix is done in "<< clock()-t1 <<" ticks!\n";
     
103. 
     
104.         for(int i=0;i< mC.width * mC.height;i++){
     
105.                 if(i % mC.width ==0 )
     
106.                 std::cout << "\n";
     
107.                 std::cout << mC.elements[i] << " ";
     
108.         }
     
109. 
     
110.         delete [] mA.elements;
     
111.         delete [] mB.elements;
     
112.         delete [] mC.elements;
     
113.         return mC.width * mC. height;
     
114. }
     
115. 
     
116. void MatrixMul4OneDev(const myMatrix& A, const myMatrix& B, myMatrix& C)
     
117. {
     
118.         Matrix d_A;
     
119.         d_A.width = A.width; d_A.height = A.height;
     
120.         size_t size = A.width * A.height * sizeof(float);
     
121.         cudaMalloc((void**)&d_A.elements, size);
     
122.         cudaMemcpy(d_A.elements, A.elements, size,cudaMemcpyHostToDevice);
     
123.        
     
124.         Matrix d_B;
     
125.         d_B.width = B.width; d_B.height = B.height;
     
126.         size = B.width * B.height * sizeof(float);
     
127.         cudaMalloc((void**)&d_B.elements, size);
     
128.         cudaMemcpy(d_B.elements, B.elements, size,cudaMemcpyHostToDevice);
     
129.        
     
130.         Matrix d_C;
     
131.         d_C.width = C.width; d_C.height = C.height;
     
132.         size = C.width * C.height * sizeof(float);
     
133.         cudaMalloc((void**)&d_C.elements, size);
     
134. 
     
135.     dim3 dimBlock(maxBlockSize/2,maxBlockSize/2);
     
136.         dim3 dimGrid(B.width / dimBlock.x, A.height / dimBlock.y);
     
137.         MatMulKernel<<<dimGrid, dimBlock>>>(d_A, d_B, d_C);
     
138.         // Read C from device memory
     
139.         cudaMemcpy(C.elements, Cd.elements, size,cudaMemcpyDeviceToHost);
     
140.         // Free device memory
     
141.         cudaFree(d_A.elements);
     
142.         cudaFree(d_B.elements);
     
143.         cudaFree(d_C.elements);
     
144. }
     
145. 
     
146. __global__ void MatMulKernel(myMatrix A, myMatrix B, myMatrix C)
     
147. {
     
148.     float Cvalue = 0;
     
149.         int row = blockIdx.y * blockDim.y + threadIdx.y;
     
150.         int col = blockIdx.x * blockDim.x + threadIdx.x;
     
151.         for (int e = 0; e < A.width; ++e)
     
152.                 Cvalue += A.elements[row * A.width + e]* B.elements[e * B.width + col];
     
153.         C.elements[row * C.width + col] = Cvalue;
     
154. }
     

复制代码