Clock Power Beyond One Gate: Gating Trees, Clock Networks and Multi-Bit Flops
Stop the clock power that leaf gates leave behind with gates higher in the tree, and share one local clock driver.
You Will Be Able To
- Explain which cells of a clock tree a gate stops at each height.
- Choose gates at the leaves, the branches or the root from the enable duties.
- Explain why gating efficiency alone does not predict the clock power.
- Estimate what a shared local clock driver saves, from a transistor-level run.
- Lesson
- W2.4
- Time
- 30 min
- Runs on
- OpenROAD
- Check
- 5 questions
A team put a clock gate on every register bank of a block. 88.8 % of all flop-cycles now get no clock edge. Yet the block still burns 116.2 µW. 71.4 µW of that is in the clock network: the buffers and the gates themselves.
| Build | Flop-cycles with the clock stopped | Total power | Clock network (buffers and gates) |
|---|---|---|---|
| Enable muxes, no gate | 0.0 % | 430.9 µW | 89.3 µW |
| A gate on every bank | 88.8 % | 116.2 µW | 71.4 µW |
| The same, plus one gate at the root | 88.8 % | 75.8 µW | 32.2 µW |
Build-time OpenSTA estimates for four banks of 16 flops behind a three-level clock tree, 10 ns clock. The block is busy in 20 % of the cycles.
One more gate, high in the tree, cuts the clock network power in half.
A Gate Stops Everything Below It
A clock tree carries the clock from one pin to thousands of flops. It uses levels of buffers: a root buffer, branch buffers, and a leaf buffer near each group of flops. Each buffer that receives an edge charges its wire and the inputs it drives.
- Clock / reset
- Storage
- Clock
- No gate
Every buffer and every flop sees every edge. The clock network burns 89.3 µW and the flops' clock pins 312.2 µW.
- Gates at the leaves
Each bank's gate sits behind its leaf buffer. The flops stop: their pins fall to 44.8 µW. Root, branch and leaf buffers still toggle in every cycle.
- A gate at the root
The root gate closes whenever the block is idle, 80 % of the time. Both branch buffers and all four leaf buffers stop with it. The clock network falls to 32.2 µW.
- A gate on one branch
A gate in front of branch 0 stops that buffer and two leaf buffers. It pays only if branch 0 is idle more often than the gate above it.
Read the diagram as text
- Root buffer: clkbuf_8
- Root gate: dlclkp_4, en_blk
- Branch 0: clkbuf_8
- Branch 1: clkbuf_8
- Banks a, b: Leaf buffer, gate, 16 flops each
- Banks c, d: Leaf buffer, gate, 16 flops each
- Root buffer → Root gate
- Root gate → Branch 0
- Root gate → Branch 1
- Branch 0 → Banks a, b
- Branch 1 → Banks c, d
Arm's power control architecture names three levels that work together. Low: inserted by synthesis. Mid: placed inside a block. High: a whole clock domain.
The table holds every build of this block. The duties stay the same: the block is busy 20 % of the time. Banks a and b load together in 10 % of the cycles, c in 5 %, and d in every busy cycle.
| Build | Total | Clock network | Flop clock pins (Sequential) | Flop-cycles stopped |
|---|---|---|---|---|
| Enable muxes, no gate | 430.9 µW | 89.3 µW | 312.2 µW | 0.0 % |
| A gate on every bank (leaf) | 116.2 µW | 71.4 µW | 44.8 µW | 88.8 % |
| One gate behind the root, muxes in the banks | 122.7 µW | 31.3 µW | 77.8 µW | 80.0 % |
| Root gate and leaf gates | 75.8 µW | 32.2 µW | 43.7 µW | 88.8 % |
| Branch gates and leaf gates | 77.1 µW | 32.9 µW | 44.2 µW | 88.8 % |
| Root, branch 0 and leaf gates | 74.0 µW | 30.3 µW | 43.7 µW | 88.8 % |
| Root, both branches and leaf gates | 75.5 µW | 31.8 µW | 43.7 µW | 88.8 % |
Build-time OpenSTA report_power, tt, 10 ns clock, data inputs toggling 0.1 times per cycle. The clock tree is part of the netlist; wires are ideal.
One root gate with muxes in the banks burns 122.7 µW. Four leaf gates burn 116.2 µW, so one cell does almost as well as four. The best builds use both heights.
Gating Efficiency Hides the Buffers
Clock-gating efficiency is the share of flop-cycles in which a flop gets no clock edge. Reviews often quote it.
Look at the last column of the table. The leaf build and every build with a root or branch gate score the same 88.8 %. Their total power runs from 116.2 µW down to 74.0 µW.
The efficiency is the same because a flop behind several gates is stopped when its own bank idles. A gate higher up stops no extra flop-cycle. It stops buffer-cycles, and the efficiency number does not count those.
| Gate higher in the tree | Its enable is 1 in | Opens more rarely than the gate above? | Effect, with leaf and root gates in place |
|---|---|---|---|
| Branch 0 (banks a, b) | 10 % of cycles | Yes: the root opens in 20 % | 75.8 µW to 74.0 µW: saves |
| Branch 1 (banks c, d) | 20 % of cycles | No: bank d loads in every busy cycle | 74.0 µW to 75.5 µW: costs |
Build-time OpenSTA estimates. A gate whose enable is 1 whenever its parent is open never closes on its own.
So a high gate pays when its subtree idles more often than the gate above it. Its enable must also cover every bank below it. A branch gate driven by one bank's enable would stop the other bank in cycles where it must load.
Multi-Bit Flops: Share the Local Driver
Inside every flop of this library sits a small clock driver. The dfxtp_1 flop has two inverters that make clkneg (not CLK) and clkpos (CLK again). The other 20 transistors, the two latches and the input and output stages, only read those two signals.
A multi-bit flop puts several flops in one cell and shares that local driver. The clock tree then sees one clock pin instead of several. sky130_fd_sc_hd has no multi-bit flop, so this lesson builds one from the transistors of dfxtp_1.
- Clock / reset
- Storage
- Clock
- Private drivers
Each flop charges its own driver's gate, drain and wiring in every cycle. The tree buffer drives four driver inputs.
- One shared driver
One driver charges the clock inputs of all four cores. Three drivers and three clock pins are gone.
Read the diagram as text
- Tree buffer A: Drives four clock pins
- Four drivers: One per flop
- Four cores: Latches of four flops
- Tree buffer B: Drives one clock pin
- One driver: clkneg and clkpos
- Four cores: The same latches
- Tree buffer A → Four drivers: CLK x4
- Four drivers → Four cores: clkneg, clkpos x4
- Tree buffer B → One driver: CLK x1
- One driver → Four cores: clkneg, clkpos to all four
Transistors from the CDL netlist of sky130_fd_sc_hd__dfxtp_1 in the pinned OpenROAD platform.
- Bank A: four private drivers
- Bank B: one shared driver
Read the plot as a table
| Time | Bank A: four private drivers | Bank B: one shared driver |
|---|---|---|
| 4 ns | 9.103 µA | 4.681 µA |
| 6 ns | 9.115 µA | 4.693 µA |
| 8 ns | 9.583 µA | 5.503 µA |
| 10 ns | 9.584 µA | 5.506 µA |
| 12 ns | 9.895 µA | 3.699 µA |
Measured on ngspice 42, tt. Per cycle the local drivers take 71.2 fJ in bank A and 46.9 fJ in bank B.
| Clock energy per cycle | Bank A: four flops | Bank B: shared driver | Change |
|---|---|---|---|
| Last clock-tree buffer | 22.1 fJ | 8.5 fJ | 2.61 times less |
| Local clock drivers | 71.2 fJ | 46.9 fJ | 34 % less |
| Total | 93.3 fJ | 55.4 fJ | 41 % less |
The same ngspice run as the plot, five cycles at 500 MHz. Each part has its own supply source, so each is measured apart.
Here a driver the size of one flop's still makes clean edges for four cores. A driver that is too weak makes slow edges, and bits go wrong at speed.
What a Real Clock Tree Adds
The tables above use ideal wires and the buffers drawn in the netlist. A real flow places the cells, then clock tree synthesis (CTS) adds its own buffers and routes the clock. Wires add capacitance, so real clock power is higher.
The lab runs the root-and-leaf build through placement and CTS. It reports 0.1542 mW in the clock network and 0.241 mW in total. The leaf-only build through the same flow reports 0.2719 mW and 0.4226 mW.
The flow cannot set the enable duties: OpenSTA uses its default activity for every input. So these numbers do not match the tables. They agree on the direction: the root gate cuts the clock network power 1.8 times here.
Asked in interviews
Why gate the clock high in the tree?
A gate stops every buffer below it as well as the flops. Leaf gates stop only the flops, and the tree above them keeps toggling. When a whole block idles, one high gate removes most of its clock network power.
What is clock-gating efficiency, and what does it miss?
It is the share of flop-cycles in which the clock is stopped. It counts flops, not buffers, so two designs with the same efficiency can differ a lot in clock power. Read the clock network row of the power report as well.
What does a multi-bit flop save?
It shares one local clock driver among several flops. The clock tree drives fewer clock pins, and the extra drivers' own capacitance disappears. The latches' clock load stays. The cell must also fit the placement and keep its timing.
How do you enable a branch-level clock gate?
With the OR of every enable below it, so that no bank loses an edge it needs. Its gate has a setup check like any clock gate, and the OR adds delay to that path.
Try It
This lab places the block, builds its clock tree, and runs report_power. Open the Clock tree stage and read the total power and the clock power.
It reports 0.241 mW in total and 0.1542 mW in the clock network, at OpenSTA's default activity.
Now remove the root gate. In the netlist, delete the cg_root line, and change .A(r1) to .A(cr) in both brbuf lines. Predict the clock power, then run. The leaf-only build measured 0.2719 mW.
Open Layout and find the root gate between the root buffer and the two branch buffers.
Run to draw the timing paths here.
Run the flow to see each stage of the layout here.
clock tree totalPower 0.241 clock tree clockPower 0.1542Check Yourself
Common Mistakes
Wrong Enable a branch gate from the enable of one bank below it.
The other bank on that branch then loses its clock in cycles where it must load, and the design no longer works.
Fix Enable a high gate from the OR of every enable below it, and time that path to the gate.
assign en_br1 = en_c;assign en_br1 = en_c | en_d;Wrong Make the shared driver of a multi-bit flop as weak as possible, to save more energy.
Slow clkneg and clkpos edges let both latches of a flop conduct at once, so bits go wrong at speed.
Fix Check every bit at the target clock and corner, and size the driver just strong enough.
Wrong Compare clock power from an ideal-clock OpenSTA run with clock power after clock tree synthesis.
The two runs model different cells and wires, so their difference is not the effect of your change.
Fix Compare two designs through the same flow, stage and activity.
Remember
- A clock gate stops everything below it in the tree: buffers as well as flops.
- Leaf gates stop the flops; the buffers above them keep toggling. A gate high in the tree stops them while the block idles.
- A higher gate pays only if its enable is 0 more often than the gate above it. Its enable must cover every bank below.
- Clock-gating efficiency counts flop-cycles, not buffer-cycles. Read the clock network power too.
- A multi-bit flop shares the local clock driver: fewer clock pins and less driver capacitance, the same latch load.