IC / chip design

standard cell

Imagine building with Lego bricks. Every brick is moulded to the same height and snaps onto the same grid, so you never have to think about whether two of them will line up — you just click them together in rows and the structure holds. A standard cell is that brick for chip design: a small, pre-designed, pre-verified chunk of logic — a single inverter, a two-input NAND, a flip-flop — drawn once by a library team (the foundry or an IP vendor) and reused millions of times across a chip. Every cell in a library shares the same fixed height, with power and ground rails running along its top and bottom edges, so the tools can abut them side by side into neat rows without hand-routing each one.

The "standard" part is really a contract between the cell and the automated tools. Because every cell has a known function, a known footprint, and known electrical behaviour, synthesis can pick cells to implement your RTL, and place-and-route can pack them into rows and wire them together — all without a human drawing a single transistor. That behaviour is characterised by circuit simulation: for each cell the library team computes its delay (as a function of input transition and output load), its input capacitance, and its power across a range of process, voltage, and temperature corners, and ships those numbers in a library file. Timing analysis then reads those numbers to decide whether your design meets its timing.

A library typically holds hundreds of cells: the same logical function comes in several drive strengths (a weak inverter that sips power and a beefy one that can charge a long, heavily-loaded wire quickly), plus variants tuned for low leakage versus high speed (different threshold-voltage flavours). The art of synthesis is choosing the right cell for each spot — small and slow where there's slack to spare, large and fast on the critical path. The cells themselves are built from CMOS transistors, but as a designer you mostly treat each one as a sealed, trustworthy brick.

NAND2_X1 u_nand (.A(sel), .B(data), .ZN(n1));
DFF_X1   u_reg  (.D(n1), .CK(clk), .Q(out));

After synthesis, your RTL is no longer behavioural code but a netlist of standard-cell instances — for example, a NAND gate and a flip-flop wired together. The cell names (NAND2_X1, DFF_X1) and pin names come from the library; the same design re-synthesised against a different library would use that library's cell and pin names instead.

Standard cells are the "automatable" middle ground on a spectrum. At one extreme is hand-crafted full-custom layout (maximum performance, enormous effort, reserved for things like high-speed I/O or analog blocks); at the other are large pre-built hard blocks, including the SRAMs and register files spun out by memory compilers. Standard cells are what make modern digital design tractable — you describe behaviour, and the tools assemble pre-built bricks to match.

Also called
celllibrary cellstandard-cellstdcell标准单元標準單元