Recovery and Removal: Timing the Reset Release
Time the release of an asynchronous reset through a synchronizer, and write an SDC that keeps that release timed.
You Will Be Able To
- Explain why a reset may assert at any time but must release on a clock edge.
- Read the recovery and removal paths of a reset synchronizer.
- Write an SDC that cuts the raw reset input but keeps the synchronized release timed.
- Predict how clock skew changes the removal slack.
- Lesson
- T3.1
- Time
- 30 min
- Runs on
- OpenROAD
- Check
- 5 questions
A reset synchronizer passes every simulation, and its first timing run shows no violation. Yet the removal slack at the data flop is only 0.0037 ns, with an ideal clock and no skew at all. After clock tree synthesis, a capture clock just 0.05 ns late makes it fail.
rs2 → ffremoval check, earliest arrival1 cell
- Clock latency
- Cell delay
- Removal time
- The release starts at an edge
The clock edge at 0 ns makes rs2's output rise, which releases ff from reset.
- Clock to Q
The output of rs2 rises 0.3412 ns after the clock edge reaches its CLK pin.
- The removal time
The data flop ff needs the release to come no sooner than 0.3375 ns after the same edge.
- Barely met
Slack = 0.3412 − 0.3375 = 0.0037 ns.
Read the path as a table
Launch: clk rise edge at 0.0000 ns, clock latency 0.0000 ns (ideal). Capture: clk rise edge at 0.0000 ns, latency 0.0000 ns, library removal time 0.3375 ns.
Arrival 0.3412 ns, required 0.3375 ns, slack 0.0037 ns (met).
| Cell | Arc | Through | Edge | Delay (ns) | Time (ns) | Slew (ns) |
|---|---|---|---|---|---|---|
| 1 | rs2/CLK → rs2/Q | dfrtp_1 | rise | 0.3412 | 0.3412 | 0.0533 |
rs2/Q → ff/RESET_B | wire s2 | rise | 0.0000 | 0.3412 | 0.0533 |
The report
Startpoint: rs2 (rising edge-triggered flip-flop clocked by clk)
Endpoint: ff (removal check against rising-edge clock clk)
Path Group: asynchronous
Path Type: min
Fanout Cap Slew Delay Time Description
-------------------------------------------------------------------------------------
0.1000 0.0000 0.0000 clock clk (rise edge)
0.0000 0.0000 clock network delay (ideal)
0.1000 0.0000 0.0000 ^ rs2/CLK (sky130_fd_sc_hd__dfrtp_1)
1 0.0036 0.0533 0.3412 0.3412 ^ rs2/Q (sky130_fd_sc_hd__dfrtp_1)
s2 (net)
0.0533 0.0000 0.3412 ^ ff/RESET_B (sky130_fd_sc_hd__dfrtp_1)
0.3412 data arrival time
0.1000 0.0000 0.0000 clock clk (rise edge)
0.0000 0.0000 clock network delay (ideal)
0.0000 0.0000 clock reconvergence pessimism
0.0000 ^ ff/CLK (sky130_fd_sc_hd__dfrtp_1)
0.3375 0.3375 library removal time
0.3375 data required time
-------------------------------------------------------------------------------------
0.3375 data required time
-0.3412 data arrival time
-------------------------------------------------------------------------------------
0.0037 slack (MET)OpenSTA 3.1.0 on the sky130 tt library, ideal 2 ns clock with a 0.1 ns slew. The path group is asynchronous.
Assert at Once, Release on an Edge
An asynchronous reset pulls a flop to 0 at once, without waiting for a clock edge. That part is safe, because every flop simply goes to its reset value. The danger is the release, when the reset pin goes inactive again. If it changes too close to a clock edge, the flop may leave reset at this edge or the next one.
A reset synchronizer, as in R2.2 and R6.5, fixes the release. Two flops with their D tied high pass the release along on two clock edges. Their output then reaches every other flop just after an edge, like ordinary data.
rst_n. The flops rs1 and rs2 form the synchronizer, and rs2 drives the RESET_B pin of ff.- Cycle 1
The input
rst_nfalls between edges. The flops rs1, rs2 and ff are all cleared at once, with no clock. - Cycle 3
The input
rst_nrises at a random time. The flop rs1 may go metastable here, which is why a second flop follows it. - Cycle 5
The flop rs2 rises just after a clock edge. Its release is now a timed path into ff, checked by recovery and removal.
These are logic values per cycle; the timing of the last step is what STA checks.
The Two Checks on the Synchronized Release
The release from rs2 to ff gets two checks in the asynchronous path group. Recovery is like setup: the release must arrive early enough before the next edge. Removal is like hold: it must not arrive too soon after the edge that launched it.
| Check | Like | Edge pair here | Library time | Slack (ns) |
|---|---|---|---|---|
| recovery | setup | launch 0 ns, capture 2 ns | −0.2451 ns (required = edge + 0.2451) | 1.9039 |
| removal | hold | launch 0 ns, capture 0 ns | 0.3375 ns | 0.0037 |
The rst design at a 2 ns ideal clock. Both checks see the same release, which arrives at the same time.
Recovery has plenty of room: 1.9039 ns. Its library value is negative, so subtracting it moves the required time 0.2451 ns after the next edge. Removal is the tight one. The clock-to-Q delay of rs2, 0.3412 ns, beats the removal time of 0.3375 ns by only a few picoseconds.
The recovery path of the same release
rs2 → ffrecovery check, latest arrival1 cell
- Clock latency
- Cell delay
- Recovery time
Read the path as a table
Launch: clk rise edge at 0.0000 ns, clock latency 0.0000 ns (ideal). Capture: clk rise edge at 2.0000 ns, latency 0.0000 ns, library recovery time 0.2451 ns.
Arrival 0.3412 ns, required 2.2451 ns, slack 1.9039 ns (met).
| Cell | Arc | Through | Edge | Delay (ns) | Time (ns) | Slew (ns) |
|---|---|---|---|---|---|---|
| 1 | rs2/CLK → rs2/Q | dfrtp_1 | rise | 0.3412 | 0.3412 | 0.0533 |
rs2/Q → ff/RESET_B | wire s2 | rise | 0.0000 | 0.3412 | 0.0533 |
The report
Startpoint: rs2 (rising edge-triggered flip-flop clocked by clk)
Endpoint: ff (recovery check against rising-edge clock clk)
Path Group: asynchronous
Path Type: max
Fanout Cap Slew Delay Time Description
-------------------------------------------------------------------------------------
0.1000 0.0000 0.0000 clock clk (rise edge)
0.0000 0.0000 clock network delay (ideal)
0.1000 0.0000 0.0000 ^ rs2/CLK (sky130_fd_sc_hd__dfrtp_1)
1 0.0036 0.0533 0.3412 0.3412 ^ rs2/Q (sky130_fd_sc_hd__dfrtp_1)
s2 (net)
0.0533 0.0000 0.3412 ^ ff/RESET_B (sky130_fd_sc_hd__dfrtp_1)
0.3412 data arrival time
0.1000 2.0000 2.0000 clock clk (rise edge)
0.0000 2.0000 clock network delay (ideal)
0.0000 2.0000 clock reconvergence pessimism
2.0000 ^ ff/CLK (sky130_fd_sc_hd__dfrtp_1)
0.2451 2.2451 library recovery time
2.2451 data required time
-------------------------------------------------------------------------------------
2.2451 data required time
-0.3412 data arrival time
-------------------------------------------------------------------------------------
1.9039 slack (MET)The max path of the same run. The capture edge is at 2 ns.
The Unsafe Window
Put the two limits on one time axis, measured from a clock edge. A release that lands before edge + 0.2451 ns meets recovery, so ff leaves reset at that edge. A release that lands after edge + 0.3375 ns meets removal, so ff leaves reset one edge later.
- Cycle 0
A release right after the edge still counts for this edge: the recovery limit lies after it.
- Cycle 12
From 0.2451 ns the release is too late for recovery at this edge.
- Cycle 17
From 0.3375 ns it meets removal, so ff leaves reset at the next edge.
The window is 92 ps wide here. The synchronized release from rs2 lands at 0.3412 ns, just past it.
Both checks together keep the release out of that window. The window sits after the edge, not around it, because this library's recovery value is negative.
Clock Skew Eats the Removal Margin
Removal compares a launch and a capture on the same edge, like hold. It fails for the same reason as hold: a capture clock that arrives late. If ff's clock comes later than rs2's, the release must also wait longer, and the margin shrinks by the skew.
With an ideal clock, both flops see the edge at 0 ns, but after clock tree synthesis they never quite do. That is why a removal check signed off before the tree exists means little. Recheck it with propagated clocks, as PD L5.5 does for hold.
The fixes are the same as the hold fixes. Add a little delay on the release net from rs2 to ff. Or balance the clock tree so that ff's clock is not late. Making the clock period longer does nothing at all for removal.
Big Reset Trees: Where Recovery Fails
On a real chip one synchronizer releases thousands of flops through a buffer tree. The tree's delay pushes the release later. That helps removal and costs recovery, so in big designs recovery is often the check that fails.
| Run of rsttree | Worst recovery (ns) | At | Worst removal (ns) |
|---|---|---|---|
| 2.0 ns clock | 1.4945 | fs | 0.2419 |
| 0.5 ns clock | -0.0055 | fs | 0.2419 |
| 0.5 ns, two-cycle release | 0.4945 | fs | 0.2419 |
A synchronizer, a buf_2 and four buf_1 drive sixteen dfrtp_1 flops and one dfstp_1 (fs, a SET_B pin).
The tree adds about 238 ps of removal margin over the single flop of rst. At a 0.5 ns clock, recovery fails instead, at the set flop fs. SET_B pins get the same two checks as RESET_B pins.
set_multicycle_path -setup 2 -from [get_cells rs2] -to [get_pins {f*/RESET_B fs/SET_B}]
set_multicycle_path -hold 1 -from [get_cells rs2] -to [get_pins {f*/RESET_B fs/SET_B}]Teams sometimes relax the release with a two-cycle multicycle path, as above. Recovery then passes with 0.4945 ns. The risk is real: flops may now leave reset one cycle apart. That is safe only if the design ignores them for two cycles after reset. T5 covers multicycle paths in full.
The rsttree netlist
// rsttree: a two-flop reset synchronizer whose release fans out through a buffer tree (one buf_2, four buf_1) to
// sixteen dfrtp_1 flops and one dfstp_1 (SET_B). Each flop samples d, so every one is a real register.
module rsttree (clk, rst_n, d, q);
input clk; input rst_n; input d; output q;
wire one, s1, s2, r0, r1, r2, r3, r4;
wire q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11, q12, q13, q14, q15, q16;
sky130_fd_sc_hd__conb_1 tie (.HI(one));
sky130_fd_sc_hd__dfrtp_1 rs1 (.CLK(clk), .D(one), .RESET_B(rst_n), .Q(s1));
sky130_fd_sc_hd__dfrtp_1 rs2 (.CLK(clk), .D(s1), .RESET_B(rst_n), .Q(s2));
sky130_fd_sc_hd__buf_2 rb0 (.A(s2), .X(r0));
sky130_fd_sc_hd__buf_1 rb1 (.A(r0), .X(r1));
sky130_fd_sc_hd__buf_1 rb2 (.A(r0), .X(r2));
sky130_fd_sc_hd__buf_1 rb3 (.A(r0), .X(r3));
sky130_fd_sc_hd__buf_1 rb4 (.A(r0), .X(r4));
sky130_fd_sc_hd__dfrtp_1 f0 (.CLK(clk), .D(d), .RESET_B(r1), .Q(q0));
sky130_fd_sc_hd__dfrtp_1 f1 (.CLK(clk), .D(d), .RESET_B(r1), .Q(q1));
sky130_fd_sc_hd__dfrtp_1 f2 (.CLK(clk), .D(d), .RESET_B(r1), .Q(q2));
sky130_fd_sc_hd__dfrtp_1 f3 (.CLK(clk), .D(d), .RESET_B(r1), .Q(q3));
sky130_fd_sc_hd__dfrtp_1 f4 (.CLK(clk), .D(d), .RESET_B(r2), .Q(q4));
sky130_fd_sc_hd__dfrtp_1 f5 (.CLK(clk), .D(d), .RESET_B(r2), .Q(q5));
sky130_fd_sc_hd__dfrtp_1 f6 (.CLK(clk), .D(d), .RESET_B(r2), .Q(q6));
sky130_fd_sc_hd__dfrtp_1 f7 (.CLK(clk), .D(d), .RESET_B(r2), .Q(q7));
sky130_fd_sc_hd__dfrtp_1 f8 (.CLK(clk), .D(d), .RESET_B(r3), .Q(q8));
sky130_fd_sc_hd__dfrtp_1 f9 (.CLK(clk), .D(d), .RESET_B(r3), .Q(q9));
sky130_fd_sc_hd__dfrtp_1 f10 (.CLK(clk), .D(d), .RESET_B(r3), .Q(q10));
sky130_fd_sc_hd__dfrtp_1 f11 (.CLK(clk), .D(d), .RESET_B(r3), .Q(q11));
sky130_fd_sc_hd__dfrtp_1 f12 (.CLK(clk), .D(d), .RESET_B(r4), .Q(q12));
sky130_fd_sc_hd__dfrtp_1 f13 (.CLK(clk), .D(d), .RESET_B(r4), .Q(q13));
sky130_fd_sc_hd__dfrtp_1 f14 (.CLK(clk), .D(d), .RESET_B(r4), .Q(q14));
sky130_fd_sc_hd__dfrtp_1 f15 (.CLK(clk), .D(d), .RESET_B(r4), .Q(q15));
sky130_fd_sc_hd__dfstp_1 fs (.CLK(clk), .D(d), .SET_B(r4), .Q(q16));
sky130_fd_sc_hd__buf_1 uo (.A(q16), .X(q));
endmoduleSynchronous Reset, for Contrast
A synchronous reset has no reset pin on the flop. A gate clears the D input instead, so the release is ordinary data. In the design syncrst, the same synchronizer feeds an AND gate in front of a plain dfxtp_1.
| Path | Group | Check | Slack (ns) |
|---|---|---|---|
| rs2 → ff | clk | setup | 1.4076 |
| rs2 → ff | clk | hold | 0.4503 |
The design syncrst at a 2 ns clock. The release into ff is a setup and hold path in the clock group.
No recovery or removal check appears, and no asynchronous group. The price is that the reset needs a running clock to take effect, and the AND gate sits on the data path.
An SDC That Keeps the Release Timed
The raw input rst_n has no timing relation to the clock. Its release can come at any moment, and the synchronizer exists for exactly that. Checks from rst_n into rs1 and rs2 therefore mean nothing, so cut them with a false path from the port.
Give rst_n an input delay and no exception, and the asynchronous group grows. It now also holds recovery and removal checks from rst_n into both synchronizer flops. The worst recovery slack becomes 1.7587 ns, on a path that means nothing.
A check on the raw input that means nothing
rst_n → rs1recovery check, latest arrival0 cells
- Clock latency
- Cell delay
- Input delay
- Recovery time
Read the path as a table
Launch: clk rise edge at 0.0000 ns, clock latency 0.0000 ns (ideal). Capture: clk rise edge at 2.0000 ns, latency 0.0000 ns, library recovery time 0.2587 ns.
Arrival 0.5000 ns, required 2.2587 ns, slack 1.7587 ns (met).
| Cell | Arc | Through | Edge | Delay (ns) | Time (ns) | Slew (ns) |
|---|---|---|---|---|---|---|
rst_n → rs1/RESET_B | wire rst_n | rise | 0.0000 | 0.5000 | 0.0000 |
The report
Startpoint: rst_n (input port clocked by clk)
Endpoint: rs1 (recovery check against rising-edge clock clk)
Path Group: asynchronous
Path Type: max
Fanout Cap Slew Delay Time Description
-------------------------------------------------------------------------------------
0.1000 0.0000 0.0000 clock clk (rise edge)
0.0000 0.0000 clock network delay (ideal)
0.5000 0.5000 ^ input external delay
2 0.0073 0.0000 0.0000 0.5000 ^ rst_n (in)
rst_n (net)
0.0000 0.0000 0.5000 ^ rs1/RESET_B (sky130_fd_sc_hd__dfrtp_1)
0.5000 data arrival time
0.1000 2.0000 2.0000 clock clk (rise edge)
0.0000 2.0000 clock network delay (ideal)
0.0000 2.0000 clock reconvergence pessimism
2.0000 ^ rs1/CLK (sky130_fd_sc_hd__dfrtp_1)
0.2587 2.2587 library recovery time
2.2587 data required time
-------------------------------------------------------------------------------------
2.2587 data required time
-0.5000 data arrival time
-------------------------------------------------------------------------------------
1.7587 slack (MET)The SDC gives rst_n a 0.5 ns input delay and no exception. The real release can come at any time, so this number describes nothing real.
Hides the release
set_false_path -to [get_pins */RESET_B]
The asynchronous group vanishes, and no recovery or removal check is left in the report.
Keeps the release
set_input_delay 0.5 -clock clk [get_ports rst_n]
set_false_path -from [get_ports rst_n]
Only the raw input is cut, and the release from rs2 to ff keeps both of its checks.
The wildcard silences many warnings at once, which makes it popular. But it hides the one reset path that must be timed. A synchronizer does not make the release untimed; it turns the release into a timed path.
Asked in interviews
What are recovery and removal checks?
Setup and hold for the release of an asynchronous reset. Recovery: the release must arrive early enough before the next edge. Removal: not too soon after the current edge.
Why do we need a reset synchronizer?
The raw reset releases at a random time. A synchronizer releases it just after a clock edge. Then every flop leaves reset on the same edge, and STA can time the release.
Should reset paths be false paths?
Only the raw asynchronous input into the synchronizer. The synchronized release into the other flops must stay timed by recovery and removal.
Try It
This SDC times every data port and cuts only the raw rst_n. Run it and open the asynchronous group: recovery 1.9039 ns and removal 0.0037 ns, both from rs2 to ff.
Now replace the false path with set_false_path -to [get_pins */RESET_B] and run again. The asynchronous group is gone. Then put the good line back and add set_clock_latency 0.05 [get_pins ff/CLK]: watch the removal slack.
Run to draw the timing paths here.
worst minimum slack 0.0037 nsRead the netlist: rst.v (the bundled design rst)
// rst: a two-flop reset synchronizer (async assert, sync release) feeding the RESET_B pin of a data flop.
module rst (clk, rst_n, d, q);
input clk; input rst_n; input d; output q;
wire one, s1, s2;
sky130_fd_sc_hd__conb_1 tie (.HI(one));
sky130_fd_sc_hd__dfrtp_1 rs1 (.CLK(clk), .D(one), .RESET_B(rst_n), .Q(s1));
sky130_fd_sc_hd__dfrtp_1 rs2 (.CLK(clk), .D(s1), .RESET_B(rst_n), .Q(s2));
sky130_fd_sc_hd__dfrtp_1 ff (.CLK(clk), .D(d), .RESET_B(s2), .Q(q));
endmodule
Check Yourself
Common Mistakes
Wrong Cut every reset pin with one wildcard false path.
The wildcard also cuts the synchronized release, so nothing checks that all flops leave reset on the same edge.
Fix Cut only the raw asynchronous input, and keep the synchronizer output timed.
set_false_path -to [get_pins */RESET_B]set_input_delay 0.5 -clock clk [get_ports rst_n]
set_false_path -from [get_ports rst_n]Wrong Look only at the setup report (report_checks -path_delay max) for reset problems.
Removal is a min check, so a removal failure appears only in the min report.
Fix Read both reports, or the asynchronous path group in each of them.
Wrong Sign off the removal check with ideal clocks before the clock tree exists.
A few picoseconds of real clock skew can turn a tiny removal margin negative.
Fix Recheck removal with propagated clocks after clock tree synthesis, as you recheck hold.
Remember
- A reset may assert at any time; its release must land outside each flop's unsafe window around the clock edge.
- A synchronizer launches the release from a clock edge, so the release becomes a timed path.
- Recovery acts like setup and removal like hold; both sit in the asynchronous path group.
- Cut only the raw reset input with a false path; never cut the synchronized release.
- Clock skew hurts removal as it hurts hold, so recheck it after clock tree synthesis.