CUDA 6.0 安装及配置( WIN7 64位 / 英伟达G卡 / VS2010 )

  1 /* Includes, system */
  2 #include <stdio.h>
  3 #include <stdlib.h>
  4 #include <string.h>
  5 
  6 /* Includes, cuda */
  7 #include <cuda_runtime.h>
  8 #include <cublas_v2.h>
  9 #include <helper_cuda.h>
 10 
 11 /* Matrix size */
 12 #define N  (275)
 13 
 14 /* Host implementation of a simple version of sgemm */
 15 static void simple_sgemm(int n, float alpha, const float *A, const float *B,
 16                          float beta, float *C)
 17 {
 18     int i;
 19     int j;
 20     int k;
 21 
 22     for (i = 0; i < n; ++i)
 23     {
 24         for (j = 0; j < n; ++j)
 25         {
 26             float prod = 0;
 27 
 28             for (k = 0; k < n; ++k)
 29             {
 30                 prod += A[k * n + i] * B[j * n + k];
 31             }
 32 
 33             C[j * n + i] = alpha * prod + beta * C[j * n + i];
 34         }
 35     }
 36 }
 37 
 38 /* Main */
 39 int main(int argc, char **argv)
 40 {
 41     cublasStatus_t status;
 42     float *h_A;
 43     float *h_B;
 44     float *h_C;
 45     float *h_C_ref;
 46     float *d_A = 0;
 47     float *d_B = 0;
 48     float *d_C = 0;
 49     float alpha = 1.0f;
 50     float beta = 0.0f;
 51     int n2 = N * N;
 52     int i;
 53     float error_norm;
 54     float ref_norm;
 55     float diff;
 56     cublasHandle_t handle;
 57 
 58     int dev = findCudaDevice(argc, (const char **) argv);
 59 
 60     if (dev == -1)
 61     {
 62         return EXIT_FAILURE;
 63     }
 64 
 65     /* Initialize CUBLAS */
 66     printf("simpleCUBLAS test running..\n");
 67 
 68     status = cublasCreate(&handle);
 69 
 70     if (status != CUBLAS_STATUS_SUCCESS)
 71     {
 72         fprintf(stderr, "!!!! CUBLAS initialization error\n");
 73         return EXIT_FAILURE;
 74     }
 75 
 76     /* Allocate host memory for the matrices */
 77     h_A = (float *)malloc(n2 * sizeof(h_A[0]));
 78 
 79     if (h_A == 0)
 80     {
 81         fprintf(stderr, "!!!! host memory allocation error (A)\n");
 82         return EXIT_FAILURE;
 83     }
 84 
 85     h_B = (float *)malloc(n2 * sizeof(h_B[0]));
 86 
 87     if (h_B == 0)
 88     {
 89         fprintf(stderr, "!!!! host memory allocation error (B)\n");
 90         return EXIT_FAILURE;
 91     }
 92 
 93     h_C = (float *)malloc(n2 * sizeof(h_C[0]));
 94 
 95     if (h_C == 0)
 96     {
 97         fprintf(stderr, "!!!! host memory allocation error (C)\n");
 98         return EXIT_FAILURE;
 99     }
100 
101     /* Fill the matrices with test data */
102     for (i = 0; i < n2; i++)
103     {
104         h_A[i] = rand() / (float)RAND_MAX;
105         h_B[i] = rand() / (float)RAND_MAX;
106         h_C[i] = rand() / (float)RAND_MAX;
107     }
108 
109     /* Allocate device memory for the matrices */
110     if (cudaMalloc((void **)&d_A, n2 * sizeof(d_A[0])) != cudaSuccess)
111     {
112         fprintf(stderr, "!!!! device memory allocation error (allocate A)\n");
113         return EXIT_FAILURE;
114     }
115 
116     if (cudaMalloc((void **)&d_B, n2 * sizeof(d_B[0])) != cudaSuccess)
117     {
118         fprintf(stderr, "!!!! device memory allocation error (allocate B)\n");
119         return EXIT_FAILURE;
120     }
121 
122     if (cudaMalloc((void **)&d_C, n2 * sizeof(d_C[0])) != cudaSuccess)
123     {
124         fprintf(stderr, "!!!! device memory allocation error (allocate C)\n");
125         return EXIT_FAILURE;
126     }
127 
128     /* Initialize the device matrices with the host matrices */
129     status = cublasSetVector(n2, sizeof(h_A[0]), h_A, 1, d_A, 1);
130 
131     if (status != CUBLAS_STATUS_SUCCESS)
132     {
133         fprintf(stderr, "!!!! device access error (write A)\n");
134         return EXIT_FAILURE;
135     }
136 
137     status = cublasSetVector(n2, sizeof(h_B[0]), h_B, 1, d_B, 1);
138 
139     if (status != CUBLAS_STATUS_SUCCESS)
140     {
141         fprintf(stderr, "!!!! device access error (write B)\n");
142         return EXIT_FAILURE;
143     }
144 
145     status = cublasSetVector(n2, sizeof(h_C[0]), h_C, 1, d_C, 1);
146 
147     if (status != CUBLAS_STATUS_SUCCESS)
148     {
149         fprintf(stderr, "!!!! device access error (write C)\n");
150         return EXIT_FAILURE;
151     }
152 
153     /* Performs operation using plain C code */
154     simple_sgemm(N, alpha, h_A, h_B, beta, h_C);
155     h_C_ref = h_C;
156 
157     /* Performs operation using cublas */
158     status = cublasSgemm(handle, CUBLAS_OP_N, CUBLAS_OP_N, N, N, N, &alpha, d_A, N, d_B, N, &beta, d_C, N);
159 
160     if (status != CUBLAS_STATUS_SUCCESS)
161     {
162         fprintf(stderr, "!!!! kernel execution error.\n");
163         return EXIT_FAILURE;
164     }
165 
166     /* Allocate host memory for reading back the result from device memory */
167     h_C = (float *)malloc(n2 * sizeof(h_C[0]));
168 
169     if (h_C == 0)
170     {
171         fprintf(stderr, "!!!! host memory allocation error (C)\n");
172         return EXIT_FAILURE;
173     }
174 
175     /* Read the result back */
176     status = cublasGetVector(n2, sizeof(h_C[0]), d_C, 1, h_C, 1);
177 
178     if (status != CUBLAS_STATUS_SUCCESS)
179     {
180         fprintf(stderr, "!!!! device access error (read C)\n");
181         return EXIT_FAILURE;
182     }
183 
184     /* Check result against reference */
185     error_norm = 0;
186     ref_norm = 0;
187 
188     for (i = 0; i < n2; ++i)
189     {
190         diff = h_C_ref[i] - h_C[i];
191         error_norm += diff * diff;
192         ref_norm += h_C_ref[i] * h_C_ref[i];
193     }
194 
195     error_norm = (float)sqrt((double)error_norm);
196     ref_norm = (float)sqrt((double)ref_norm);
197 
198     if (fabs(ref_norm) < 1e-7)
199     {
200         fprintf(stderr, "!!!! reference norm is 0\n");
201         return EXIT_FAILURE;
202     }
203 
204     /* Memory clean up */
205     free(h_A);
206     free(h_B);
207     free(h_C);
208     free(h_C_ref);
209 
210     if (cudaFree(d_A) != cudaSuccess)
211     {
212         fprintf(stderr, "!!!! memory free error (A)\n");
213         return EXIT_FAILURE;
214     }
215 
216     if (cudaFree(d_B) != cudaSuccess)
217     {
218         fprintf(stderr, "!!!! memory free error (B)\n");
219         return EXIT_FAILURE;
220     }
221 
222     if (cudaFree(d_C) != cudaSuccess)
223     {
224         fprintf(stderr, "!!!! memory free error (C)\n");
225         return EXIT_FAILURE;
226     }
227 
228     /* Shutdown */
229     status = cublasDestroy(handle);
230 
231     if (status != CUBLAS_STATUS_SUCCESS)
232     {
233         fprintf(stderr, "!!!! shutdown error (A)\n");
234         return EXIT_FAILURE;
235     }
236 
237     exit(error_norm / ref_norm < 1e-6f ? EXIT_SUCCESS : EXIT_FAILURE);
238 }