
Scaling Production-Ready AI Workloads
A Systems Engineering Guide to Measuring and Improving Model Training and Inference With GPUsBy Kenji WatanukiLength14h 43m
About this audiobook
Your model works. It is also three times slower and five times more expensive than it needs to be, and nobody on the team can say why.
Most AI performance problems are not solved by trying random optimisations until something improves. They are solved by building a model of the workload, measuring where time and memory actually go, and then applying the right fix to the right bottleneck. This book gives you that method. You will learn to construct a roofline for a real workload, classify whether it is compute-bound, memory-bound, or communication-bound, and only then reach for a fix. That discipline separates teams that ship reliable, cost-effective systems from teams that keep guessing.
Starting from GPU architecture and profiling fundamentals, the book moves through the full stack of production AI systems. You will profile kernels and input pipelines, adopt reduced precision without silently losing accuracy, fuse operators, and choose intelligently between data, tensor, pipeline, and sharded-optimiser parallelism once communication starts dominating. On the serving side, you will implement continuous batching, manage the key-value cache, apply quantisation and distillation with measured trade-offs, and size capacity against real latency objectives. Every technique is presented with the measurement that tells you whether it worked.
What you will learn:
• Build a performance model that predicts whether a workload is compute-, memory-, or communication-bound before you change a line of code
• Profile GPU kernels and data pipelines to find the real bottleneck instead of the assumed one
• Keep accelerators fed with input pipelines that do not stall on I/O or preprocessing
• Apply mixed precision and numerical techniques without degrading model quality
• Optimise at the kernel level through operator fusion and memory-aware implementation
• Choose between data, tensor, pipeline, and sharded-optimiser parallelism as communication begins to dominate
• Measure and improve interconnect and scaling efficiency across multi-GPU and multi-node training
• Design inference serving with continuous batching, key-value cache management, and quantisation or distillation trade-offs
• Size capacity and cost against explicit latency and service objectives, then operate the system in production
For machine learning engineers, platform and systems engineers, and technical leads running training or inference at scale, this is the systems engineering guide that turns performance work from folklore into a repeatable engineering practice.
Audiobook details
GenreTechnology
Length14 hrs 43 mins
Narrated byListen with 1,000+ voices
FormateBook with Audio
Publish dateSep 27, 2026
LanguageEnglish
Table of contents
1Scaling Production-Ready AI Workloads
2Foreword
3Preface
4About This Book
5Chapter 1: A Performance Model for AI Systems
Show all chaptersShow less
61.1 Latency, Throughput, and the Shape of the Curve
71.2 Arithmetic Intensity and the Memory Wall
81.3 Building a Roofline for a Workload
91.4 Classifying the Bottleneck
101.5 Amdahl, Gustafson, and the Cost of a Fix
111.6 A Worked End-to-End Performance Audit
12Chapter 2: GPU Architecture for Systems Engineers
132.1 Streaming Multiprocessors and the Execution Model
142.2 The Memory Hierarchy and Its Costs
152.3 Tensor Cores and Matrix Units
162.4 Latency Hiding and the Occupancy Trade
172.5 Hardware Classes and What They Imply
18Chapter 3: Measure Before You Optimise
193.1 What to Measure and Why
203.2 Profilers and Kernel Timelines
213.3 Hardware Counters and Derived Ratios
223.4 Benchmark Hygiene and Variance
233.5 Building a Repeatable Microbenchmark
24Chapter 4: Data Pipelines That Keep Accelerators Fed
254.1 Diagnosing a Starved Accelerator
264.2 Sharded Storage and Read Patterns
274.3 Prefetch Depth and Worker Sizing
284.4 The Real Cost of Augmentation
294.5 Caching, Determinism, and Reproducibility
30Chapter 5: Mixed Precision and Numerics
315.1 Reduced-Precision Formats
325.2 Loss Scaling and Gradient Underflow
335.3 Accumulation Order and Numerical Error
345.4 Verifying Accuracy Didn’t Move
35Chapter 6: Kernel-Level Optimisation
366.1 Operator Fusion and Traffic Reduction
376.2 Coalescing, Tiling, and Shared Memory
386.3 Writing and Reading Custom Kernels
396.4 Compiler Backends and Graph Capture
40Chapter 7: Distributed Training Strategies
417.1 Data Parallelism and Gradient Reduction
427.2 Tensor Parallelism
437.3 Pipeline Parallelism and Bubble Cost
447.4 Sharded Optimizers and State Memory
457.5 Composing Strategies
46Chapter 8: Interconnect and Scaling Efficiency
478.1 Collective Communication Patterns
488.2 Fabric Topology and Bandwidth Tiers
498.3 Overlapping Communication with Compute
508.4 Measuring Scaling Efficiency