Synchronous vs. Asynchronous Reset in Verilog: Which Should You Use?

A synchronous reset in Verilog takes effect only on an active clock edge. An asynchronous reset forces a register into its reset state immediately, without waiting for the clock.
Short answer: use a synchronous reset when the clock is guaranteed to run during reset and your target device maps it efficiently. Use an asynchronous reset when state must go safe before a clock exists or while it is stopped, and always release it synchronously to each destination clock.
That last point is where most reset bugs come from. Asserting an asynchronous reset is easy. Releasing it near a clock edge can violate recovery/removal timing, cause metastability, or let registers leave reset on different cycles.
This guide covers the Verilog coding patterns for both styles, the reset synchronizer, multi-clock designs, which registers actually need a reset, vendor-specific FPGA guidance, and how to test reset in a testbench.
Synchronous vs. Asynchronous Reset at a Glance
The fundamental difference is when the reset is allowed to change state.
| Synchronous reset | Asynchronous reset | |
|---|---|---|
| When it acts | On the active clock edge | Immediately on assertion |
| Needs a running clock? | Yes | No, for assertion |
| Short reset pulse | Missed if it falls between clock edges | Acts immediately, even on a glitch |
| Glitch behavior | Clock filters most glitches | A noisy reset line can cause spurious resets |
| Release | Naturally aligned to the clock | Must be synchronized to each clock domain |
| Timing checks | Ordinary setup/hold on the reset path | Recovery/removal checks on reset release |
| Typical FPGA fit | Recommended by AMD when a reset is needed | Recommended by Altera as a synchronized asynchronous reset |
The table hides the most important issue: for an asynchronous reset, assertion is the easy part — deassertion is where things go wrong. We cover that in detail below.
Quick answer by situation
| Situation | Recommended approach |
|---|---|
| Clock always running, AMD (Xilinx) FPGA | Synchronous reset, only on registers that need it |
| Altera (formerly Intel) FPGA | Asynchronous assert, synchronous deassert |
| State must be safe before the clock starts, or the clock can stop | Asynchronous assert, synchronous deassert |
| ASIC with async-reset flops in the cell library | Asynchronous assert, synchronous deassert, one synchronizer per domain |
| Wide datapath qualified by a valid bit | Reset the valid bit only; leave data unreset |
What Should a Reset Actually Do?
A reset puts selected state elements into a known state. For a counter that might be count = 0; for a state machine, state = IDLE; for a FIFO:
read pointer = 0
write pointer = 0
empty = 1
full = 0
Reset is not a magic signal that must touch every register. The better question is: which state must be known for the block to behave correctly?
Control state usually needs a defined reset value. Many datapath registers do not. If a pipeline has eight data registers and a valid bit, clearing valid already tells downstream logic to ignore the data. Resetting all eight data registers adds reset fanout and can block efficient FPGA resource mapping without improving behavior.
How to Code a Synchronous Reset in Verilog
A synchronous reset is checked only when the clock triggers the sequential block. Here is an 8-bit register with enable:
module sync_reset_register (
input wire clk,
input wire rst_n, // synchronous, active-low
input wire en,
input wire [7:0] d,
output reg [7:0] q
);
always @(posedge clk) begin
if (!rst_n)
q <= 8'h00;
else if (en)
q <= d;
end
endmodule
The key detail is the sensitivity list: always @(posedge clk). Reset is not in it, so a change on rst_n alone does nothing to q. Reset is observed only at a rising edge of clk.
clk __/‾‾\__/‾‾\__/‾‾\__
rst_n ‾‾‾‾‾‾‾\_______/‾‾‾‾‾
q A5 A5 00
^ reset sampled here
If rst_n falls between edges, q keeps its value until the next active edge samples the reset. In SystemVerilog, the same register is written with always_ff @(posedge clk), which also lets tools flag accidental latches or combinational logic.
How to Code an Asynchronous Reset in Verilog
The asynchronous version adds the reset edge to the sensitivity list:
module async_reset_register (
input wire clk,
input wire rst_n, // asynchronous, active-low
input wire en,
input wire [7:0] d,
output reg [7:0] q
);
always @(posedge clk or negedge rst_n) begin
if (!rst_n)
q <= 8'h00;
else if (en)
q <= d;
end
endmodule
Now the block runs on a rising edge of clk or a falling edge of rst_n. When rst_n goes low, q clears immediately, even if the clock is stopped.
Synthesis tools recognize this template only in this shape: the reset edge in the sensitivity list must match the polarity tested first in the if. Writing negedge rst_n but testing if (rst_n) produces logic that simulates strangely and may not synthesize as an asynchronous-reset flip-flop.
Why Asynchronous Reset Release Is the Hard Part
Releasing an asynchronous reset is a timing event relative to the clock, just like a data input changing. Flip-flops with asynchronous reset have two timing requirements on release:
- Recovery time: the minimum time between reset deasserting and the next active clock edge.
- Removal time: the minimum time reset must stay asserted after an active clock edge.
If rst_n rises inside that window, a flip-flop can go metastable. Across many flip-flops, the reset reaches each one with different routing delay, so some leave reset on one clock edge and others on the next.
For a one-hot state machine, that can be fatal: if some state bits start running a cycle before others, the machine can enter an illegal state with zero or two hot bits and never recover.
Both major FPGA vendors flag this directly. AMD's UltraFast Design Methodology Guide (UG949) explains the importance of synchronizing asynchronous reset release to the destination clock. Altera's Quartus Design Assistant rule RES-50001 identifies unsynchronized asynchronous resets as high-severity violations because reset release can cause metastability.
Asynchronous Assert, Synchronous Deassert: The Reset Synchronizer
The standard fix is to assert reset asynchronously and release it synchronously. Reset still takes effect immediately with no clock, but functional logic only leaves reset on a clean clock edge.
A parameterized reset synchronizer:
module reset_synchronizer #(
parameter STAGES = 2 // must be 2 or more
)(
input wire clk,
input wire arst_n, // raw asynchronous reset, active-low
output wire rst_n // async assert, sync deassert
);
(* ASYNC_REG = "TRUE" *) reg [STAGES-1:0] sync;
always @(posedge clk or negedge arst_n) begin
if (!arst_n)
sync <= {STAGES{1'b0}};
else
sync <= {sync[STAGES-2:0], 1'b1};
end
assign rst_n = sync[STAGES-1];
endmodule
When arst_n goes low, every stage clears at once and rst_n asserts immediately. When arst_n goes high, a constant 1 shifts through the chain, so internal reset releases a fixed number of clock edges later:
arst_n released
→ clock edge 1: sync[0] = 1 (may resolve metastability here)
→ clock edge 2: sync[1] = 1
→ rst_n released, aligned to clk
Practical details that matter in real designs:
- Keep at least two stages, with no fanout between them. Altera's Design Assistant flags single-register reset synchronizers as insufficient (RES-50002). Use more stages for very high clock rates or stricter MTBF targets.
- Mark the synchronizer registers. On AMD devices,
ASYNC_REGtells Vivado to place the stages close together and treat them as a synchronizer. Other tools have their own attributes or detect the pattern. - Filter noisy reset inputs. Immediate assertion means a glitch on an external reset pin can reset the device. Altera recommends debouncing and filtering the asynchronous reset before it enters the device (Quartus design recommendations).
- Constrain it correctly. Treat the raw
arst_ninput into the synchronizer as asynchronous (a false path), but let the timing tool check recovery/removal on the synchronizedrst_nto every register it drives.
One Reset Synchronizer per Clock Domain
In a design with several clocks, synchronize the release of the external reset separately into each destination domain:
external_reset
├─> synchronizer @ 100 MHz ─> rst_ctrl_n
├─> synchronizer @ 250 MHz ─> rst_dp_n
└─> synchronizer @ 50 MHz ─> rst_periph_n
Each domain then exits reset on its own clock. Three rules keep this safe:
- One synchronizer per reset per domain. Two independent synchronizers for the same reset in the same domain can resolve on different edges, recreating the problem they were meant to fix.
- Hold PLL/MMCM-derived domains in reset until the clock is locked. A common pattern is to feed
ext_rst_n & pll_lockedinto that domain's synchronizer, so the domain releases only once its clock is stable. - Make release ordering explicit. If the datapath must start after the control domain, sequence it deliberately (for example, gate one domain's reset with a synchronized "ready" from the other) instead of relying on clock-frequency luck.
When Should You Use a Synchronous Reset?
A synchronous reset is usually the right choice when:
- the clock is guaranteed to be running whenever reset is asserted;
- the reset pulse is guaranteed to span at least one active clock edge;
- the target device maps synchronous resets efficiently (AMD devices are the main example);
- immediate, clock-independent clearing is not a system requirement.
AMD's methodology guide recommends synchronous resets when a reset is needed, because they map to more dedicated resources and the clock filters small reset glitches (UG949). That is an architecture-specific recommendation, not a universal Verilog rule.
When Should You Use an Asynchronous Reset?
An asynchronous reset makes sense when:
- outputs or control state must go safe before any clock is available;
- the clock can stop, but the block must still respond to reset;
- an external device-level reset must act on control state immediately;
- the target architecture favors it, such as Altera FPGAs or ASIC libraries with async-reset flip-flops;
- safety or startup requirements explicitly demand asynchronous assertion.
Choosing asynchronous reset never means "release it whenever." If logic resumes on a clock, its release must respect that clock, which in practice means the reset synchronizer shown above.
Should Every Register Have a Reset?
Usually not. Reset belongs in the functional specification, not on every always block by reflex. Take this example:
valid_reg
data_reg[127:0]
If data_reg is only used while valid_reg = 1, resetting valid_reg is enough. The 128 data bits do not need the reset network. Leaving them unreset helps FPGA tools infer shift registers (SRLs), block RAM, and DSP pipeline registers, which often cannot absorb a reset.
A useful review question: what breaks if this register is not reset? If the answer is "nothing, its value is ignored until a valid bit is set," skip the reset.
Two more points that are easy to miss:
- FPGA registers already have a known power-up value. Configuration loads every register with its initial value, so many FPGA designs only need reset for runtime recovery, not for power-up. AMD lists "check whether a global reset is really needed" as its first control-signal tip (UG949). ASICs have no such guarantee.
- Don't mix reset and non-reset registers in one asynchronous-reset block.
// Avoid: data has no reset value but shares the async-reset block
always @(posedge clk or negedge rst_n) begin
if (!rst_n)
valid <= 1'b0;
else begin
valid <= in_valid;
data <= in_data; // rst_n now acts as a hold/enable on data
end
end
// Better: separate blocks
always @(posedge clk or negedge rst_n)
if (!rst_n) valid <= 1'b0;
else valid <= in_valid;
always @(posedge clk)
data <= in_data;
In the first version, data must hold its value while reset is active, so synthesis adds reset-dependent enable logic to every data bit — exactly the overhead you were trying to avoid.
Reset and Clock Enable Priority
With both reset and enable, the coding order defines the priority:
always @(posedge clk) begin
if (!rst_n)
q <= 8'h00; // 1. reset
else if (en)
q <= d; // 2. enable
// 3. otherwise hold
end
If reset and enable are both active on the same edge, reset wins. On AMD devices, every register is built with set/reset taking precedence over clock enable (UG1387). Coding the enable first forces the reset into the data path and creates extra logic (UG949). Unless the specification genuinely requires enable-before-reset, code reset first.
Active-High vs. Active-Low Reset
Both work. The asynchronous templates differ only in the event expression:
always @(posedge clk or posedge reset) // active-high
always @(posedge clk or negedge rst_n) // active-low
What matters more is consistency and clear naming. Use a suffix such as _n (rst_n, aresetn) for active-low signals, match the polarity of your system interface or IP (AXI uses active-low aresetn), and keep control-signal polarities consistent across a design, as AMD's methodology guide recommends.
Common Reset Mistakes in Verilog
| Mistake | What goes wrong | Fix |
|---|---|---|
negedge rst_n in the sensitivity list when you wanted a synchronous reset |
You get an asynchronous-reset flop with different timing and resource mapping | Use always @(posedge clk) and test reset inside |
| Releasing an external async reset directly to functional registers | Recovery/removal violations, metastability, registers leaving reset on different cycles | Add a reset synchronizer per clock domain |
| Resetting every datapath register | Large reset fanout; blocks SRL, RAM and DSP inference | Reset control state and valid bits only |
| Mixing reset and non-reset registers in one async block | Extra enable logic on every unreset bit | Put unreset registers in a separate always block |
| Inconsistent reset styles along a DSP or RAM pipeline | Synthesis cannot pack registers into the dedicated block | Use one style per pipeline unless there is a functional reason |
| Synchronous reset pulse shorter than a clock period | Reset is never sampled | Stretch the pulse or synchronize it with enough stages |
| Unfiltered external async reset pin | Noise or glitches cause spurious resets | Debounce and filter before the synchronizer |
| Two synchronizers for the same reset in one domain | Parts of the domain leave reset on different edges | One synchronizer per reset per domain |
| Treating RTL simulation as proof of reset safety | Metastability and recovery/removal are not modeled | Run static timing plus CDC/RDC checks |
How to Test Reset in a Verilog Testbench
Reset deserves its own test scenarios, not just a few cycles of rst_n = 0 at time zero. A good reset test checks:
- the post-reset state of every output and control register;
- that reset wins when enable (or other controls) are active at the same time;
- that a synchronous reset waits for the clock, and an asynchronous reset does not;
- reset asserted in the middle of normal operation, not only at startup;
- that normal operation resumes correctly after release.
Here is a self-checking test for a simple counter with a synchronous reset:
module counter8 (
input wire clk,
input wire rst_n,
input wire en,
output reg [7:0] count
);
always @(posedge clk) begin
if (!rst_n)
count <= 8'h00;
else if (en)
count <= count + 1'b1;
end
endmodule
`timescale 1ns/1ps
module tb_counter8;
reg clk = 1'b0;
reg rst_n = 1'b0; // start in reset
reg en = 1'b1; // enable high during reset: reset must win
wire [7:0] count;
integer errors = 0;
counter8 dut (.clk(clk), .rst_n(rst_n), .en(en), .count(count));
always #5 clk = ~clk;
initial begin
// 1. Reset has priority over enable
repeat (3) @(posedge clk); #1;
if (count !== 8'd0) begin
$display("FAIL: not 0 during reset");
errors = errors + 1;
end
// 2. Release away from the active edge, count 5 cycles
@(negedge clk) rst_n = 1'b1;
repeat (5) @(posedge clk); #1;
if (count !== 8'd5) begin
$display("FAIL: expected 5, got %0d", count);
errors = errors + 1;
end
// 3. Assert reset mid-operation, between clock edges
@(negedge clk) rst_n = 1'b0;
#1;
if (count !== 8'd5) begin
$display("FAIL: sync reset acted before the edge");
errors = errors + 1;
end
@(posedge clk); #1;
if (count !== 8'd0) begin
$display("FAIL: not cleared on the edge");
errors = errors + 1;
end
// 4. Release and confirm counting resumes from zero
@(negedge clk) rst_n = 1'b1;
repeat (3) @(posedge clk); #1;
if (count !== 8'd3) begin
$display("FAIL: expected 3, got %0d", count);
errors = errors + 1;
end
if (errors == 0) $display("PASS: all reset checks");
else $display("FAIL: %0d reset check(s) failed", errors);
$finish;
end
endmodule
For an asynchronous-reset design, change check 3: count should already be 0 one time unit after rst_n falls, before any clock edge. Also assert and release reset at several offsets relative to the clock.
One limit to keep in mind: RTL simulation verifies the intended digital reset protocol, but it does not model metastability or recovery/removal timing. Those need static timing analysis and CDC/RDC checks in the implementation flow. For more on building tests like this one, see our guide on how to write a self-checking testbench in Verilog.
Reset Strategy for FPGA vs. ASIC
The common shortcut "FPGA = synchronous, ASIC = asynchronous" is wrong even within FPGAs: the two largest FPGA vendors give different defaults.
| Target | What the vendor or flow recommends | Practical default |
|---|---|---|
| AMD (Xilinx) FPGA | Synchronous reset when a reset is needed; avoid unnecessary resets; code reset before enable (UG949) | Synchronous reset on control state; synchronize any external async reset first |
| Altera (formerly Intel) FPGA | Synchronized asynchronous reset is preferred for FPGA circuits (Quartus design recommendations) | Async assert, sync deassert, one synchronizer per domain |
| ASIC | Depends on the cell library, DFT/scan strategy, power domains and safety requirements | Often async-reset flops plus a reset synchronizer, with a scan-mode bypass so test can control reset |
In every case, check the guidance for the specific device family or library you target. Reset architecture is a system and implementation decision, not a Verilog syntax preference.
A Practical Reset Decision Checklist
| Question | Why it matters |
|---|---|
| Does this register actually need a reset? | Avoids unnecessary reset networks and blocked resource inference |
| Must reset work without a clock? | If yes, you need asynchronous assertion |
| Is the clock guaranteed during reset? | Required for a synchronous reset to be seen |
| How is reset released, and into which clock domains? | Each domain needs its own synchronized release |
| Are any clocks from a PLL or MMCM? | Hold those domains in reset until lock |
| Does the target device map this reset style efficiently? | Affects RAM, DSP and register packing |
| Should reset beat clock enable on the same edge? | Priority must be explicit in the code |
| Is the reset pulse width guaranteed? | A synchronous reset must reach an active edge |
| Is the external reset pin noisy? | Async assertion needs debouncing and filtering |
| What state must outputs have after reset? | Belongs in the RTL specification |
| Does the testbench exercise reset during real traffic? | Prevents reset-only happy-path testing |
Write Reset Requirements Into Your RTL Specification
Most reset bugs start as an unstated assumption. "Add reset" leaves the style, polarity, priority and scope open to interpretation. A precise version looks like this:
The module uses a synchronous active-low reset (rst_n),
sampled on the rising edge of clk.
When rst_n = 0: state = IDLE, valid = 0, error = 0.
Datapath registers are not reset; their contents are
ignored while valid = 0.
Reset has priority over enable.
Normal operation resumes on the first rising edge after
rst_n is released.
If asynchronous assertion is required, say so explicitly, and state that deassertion must be synchronized independently to each destination clock domain. For a full template covering interfaces, timing and edge cases, see how to write an RTL design specification.
Reset and AI-generated RTL
Reset is one of the areas where a vague prompt quickly produces the wrong circuit. Compare "build an 8-bit counter with reset" with a prompt that states the reset style, polarity, priority over enable, and the expected behavior after release.
SiliCode turns a hardware specification into an explicit interface and behavior before generating the RTL. With Auto-Verify enabled, it also generates a self-checking testbench from that specification and runs simulation against the resulting module. For reset, that means the testbench checks the requirement itself — reset clears state, reset has priority, release resumes operation — rather than merely confirming the code contains a reset branch.
Try the SiliCode AI Verilog generator with your next reset spec, or create a free account to generate RTL and a matching testbench.
Frequently Asked Questions
What is the difference between synchronous and asynchronous reset in Verilog?
A synchronous reset is tested inside always @(posedge clk) and changes state only on an active clock edge. An asynchronous reset appears in the sensitivity list (always @(posedge clk or negedge rst_n)) and changes state as soon as it asserts, with or without a clock.
Which is better for FPGAs: synchronous or asynchronous reset?
It depends on the vendor. AMD recommends synchronous resets on its devices when a reset is needed. Altera prefers a synchronized asynchronous reset. In both cases, an external asynchronous reset source must be synchronized before it releases functional logic.
What are reset recovery and removal times?
They are the timing checks on asynchronous reset release. Recovery time is how long before the clock edge reset must deassert; removal time is how long after the edge it must stay asserted. Violating either can make a flip-flop metastable.
How many flip-flops does a reset synchronizer need?
At least two in series, with no logic or fanout between them. Very high clock rates or strict reliability targets may need three or more; Altera also adds stages when the synchronized reset must last several clock periods.
Is an asynchronous reset synthesizable?
Yes, as long as you follow the standard template: the reset edge in the sensitivity list, tested first in the if, with matching polarity. Synthesis maps it to flip-flops with a dedicated asynchronous clear or preset pin.
Can I use initial values instead of a reset on an FPGA?
Often, for power-up. FPGA configuration loads registers with their initial values, and most FPGA synthesis tools honor Verilog initial values. That does not give you a runtime reset, and it does not apply to ASICs.
Can a synchronous reset work if the clock is stopped?
No. A synchronous reset is only sampled on an active clock edge. If the clock is stopped or not yet stable, use asynchronous assertion with synchronous release.
Conclusion: Choose Reset From the Requirement, Not Habit
The synchronous vs. asynchronous reset decision in Verilog comes down to a few questions: which state actually needs a known value, whether reset must work without a clock, how many clock domains you have, and what your target device or library supports efficiently.
Use a synchronous reset when it fits the architecture. Use asynchronous assertion when you genuinely need an immediate response, and always release it through a reset synchronizer in each clock domain. Leave unreset whatever does not need it.
The Verilog syntax is the easy part; the reset architecture is the real design decision. When you have that decision written down, describe your module in SiliCode and get RTL plus a self-checking testbench that verifies the reset behavior you specified.