A flop with an asynchronous reset has a reset pin whose deasserting edge acts like a data input for one purpose: it decides whether the next clock edge is a normal one. If the release lands in a window around a clock edge, the outcome is not defined. Recovery and removal define that window.
Check | Reference | Rule | Resembles |
|---|---|---|---|
Recovery | The next clock edge after the release | Release must arrive at least the recovery time before that edge | Setup |
Removal | The clock edge at or just before the release | Release must arrive at least the removal time after that edge | Hold |
recovery slack = (capture edge - recovery time + capture latency) - (launch edge + launch latency + max arrival of the release)
removal slack = (launch edge + launch latency + min arrival of the release) - (same edge + capture latency + removal time)
arrival of the release = clock-to-Q (or input delay) + reset network delay# Release launched by a rising-edge flop at t=0 (period 10, ideal clocks, latency 0). Illustrative numbers, ns.
T, rec, rem = 10.0, 0.20, 0.15
cq_max, cq_min = 0.45, 0.35
net_max, net_min = 3.10, 1.80
arr_max, arr_min = cq_max + net_max, cq_min + net_min # 3.55 and 2.15
rec_slack = (T - rec) - arr_max
rem_slack = arr_min - rem
assert abs(rec_slack - 6.25) < 1e-9 and abs(rem_slack - 2.00) < 1e-9
# a release whose launch clock is later than the capture clock (skew) can fail removal
launch_lat, cap_lat = 0.50, 0.90
arr_min2 = launch_lat + 0.35 + 0.05 # very short reset path: 0.90
rem_slack2 = arr_min2 - (cap_lat + rem)
assert abs(rem_slack2 - (-0.15)) < 1e-9
fixed = (arr_min2 + 0.20) - (cap_lat + rem) # add 0.20 ns of delay on the short path
assert abs(fixed - 0.05) < 1e-9
print("PASS: recovery", round(rec_slack, 2), "removal", round(rem_slack, 2), "short-path removal", round(rem_slack2, 2), "after fix", round(fixed, 2))With a 10 ns period the recovery slack is large (6.25 ns) because the release has almost a whole cycle to arrive. The removal slack is what matters when the reset path is short: with a launch clock 0.4 ns earlier than the capture clock and only 0.40 ns of path, the release reaches the flop before the removal requirement is met (-0.15 ns). Adding 0.20 ns of delay on that path restores 0.05 ns of margin, exactly as for a hold fix.
Recovery and removal checks exist for every flop with an asynchronous reset or set, and none are disabled.
Both checks are clean in every corner; in the conventional case removal is worst in the fast corner and recovery in the slow corner, while at low voltage both temperature extremes are checked.
The release source is known: a synchroniser flop in the same clock domain, or an input port with a defined input delay.
In the conventional case removal is a hold-type check: its slack is the difference of the release arrival and the capture clock latency (skew), so it fails when the release arrives too soon relative to the clock, and paths are shortest in the fast corner. At low voltage both temperature extremes are checked.