CUDA by example/chapter 4 - Revision history

Heth: /* Memory on the host and memory on the device */

2010-12-05T08:55:26Z

‎Memory on the host and memory on the device

Heth: /* CUDA threaded example */

2010-12-05T08:52:21Z

‎CUDA threaded example

Heth: /* Normal single threaded programming */

2010-12-05T08:40:27Z

‎Normal single threaded programming

Heth: /* CUDA threaded example */

2010-12-05T08:30:44Z

‎CUDA threaded example

Heth at 08:28, 5 December 2010

2010-12-05T08:28:00Z

Heth: New page: =Normal single threaded programming= #define N 10 void add( int a, int b, int *c ) { int tid = 0; // this is CPU zero, so we start at zero while (tid < N) {...

2010-12-05T08:27:34Z

New page: =Normal single threaded programming= <source lang=c> #define N 10 void add( int *a, int *b, int *c ) { int tid = 0; // this is CPU zero, so we start at zero while (tid < N) {...

New page

=Normal single threaded programming=
<source lang=c>
#define N 10

void add( int *a, int *b, int *c ) {
int tid = 0; // this is CPU zero, so we start at zero
while (tid < N) {
c[tid] = a[tid] + b[tid];
tid += 1; // we have one CPU, so we increment by one
}
}

int main( void ) {
int a[N], b[N], c[N];

// fill the arrays 'a' and 'b' on the CPU
for (int i=0; i<N; i++) {
a[i] = -i;
b[i] = i * i;
}

add( a, b, c );

// display the results
for (int i=0; i<N; i++) {
printf( "%d + %d = %d\n", a[i], b[i], c[i] );
}

return 0;
}
</source>
=CUDA threaded example=
<source lang=cli>
#define N 10

__global__ void add( int *a, int *b, int *c ) {
int tid = blockIdx.x; // this thread handles the data at its thread id
if (tid < N)
c[tid] = a[tid] + b[tid];
}

int main( void ) {
int a[N], b[N], c[N];
int *dev_a, *dev_b, *dev_c;

// 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) ) );

// fill the arrays 'a' and 'b' on the CPU
for (int i=0; i<N; i++) {
a[i] = -i;
b[i] = i * i;
}

// copy the arrays 'a' and 'b' to the GPU
HANDLE_ERROR( cudaMemcpy( dev_a, a, N * sizeof(int),
cudaMemcpyHostToDevice ) );
HANDLE_ERROR( cudaMemcpy( dev_b, b, N * sizeof(int),
cudaMemcpyHostToDevice ) );

add<<<N,1>>>( dev_a, dev_b, dev_c );

// copy the array 'c' back from the GPU to the CPU
HANDLE_ERROR( cudaMemcpy( c, dev_c, N * sizeof(int),
cudaMemcpyDeviceToHost ) );

// display the results
for (int i=0; i<N; i++) {
printf( "%d + %d = %d\n", a[i], b[i], c[i] );
}

// free the memory allocated on the GPU
HANDLE_ERROR( cudaFree( dev_a ) );
HANDLE_ERROR( cudaFree( dev_b ) );
HANDLE_ERROR( cudaFree( dev_c ) );

return 0;
}
</source>

{{Source cli}}

@@ Line 110: / Line 110: @@
 </source>
 == Memory on the host and memory on the device==
 *You '''can''' pass pointers allocated with cudaMalloc( ) to functions that execute on the device.
 *You '''can''' use pointers allocated with cudaMalloc() to read or write memory from code that executes on the device.
 *You '''can''' pass pointers allocated with cudaMalloc( ) to functions that execute on the host.
 *You '''cannot''' use pointers allocated with cudaMalloc() to read or write memory from code that executes on the host.

@@ Line 59: / Line 59: @@
 =CUDA threaded example=
 <source lang=c>
 #define N   10
@@ Line 108: / Line 109: @@
+}
 </source>

@@ Line 45: / Line 45: @@
      // allocate the memory on the GPU
-     HANDLE_ERROR( cudaMalloc( (void**)&dev_a, N * sizeof(int) ) );
+     cudaMalloc( (void**)&dev_a, N * sizeof(int) );
-     HANDLE_ERROR( cudaMalloc( (void**)&dev_b, N * sizeof(int) ) );
+     cudaMalloc( (void**)&dev_b, N * sizeof(int) );
-     HANDLE_ERROR( cudaMalloc( (void**)&dev_c, N * sizeof(int) ) );
+     cudaMalloc( (void**)&dev_c, N * sizeof(int) );
      // fill the arrays 'a' and 'b' on the CPU
@@ Line 56: / Line 56: @@
      // copy the arrays 'a' and 'b' to the GPU
-     HANDLE_ERROR( cudaMemcpy( dev_a, a, N * sizeof(int),
+     cudaMemcpy( dev_a, a, N * sizeof(int),
-                               cudaMemcpyHostToDevice ) );
+                               cudaMemcpyHostToDevice );
-     HANDLE_ERROR( cudaMemcpy( dev_b, b, N * sizeof(int),
+     cudaMemcpy( dev_b, b, N * sizeof(int),
-                               cudaMemcpyHostToDevice ) );
+                               cudaMemcpyHostToDevice );
      add<<<N,1>>>( dev_a, dev_b, dev_c );
      // copy the array 'c' back from the GPU to the CPU
-     HANDLE_ERROR( cudaMemcpy( c, dev_c, N * sizeof(int),
+     cudaMemcpy( c, dev_c, N * sizeof(int),
-                               cudaMemcpyDeviceToHost ) );
+                               cudaMemcpyDeviceToHost );
      // display the results
@@ Line 73: / Line 73: @@
      // free the memory allocated on the GPU
-     HANDLE_ERROR( cudaFree( dev_a ) );
+     cudaFree( dev_a );
-     HANDLE_ERROR( cudaFree( dev_b ) );
+     cudaFree( dev_b );
-     HANDLE_ERROR( cudaFree( dev_c ) );
+     cudaFree( dev_c );
      return 0;
+}
 </source>

CUDA by example/chapter 4 - Revision history

Heth: /* Memory on the host and memory on the device */

Heth: /* CUDA threaded example */

Heth: /* Normal single threaded programming */

Heth: /* CUDA threaded example */

Heth at 08:28, 5 December 2010

Heth: New page: =Normal single threaded programming= #define N 10 void add( int *a, int *b, int *c ) { int tid = 0; // this is CPU zero, so we start at zero while (tid < N) {...

Heth: New page: =Normal single threaded programming= #define N 10 void add( int a, int b, int *c ) { int tid = 0; // this is CPU zero, so we start at zero while (tid < N) {...