प्रौद्योगिकी साझेदारी

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

1. सम्पूर्ण कोड

#include <stdio.h>

// includes CUDA Runtime
#include <cuda_runtime.h>
#include <cuda_profiler_api.h>

// includes, project
#include <helper_cuda.h>
#include <helper_functions.h>  // helper utility functions

__global__ void increment_kernel(int *g_data, int inc_value) {
  int idx = blockIdx.x * blockDim.x + threadIdx.x;
  g_data[idx] = g_data[idx] + inc_value;
}

bool correct_output(int *data, const int n, const int x) {
  for (int i = 0; i < n; i++)
    if (data[i] != x) {
      printf("Error! data[%d] = %d, ref = %dn", i, data[i], x);
      return false;
    }

  return true;
}

int main(int argc, char *argv[]) {
  int devID;
  cudaDeviceProp deviceProps;

  printf("[%s] - Starting...n", argv[0]);

  // This will pick the best possible CUDA capable device
  devID = findCudaDevice(argc, (const char **)argv);

  // get device name
  checkCudaErrors(cudaGetDeviceProperties(&deviceProps, devID));
  printf("CUDA device [%s]n", deviceProps.name);

  int n = 16 * 1024 * 1024;
  int nbytes = n * sizeof(int);
  int value = 26;

  // allocate host memory
  int *a = 0;
  checkCudaErrors(cudaMallocHost((void **)&a, nbytes));
  memset(a, 0, nbytes);

  // allocate device memory
  int *d_a = 0;
  checkCudaErrors(cudaMalloc((void **)&d_a, nbytes));
  checkCudaErrors(cudaMemset(d_a, 255, nbytes));

  // set kernel launch configuration
  dim3 threads = dim3(512, 1);
  dim3 blocks = dim3(n / threads.x, 1);

  // create cuda event handles
  cudaEvent_t start, stop;
  checkCudaErrors(cudaEventCreate(&start));
  checkCudaErrors(cudaEventCreate(&stop));

  StopWatchInterface *timer = NULL;
  sdkCreateTimer(&timer);
  sdkResetTimer(&timer);

  checkCudaErrors(cudaDeviceSynchronize());
  float gpu_time = 0.0f;

  // asynchronously issue work to the GPU (all to stream 0)
  checkCudaErrors(cudaProfilerStart());
  sdkStartTimer(&timer);
  cudaEventRecord(start, 0);
  cudaMemcpyAsync(d_a, a, nbytes, cudaMemcpyHostToDevice, 0);
  increment_kernel<<<blocks, threads, 0, 0>>>(d_a, value);
  cudaMemcpyAsync(a, d_a, nbytes, cudaMemcpyDeviceToHost, 0);
  cudaEventRecord(stop, 0);
  sdkStopTimer(&timer);
  checkCudaErrors(cudaProfilerStop());

  // have CPU do some work while waiting for stage 1 to finish
  unsigned long int counter = 0;

  while (cudaEventQuery(stop) == cudaErrorNotReady) {
    counter++;
  }

  checkCudaErrors(cudaEventElapsedTime(&gpu_time, start, stop));

  // print the cpu and gpu times
  printf("time spent executing by the GPU: %.2fn", gpu_time);
  printf("time spent by CPU in CUDA calls: %.2fn", sdkGetTimerValue(&timer));
  printf("CPU executed %lu iterations while waiting for GPU to finishn",
         counter);

  // check the output for correctness
  bool bFinalResults = correct_output(a, n, value);

  // release resources
  checkCudaErrors(cudaEventDestroy(start));
  checkCudaErrors(cudaEventDestroy(stop));
  checkCudaErrors(cudaFreeHost(a));
  checkCudaErrors(cudaFree(d_a));

  exit(bFinalResults ? EXIT_SUCCESS : EXIT_FAILURE);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

2. महत्त्वपूर्णभागानाम् विश्लेषणम्

उपकरणम्‌आरम्भीकरणम्:findCudaDevice फंक्शन् इत्यस्य उपयोगः उत्तमः CUDA उपकरणं चयनं कृत्वा उपकरण ID प्रत्यागन्तुं भवति ।

devID = findCudaDevice(argc, (const char **)argv);

1
2

उपकरणगुणान् प्राप्नुत: cudaGetDeviceProperties कार्यं निर्दिष्टस्य उपकरणस्य गुणं प्राप्नोति, येषु उपकरणनाम अन्यसूचना च सन्ति ।

checkCudaErrors(cudaGetDeviceProperties(&deviceProps, devID));

1
2

स्मृतिविनियोगः : CPU इत्यत्र सुलभं पृष्ठ-तालाबद्ध-स्मृतिम् आवंटयितुं cudaMallocHost इत्यस्य उपयोगं कुर्वन्तु, तथा च उपकरणे स्मृति-आवंटनार्थं cudaMalloc इत्यस्य उपयोगं कुर्वन्तु ।

int *a = 0;
checkCudaErrors(cudaMallocHost((void **)&a, nbytes));

1
2
3

थ्रेड् ब्लॉक् तथा ग्रिड् सेट् कुर्वन्तु: अत्र थ्रेड् ब्लॉक् आकारः ५१२ थ्रेड् इति सेट् भवति, तथा च ग्रिड् आकारः दत्तांशस्य आकारस्य आधारेण गतिशीलरूपेण गण्यते ।

dim3 threads = dim3(512, 1);
dim3 blocks = dim3(n / threads.x, 1);

1
2
3

CUDA इवेण्ट् तथा टाइमर् रचयन्तु: CUDA इवेण्ट् इत्यस्य उपयोगः समयस्य अभिलेखनार्थं भवति, तथा च टाइमर् इत्यस्य उपयोगः CPU निष्पादनसमयस्य मापनार्थं भवति ।

cudaEvent_t start, stop;
checkCudaErrors(cudaEventCreate(&start));
checkCudaErrors(cudaEventCreate(&stop));

1
2
3
4

CUDA धारा संसाधनम्: अतुल्यकालिकस्मृतिप्रतिलिपि कृते cudaMemcpyAsync इत्यस्य उपयोगः, &lt;&lt;<blocks, threads> &gt;&gt;वाक्यविन्यासः समवर्तीरूपेण निष्पादितं CUDA कर्नेल् फंक्शन् increment_kernel आरभते ।

cudaMemcpyAsync(d_a, a, nbytes, cudaMemcpyHostToDevice, 0);
increment_kernel<<<blocks, threads, 0, 0>>>(d_a, value);
cudaMemcpyAsync(a, d_a, nbytes, cudaMemcpyDeviceToHost, 0);

1
2
3
4

समयः प्रतीक्षा च: cudaEventRecord घटनाः अभिलेखयति तथा च GPU निष्पादनसमयस्य गणनाय उपयुज्यते । cudaEventQuery(stop) इत्यस्य माध्यमेन GPU-सञ्चालनस्य पूर्णतायाः प्रतीक्षां कुर्वन्तु ।

cudaEventRecord(start, 0);
// ...
cudaEventRecord(stop, 0);

1
2
3
4

परिणामसत्यापनम् : GPU गणनापरिणामानां समीचीनतां सत्यापयितुं correct_output फंक्शन् इत्यस्य उपयोगं कुर्वन्तु ।

bool bFinalResults = correct_output(a, n, value);

1
2

संसाधनविमोचनम् : आवंटितस्मृतिः CUDA इवेण्ट् च विमोचयन्तु ।

checkCudaErrors(cudaEventDestroy(start));
checkCudaErrors(cudaEventDestroy(stop));
checkCudaErrors(cudaFreeHost(a));
checkCudaErrors(cudaFree(d_a));

1
2
3
4
5

CUDA कर्नेल फ़ंक्शन increment_kernel:

इदं सरलं CUDA कर्नेल् फंक्शन् निर्दिष्टेन मूल्येन inc_value इत्यनेन सरणीयां प्रत्येकं तत्त्वं वर्धयितुं उपयुज्यते । blockIdx.x तथा threadIdx.x इत्येतयोः उपयोगः प्रत्येकस्य थ्रेड् इत्यस्य वैश्विकसूचकाङ्क idx गणयितुं ततः योजनक्रियां कर्तुं भवति ।

__global__ void increment_kernel(int *g_data, int inc_value) {
  int idx = blockIdx.x * blockDim.x + threadIdx.x;
  g_data[idx] = g_data[idx] + inc_value;
}

1
2
3
4
5

अन्ये सहायककार्यम्
checkCudaErrors: 1.1.CUDA चेक करेंफंक्शन् आह्वानस्य त्रुटिः अस्ति वा।
sdkCreateTimer तथा sdkResetTimer: समयनिर्धारणाय पुनः सेट् कर्तुं च उपयुज्यते ।
sdkStartTimer तथा sdkStopTimer: टाइमर् आरभ्य स्थगयितुं च CPU निष्पादनसमयं अभिलेखयितुं च उपयुज्यते ।