a domain-specific architecture
Imagine a kitchen full of all-purpose chef's knives. One good knife can do almost anything — chop, slice, peel — which is wonderful when you do not know what dish is coming. But if your restaurant serves nothing but sushi all day, every day, a rack of dedicated sushi tools will out-cut the general knife, work faster, and tire the chef's hand less. A domain-specific architecture is hardware built that way: instead of a general-purpose CPU that runs any program tolerably, it is a processor shaped around the patterns of one narrow domain (deep learning, video, networking) so that it runs that one kind of work far faster and with far less energy.
Concretely, a DSA is not a whole new way of computing — it is a CPU's transistors re-spent. The architect studies the target workload and notices, for example, that deep learning is almost entirely matrix multiplication on low-precision numbers with very predictable, streaming memory access. So they strip out the things that domain does not need (deep speculation, big out-of-order windows, large general caches) and pour the freed silicon into what it does need: hundreds of small multiply-add units, software-managed scratchpad memories instead of automatic caches, and arithmetic narrowed to int8 or bfloat16. The result is a machine that is excellent at one job and useless at most others. Google's TPU, video codec blocks, and crypto engines are all DSAs.
The honest framing: a DSA wins on efficiency precisely because it gives up generality. That is a real trade, not a free lunch. It only pays off when the domain is big enough and stable enough to justify the huge design and verification cost, and when the workload genuinely has the parallelism and tolerance for lower precision the design assumes. DSAs became the central story of the post-Moore, post-Dennard era because general-purpose chips stopped getting automatically faster — so the only way to keep gaining was to specialize.
A general CPU running a neural-network layer might spend most of its energy fetching instructions, predicting branches, and shuffling a general cache — overhead that has nothing to do with the actual multiplies. A DSA for the same layer removes that overhead: it streams the data through a grid of multiply-add units, doing thousands of useful arithmetic operations for every control decision.
A DSA re-spends a CPU's silicon: less control overhead, far more arithmetic, for one chosen domain.
A DSA is not 'a better CPU' — it is a worse CPU at everything except its target. Outside its domain it can be slower than a cheap general processor, so it must be paired with one in a heterogeneous system rather than replacing it.