clock tree synthesis
**Clock tree synthesis (CTS)** is the physical-design step that builds a balanced distribution network to deliver the clock signal from a single source (PLL output) to thousands or millions of sequential elements (flip-flops, latches, SRAMs) across the die — with minimum skew (difference in arrival time between any two endpoints), controlled insertion delay, and bounded transition time. A modern AI accelerator at 1–2 GHz may have 10–50 million flip-flops grouped into hundreds of clock domains; the clock tree that drives them consumes 30–40% of total chip dynamic power and is the single largest contributor to signal integrity and timing closure difficulty.
**Why clock skew matters.** Every flip-flop in a synchronous design samples data on the clock edge. If two flip-flops on the same combinational path see different clock arrival times, the effective setup or hold margin shifts:
$$T_{\text{setup,eff}} = T_{\text{clk}} - t_{\text{comb}} - t_{\text{setup}} - (t_{\text{clk,launch}} - t_{\text{clk,capture}})$$
$$T_{\text{hold,eff}} = t_{\text{comb}} - t_{\text{hold}} + (t_{\text{clk,launch}} - t_{\text{clk,capture}})$$
Positive skew (launch arrives before capture) helps setup but hurts hold; negative skew does the opposite. Uncontrolled skew of even 20–30 ps at a 1 GHz clock (1000 ps period) can violate hundreds of timing paths, requiring expensive ECO fixes or frequency derating.
**CTS algorithms — H-tree, fishbone, and buffer tree.** The fundamental goal is to equalize wire delay from source to every sink:
| Topology | Structure | Skew | Power | Use case |
|---|---|---|---|---|
| H-tree | Symmetric binary branching (fractal H-shape) | Very low (inherently balanced) | Moderate | Small, regular arrays (SRAM, register file) |
| Fishbone / spine | Central trunk with lateral branches | Low (trunk balanced, branches short) | Low (fewer buffers) | Datapaths with regular placement |
| Buffer tree (CTS engine) | Irregular tree of buffers/inverters built by tool | Tool-optimized | Optimized | General logic (primary method) |
| Mesh + tree | Global mesh for low-skew distribution, local trees from mesh taps | Very low | High (short-circuit current in mesh) | High-performance CPUs, GPUs |
| Hybrid mesh-tree | Mesh at top level, trees below | Low | Moderate-high | AI accelerators |
**The CTS flow — what the EDA tool does.** After placement, the CTS engine (Innovus CCOpt, ICC2 CTS):
1. **Clustering** — groups flip-flops by physical proximity and clock domain into balanced clusters (~32–256 sinks per leaf buffer).
2. **Tree construction** — builds a multi-level buffer tree from source to clusters, inserting clock buffers (CK-BUF) or inverters (CK-INV) to drive the capacitive load at each branch point. Buffer sizing is chosen to meet transition-time constraints (typically <50 ps slew at each stage).
3. **Skew balancing** — adjusts wire detours (snaking) and buffer delays to equalize path lengths. Target: local skew <10–15 ps; global skew <30–50 ps.
4. **Useful skew (intentional skew)** — CTS can deliberately skew certain endpoints to help setup-critical paths (borrow time from the next cycle) — a controlled trade-off that synthesis tools exploit during optimization.
5. **OCV / AOCV derating** — after CTS, timing analysis accounts for on-chip variation (voltage/temperature gradients, process mismatch) that adds random skew on top of the tree's systematic skew.
**Power — the clock tree's dominant cost.** The clock net toggles every cycle at full frequency. Its dynamic power:
$$P_{\text{clock}} = \alpha \cdot C_{\text{tree}} \cdot V_{\text{DD}}^2 \cdot f$$
where $\alpha$ = 1 (full activity), $C_{\text{tree}}$ is the total capacitance of all clock wires + buffer input caps + flip-flop clock pins. In a 5 nm GPU, $C_{\text{tree}}$ can exceed 10 nF, giving >5 W of clock-tree power at 1.5 GHz and 0.75 V — motivating clock gating (shutting off branches to idle blocks, reducing effective $\alpha$ to 0.3–0.5).
**Clock gating — the primary power optimization.** An integrated clock gating (ICG) cell (latch + AND/OR gate) gates the clock to a group of flip-flops: when the enable signal is low, the downstream clock stops toggling and those flops hold state with zero dynamic power. A well-gated design achieves 40–70% clock-tree power reduction. CTS must build the tree considering gating cells as intermediate nodes — each ICG is both a sink (from the parent tree) and a source (for the gated subtree).
```svg
```
**Multi-domain CTS in AI accelerators.** A GPU or TPU has dozens of independent clock domains — the shader cores run at one frequency, the memory controller at another, the NoC at a third. Each domain gets its own tree, and crossings between domains use synchronizers (2-flop or FIFO). The CTS tool must respect domain boundaries, insert proper buffers at each domain root (often driven by a separate PLL or clock divider), and verify that no clock signal leaks across domains. At 50+ million flip-flops and 30+ domains, CTS runtime is one of the longest single steps in the physical-design flow (hours to days on a high-end server).
**CTS and the CFS ecosystem.** Clock tree performance ties directly to multiple CFS simulators: the Transistor Simulator at /transistor determines buffer drive strength and leakage; the Interconnect Simulator at /interconnect models wire RC delay in the clock nets; and the Thermal Simulator at /thermal captures the self-heating from clock-tree power dissipation across the die.