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.

Timing pathRemoval: The Synchronized Release Reaches Ffrs2 is the second synchronizer flop. Its Q drives the RESET_B pin of the data flop ff.

rs2 → ffremoval check, earliest arrival1 cell

  • Clock latency
  • Cell delay
  • Removal time
Removal: the synchronized release reaches ff00.050.10.150.20.250.30.35time (ns)launch and capture clk ↑Data arrivesRequired afterrs2/CLK → rs2/Q (dfrtp_1): 0.3412 ns1 dfrtp_1removal 0.3375 nsremoval 0.3375slack +0.0037 ns · metarrival 0.3412required 0.3375Removal: the synchronized release reaches ff00.10.20.3time (ns)launch and capture clk ↑Data arrivesRequired afterrs2/CLK → rs2/Q (dfrtp_1): 0.3412 ns1 dfrtp_1removal 0.3375 nsremoval 0.3375slack +0.0037 ns · metarrival 0.3412required 0.3375
  1. The release starts at an edge

    The clock edge at 0 ns makes rs2's output rise, which releases ff from reset.

  2. Clock to Q

    The output of rs2 rises 0.3412 ns after the clock edge reaches its CLK pin.

  3. The removal time

    The data flop ff needs the release to come no sooner than 0.3375 ns after the same edge.

  4. 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).

CellArcThroughEdgeDelay (ns)Time (ns)Slew (ns)
1rs2/CLK → rs2/Qdfrtp_1rise0.34120.34120.0533
rs2/Q → ff/RESET_Bwire s2rise0.00000.34120.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.

The Design Rst: Assert at Once, Release on the ClockOne column per clock cycle. The raw reset input is rst_n. The flops rs1 and rs2 form the synchronizer, and rs2 drives the RESET_B pin of ff.
0123456rst_nrs1/Qrs2/Q = ff/RESET_Bassertraw releaseff leaves reset
Scroll horizontally ↔
  1. Cycle 1

    The input rst_n falls between edges. The flops rs1, rs2 and ff are all cleared at once, with no clock.

  2. Cycle 3

    The input rst_n rises at a random time. The flop rs1 may go metastable here, which is why a second flop follows it.

  3. 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.

CheckLikeEdge pair hereLibrary timeSlack (ns)
recoverysetuplaunch 0 ns, capture 2 ns−0.2451 ns (required = edge + 0.2451)1.9039
removalholdlaunch 0 ns, capture 0 ns0.3375 ns0.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
Timing pathRecovery: The Release Before the Next Edge

rs2 → ffrecovery check, latest arrival1 cell

  • Clock latency
  • Cell delay
  • Recovery time
Recovery: the release before the next edge00.20.40.60.811.21.41.61.822.2time (ns)launch clk ↑capture clk ↑Data arrivesRequired byrs2/CLK → rs2/Q (dfrtp_1): 0.3412 ns1 dfrtp_1recovery 0.2451 nsslack +1.9039 ns · metarrival 0.3412required 2.2451Recovery: the release before the next edge00.511.52time (ns)launch clk ↑capture clk ↑Data arrivesRequired byrs2/CLK → rs2/Q (dfrtp_1): 0.3412 ns1recovery 0.2451 nsslack +1.9039 ns · metarrival 0.3412required 2.2451
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).

CellArcThroughEdgeDelay (ns)Time (ns)Slew (ns)
1rs2/CLK → rs2/Qdfrtp_1rise0.34120.34120.0533
rs2/Q → ff/RESET_Bwire s2rise0.00000.34120.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.

Where the Release May Land, in 20 Ps Steps After a Clock EdgeIn the release row, 1 means ff leaves reset at this edge and 0 at the next. An x means either edge, or a metastable flop.
01234567891011121314151617181920212223242526272829clkreleaseedge+0.2451+0.3375
Scroll horizontally ↔
  1. Cycle 0

    A release right after the edge still counts for this edge: the recovery limit lies after it.

  2. Cycle 12

    From 0.2451 ns the release is too late for recovery at this edge.

  3. 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 rsttreeWorst recovery (ns)AtWorst removal (ns)
2.0 ns clock1.4945fs0.2419
0.5 ns clock-0.0055fs0.2419
0.5 ns, two-cycle release0.4945fs0.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.

Give the release two cycles for recovery, and keep its removal check at the launch edge.
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
Seventeen flops released by one synchronizer through a two-level buffer tree.
// 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));
endmodule

Synchronous 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.

PathGroupCheckSlack (ns)
rs2 → ffclksetup1.4076
rs2 → ffclkhold0.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
Timing pathRecovery from rst_n into rs1

rst_n → rs1recovery check, latest arrival0 cells

  • Clock latency
  • Cell delay
  • Input delay
  • Recovery time
Recovery from rst_n into rs100.20.40.60.811.21.41.61.822.2time (ns)launch clk ↑capture clk ↑Data arrivesRequired byinput delay 0.5000 nsrecovery 0.2587 nsslack +1.7587 ns · metarrival 0.5000required 2.2587Recovery from rst_n into rs100.511.52time (ns)launch clk ↑capture clk ↑Data arrivesRequired byinput delay 0.5000 nsrecovery 0.2587 nsslack +1.7587 ns · metarrival 0.5000required 2.2587
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).

CellArcThroughEdgeDelay (ns)Time (ns)Slew (ns)
rst_n → rs1/RESET_Bwire rst_nrise0.00000.50000.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
  1. 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.

  2. 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.

  3. 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.

STAOpenSTA in OpenROAD 26Q2 · sky130hd tt_025C_1v80 Liberty · simulator service
Edit the constraints, then run them

          
Expected: worst minimum slack 0.0037 ns
Read 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

Predict the outputThe base SDC (2 ns clock) plus set_clock_latency 0.05 [get_pins ff/CLK]: ff's clock now arrives 0.05 ns late. What is the worst min slack (WHS), in ns?
create_clock -name clk -period 2.0 [get_ports clk]
set_clock_transition 0.1 [all_clocks]
set_clock_latency 0.05 [get_pins ff/CLK]
ConceptA team false-paths the synchronized release from rs2 to ff. What can go wrong on silicon?
ConceptWhy does the synchronizer's output need timing at all?
ConceptA release lands 0.20 ns after a clock edge, at the ff of this lesson (window from 0.2451 to 0.3375 ns). When does ff leave reset?
ConceptAfter clock tree synthesis, removal at ff fails by a few picoseconds. Which change fixes it?

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.

Before
set_false_path -to [get_pins */RESET_B]
After
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.

Practice

Report a problem with this page