Spend memory on enough ready work to hide bounded stalls
Budget buffered representations across ranks and workers while separating latency overlap from sustained production capacity.
On this page
The question for today
What you’ll understand
- Estimate the payload and auxiliary memory of prefetched batches.
- Relate ready-buffer depth to a bounded producer interruption.
- Explain why deeper prefetch does not repair a sustained rate deficit.
Increasing prefetch depth removes occasional input waits, then a larger setting exhausts host memory. The queue contains decoded tensors, not the much smaller compressed files listed in the dataset. Prefetch trades memory for overlap and short-term resilience to stalls. Its useful depth depends on the representation being buffered, the number of concurrent ranks and workers, and the consumer's rate. A budget must include the whole input path rather than multiply one configured depth and call it total process memory.
Count the representation at each buffering boundary
A batch may exist as compressed records, decoded arrays, transformed tensors, a collated result, and a pinned transfer buffer at different stages. The same sample count can therefore imply very different resident bytes. TensorFlow's performance guide notes that placing size-expanding transformations before buffered operations changes memory use. Decide where buffering occurs and identify which allocations coexist rather than assuming every representation is an additional independent full copy. Include decoder scratch space, metadata, allocator behavior, and framework queues. Measure the largest relevant batches as well as the average, especially when sequence lengths or image resolutions vary.
PyTorch 2.9 defines prefetch_factor as batches loaded in advance per worker when using worker processes. Multiple local training ranks can each own a loader and multiply the host-level budget. This parameter is not a complete exact resident-memory formula: dispatched work, collation, pinned staging, and active consumption can have different lifetimes. Use the configured product as one planning term, then measure actual allocations under representative load. Also check shared-memory and pinned-memory pressure. Avoid spending all available host memory on estimated queued payload while leaving no room for source metadata, worker state, or the training process.
A ready buffer covers an interval, not an unlimited deficit
Suppose D batches are ready and the consumer uses r batches per second. If production stops completely, D/r seconds is the ideal coverage time before the buffer empties. This is a simple inventory bound, not a guarantee under variable batch costs, transfer delays, or scheduling. Size for the interruption you intend to absorb and test it. A larger buffer can hide a brief remote-read pause while increasing recovery-state size and memory. If the producer's sustained rate remains below consumption, every finite initial buffer eventually empties; depth postpones the stall rather than removes its cause.
When production and consumption overlap, steady-step time can approach the slower of preparation and model work instead of their sum, subject to shared-resource limits. Warmup and pipeline fill still cost time, and very short runs may not benefit enough to amortize them. Check whether the ready queue is often empty, usually full, or oscillating with bursts. An always-full queue suggests extra depth may bring little benefit, while repeated emptiness requires investigating the source of stalls or average capacity. Compare useful delivered work and memory together, keeping batch shape and visitation semantics constant.
Tune depth within an observed system budget
Increase depth in bounded increments while measuring training waits, peak host memory, shared-memory use, and transfer staging. Revisit the budget after changing workers, local ranks, batch size, dtype, or transforms. Persistent workers may retain dataset state between epochs; cached preprocessing can consume another substantial pool. An automatic tuning feature still operates within a real resource envelope and does not make bytes free. Define behavior under pressure rather than allowing repeated out-of-memory worker failures to silently alter input visitation through retries or skipped samples.
The queue lab depicts depletion of an already-ready inventory. Reset, set both arrival λ=0 and service μ=4, predict the empty time, then Play or Step. Starting at four fluid batches, the model reaches zero after one second, or two half-second Steps. This is an uncapped deterministic queue, not a configurable prefetch buffer or an allocator, and its service represents consumption in this analogy. It illustrates coverage during a complete producer stall only. A real prefetch design must separately enforce a finite capacity and account for each stored representation's actual bytes.
Work it through
Budget all explicitly separate host allocations
A fictional host runs two training ranks. Each uses four loader workers and prefetch factor two, with 64 samples per batch and 256 KiB per decoded sample. Assume all configured queued payloads coexist, plus separate scratch 64 MiB, pinned staging 64 MiB, and main-process input allocations 32 MiB across the host.
One decoded batch occupies 64×256 KiB=16384 KiB=16 MiB. Each rank’s estimated queued payload is 4×2×16=128 MiB.
Two ranks therefore queue 256 MiB. Under the explicitly separate-allocation assumption, total input memory is 256+64+64+32=416 MiB.
This is a planning estimate, not measured peak resident memory. Validate allocation sharing and lifetimes, and leave room for the training application, metadata, fragmentation, and larger-than-typical batches.
The specified terms total 416 MiB. Counting only one rank’s 128 MiB queue would omit most of the stated host input budget.
The living notebook
Explore the model
Interactive lab · queue
Watch a ready inventory empty during a producer stall
Reset, set both λ=0 and μ=4, predict, then Play or Step. The four-unit fluid backlog reaches zero at 1 second, two half-second Steps. Here service represents batch consumption. This uncapped fixed-rate model has no prefetch-depth control, byte accounting, allocator, or real loader.
- Fluid backlog
- 4
- Net rate · λ − μ
- −1 /s
- M/M/1 mean residence
- 1 s
Fluid backlog starts at 4 and follows max(0, 4 + (λ − μ)t). The separate M/M/1 residence-time formula assumes Poisson arrivals, exponential service and λ < μ. Parameter changes pause playback and recompute the model at the current elapsed time. Reset restores both parameters and returns time to zero. Playback starts paused. Adjust either parameter, then choose Play or Step.
Look forA finite ready inventory hides only a bounded interruption. Sustained production capacity and the actual memory budget require separate measurements.
Pause & reason
Check your understanding
Your turn
Try it yourself
A ready queue has six batches and production pauses. Consumption is 75 batches/s. Compute ideal coverage time. If each batch occupies 12 MiB, what payload is stored?
Take a moment to make a prediction or work it out on paper. Open a hint when you need one.
Give me a hint
Divide batch count by batch rate, and multiply count by bytes per batch separately.
Compare with the solution
Coverage is 6/75=0.08 seconds, or 80 ms, under fixed consumption with no replenishment. Stored payload is 6×12=72 MiB, excluding scratch, metadata, pinned copies, and active batches.
Keep the idea
Take it with you
- Budget actual buffered representations across every local rank and worker.
- Prefetch hides bounded stalls and overlaps stages but does not create sustained capacity.
- Measure peak memory and wait reduction together when tuning depth.
Read further
Original sources and deeper explanations to follow at your own pace.
Optional progress, saved in this browser when available. Revisit any lesson at any time.
Lesson not marked complete.