🔒 No Access

You don't have approved access to this course yet.

Go back and request access →
CDC Course / Module 7: Passing Multiple CDC Signals
Lesson 7.3

Multi-Cycle Path (MCP) Formulation

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.

1 The MCP Concept

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.

2 Open-Loop MCP Architecture

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.

Domain A (clk_a) D FF data_a D FF en_a Domain B (clk_b) data_bus [N-1:0] Unsynchronized Data en_a_pulse D FF & en_b_sync

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.

CRITICAL CONSTRAINT: Data Stability Window The sender MUST guarantee that the data remains completely stable on the bus for the entire duration of the synchronizer latency, plus any setup/hold time requirements of the destination register. If the sender changes the data before the synchronized enable reaches the destination register, the receiver will sample corrupted or transitioning data, causing catastrophic failure. This is why closed-loop (with acknowledge) is safer for dynamic frequency ratios.

3 Timing Diagram

clk_b data_bus STABLE DATA (Held by sender) en_a en_b_sync Safe Sample Point
Minimum Data Stability Time
T_hold ≥ (Sync_Stages + 1) × T_clk_dest + T_skew

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.

4 Worked Example

Configuration Register Crossing

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.

5 Verilog Implementation

Below is the synthesizable RTL for an open-loop MCP. Notice how the destination domain uses en_b_sync as a clock enable.

filename.v
// 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
Key Takeaway

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.

← Previous: Multi-Bit Signal Consolidation Next: Closed-Loop MCP with Acknowledge →
Advertisement