mirror of
https://github.com/NVIDIA/cuda-samples.git
synced 2026-11-17 17:38:18 +08:00
CUDA 13.4 samples update - v13.4-public
Release 13.4 of the CUDA Samples supported by CUDA Toolkit 13.4. See Changelog for more information.
This commit is contained in:
@@ -1,4 +1,4 @@
|
||||
/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
|
||||
/* Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
@@ -27,396 +27,200 @@
|
||||
|
||||
/*
|
||||
* This sample illustrates the usage of CUDA streams for overlapping
|
||||
* kernel execution with device/host memcopies. The kernel is used to
|
||||
* initialize an array to a specific value, after which the array is
|
||||
* copied to the host (CPU) memory. To increase performance, multiple
|
||||
* kernel execution with device/host memcopies. The kernel computes an
|
||||
* element-wise square of a float array, after which the result is copied
|
||||
* back to host (CPU) memory. To increase performance, multiple
|
||||
* kernel/memcopy pairs are launched asynchronously, each pair in its
|
||||
* own stream. Devices with Compute Capability 1.1 can overlap a kernel
|
||||
* and a memcopy as long as they are issued in different streams. Kernels
|
||||
* are serialized. Thus, if n pairs are launched, streamed approach
|
||||
* can reduce the memcopy cost to the (1/n)th of a single copy of the entire
|
||||
* data set.
|
||||
* own stream. A GPU can overlap a kernel and a memcopy as long as they
|
||||
* are issued in different streams. Thus, if n pairs are launched, the
|
||||
* streamed approach can reduce the memcopy cost to the (1/n)th of a
|
||||
* single copy of the entire data set.
|
||||
*
|
||||
* Additionally, this sample uses CUDA events to measure elapsed time for
|
||||
* CUDA calls. Events are a part of CUDA API and provide a system independent
|
||||
* way to measure execution times on CUDA devices with approximately 0.5
|
||||
* microsecond precision.
|
||||
*
|
||||
* Elapsed times are averaged over nreps repetitions (10 by default).
|
||||
*
|
||||
*/
|
||||
|
||||
const char *sSDKsample = "simpleStreams";
|
||||
|
||||
const char *sEventSyncMethod[] = {"cudaEventDefault", "cudaEventBlockingSync", "cudaEventDisableTiming", NULL};
|
||||
|
||||
const char *sDeviceSyncMethod[] = {"cudaDeviceScheduleAuto",
|
||||
"cudaDeviceScheduleSpin",
|
||||
"cudaDeviceScheduleYield",
|
||||
"INVALID",
|
||||
"cudaDeviceScheduleBlockingSync",
|
||||
NULL};
|
||||
|
||||
// System includes
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
|
||||
// CUDA runtime
|
||||
#include <cuda_runtime.h>
|
||||
|
||||
// helper functions and utilities to work with CUDA
|
||||
#include <helper_cuda.h>
|
||||
#include <helper_functions.h>
|
||||
#define N (1 << 24) // ~16M elements
|
||||
#define BLOCK 256 // threads per block
|
||||
#define NUM_STREAMS 4 // number of concurrent streams
|
||||
|
||||
#ifndef WIN32
|
||||
#include <sys/mman.h> // for mmap() / munmap()
|
||||
#endif
|
||||
|
||||
// Macro to aligned up to the memory size in question
|
||||
#define MEMORY_ALIGNMENT 4096
|
||||
#define ALIGN_UP(x, size) (((size_t)x + (size - 1)) & (~(size - 1)))
|
||||
|
||||
__global__ void init_array(int *g_data, int *factor, int num_iterations)
|
||||
{
|
||||
// Kernel: computes element-wise square of the input array
|
||||
__global__ void square_kernel(const float* in, float* out, int n){
|
||||
int idx = blockIdx.x * blockDim.x + threadIdx.x;
|
||||
|
||||
for (int i = 0; i < num_iterations; i++) {
|
||||
g_data[idx] += *factor; // non-coalesced on purpose, to burn time
|
||||
if (idx < n){
|
||||
out[idx] = in[idx] * in[idx];
|
||||
}
|
||||
}
|
||||
|
||||
bool correct_data(int *a, const int n, const int c)
|
||||
{
|
||||
for (int i = 0; i < n; i++) {
|
||||
if (a[i] != c) {
|
||||
printf("%d: %d %d\n", i, a[i], c);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline void AllocateHostMemory(bool bPinGenericMemory, int **pp_a, int **ppAligned_a, int nbytes)
|
||||
{
|
||||
#if CUDART_VERSION >= 4000
|
||||
#if !defined(__arm__) && !defined(__aarch64__)
|
||||
if (bPinGenericMemory) {
|
||||
// allocate a generic page-aligned chunk of system memory
|
||||
#ifdef WIN32
|
||||
printf("> VirtualAlloc() allocating %4.2f Mbytes of (generic page-aligned "
|
||||
"system memory)\n",
|
||||
(float)nbytes / 1048576.0f);
|
||||
*pp_a = (int *)VirtualAlloc(NULL, (nbytes + MEMORY_ALIGNMENT), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
|
||||
#else
|
||||
printf("> mmap() allocating %4.2f Mbytes (generic page-aligned system "
|
||||
"memory)\n",
|
||||
(float)nbytes / 1048576.0f);
|
||||
*pp_a = (int *)mmap(NULL, (nbytes + MEMORY_ALIGNMENT), PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
|
||||
#endif
|
||||
|
||||
*ppAligned_a = (int *)ALIGN_UP(*pp_a, MEMORY_ALIGNMENT);
|
||||
|
||||
printf("> cudaHostRegister() registering %4.2f Mbytes of generic allocated "
|
||||
"system memory\n",
|
||||
(float)nbytes / 1048576.0f);
|
||||
// pin allocate memory
|
||||
checkCudaErrors(cudaHostRegister(*ppAligned_a, nbytes, cudaHostRegisterMapped));
|
||||
}
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
printf("> cudaMallocHost() allocating %4.2f Mbytes of system memory\n", (float)nbytes / 1048576.0f);
|
||||
// allocate host memory (pinned is required for achieve asynchronicity)
|
||||
checkCudaErrors(cudaMallocHost((void **)pp_a, nbytes));
|
||||
*ppAligned_a = *pp_a;
|
||||
}
|
||||
}
|
||||
|
||||
inline void FreeHostMemory(bool bPinGenericMemory, int **pp_a, int **ppAligned_a, int nbytes)
|
||||
{
|
||||
#if CUDART_VERSION >= 4000
|
||||
#if !defined(__arm__) && !defined(__aarch64__)
|
||||
// CUDA 4.0 support pinning of generic host memory
|
||||
if (bPinGenericMemory) {
|
||||
// unpin and delete host memory
|
||||
checkCudaErrors(cudaHostUnregister(*ppAligned_a));
|
||||
#ifdef WIN32
|
||||
VirtualFree(*pp_a, 0, MEM_RELEASE);
|
||||
#else
|
||||
munmap(*pp_a, nbytes);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
cudaFreeHost(*pp_a);
|
||||
}
|
||||
}
|
||||
|
||||
static const char *sSyncMethod[] = {"0 (Automatic Blocking)",
|
||||
"1 (Spin Blocking)",
|
||||
"2 (Yield Blocking)",
|
||||
"3 (Undefined Blocking Method)",
|
||||
"4 (Blocking Sync Event) = low CPU utilization",
|
||||
NULL};
|
||||
|
||||
void printHelp()
|
||||
{
|
||||
printf("Usage: %s [options below]\n", sSDKsample);
|
||||
printf("\t--sync_method=n for CPU/GPU synchronization\n");
|
||||
printf("\t n=%s\n", sSyncMethod[0]);
|
||||
printf("\t n=%s\n", sSyncMethod[1]);
|
||||
printf("\t n=%s\n", sSyncMethod[2]);
|
||||
printf("\t <Default> n=%s\n", sSyncMethod[4]);
|
||||
printf("\t--use_generic_memory (default) use generic page-aligned for system "
|
||||
"memory\n");
|
||||
printf("\t--use_cuda_malloc_host (optional) use cudaMallocHost to allocate "
|
||||
"system memory\n");
|
||||
}
|
||||
|
||||
#if defined(__APPLE__) || defined(MACOSX)
|
||||
#define DEFAULT_PINNED_GENERIC_MEMORY false
|
||||
#else
|
||||
#define DEFAULT_PINNED_GENERIC_MEMORY true
|
||||
#endif
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int cuda_device = 0;
|
||||
int nstreams = 4; // number of streams for CUDA calls
|
||||
int nreps = 10; // number of times each experiment is repeated
|
||||
int n = 16 * 1024 * 1024; // number of ints in the data set
|
||||
int nbytes = n * sizeof(int); // number of data bytes
|
||||
dim3 threads, blocks; // kernel launch configuration
|
||||
float elapsed_time, time_memcpy, time_kernel; // timing variables
|
||||
float scale_factor = 1.0f;
|
||||
|
||||
// allocate generic memory and pin it laster instead of using cudaHostAlloc()
|
||||
|
||||
bool bPinGenericMemory = DEFAULT_PINNED_GENERIC_MEMORY; // we want this to be the default behavior
|
||||
int device_sync_method = cudaDeviceBlockingSync; // by default we use BlockingSync
|
||||
|
||||
int niterations; // number of iterations for the loop inside the kernel
|
||||
|
||||
printf("[ %s ]\n\n", sSDKsample);
|
||||
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "help")) {
|
||||
printHelp();
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
if ((device_sync_method = getCmdLineArgumentInt(argc, (const char **)argv, "sync_method")) >= 0) {
|
||||
if (device_sync_method == 0 || device_sync_method == 1 || device_sync_method == 2 || device_sync_method == 4) {
|
||||
printf("Device synchronization method set to = %s\n", sSyncMethod[device_sync_method]);
|
||||
printf("Setting reps to 100 to demonstrate steady state\n");
|
||||
nreps = 100;
|
||||
}
|
||||
else {
|
||||
printf("Invalid command line option sync_method=\"%d\"\n", device_sync_method);
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
}
|
||||
else {
|
||||
printHelp();
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "use_generic_memory")) {
|
||||
#if defined(__APPLE__) || defined(MACOSX)
|
||||
bPinGenericMemory = false; // Generic Pinning of System Paged memory not
|
||||
// currently supported on Mac OSX
|
||||
#else
|
||||
bPinGenericMemory = true;
|
||||
#endif
|
||||
}
|
||||
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "use_cuda_malloc_host")) {
|
||||
bPinGenericMemory = false;
|
||||
}
|
||||
|
||||
printf("\n> ");
|
||||
cuda_device = findCudaDevice(argc, (const char **)argv);
|
||||
|
||||
// check the compute capability of the device
|
||||
int num_devices = 0;
|
||||
checkCudaErrors(cudaGetDeviceCount(&num_devices));
|
||||
|
||||
if (0 == num_devices) {
|
||||
printf("your system does not have a CUDA capable device, waiving test...\n");
|
||||
return EXIT_WAIVED;
|
||||
}
|
||||
|
||||
// check if the command-line chosen device ID is within range, exit if not
|
||||
if (cuda_device >= num_devices) {
|
||||
printf("cuda_device=%d is invalid, must choose device ID between 0 and %d\n", cuda_device, num_devices - 1);
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
checkCudaErrors(cudaSetDevice(cuda_device));
|
||||
|
||||
// Checking for compute capabilities
|
||||
cudaDeviceProp deviceProp;
|
||||
checkCudaErrors(cudaGetDeviceProperties(&deviceProp, cuda_device));
|
||||
|
||||
niterations = 5;
|
||||
|
||||
// Check if GPU can map host memory (Generic Method), if not then we override
|
||||
// bPinGenericMemory to be false
|
||||
if (bPinGenericMemory) {
|
||||
printf("Device: <%s> canMapHostMemory: %s\n", deviceProp.name, deviceProp.canMapHostMemory ? "Yes" : "No");
|
||||
|
||||
if (deviceProp.canMapHostMemory == 0) {
|
||||
printf("Using cudaMallocHost, CUDA device does not support mapping of "
|
||||
"generic host memory\n");
|
||||
bPinGenericMemory = false;
|
||||
}
|
||||
}
|
||||
|
||||
// Anything that is less than 32 Cores will have scaled down workload
|
||||
scale_factor =
|
||||
max((32.0f / (_ConvertSMVer2Cores(deviceProp.major, deviceProp.minor) * (float)deviceProp.multiProcessorCount)),
|
||||
1.0f);
|
||||
n = (int)rint((float)n / scale_factor);
|
||||
|
||||
printf("> CUDA Capable: SM %d.%d hardware\n", deviceProp.major, deviceProp.minor);
|
||||
printf("> %d Multiprocessor(s) x %d (Cores/Multiprocessor) = %d (Cores)\n",
|
||||
deviceProp.multiProcessorCount,
|
||||
_ConvertSMVer2Cores(deviceProp.major, deviceProp.minor),
|
||||
_ConvertSMVer2Cores(deviceProp.major, deviceProp.minor) * deviceProp.multiProcessorCount);
|
||||
|
||||
printf("> scale_factor = %1.4f\n", 1.0f / scale_factor);
|
||||
printf("> array_size = %d\n\n", n);
|
||||
|
||||
// enable use of blocking sync, to reduce CPU usage
|
||||
printf("> Using CPU/GPU Device Synchronization method (%s)\n", sDeviceSyncMethod[device_sync_method]);
|
||||
checkCudaErrors(cudaSetDeviceFlags(device_sync_method | (bPinGenericMemory ? cudaDeviceMapHost : 0)));
|
||||
|
||||
// allocate host memory
|
||||
int c = 5; // value to which the array will be initialized
|
||||
int *h_a = 0; // pointer to the array data in host memory
|
||||
int *hAligned_a = 0; // pointer to the array data in host memory (aligned to
|
||||
// MEMORY_ALIGNMENT)
|
||||
|
||||
// Allocate Host memory (could be using cudaMallocHost or VirtualAlloc/mmap if
|
||||
// using the new CUDA 4.0 features
|
||||
AllocateHostMemory(bPinGenericMemory, &h_a, &hAligned_a, nbytes);
|
||||
// Run the full H2D memcopy + kernel + D2H memcopy in a single default stream.
|
||||
// Returns elapsed time in milliseconds.
|
||||
float run_default_stream(float* h_in, float* h_out, int n){
|
||||
float *d_in, *d_out; // device input and output buffers
|
||||
size_t bytes = n * sizeof(float);
|
||||
|
||||
// allocate device memory
|
||||
int *d_a = 0,
|
||||
*d_c = 0; // pointers to data and init value in the device memory
|
||||
checkCudaErrors(cudaMalloc((void **)&d_a, nbytes));
|
||||
checkCudaErrors(cudaMemset(d_a, 0x0, nbytes));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_c, sizeof(int)));
|
||||
checkCudaErrors(cudaMemcpy(d_c, &c, sizeof(int), cudaMemcpyHostToDevice));
|
||||
cudaMalloc(&d_in, bytes);
|
||||
cudaMalloc(&d_out, bytes);
|
||||
|
||||
printf("\nStarting Test\n");
|
||||
// create CUDA event handles for timing
|
||||
cudaEvent_t start, stop;
|
||||
cudaEventCreate(&start);
|
||||
cudaEventCreate(&stop);
|
||||
|
||||
cudaEventRecord(start);
|
||||
|
||||
// copy input to device, run kernel, copy result back
|
||||
cudaMemcpy(d_in, h_in, bytes, cudaMemcpyHostToDevice);
|
||||
int grid = (n + BLOCK - 1) / BLOCK;
|
||||
square_kernel<<<grid, BLOCK>>>(d_in, d_out, n);
|
||||
cudaMemcpy(h_out, d_out, bytes, cudaMemcpyDeviceToHost);
|
||||
|
||||
cudaEventRecord(stop);
|
||||
cudaEventSynchronize(stop); // block until the event is actually recorded
|
||||
|
||||
float ms;
|
||||
cudaEventElapsedTime(&ms, start, stop);
|
||||
|
||||
// release device resources
|
||||
cudaFree(d_in);
|
||||
cudaFree(d_out);
|
||||
cudaEventDestroy(start);
|
||||
cudaEventDestroy(stop);
|
||||
|
||||
return ms;
|
||||
}
|
||||
|
||||
// Run the same workload split across 4 streams so that H2D memcopies,
|
||||
// kernel execution, and D2H memcopies can overlap on the device.
|
||||
// Returns elapsed time in milliseconds.
|
||||
float run_multi_stream(float* h_in, float* h_out, int n){
|
||||
int chunk = n/NUM_STREAMS; // number of elements per stream
|
||||
size_t chunk_bytes = chunk * sizeof(float);
|
||||
|
||||
float *d_in[NUM_STREAMS], *d_out[NUM_STREAMS]; // per-stream device buffers
|
||||
cudaStream_t streams[NUM_STREAMS];
|
||||
|
||||
// allocate and initialize an array of stream handles
|
||||
cudaStream_t *streams = (cudaStream_t *)malloc(nstreams * sizeof(cudaStream_t));
|
||||
|
||||
for (int i = 0; i < nstreams; i++) {
|
||||
checkCudaErrors(cudaStreamCreate(&(streams[i])));
|
||||
for(int i = 0; i < NUM_STREAMS; i++){
|
||||
cudaStreamCreateWithFlags(&streams[i], cudaStreamNonBlocking);
|
||||
cudaMalloc(&d_in[i], chunk_bytes);
|
||||
cudaMalloc(&d_out[i], chunk_bytes);
|
||||
}
|
||||
|
||||
// create CUDA event handles
|
||||
// use blocking sync
|
||||
cudaEvent_t start_event, stop_event;
|
||||
int eventflags = ((device_sync_method == cudaDeviceBlockingSync) ? cudaEventBlockingSync : cudaEventDefault);
|
||||
// create CUDA event handles for timing
|
||||
cudaEvent_t start, stop;
|
||||
cudaEventCreate(&start);
|
||||
cudaEventCreate(&stop);
|
||||
|
||||
checkCudaErrors(cudaEventCreateWithFlags(&start_event, eventflags));
|
||||
checkCudaErrors(cudaEventCreateWithFlags(&stop_event, eventflags));
|
||||
cudaEventRecord(start, streams[0]);
|
||||
|
||||
// time memcopy from device
|
||||
checkCudaErrors(cudaEventRecord(start_event, 0)); // record in stream-0, to
|
||||
// ensure that all previous
|
||||
// CUDA calls have
|
||||
// completed
|
||||
checkCudaErrors(cudaMemcpyAsync(hAligned_a, d_a, nbytes, cudaMemcpyDeviceToHost, streams[0]));
|
||||
checkCudaErrors(cudaEventRecord(stop_event, 0));
|
||||
checkCudaErrors(cudaEventSynchronize(stop_event)); // block until the event is actually recorded
|
||||
checkCudaErrors(cudaEventElapsedTime(&time_memcpy, start_event, stop_event));
|
||||
printf("memcopy:\t%.2f\n", time_memcpy);
|
||||
// asynchronously launch 4 copies + kernels + copies, each in its own
|
||||
// stream so they can overlap on the device
|
||||
for(int i = 0; i < NUM_STREAMS; i++){
|
||||
int offset = i * chunk; // element offset into the host arrays for this stream
|
||||
|
||||
// time kernel
|
||||
threads = dim3(512, 1);
|
||||
blocks = dim3(n / threads.x, 1);
|
||||
checkCudaErrors(cudaEventRecord(start_event, 0));
|
||||
init_array<<<blocks, threads, 0, streams[0]>>>(d_a, d_c, niterations);
|
||||
checkCudaErrors(cudaEventRecord(stop_event, 0));
|
||||
checkCudaErrors(cudaEventSynchronize(stop_event));
|
||||
checkCudaErrors(cudaEventElapsedTime(&time_kernel, start_event, stop_event));
|
||||
printf("kernel:\t\t%.2f\n", time_kernel);
|
||||
// H2D: copy this stream's chunk to device (non-blocking on host)
|
||||
cudaMemcpyAsync(
|
||||
d_in[i],
|
||||
h_in + offset,
|
||||
chunk_bytes,
|
||||
cudaMemcpyHostToDevice,
|
||||
streams[i]
|
||||
);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// time non-streamed execution for reference
|
||||
threads = dim3(512, 1);
|
||||
blocks = dim3(n / threads.x, 1);
|
||||
checkCudaErrors(cudaEventRecord(start_event, 0));
|
||||
// kernel: will only start after the H2D copy in this stream completes
|
||||
int grid = (chunk + BLOCK - 1) / BLOCK;
|
||||
square_kernel<<<grid, BLOCK, 0, streams[i]>>>(
|
||||
d_in[i], d_out[i], chunk
|
||||
);
|
||||
|
||||
for (int k = 0; k < nreps; k++) {
|
||||
init_array<<<blocks, threads>>>(d_a, d_c, niterations);
|
||||
checkCudaErrors(cudaMemcpy(hAligned_a, d_a, nbytes, cudaMemcpyDeviceToHost));
|
||||
// D2H: copy result back; starts after the kernel in this stream finishes
|
||||
cudaMemcpyAsync(
|
||||
h_out + offset,
|
||||
d_out[i],
|
||||
chunk_bytes,
|
||||
cudaMemcpyDeviceToHost,
|
||||
streams[i]
|
||||
);
|
||||
}
|
||||
|
||||
checkCudaErrors(cudaEventRecord(stop_event, 0));
|
||||
checkCudaErrors(cudaEventSynchronize(stop_event));
|
||||
checkCudaErrors(cudaEventElapsedTime(&elapsed_time, start_event, stop_event));
|
||||
printf("non-streamed:\t%.2f\n", elapsed_time / nreps);
|
||||
// Wait for all streams to complete their work
|
||||
for(int i=0; i < NUM_STREAMS; i++) {
|
||||
cudaStreamSynchronize(streams[i]);
|
||||
}
|
||||
cudaEventRecord(stop, streams[0]);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// time execution with nstreams streams
|
||||
threads = dim3(512, 1);
|
||||
blocks = dim3(n / (nstreams * threads.x), 1);
|
||||
memset(hAligned_a, 255,
|
||||
nbytes); // set host memory bits to all 1s, for testing correctness
|
||||
checkCudaErrors(cudaMemset(d_a, 0, nbytes)); // set device memory to all 0s, for testing correctness
|
||||
checkCudaErrors(cudaEventRecord(start_event, 0));
|
||||
// Sync with stream 0, which only completes once all other work
|
||||
// is done and the stop event is recorded
|
||||
cudaStreamSynchronize(streams[0]);
|
||||
|
||||
for (int k = 0; k < nreps; k++) {
|
||||
// asynchronously launch nstreams kernels, each operating on its own portion
|
||||
// of data
|
||||
for (int i = 0; i < nstreams; i++) {
|
||||
init_array<<<blocks, threads, 0, streams[i]>>>(d_a + i * n / nstreams, d_c, niterations);
|
||||
}
|
||||
float ms;
|
||||
cudaEventElapsedTime(&ms, start, stop);
|
||||
|
||||
// asynchronously launch nstreams memcopies. Note that memcopy in stream x
|
||||
// will only
|
||||
// commence executing when all previous CUDA calls in stream x have
|
||||
// completed
|
||||
for (int i = 0; i < nstreams; i++) {
|
||||
checkCudaErrors(cudaMemcpyAsync(hAligned_a + i * n / nstreams,
|
||||
d_a + i * n / nstreams,
|
||||
nbytes / nstreams,
|
||||
cudaMemcpyDeviceToHost,
|
||||
streams[i]));
|
||||
}
|
||||
// release per-stream resources
|
||||
for(int i=0; i < NUM_STREAMS; i++){
|
||||
cudaFree(d_in[i]);
|
||||
cudaFree(d_out[i]);
|
||||
cudaStreamDestroy(streams[i]);
|
||||
}
|
||||
|
||||
checkCudaErrors(cudaEventRecord(stop_event, 0));
|
||||
checkCudaErrors(cudaEventSynchronize(stop_event));
|
||||
checkCudaErrors(cudaEventElapsedTime(&elapsed_time, start_event, stop_event));
|
||||
printf("%d streams:\t%.2f\n", nstreams, elapsed_time / nreps);
|
||||
cudaEventDestroy(start);
|
||||
cudaEventDestroy(stop);
|
||||
|
||||
// check whether the output is correct
|
||||
printf("-------------------------------\n");
|
||||
bool bResults = correct_data(hAligned_a, n, c * nreps * niterations);
|
||||
|
||||
// release resources
|
||||
for (int i = 0; i < nstreams; i++) {
|
||||
checkCudaErrors(cudaStreamDestroy(streams[i]));
|
||||
}
|
||||
|
||||
checkCudaErrors(cudaEventDestroy(start_event));
|
||||
checkCudaErrors(cudaEventDestroy(stop_event));
|
||||
|
||||
// Free cudaMallocHost or Generic Host allocated memory (from CUDA 4.0)
|
||||
FreeHostMemory(bPinGenericMemory, &h_a, &hAligned_a, nbytes);
|
||||
|
||||
checkCudaErrors(cudaFree(d_a));
|
||||
checkCudaErrors(cudaFree(d_c));
|
||||
|
||||
return bResults ? EXIT_SUCCESS : EXIT_FAILURE;
|
||||
return ms;
|
||||
}
|
||||
|
||||
int main(){
|
||||
|
||||
printf("[ CUDA Sample: Streams ]\n\n");
|
||||
|
||||
// Query compute capability and number of SMs on device 0
|
||||
int cuda_device = 0;
|
||||
int major = 0, minor = 0, smCount = 0;
|
||||
cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, cuda_device);
|
||||
cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, cuda_device);
|
||||
cudaDeviceGetAttribute(&smCount, cudaDevAttrMultiProcessorCount, cuda_device);
|
||||
printf("GPU Device %d: with compute capability %d.%d and Number of SMs %d\n\n",
|
||||
cuda_device, major, minor, smCount);
|
||||
|
||||
size_t bytes = N * sizeof(float);
|
||||
|
||||
// allocate pinned host memory: the OS normally moves RAM pages around freely,
|
||||
// pinning locks these pages in place so the GPU can read them directly
|
||||
// without the data being moved away mid-transfer
|
||||
float *h_in = 0; // pointer to input data in host memory
|
||||
float *h_out = 0; // pointer to output data in host memory
|
||||
cudaMallocHost(&h_in, bytes);
|
||||
cudaMallocHost(&h_out, bytes);
|
||||
|
||||
// initialize input array
|
||||
for (int i = 0; i < N; i++)
|
||||
h_in[i] = (float)i;
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// time single-stream execution for reference
|
||||
float t1 = run_default_stream(h_in, h_out, N);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// time execution with 4 streams
|
||||
float t2 = run_multi_stream(h_in, h_out, N);
|
||||
|
||||
printf("Single stream = %.3f ms\n", t1);
|
||||
printf("Multi-stream = %.3f ms\n", t2);
|
||||
printf("Speedup = %.2fx\n", t1 / t2);
|
||||
|
||||
// release pinned host memory
|
||||
cudaFreeHost(h_in);
|
||||
cudaFreeHost(h_out);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user