GPU execution and synchronization

Understand thread hierarchy, execution ordering, synchronization scope, and launch overhead before optimizing device programs.

10 published lessons1 module240 min of guided study
  1. 01
    GPU execution and synchronizationcore · 10 lessons

Follow the path or begin with a question. Every lesson is open.

Your notebook0 of 10 lessons completed

Your place, at your pace. Progress is optional and saved only in this browser when available.

Inside this module

Each lesson includes an interactive lab

GPU execution and synchronization

Understand thread hierarchy, execution ordering, synchronization scope, and launch overhead before optimizing device programs.

  1. 01

    Threads, blocks, and warps: map work without assuming an order

    Trace CUDA indices, partial warps, block independence, and the difference between launched threads and useful elements.

    24 min
  2. 02

    SIMT divergence: count active lanes without assuming lockstep

    Analyze branch paths within a warp and use explicit synchronization under Volta-style independent thread scheduling.

    24 min
  3. 03

    SM residency: account for every binding resource

    Calculate an explicit hypothetical residency bound using effective allocated registers, shared memory, threads, and block limits.

    24 min
  4. 04

    Occupancy: a latency-hiding tool, not the performance score

    Separate resident warp fractions from ready work, memory traffic, arithmetic intensity, and measured application throughput.

    24 min
  5. 05

    Synchronization scopes: order the right memory for the right participants

    Separate warp and block barriers, memory fences, atomic publication, and host-visible completion.

    24 min
  6. 06

    Streams: order work without assuming overlap

    Trace same-stream dependencies, independent streams, host buffer lifetime, and the configured default-stream mode.

    24 min
  7. 07

    Events: connect streams without blocking the entire device

    Trace record and wait placement, event timing boundaries, and safe buffer reuse.

    24 min
  8. 08

    Launch overhead and graphs: amortize a repeated dependency structure

    Compare declared submission budgets, graph setup costs, and device critical paths without promising universal acceleration.

    24 min
  9. 09

    Cooperative grids: synchronize only within a supported launch

    Calculate a hypothetical all-resident grid limit and explain why ordinary inter-block spinning can deadlock.

    24 min
  10. 10

    Asynchronous errors: find the failing work, not just the reporting call

    Separate API and launch checks from execution completion, then use scoped synchronization and sanitizer evidence to narrow a device fault.

    24 min
All engineering modules