Synchronizing a single control bit across clock domains is straightforward using a 2-flop synchronizer. However, when passing a multi-bit data bus across clock domains, synchronizing each bit individually is a recipe for disaster due to routing skew and differing meta-stability resolution times. The solution? Multi-Cycle Path (MCP) Formulation.
The core philosophy of MCP is simple: Do not synchronize the data. Synchronize a control signal instead.
Since we cannot safely pass a multi-bit bus through multiple synchronizers and expect the bits to arrive coherently on the other side, we rely on a single control signal (often an enable or valid bit) to indicate when the data is safe to sample. We hold the multi-bit data stable on the bus for a long period—long enough for the control signal to traverse the synchronizer in the destination domain and for the destination logic to sample the stable data bus.
In an "Open-Loop" MCP formulation, the sender operates blindly. It asserts the data, asserts an enable pulse, and then holds the data stable for a predetermined number of cycles based on its knowledge of the destination clock frequency and synchronizer latency. There is no acknowledgment back from the receiver.
In this architecture, the data_bus crosses the clock domain boundary entirely unsynchronized. It feeds directly into the D-input of a flip-flop (or register) in Domain B. The en_a signal, however, is synchronized using a standard 2-flop synchronizer. The output of the synchronizer, en_b_sync, is used as a clock enable for the data register in Domain B. By the time en_b_sync asserts, data_bus must have been stable for a long time.
Where Sync_Stages is typically 2, making the hold time requirement at least 3 clock cycles of the destination domain to guarantee safe capture, plus routing skew margins.
Consider an 8-bit configuration register that needs to cross from a 100MHz fast domain to a 25MHz slow domain.
| Parameter | Value | Implication |
|---|---|---|
| Domain A Clock | 100MHz (10ns) | Sender operates fast. |
| Domain B Clock | 25MHz (40ns) | Destination is 4x slower. |
| Sync Stages | 2 | Requires ~3 destination cycles to resolve and sample. |
| Data Stability Reqm. | 3 * 40ns = 120ns | Sender must hold data stable for at least 12 cycles of clk_a (120ns / 10ns). |
Since the sender clock is 4x faster, holding the data for 3 destination cycles requires the sender to hold it for 12 of its own cycles. If the sender changes the data after 5 cycles, the slow domain's synchronizer will still be resolving the enable, and when it finally samples, the data will be incorrect.
Below is the synthesizable RTL for an open-loop MCP. Notice how the destination domain uses en_b_sync as a clock enable.
// Multi-Cycle Path (MCP) Synchronizer
module mcp_sync #(parameter WIDTH = 8) (
// Domain A (Sender)
input wire clk_a,
input wire [WIDTH-1:0] data_a,
input wire en_a, // Must be pulsed for 1 clk_a cycle
// Domain B (Receiver)
input wire clk_b,
output reg [WIDTH-1:0] data_b,
output reg valid_b
);
// Synchronizer registers in Domain B
reg en_b_meta;
reg en_b_sync;
// 2-Flop Synchronizer for the enable signal
always @(posedge clk_b) begin
en_b_meta <= en_a; // Note: For robustness across all freq ratios,
en_b_sync <= en_b_meta; // en_a should be widened or toggled (see toggle syncs).
end
// Data Capture in Domain B
always @(posedge clk_b) begin
valid_b <= en_b_sync;
if (en_b_sync) begin
// Safe to sample unsynchronized data_a here
// because it has been stable for multiple clk_b cycles.
data_b <= data_a;
end
end
endmodule
MCP formulation avoids the latency and area overhead of FIFOs by passing multi-bit data asynchronously and synchronizing only a control signal. However, it relies entirely on the architectural guarantee that the sender will hold the data stable for the duration of the synchronization latency. When this guarantee cannot be made blindly, a closed-loop (handshake) protocol is required.