Learn CUDA with Docker!

Explore how CUDA provides a software layer for parallel GPU programming and interfaces with C, C++, Java, and Python, enabling development on Tesla GPUs for deep learning and big data.

Explore how GPUs execute CUDA kernels by a hierarchy of streaming multiprocessors containing cores, registers, local memory, shared memory, and texture memory, with threads organized into blocks running concurrently.

Learn CUDA's heterogeneous computing by coordinating host memory and device memory, transferring data to the device, executing host and device code, and returning results to the host.

Explore how CUDA threads map to blocks and grids, and how streaming multiprocessors execute blocks of threads, sharing registers and L1 cache while handling kernels.

Compute the index of a CUDA thread in 1d using blockIdx.x * blockDim.x + threadIdx.x. Set blockDim.x to 256 and assign a specific thread (block 2, thread 3) to work.

Learn how CUDA maps a grid of blocks to two-dimensional indices and breaks each block into threads, enabling two-dimensional addressing across streaming multiprocessors.

Explore the CUDA memory hierarchy from device memory to caches and registers, and learn how unified address space maps local and shared memory onto global memory.

Learn how to write a CUDA hello world program, starting from a simple C hello world, adding a global kernel called my_kernel, and running with one thread in one block.

Write a simple cuda kernel to add two integers on the device, allocate device memory with cudaMalloc, copy inputs with cudaMemcpy, launch a 1-block kernel, and copy the result back.

Learn how cuda performs a simple addition by implementing a gpu kernel to add two integers, with host-to-device memory copies, kernel launch, and device-to-host copy to print 10.

Learn how CUDA uses blocks and grids to run kernels on the device in parallel and perform vector addition with 512 blocks, adding arrays A and B into C.

Demonstrate CUDA addition with a single block and multiple threads, indexing with threadIdx.x to add arrays on the device and copy results back.

Learn to perform vector addition on the CUDA-enabled GPU, using host and device memory, one-dimensional grid with a 512-thread block, and kernel synchronization.

map cuda threads one-to-one to matrix cells to perform basic matrix multiplication on the gpu, using 2d and 1d data layouts.

Transform the two loops into a CUDA kernel using threadIdx.x and threadIdx.y, with blocks handling chunks in shared memory to compute the output matrix.

Showcases cuda code for matrix multiplication by loading matrices A and B, transferring to the device, and executing a kernel with 2D thread blocks and shared memory.

Execute a matrix multiplication using CUDA in Visual Studio, detailing building, linking, and running on a GPU device, with notes on compute architecture and driver toolkit setup.

Install the NVIDIA container toolkit on a multi-GPU server to allocate GPUs to Docker containers using device IDs and enable GPU access for each user.

Explore cuda high level concepts focusing on gpu versus cpu throughput, data parallelism, kernels, threads, blocks, grids, and the host-device model of heterogeneous parallel programming.

The host controls the program flow, launching kernels with grid and block dimensions and using explicit barriers for synchronization. Allocate device memory and copy data between host and device.

Learn kernel syntax with the global declaration, manage host–device memory, and map threads using threadIdx.x for parallel execution, including converting a for loop to parallel threads and vector addition.

Master computing a unique CUDA thread index by combining blockIdx.x, gridDim.x, blockDim.x, and threadIdx.x, then apply this across x dimensions using dot notation for x, y, z.

Understand the CUDA memory model and thread hierarchy, detailing local, shared, and global memory, plus registers and constant memory, and how data placement impacts performance.

Learn how CUDA threads race data and how barriers synchronize threads within a block. See explicit barriers with sync threads and understand host-device synchronization and implicit barriers between kernel launches.

Explore how to access the live class and code playgrounds in your browser with a free interactive version, demo included, and no registrations required.