CUDA_BIN_PATH　　%CUDA_PATH%\bin
CUDA_LIB_PATH　　%CUDA_PATH%\lib\Win32
CUDA_SDK_BIN　　%CUDA_SDK_PATH%\bin\Win32
CUDA_SDK_LIB　　%CUDA_SDK_PATH%\common\lib\Win32
CUDA_SDK_PATH　　C:\cuda\cudasdk\common

1. #include "cuda_runtime.h"
2. #include "device_launch_parameters.h"
3. #include <stdio.h>
4. __global__ void addKernel(int *c, const int *a, const int *b)
5. {
6. int i = threadIdx.x;
7. c[i] = a[i] + b[i];
8. }
9. // Helper function for using CUDA to add vectors in parallel.
10. extern "C"
11. cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size)
12. {
13. int *dev_a = 0;
14. int *dev_b = 0;
15. int *dev_c = 0;
16. cudaError_t cudaStatus;
17. // Choose which GPU to run on, change this on a multi-GPU system.
18. cudaStatus = cudaSetDevice(0);
19. if (cudaStatus != cudaSuccess) {
20. fprintf(stderr, "cudaSetDevice failed!  Do you have a CUDA-capable GPU installed?");
21. goto Error;
22. }
23. // Allocate GPU buffers for three vectors (two input, one output)    .
24. cudaStatus = cudaMalloc((void**)&dev_c, size * sizeof(int));
25. if (cudaStatus != cudaSuccess) {
26. fprintf(stderr, "cudaMalloc failed!");
27. goto Error;
28. }
29. cudaStatus = cudaMalloc((void**)&dev_a, size * sizeof(int));
30. if (cudaStatus != cudaSuccess) {
31. fprintf(stderr, "cudaMalloc failed!");
32. goto Error;
33. }
34. cudaStatus = cudaMalloc((void**)&dev_b, size * sizeof(int));
35. if (cudaStatus != cudaSuccess) {
36. fprintf(stderr, "cudaMalloc failed!");
37. goto Error;
38. }
39. // Copy input vectors from host memory to GPU buffers.
40. cudaStatus = cudaMemcpy(dev_a, a, size * sizeof(int), cudaMemcpyHostToDevice);
41. if (cudaStatus != cudaSuccess) {
42. fprintf(stderr, "cudaMemcpy failed!");
43. goto Error;
44. }
45. cudaStatus = cudaMemcpy(dev_b, b, size * sizeof(int), cudaMemcpyHostToDevice);
46. if (cudaStatus != cudaSuccess) {
47. fprintf(stderr, "cudaMemcpy failed!");
48. goto Error;
49. }
50. // Launch a kernel on the GPU with one thread for each element.
51. addKernel<<<1, size>>>(dev_c, dev_a, dev_b);
52. // Check for any errors launching the kernel
53. cudaStatus = cudaGetLastError();
54. if (cudaStatus != cudaSuccess) {
55. fprintf(stderr, "addKernel launch failed: %s\n", cudaGetErrorString(cudaStatus));
56. goto Error;
57. }
58. // cudaDeviceSynchronize waits for the kernel to finish, and returns
59. // any errors encountered during the launch.
60. cudaStatus = cudaDeviceSynchronize();
61. if (cudaStatus != cudaSuccess) {
62. fprintf(stderr, "cudaDeviceSynchronize returned error code %d after launching addKernel!\n", cudaStatus);
63. goto Error;
64. }
65. // Copy output vector from GPU buffer to host memory.
66. cudaStatus = cudaMemcpy(c, dev_c, size * sizeof(int), cudaMemcpyDeviceToHost);
67. if (cudaStatus != cudaSuccess) {
68. fprintf(stderr, "cudaMemcpy failed!");
69. goto Error;
70. }
71. Error:
72. cudaFree(dev_c);
73. cudaFree(dev_a);
74. cudaFree(dev_b);
75. return cudaStatus;
76. }

1. #include <stdio.h>
2. #include "cuda_runtime.h"
3. #include "device_launch_parameters.h"
4. extern "C"
5. cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size);
6. int main()
7. {
8. const int arraySize = 5;
9. const int a[arraySize] = { 1, 2, 3, 4, 5 };
10. const int b[arraySize] = { 10, 20, 30, 40, 50 };
11. int c[arraySize] = { 0 };
12. // Add vectors in parallel.
13. cudaError_t cudaStatus = addWithCuda(c, a, b, arraySize);
14. if (cudaStatus != cudaSuccess) {
15. fprintf(stderr, "addWithCuda failed!");
16. return 1;
17. }
18. printf("{1,2,3,4,5} + {10,20,30,40,50} = {%d,%d,%d,%d,%d}\n",
19. c[0], c[1], c[2], c[3], c[4]);
20. printf("cuda工程中调用cpp成功！\n");
21. // cudaDeviceReset must be called before exiting in order for profiling and
22. // tracing tools such as Nsight and Visual Profiler to show complete traces.
23. cudaStatus = cudaDeviceReset();
24. if (cudaStatus != cudaSuccess) {
25. fprintf(stderr, "cudaDeviceReset failed!");
26. return 1;
27. }
28. getchar(); //here we want the console to hold for a while
29. return 0;
30. }

1. #include "cuda_runtime.h"
2. #include "device_launch_parameters.h"
3. #include <stdio.h>
4. //cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size);
5. __global__ void addKernel(int *c, const int *a, const int *b)
6. {
7. int i = threadIdx.x;
8. c[i] = a[i] + b[i];
9. }
10. // Helper function for using CUDA to add vectors in parallel.
11. extern "C"
12. cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size)
13. {
14. int *dev_a = 0;
15. int *dev_b = 0;
16. int *dev_c = 0;
17. cudaError_t cudaStatus;
18. // Choose which GPU to run on, change this on a multi-GPU system.
19. cudaStatus = cudaSetDevice(0);
20. if (cudaStatus != cudaSuccess) {
21. fprintf(stderr, "cudaSetDevice failed!  Do you have a CUDA-capable GPU installed?");
22. goto Error;
23. }
24. // Allocate GPU buffers for three vectors (two input, one output)    .
25. cudaStatus = cudaMalloc((void**)&dev_c, size * sizeof(int));
26. if (cudaStatus != cudaSuccess) {
27. fprintf(stderr, "cudaMalloc failed!");
28. goto Error;
29. }
30. cudaStatus = cudaMalloc((void**)&dev_a, size * sizeof(int));
31. if (cudaStatus != cudaSuccess) {
32. fprintf(stderr, "cudaMalloc failed!");
33. goto Error;
34. }
35. cudaStatus = cudaMalloc((void**)&dev_b, size * sizeof(int));
36. if (cudaStatus != cudaSuccess) {
37. fprintf(stderr, "cudaMalloc failed!");
38. goto Error;
39. }
40. // Copy input vectors from host memory to GPU buffers.
41. cudaStatus = cudaMemcpy(dev_a, a, size * sizeof(int), cudaMemcpyHostToDevice);
42. if (cudaStatus != cudaSuccess) {
43. fprintf(stderr, "cudaMemcpy failed!");
44. goto Error;
45. }
46. cudaStatus = cudaMemcpy(dev_b, b, size * sizeof(int), cudaMemcpyHostToDevice);
47. if (cudaStatus != cudaSuccess) {
48. fprintf(stderr, "cudaMemcpy failed!");
49. goto Error;
50. }
51. // Launch a kernel on the GPU with one thread for each element.
52. addKernel<<<1, size>>>(dev_c, dev_a, dev_b);
53. // Check for any errors launching the kernel
54. cudaStatus = cudaGetLastError();
55. if (cudaStatus != cudaSuccess) {
56. fprintf(stderr, "addKernel launch failed: %s\n", cudaGetErrorString(cudaStatus));
57. goto Error;
58. }
59. // cudaDeviceSynchronize waits for the kernel to finish, and returns
60. // any errors encountered during the launch.
61. cudaStatus = cudaDeviceSynchronize();
62. if (cudaStatus != cudaSuccess) {
63. fprintf(stderr, "cudaDeviceSynchronize returned error code %d after launching addKernel!\n", cudaStatus);
64. goto Error;
65. }
66. // Copy output vector from GPU buffer to host memory.
67. cudaStatus = cudaMemcpy(c, dev_c, size * sizeof(int), cudaMemcpyDeviceToHost);
68. if (cudaStatus != cudaSuccess) {
69. fprintf(stderr, "cudaMemcpy failed!");
70. goto Error;
71. }
72. Error:
73. cudaFree(dev_c);
74. cudaFree(dev_a);
75. cudaFree(dev_b);
76. return cudaStatus;
77. }

1. #include <iostream>
2. #include "cuda_runtime.h"
3. #include "device_launch_parameters.h"
4. using namespace std;
5. extern "C"
6. cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size);
7. int main(int argc,char **argv)
8. {
9. const int arraySize = 5;
10. const int a[arraySize] = { 1, 2, 3, 4, 5 };
11. const int b[arraySize] = { 10, 20, 30, 40, 50 };
12. int c[arraySize] = { 0 };
13. // Add vectors in parallel.
14. cudaError_t cudaStatus = addWithCuda(c, a, b, arraySize);
15. if (cudaStatus != cudaSuccess) {
16. fprintf(stderr, "addWithCuda failed!");
17. return 1;
18. }
19. cout<<"{1,2,3,4,5} + {10,20,30,40,50} = {"<<c[0]<<','<<c[1]<<','<<c[2]<<','<<c[3]<<'}'<<endl;
20. printf("cpp工程中调用cu成功！\n");
21. // cudaDeviceReset must be called before exiting in order for profiling and
22. // tracing tools such as Nsight and Visual Profiler to show complete traces.
23. cudaStatus = cudaDeviceReset();
24. if (cudaStatus != cudaSuccess) {
25. fprintf(stderr, "cudaDeviceReset failed!");
26. return 1;
27. }
28. system("pause"); //here we want the console to hold for a while
29. return 0;
30. }