初学遇到疑问

Ck_Zheng

我搭建了一个平台后在github上找了个例子试运行运行不了，我已经加载了cublas和cusparse这两个需要加载的库了.希望有人可以帮忙解答问题，因为我附近的人没人学过这个

我在这个网站上找到的代码想去跑跑，这个代码应该在linux系统中编写的

1. #include <cuda_runtime.h>
   
2. #include <stdio.h>
   
3. #include "cusparse.h"
   
4. #include "cublas_v2.h"
   
5. #include <time.h>
   
6. #ifdef _WIN32
   
7. #include <windows.h>
   
8. #else
   
9. #include <sys/time.h>
   
10. #endif
    
11. 
    
12. #define CLEANUP(s){\
    
13.         printf("%s\n", s);\
    
14.         if(h_valA) free(h_valA);\
    
15.         if(h_csrRowPtrA) free(h_csrRowPtrA);\
    
16.         if(h_csrColIndA) free(h_csrColIndA);\
    
17.         if(valA) cudaFree(valA);\
    
18.         if(csrRowPtrA) cudaFree(csrRowPtrA);\
    
19.         if(csrColIndA) cudaFree(csrColIndA);\
    
20.         if(h_b) free(h_b);\
    
21.         if(b) cudaFree(b);\
    
22.         if(r) cudaFree(r);\
    
23.         if(p) cudaFree(p);\
    
24.         if(Ap) cudaFree(Ap);\
    
25.         if(h_x) free(h_x);\
    
26.         if(x) cudaFree(x);\
    
27.         if(handle1) cublasDestroy(handle1);\
    
28.         if(descrA) cusparseDestroyMatDescr(descrA);\
    
29.         if(handle2) cusparseDestroy(handle2);\
    
30.         cudaDeviceReset();\
    
31. }
    
32. 
    
33. //用于统计程序时间
    
34. double cpuSecond(){
    
35.         struct timeval tp;
    
36.         gettimeofday(&tp, NULL);
    
37.         return ((double)tp.tv_sec + (double)tp.tv_usec * 1e-6);
    
38. }
    
39. 
    
40. int main(){
    
41.         //initialization
    
42.         cudaError_t cudaStat1, cudaStat2, cudaStat3;       
    
43. 
    
44.         double* h_valA = 0;
    
45.         int* h_csrRowPtrA = 0;
    
46.         int* h_csrColIndA = 0;
    
47.         double* valA = 0;
    
48.         int* csrRowPtrA = 0;
    
49.         int* csrColIndA = 0;
    
50.         double* h_b = 0;
    
51.         double* b = 0;
    
52.         double* r = 0;
    
53.         double* p = 0;
    
54.         double* Ap = 0;
    
55.         double* h_x = 0;
    
56.         double* x = 0;
    
57. 
    
58.         cublasStatus_t status1;
    
59.         cublasHandle_t handle1 = 0;
    
60.         cusparseStatus_t status2;
    
61.         cusparseHandle_t handle2 = 0;
    
62.         cusparseMatDescr_t descrA = 0;
    
63. 
    
64.         int n, nnz;
    
65.         double dzero = 0.0;
    
66.         double done = 1.0;
    
67.         /*
    
68.         use CG to solve following linear system:
    
69.                 Ax = b;
    
70.                 A = |3 0 2|
    
71.                         |0 2 0|
    
72.                         |2 0 1|
    
73.                 b = |3.5|
    
74.                         |1.5|
    
75.                         |2.0|
    
76.         correct result x:
    
77.                 x = |0.50|
    
78.                         |0.75|
    
79.                         |1.00|
    
80.            */
    
81.         n = 3;
    
82.         nnz = 5;
    
83.         //which device(gpu) to use
    
84.         cudaStat1 = cudaSetDevice(0);
    
85.         if(cudaStat1 != cudaSuccess){
    
86.                 CLEANUP("Device Set failed");
    
87.                 return EXIT_FAILURE;
    
88.         }
    
89. 
    
90.         //matrix A(csr format) in host
    
91.         h_valA = (double*)malloc(nnz*sizeof(double));
    
92.         h_csrRowPtrA = (int*)malloc((n+1)*sizeof(int));
    
93.         h_csrColIndA = (int*)malloc(nnz*sizeof(int));
    
94.         if(!h_valA||!h_csrRowPtrA||!h_csrColIndA){
    
95.                 CLEANUP("Host malloc failed(A)");
    
96.                 return EXIT_FAILURE;
    
97.         }
    
98. 
    
99.         h_valA[0] = 3.0;
    
100.         h_valA[1] = 2.0;
     
101.         h_valA[2] = 2.0;
     
102.         h_valA[3] = 2.0;
     
103.         h_valA[4] = 1.0;
     
104.        
     
105.         h_csrRowPtrA[0] = 0;
     
106.         h_csrRowPtrA[1] = 2;
     
107.         h_csrRowPtrA[2] = 3;
     
108.         h_csrRowPtrA[3] = 5;
     
109.        
     
110.         h_csrColIndA[0] = 0;
     
111.         h_csrColIndA[1] = 2;
     
112.         h_csrColIndA[2] = 1;
     
113.         h_csrColIndA[3] = 0;
     
114.         h_csrColIndA[4] = 2;
     
115. 
     
116.         //matrix A(csr format) in device
     
117.         cudaStat1 = cudaMalloc((void**)&valA, nnz*sizeof(double));
     
118.         cudaStat2 = cudaMalloc((void**)&csrRowPtrA, (n+1)*sizeof(int));
     
119.         cudaStat3 = cudaMalloc((void**)&csrColIndA, nnz*sizeof(int));
     
120.         if(cudaStat1 != cudaSuccess || cudaStat2 != cudaSuccess || cudaStat3 != cudaSuccess){
     
121.                 CLEANUP("device malloc failed(A)");
     
122.                 return EXIT_FAILURE;
     
123.         }
     
124.         cudaStat1 = cudaMemcpy(valA, h_valA, (size_t)(nnz*sizeof(double)), cudaMemcpyHostToDevice);
     
125.         cudaStat2 = cudaMemcpy(csrRowPtrA, h_csrRowPtrA, (size_t)((n+1)*sizeof(int)), cudaMemcpyHostToDevice);
     
126.         cudaStat3 = cudaMemcpy(csrColIndA, h_csrColIndA, (size_t)(nnz*sizeof(int)), cudaMemcpyHostToDevice);
     
127.         if(cudaStat1 != cudaSuccess || cudaStat2 != cudaSuccess || cudaStat3 != cudaSuccess){
     
128.                 CLEANUP("memcpy from host to device failed(A)");
     
129.                 return EXIT_FAILURE;
     
130.         }
     
131. 
     
132.         //vector b in host
     
133.         h_b = (double*)malloc(n*sizeof(double));
     
134.         h_b[0] = 3.5;
     
135.         h_b[1] = 1.5;
     
136.         h_b[2] = 2.0;
     
137. 
     
138.         //vector b in device
     
139.         cudaStat1 = cudaMalloc((void**)&b, n*sizeof(double));
     
140.         if(cudaStat1 != cudaSuccess){
     
141.                 CLEANUP("device malloc failed(b)");
     
142.                 return EXIT_FAILURE;
     
143.         }
     
144.         cudaStat1 = cudaMemcpy(b, h_b, (size_t)(n*sizeof(double)), cudaMemcpyHostToDevice);
     
145.         if(cudaStat1 != cudaSuccess){
     
146.                 CLEANUP("memcpy from host to device failed(b)");
     
147.                 return EXIT_FAILURE;
     
148.         }
     
149. 
     
150.         //vector r in device
     
151.         cudaStat1 = cudaMalloc((void**)&r, n*sizeof(double));
     
152.         if(cudaStat1 != cudaSuccess){
     
153.                 CLEANUP("device malloc failed(r)");
     
154.                 return EXIT_FAILURE;
     
155.         }
     
156. 
     
157.         //vector p in device
     
158.         cudaStat1 = cudaMalloc((void**)&p, n*sizeof(double));
     
159.         if(cudaStat1 != cudaSuccess){
     
160.                 CLEANUP("device malloc failed(p)");
     
161.                 return EXIT_FAILURE;
     
162.         }
     
163. 
     
164.         //vector Ap in device
     
165.         cudaStat1 = cudaMalloc((void**)&Ap, n*sizeof(double));
     
166.         if(cudaStat1 != cudaSuccess){
     
167.                 CLEANUP("device malloc failed(Ap)");
     
168.                 return EXIT_FAILURE;
     
169.         }
     
170. 
     
171.         //vector x in host
     
172.         h_x = (double*)malloc(n*sizeof(double));
     
173.         for(int i=0; i<n; ++i)
     
174.                 h_x[i] = 0.0;
     
175. 
     
176.         //vector x in device
     
177.         cudaStat1 = cudaMalloc((void**)&x, n*sizeof(double));
     
178.         if(cudaStat1 != cudaSuccess){
     
179.                 CLEANUP("device malloc faile(x)");
     
180.                 return EXIT_FAILURE;
     
181.         }
     
182.         cudaStat1 = cudaMemcpy(x, h_x, (size_t)(n*sizeof(double)), cudaMemcpyHostToDevice);
     
183.         if(cudaStat1 != cudaSuccess){
     
184.                 CLEANUP("memcpy from host to device failed(x)");
     
185.                 return EXIT_FAILURE;
     
186.         }
     
187. 
     
188.         //initialize cublas library
     
189.         status1 = cublasCreate(&handle1);
     
190.         if(status1 != CUBLAS_STATUS_SUCCESS){
     
191.                 CLEANUP("CUBLAS initialize failed");
     
192.                 return EXIT_FAILURE;
     
193.         }
     
194.         //initialize cusparse library
     
195.         status2 = cusparseCreate(&handle2);
     
196.         if(status2 != CUSPARSE_STATUS_SUCCESS){
     
197.                 CLEANUP("CUSPARSE Library initialize failed");
     
198.                 return EXIT_FAILURE;
     
199.         }
     
200.         //initialize matrix descriptor
     
201.         status2 = cusparseCreateMatDescr(&descrA);
     
202.         if(status2 != CUSPARSE_STATUS_SUCCESS){
     
203.                 CLEANUP("Matrix descriptor initialize failed");
     
204.                 return EXIT_FAILURE;
     
205.         }
     
206.         cusparseSetMatType(descrA, CUSPARSE_MATRIX_TYPE_GENERAL);
     
207.         cusparseSetMatIndexBase(descrA, CUSPARSE_INDEX_BASE_ZERO);
     
208. 
     
209. 
     
210.         //CG
     
211.         //1:
     
212.         //max iteration number = 2000
     
213.         //relative residual = 1e-7
     
214.         //compute initial residual r = b - Ax_0
     
215.         //x_0 = |0|
     
216.         //                |0|
     
217.         //                |0|
     
218.         //initial p = r
     
219.         int maxit = 2000;
     
220.         double tol = 1e-7;
     
221.         double alpha, beta, rhop, rho;
     
222.         //r = b
     
223.         status1 = cublasDcopy(handle1, n, b, 1, r, 1);
     
224.         if(status1 != CUBLAS_STATUS_SUCCESS){
     
225.                 CLEANUP("Vector copy failed(r)");
     
226.                 return EXIT_FAILURE;
     
227.         }
     
228.         //p = b
     
229.         status1 = cublasDcopy(handle1, n, b, 1, p, 1);
     
230.         if(status1 != CUBLAS_STATUS_SUCCESS){
     
231.                 CLEANUP("Vector copy failed(p)");
     
232.                 return EXIT_FAILURE;
     
233.         }
     
234.         status1 = cublasDnrm2(handle1, n, r, 1, &rho);
     
235.         if(status1 != CUBLAS_STATUS_SUCCESS){
     
236.                 CLEANUP("compute norm2 failed(r)");
     
237.                 return EXIT_FAILURE;
     
238.         }
     
239.         rho = rho*rho;
     
240. 
     
241.         //2: repeat until convergence
     
242.         for(int i=0; i<maxit; ++i){
     
243.                 status2 = cusparseDcsrmv(handle2, CUSPARSE_OPERATION_NON_TRANSPOSE, n, n, nnz, &done,
     
244.                                                                         descrA, valA, csrRowPtrA, csrColIndA, p, &dzero, Ap);
     
245.                 if(status2 != CUSPARSE_STATUS_SUCCESS){
     
246.                         CLEANUP("compute mv failed(Ap)");
     
247.                         return EXIT_FAILURE;
     
248.                 }
     
249.                 double tmp;
     
250.                 status1 = cublasDdot(handle1, n, p, 1, Ap, 1, &tmp);
     
251.                 if(status1 != CUBLAS_STATUS_SUCCESS){
     
252.                         CLEANUP("compute dot failed(tmp)");
     
253.                         return EXIT_FAILURE;
     
254.                 }
     
255.                 //alpha = (r^T*r)/(p^T*A*p)
     
256.                 alpha = rho/tmp;
     
257.                 //x = x + alpha*p
     
258.                 status1 = cublasDaxpy(handle1, n, &alpha, p, 1, x, 1);
     
259.                 if(status1 != CUBLAS_STATUS_SUCCESS){
     
260.                         CLEANUP("compute axpy failed(x)");
     
261.                         return EXIT_FAILURE;
     
262.                 }
     
263.                 double tmp2 = -alpha;
     
264.                 //r = r - alpha*A*p
     
265.                 status1 = cublasDaxpy(handle1, n, &tmp2, Ap, 1, r, 1);
     
266.                 if(status1 != CUBLAS_STATUS_SUCCESS){
     
267.                         CLEANUP("compute axpy failed(r)");
     
268.                         return EXIT_FAILURE;
     
269.                 }
     
270. 
     
271.                 rhop = rho;
     
272.                 status1 = cublasDnrm2(handle1, n, r, 1, &rho);
     
273.                 if(status1 != CUBLAS_STATUS_SUCCESS){
     
274.                         CLEANUP("compute norm2 failed(r)");
     
275.                         return EXIT_FAILURE;
     
276.                 }
     
277.                 if(rho < tol){
     
278.                         break;
     
279.                 }
     
280.                 rho = rho*rho;
     
281.                
     
282.                 //beta = rho/rhop
     
283.                 beta = rho/rhop;
     
284.                
     
285.                 //p = r + beta*p
     
286.                 status1 = cublasDscal(handle1, n, &beta, p, 1);
     
287.                 if(status1 != CUBLAS_STATUS_SUCCESS){
     
288.                         CLEANUP("compute scal failed(p)");
     
289.                         return EXIT_FAILURE;
     
290.                 }
     
291.                 status1 = cublasDaxpy(handle1, n, &done, r, 1, p, 1);
     
292.                 if(status1 != CUBLAS_STATUS_SUCCESS){
     
293.                         CLEANUP("compute axpy failed(p)");
     
294.                         return EXIT_FAILURE;
     
295.                 }
     
296.         }
     
297.        
     
298.         //copy x to h_x, and output h_x
     
299.         cudaStat1 = cudaMemcpy(h_x, x, (size_t)(n*sizeof(double)), cudaMemcpyDeviceToHost);
     
300.         if(cudaStat1 != cudaSuccess){
     
301.                 CLEANUP("memcpy from device to host failed(x)");
     
302.                 return EXIT_FAILURE;
     
303.         }
     
304.         for(int i=0; i<n; ++i)
     
305.                 printf("%f\n", h_x[i]);
     
306. 
     
307.         CLEANUP("Success!");
     
308.         return 0;
     
309. }

复制代码