cuda流测试=basic_single_stream

cuda流测试

 /*
 * 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 N   (1024*1024)
 #define FULL_DATA_SIZE   (N*20)

 __global__ void kernel(int *a, int *b, int *c) {
     int idx = threadIdx.x + blockIdx.x * blockDim.x;
     if (idx < N) {
         //idx后两个数
         int idx1 = (idx + ) % ;
         int idx2 = (idx + ) % ;
         float   as = (a[idx] + a[idx1] + a[idx2]) / 3.0f;
         float   bs = (b[idx] + b[idx1] + b[idx2]) / 3.0f;
         c[idx] = (as + bs) / ;
     }
 }

 int main(void) {
     cudaDeviceProp  prop;
     int whichDevice;
     HANDLE_ERROR(cudaGetDevice(&whichDevice));
     HANDLE_ERROR(cudaGetDeviceProperties(&prop, whichDevice));
     if (!prop.deviceOverlap) {
         printf("Device will not handle overlaps, so no speed up from streams\n");
         return ;
     }

     cudaEvent_t     start, stop;
     float           elapsedTime;

     cudaStream_t    stream;
     int *host_a, *host_b, *host_c;
     int *dev_a, *dev_b, *dev_c;

     // start the timers
     HANDLE_ERROR(cudaEventCreate(&start));
     HANDLE_ERROR(cudaEventCreate(&stop));

     //初始化流
     HANDLE_ERROR(cudaStreamCreate(&stream));

     // allocate the memory on the GPU
     HANDLE_ERROR(cudaMalloc((void**)&dev_a,
         N * sizeof(int)));
     HANDLE_ERROR(cudaMalloc((void**)&dev_b,
         N * sizeof(int)));
     HANDLE_ERROR(cudaMalloc((void**)&dev_c,
         N * sizeof(int)));

     //分配由于GPU访问的主机无分页内存（锁定内存页）
     HANDLE_ERROR(cudaHostAlloc((void**)&host_a,
         FULL_DATA_SIZE * sizeof(int),
         cudaHostAllocDefault));
     HANDLE_ERROR(cudaHostAlloc((void**)&host_b,
         FULL_DATA_SIZE * sizeof(int),
         cudaHostAllocDefault));
     HANDLE_ERROR(cudaHostAlloc((void**)&host_c,
         FULL_DATA_SIZE * sizeof(int),
         cudaHostAllocDefault));

     for (int i = ; i<FULL_DATA_SIZE; i++) {
         host_a[i] = rand();
         host_b[i] = rand();
     }

     HANDLE_ERROR(cudaEventRecord(start, ));
     // now loop over full data, in bite-sized chunks
     for (int i = ; i<FULL_DATA_SIZE; i += N) {
         //异步复制主机上内存的值到设备上
         HANDLE_ERROR(cudaMemcpyAsync(dev_a, host_a + i,
             N * sizeof(int),
             cudaMemcpyHostToDevice,
             stream));
         HANDLE_ERROR(cudaMemcpyAsync(dev_b, host_b + i,
             N * sizeof(int),
             cudaMemcpyHostToDevice,
             stream));

         kernel << <N / , , , stream >> >(dev_a, dev_b, dev_c);

         //将计算的值复制会主机
         HANDLE_ERROR(cudaMemcpyAsync(host_c + i, dev_c,
             N * sizeof(int),
             cudaMemcpyDeviceToHost,
             stream));

     }
     //从锁定页将结果块复制到主机内存
     HANDLE_ERROR(cudaStreamSynchronize(stream));

     HANDLE_ERROR(cudaEventRecord(stop, ));

     HANDLE_ERROR(cudaEventSynchronize(stop));
     HANDLE_ERROR(cudaEventElapsedTime(&elapsedTime,
         start, stop));
     printf("Time taken:  %3.1f ms\n", elapsedTime);

     // cleanup the streams and memory
     HANDLE_ERROR(cudaFreeHost(host_a));
     HANDLE_ERROR(cudaFreeHost(host_b));
     HANDLE_ERROR(cudaFreeHost(host_c));
     HANDLE_ERROR(cudaFree(dev_a));
     HANDLE_ERROR(cudaFree(dev_b));
     HANDLE_ERROR(cudaFree(dev_c));
     HANDLE_ERROR(cudaStreamDestroy(stream));

     return ;
 }

项目打包下载