what is distributed training
**Distributed training is how a single model gets trained across thousands of chips at once, and the mechanism that makes it work — collective communication, most commonly all-reduce — is the direct interconnect-side counterpart to everything the training-vs-inference entry described about training's compute-heavy, cluster-scaled profile.** A model too large or a dataset too vast for one chip to handle in a reasonable time gets split across many chips working together, but splitting the work only helps if those chips can efficiently share what they compute. Each chip in a training cluster processes its own slice of data and computes its own partial update to the model's weights — a gradient — and those partial gradients from every chip have to be combined into one consistent update before any chip can move on to the next training step. That combining operation, run over and over across the entire cluster for the whole training run, is where distributed training either scales efficiently or grinds to a halt waiting on communication.
**All-reduce is the specific operation that takes each chip's local gradient and produces the same combined result on every chip, and doing it efficiently is a genuinely hard networking problem at scale.** The naive way to combine values from many chips would be to send everything to one central chip, have it sum the values, and send the result back out — but that single chip becomes a severe bottleneck the moment cluster size grows, since it has to receive from and send to every other chip. Efficient all-reduce implementations instead arrange chips into a ring or a tree and pass partial sums step by step between neighbors, so no single chip ever has to handle the full traffic load alone; by the time the pattern completes, every chip holds the identical, fully-combined result, without any one link in the network becoming the chokepoint the naive approach would create.
```svg
```
**This is where the packaging and interconnect discussion earlier in this series stops being abstract, because all-reduce's performance is dominated almost entirely by interconnect bandwidth and latency, not by compute.** Every chip in the cluster has already finished the heavy compute work — its own gradient — before all-reduce even begins; what happens next is pure data movement between chips, at a scale where even small inefficiencies in the network compound across thousands of participants and potentially millions of training steps. This is exactly why training-optimized silicon, as the earlier training-vs-inference entry described, invests so heavily in extremely fast chip-to-chip interconnects — the same underlying need for fast, standardized die-to-die and chip-to-chip communication that motivated UCIe at the packaging level shows up again here at the cluster level, just at a much larger physical scale connecting whole chips instead of chiplets within one package.
| Approach | Communication Pattern | Bottleneck Risk | Scales To |
|---|---|---|---|
| Centralized (naive) | Every chip talks to one central chip | Severe — central chip's bandwidth caps the whole cluster | Small clusters only |
| Ring All-Reduce | Chips pass partial sums to immediate neighbors | Low — no chip handles disproportionate traffic | Large clusters, common in practice |
| Tree All-Reduce | Combined in stages up and back down a tree structure | Moderate — depends on tree depth and fan-out | Very large clusters, latency-sensitive cases |
```flowchart
st=>start: Each chip computes its own local gradient from its data slice
initiate=>operation: All-reduce operation begins across the training cluster
exchange=>operation: Chips exchange partial sums with neighbors (ring) or through stages (tree)
combine=>operation: Partial sums accumulate into the full combined gradient
distribute=>operation: Combined gradient propagated back so every chip holds the identical result
update=>operation: Every chip applies the same weight update using the combined gradient
pass=>end: Cluster proceeds to the next training step in perfect sync
st->initiate->exchange->combine->distribute->update->pass
```
**For AI accelerator and cluster design, this means interconnect bandwidth between chips is just as important a spec as compute or memory bandwidth within a single chip — arguably the defining constraint once cluster size grows large enough.** A cluster with excellent per-chip compute but a weak inter-chip network spends a large fraction of every training step waiting for all-reduce to finish rather than computing, which is why training-cluster network topology, link speed, and collective-communication software receive as much engineering investment as the chips themselves. It's the same principle that ran through this whole packaging branch, applied at cluster scale instead of within one package: moving data between compute elements efficiently is often the harder and more consequential problem than making any single compute element faster.