Have you ever profiled a kernel, seen it hit a wall well below the throughput the hardware should be capable of, and had absolutely no idea why?
That question is really what this book is for.
Most GPU programming resources stop at the point where your code compiles and runs correctly. They teach you how to write parallel kernels, how to manage memory, how to launch a grid of threads — and then they leave you there, assuming the compiler will handle everything else. For a lot of work, that's fine. But if you've ever asked yourself why two kernels that look almost identical on paper perform completely differently in practice, or why a profiler keeps telling you something is "memory-bound" without ever explaining what to actually do about it, you already know that stopping at the high-level language isn't enough.
So what does this book actually cover?
It takes you underneath the compiler, into the native assembly instructions that a modern parallel processor actually executes — how to read them, how to disassemble compiled code and understand what you're looking at, and how to connect what you see in that low-level output back to the C++ you originally wrote. From there, it works through the full stack of what real performance engineering involves: how thousands of threads actually get scheduled on the hardware, why memory access patterns can make or break your throughput, how synchronization and atomic operations behave under contention, and how to squeeze more out of individual instructions once the bigger structural issues are solved.
Is this only for people chasing raw speed for its own sake?
Not really. A lot of it is about knowing where your time is actually being spent, rather than guessing. You'll work through how to use profiling tools properly — not just running them and staring at a wall of numbers, but reading the metrics that actually tell you whether you're bound by computation, by memory bandwidth, or by something more subtle like poor occupancy or unnecessary synchronization. There's a full section on debugging at this level too, for the kind of bug that doesn't show up consistently and doesn't make sense until you can see what individual threads are actually doing.
Who is this actually written for?
Honestly, it assumes you already know how to write and launch parallel kernels. If you're completely new to GPU programming, this probably isn't your starting point — but if you've written kernels before and you're ready to understand what happens after you hit compile, this is built for exactly that stage. It's aimed at engineers working on machine learning infrastructure, people doing high-performance and scientific computing, anyone building latency-sensitive graphics or real-time applications, and honestly, anyone who's just curious enough about what's happening inside the hardware to want the real answer instead of a surface-level one.
Does it stay theoretical, or is it actually practical?
Every concept in this book is tied to real, disassembled code and real profiler output — not abstract descriptions of what "should" happen. You'll see actual instruction sequences, actual before-and-after comparisons, and actual case studies of kernels being diagnosed and rebuilt from the ground up. It also covers mixed-precision computation, multi-device scaling, and how to build a repeatable, professional workflow around performance work — the kind of process that holds up in a real engineering team, not just in a one-off benchmark.
If you're tired of performance tuning that feels like guesswork, this is meant to be the book that finally makes it feel like engineering instead.
