拷贝时间测试=cudamelloc+cudahostalloc

 /*

 * Copyright 1993-2010 NVIDIA Corporation.  All rights reserved.

 *

 * NVIDIA Corporation and its licensors retain all intellectual property and

 * proprietary rights in and to this software and related documentation.

 * Any use, reproduction, disclosure, or distribution of this software

 * and related documentation without an express license agreement from

 * NVIDIA Corporation is strictly prohibited.

 *

 * Please refer to the applicable NVIDIA end user license agreement (EULA)

 * associated with this source code for terms and conditions that govern

 * your use of this NVIDIA software.

 *

 */

 #include "../common/book.h"

 #include <cuda.h>

 #include "cuda_runtime.h"

 #include "device_launch_parameters.h"

 #define SIZE    (64*1024*1024)

 float cuda_malloc_test(int size, bool up) {

     cudaEvent_t     start, stop;

     int             *a, *dev_a;

     float           elapsedTime;

     HANDLE_ERROR(cudaEventCreate(&start));

     HANDLE_ERROR(cudaEventCreate(&stop));

     a = (int*)malloc(size * sizeof(*a));

     HANDLE_NULL(a);

     HANDLE_ERROR(cudaMalloc((void**)&dev_a,

         size * sizeof(*dev_a)));

     HANDLE_ERROR(cudaEventRecord(start, ));

     for (int i = ; i<; i++) {

         if (up)

             HANDLE_ERROR(cudaMemcpy(dev_a, a,

             size * sizeof(*dev_a),

             cudaMemcpyHostToDevice));

         else

             HANDLE_ERROR(cudaMemcpy(a, dev_a,

             size * sizeof(*dev_a),

             cudaMemcpyDeviceToHost));

     }

     HANDLE_ERROR(cudaEventRecord(stop, ));

     HANDLE_ERROR(cudaEventSynchronize(stop));

     HANDLE_ERROR(cudaEventElapsedTime(&elapsedTime,

         start, stop));

     free(a);

     HANDLE_ERROR(cudaFree(dev_a));

     HANDLE_ERROR(cudaEventDestroy(start));

     HANDLE_ERROR(cudaEventDestroy(stop));

     return elapsedTime;

 }

 float cuda_host_alloc_test(int size, bool up) {

     cudaEvent_t     start, stop;

     int             *a, *dev_a;

     float           elapsedTime;

     HANDLE_ERROR(cudaEventCreate(&start));

     HANDLE_ERROR(cudaEventCreate(&stop));

     HANDLE_ERROR(cudaHostAlloc((void**)&a,

         size * sizeof(*a),

         cudaHostAllocDefault));

     HANDLE_ERROR(cudaMalloc((void**)&dev_a,

         size * sizeof(*dev_a)));

     HANDLE_ERROR(cudaEventRecord(start, ));

     for (int i = ; i<; i++) {

         if (up)

             HANDLE_ERROR(cudaMemcpy(dev_a, a,

             size * sizeof(*a),

             cudaMemcpyHostToDevice));

         else

             HANDLE_ERROR(cudaMemcpy(a, dev_a,

             size * sizeof(*a),

             cudaMemcpyDeviceToHost));

     }

     HANDLE_ERROR(cudaEventRecord(stop, ));

     HANDLE_ERROR(cudaEventSynchronize(stop));

     HANDLE_ERROR(cudaEventElapsedTime(&elapsedTime,

         start, stop));

     HANDLE_ERROR(cudaFreeHost(a));

     HANDLE_ERROR(cudaFree(dev_a));

     HANDLE_ERROR(cudaEventDestroy(start));

     HANDLE_ERROR(cudaEventDestroy(stop));

     return elapsedTime;

 }

 int main(void) {

     float           elapsedTime;

     float           MB = (float) * SIZE*sizeof(int) /  / ;

     // try it with cudaMalloc

     elapsedTime = cuda_malloc_test(SIZE, true);

     printf("Time using cudaMalloc:  %3.1f ms\n",

         elapsedTime);

     printf("\tMB/s during copy up:  %3.1f\n",

         MB / (elapsedTime / ));

     elapsedTime = cuda_malloc_test(SIZE, false);

     printf("Time using cudaMalloc:  %3.1f ms\n",

         elapsedTime);

     printf("\tMB/s during copy down:  %3.1f\n",

         MB / (elapsedTime / ));

     // now try it with cudaHostAlloc

     elapsedTime = cuda_host_alloc_test(SIZE, true);

     printf("Time using cudaHostAlloc:  %3.1f ms\n",

         elapsedTime);

     printf("\tMB/s during copy up:  %3.1f\n",

         MB / (elapsedTime / ));

     elapsedTime = cuda_host_alloc_test(SIZE, false);

     printf("Time using cudaHostAlloc:  %3.1f ms\n",

         elapsedTime);

     printf("\tMB/s during copy down:  %3.1f\n",

         MB / (elapsedTime / ));

 }