A multicycle path is a timing path between two registers on related clocks where the design intentionally gives the data more than one clock period to arrive. The logic is built so the destination only uses the value every N cycles, typically through a clock enable, so the default single-cycle check is too strict. You tell the timing tool about that intent with a multicycle path constraint, and you must adjust the hold check at the same time, or you trade a false setup violation for a real hold problem.
Multicycle paths are a common challenge in timing analysis and closure. This post looks at them from two perspectives, the designer's and the tool's, explains the intent behind them, and shows how to constrain them correctly with a worked example.
Key takeaways
- A multicycle path is a real, functional path that is only sampled every N cycles. It is not a false path.
- The designer knows the intent; the tool does not. Without a constraint, the tool assumes every path must settle in one cycle.
- In SDC,
set_multicycle_path N -setupmoves the setup capture edge out by N minus 1 periods, and the hold check moves with it. - For the usual same-clock case, pair it with
set_multicycle_path N-1 -holdto put the hold check back on the launch edge. - The constraint is only safe if the logic really guarantees the N-cycle behaviour. Verify the enable scheme, do not just assert it in a constraints file.
Perspectives of multicycle paths
There are two main perspectives of multicycle paths: the designer's perspective and the tool's perspective. The designer's perspective is based on the functional behaviour and intent of the circuit, while the tool's perspective is based on the physical implementation and timing constraints of the circuit.
The designer's perspective
The designer's perspective is that multicycle paths are intentional and valid. The designer knows that the signal does not need to arrive at the destination register within one clock cycle, and that it can be safely captured by a later clock edge. The designer may use multicycle paths to optimise the circuit for area, power or performance, for example by keeping a long arithmetic path in one stage instead of adding pipeline registers, or by running a slow-moving datapath off an enable rather than a separate divided clock. The designer may also use multicycle behaviour to implement different modes of operation, such as normal mode, low power mode and ultra low power mode, by changing the clock frequency or gating the clock signal. In practice each such mode is usually timed with its own constraint set (a separate mode in multi-mode, multi-corner analysis), because the cycle relationships differ between modes.
The tool's perspective
The tool's perspective is that multicycle paths are potential timing violations. The tool does not know the functional behaviour and intent of the circuit, and it assumes that every signal launched on one edge must be captured on the next edge of the capture clock. Without guidance it will report these paths as setup violations and try to fix them by upsizing gates, inserting buffers, restructuring logic or changing placement and routing. That wastes area and power, and it can make other paths worse while the tool chases a problem that does not exist.
Intent of multicycle paths
The intent of a multicycle path constraint is to communicate to the tool the functional behaviour and design constraints of the circuit. By specifying multicycle paths, the designer instructs the tool to relax certain timing checks to match what the logic actually does, and to avoid unnecessary or counterproductive optimisations.
Multicycle paths and false paths are different exceptions
Multicycle paths are often discussed alongside false paths, and the two are easy to confuse. Both are timing exceptions, but they say very different things to the tool:
| Exception | What it tells the tool | Typical example | SDC command |
|---|---|---|---|
| False path | This path can never carry a meaningful transition in operation, so do not time it at all | Registers enabled by mutually exclusive signals, registers that belong to different modes of operation, static configuration bits | set_false_path |
| Multicycle path | This path is real and is timed, but the capture happens N cycles after launch | A multiplier between two registers that are both enabled every second cycle | set_multicycle_path |
False paths can be ignored by the tool, as they do not affect the functionality or performance of the circuit. True multicycle paths do occur in operation and must still be timed, just against a later capture edge. The tool keeps optimising them, but against the correct, relaxed requirement, so it can meet timing without violating the functional requirements.
An earlier version of this post described false paths as a type of multicycle path, and suggested multicycle constraints for paths between different clock domains. Both points needed correcting. A false path is a separate exception, as above. A path between asynchronous clock domains is not a multicycle path either: it needs a synchroniser in the design, and the crossing is normally constrained with a false path, clock groups or a maximum delay limit, depending on the synchroniser type. A path that is guarded by a handshake protocol on a single clock, where the data is held stable until the handshake completes, can legitimately be a multicycle path.
One more correction of wording: a multicycle constraint does not give the destination register a larger setup or hold time. It moves which clock edge the tool uses for the setup and hold checks. The register's own setup and hold requirements from the library stay the same.
How the setup and hold edges move
Take a single clock with period T, launch at time 0. By default the tool checks setup against the next edge at T, and hold against the launch edge at 0.
set_multicycle_path 2 -setupmoves the setup check to the edge at 2T.- The hold check moves with it, to one edge before the new setup edge, which is T. That is now a much harder hold check: the fastest path must not change the destination before T plus the hold time.
set_multicycle_path 1 -holdmoves the hold check back by one period, to 0, where it belongs for a register that only captures every second cycle.
The general rule for a same-clock multicycle path of N cycles is setup N and hold N minus 1. Vendor guides that follow SDC semantics, such as the AMD Vivado constraints guide (UG903) and the Intel Quartus Prime Timing Analyzer user guide, describe the same edge movement. Paths between related clocks of different frequencies follow the same idea, but you also need to choose whether the multiplier counts source or destination clock periods (the -start and -end options), so read the tool report to confirm which edges were selected.
# Both registers enabled every second cycle on clk
set_multicycle_path 2 -setup -from [get_cells a_q_reg*] -to [get_cells p_reg*]
set_multicycle_path 1 -hold -from [get_cells a_q_reg*] -to [get_cells p_reg*]
Worked example
The numbers below are illustrative, not from a real library. Clock period T = 1.0 ns. Clock to Q delay is 0.10 ns, the multiplier path has a maximum delay of 1.60 ns and a minimum delay of 0.40 ns. The capture flop has a setup time of 0.05 ns and a hold time of 0.03 ns. Ignore skew for simplicity.
| Constraint | Setup check | Setup slack | Hold check | Hold slack |
|---|---|---|---|---|
| None (default) | 1.70 must be <= 1.00 minus 0.05 | minus 0.75 ns, fails | 0.50 must be >= 0 plus 0.03 | plus 0.47 ns |
| Setup 2 only | 1.70 must be <= 2.00 minus 0.05 | plus 0.25 ns | 0.50 must be >= 1.00 plus 0.03 | minus 0.53 ns, fails |
| Setup 2 and hold 1 | 1.70 must be <= 2.00 minus 0.05 | plus 0.25 ns | 0.50 must be >= 0 plus 0.03 | plus 0.47 ns |
The middle row is the classic mistake. With only the setup multiplier, the tool sees a hold violation and inserts delay buffers into a path that never needed them, sometimes enough to then break setup again. The hold multiplier removes that false requirement.
What the RTL must guarantee
A multicycle constraint is a promise that the logic only samples the path every N cycles. The usual way to keep that promise is a shared clock enable on the launch and capture registers. The Verilog below was checked in simulation: the operands are launched on one enabled edge and the product is captured two edges later.
// Source and destination registers are both enabled every second cycle,
// so the multiplier between them has two clock periods to settle.
module mcp2 (input clk, input rst_n, input [15:0] a, b, output reg [31:0] p);
reg en; // toggles: 1, 0, 1, 0 ...
reg [15:0] a_q, b_q;
always @(posedge clk or negedge rst_n)
if (!rst_n) en <= 1'b0;
else en <= ~en;
always @(posedge clk)
if (en) begin a_q <= a; b_q <= b; end // launch on enabled edges
always @(posedge clk)
if (en) p <= a_q * b_q; // capture two edges later
endmodule
If someone later changes the enable so it can fire on consecutive cycles, the constraint becomes wrong and silicon can fail even though STA is clean. That is why multicycle constraints deserve the same review as RTL.
Architectural and design intent of multicycle paths
Multicycle paths are not only a result of physical implementation, but also a reflection of architectural and design intent. The designer may choose to use multicycle paths to achieve certain goals, such as reducing power consumption, increasing performance or simplifying design complexity. For example, the designer may use a multicycle path to implement a pipeline stage that has a long combinational logic path, or to implement a memory controller that has a variable latency depending on the memory type. By using multicycle paths, the designer can avoid splitting the logic into multiple stages or adding extra logic to handle different latencies. For a variable latency case, the constraint has to match the shortest number of cycles the logic can actually allow, since STA times one fixed multiplier per path.
However, using multicycle paths also comes with some challenges and trade-offs:
- Functional correctness in every scenario. The designer needs to ensure that the multicycle behaviour holds under all possible scenarios: every mode, reset and start-up sequence, and every input data pattern. Variation in temperature, voltage and process is covered by timing the path at all signoff corners with the multicycle constraint applied.
- Glitches and unsafe sampling. The designer also needs to verify that the multicycle paths do not introduce glitches into logic that is not enabled the same way, for example an asynchronous reset or a clock gate fed from the slow path. Metastability is not a concern for a correctly enabled same-clock path, but it is if the path really crosses asynchronous domains, which is a synchroniser problem, not a multicycle one.
- Costs and benefits. The designer needs to balance the benefits and costs of using multicycle paths, such as area overhead, power consumption, timing margin and design complexity. Each exception adds review and verification effort, and a large number of exceptions makes the constraint set fragile.
Common mistakes
- Setting the setup multiplier and forgetting the hold multiplier, then accepting the hold buffers the tool inserts.
- Using wildcards that catch more registers than intended, so a single-cycle path is silently relaxed.
- Using a multicycle path for an asynchronous clock domain crossing instead of a synchroniser and the correct crossing constraint.
- Not re-checking the constraint after an RTL change to the enable logic.
- Not checking the timing report to confirm which launch and capture edges the tool chose, especially between clocks of different frequency.
FAQ
Is a multicycle path the same as a false path?
No. A false path is not timed at all. A multicycle path is timed, but against a later capture edge.
Why do I need a hold multiplier if hold looked fine before?
Because the setup multiplier also moves the default hold check forward. The hold multiplier moves it back to the launch edge.
Can multicycle constraints be checked automatically?
Partly. Constraint linting tools flag missing hold multipliers and suspicious wildcards, and formal or assertion-based checks can confirm that the enable really fires only every N cycles. A human review of the intent is still needed.
Do multicycle paths help power?
They can. A relaxed requirement lets the tool use smaller, lower-leakage cells on the path instead of upsizing it, and an enable-based scheme avoids toggling the capture register every cycle.


Your comments will be moderated before it appears here.