非同期信号を扱うための危ういVerilogライブラリ の履歴(No.25)

メタステーブル状態†

メタステーブル状態とは、簡単に言うと あるラッチあるいはフリップフロップ（ＦＦ）の出力が１つの値に定まらず、 ふらついている状況を表す言葉です。

どうしてそんなことが起きるのか。

セットアップ時間とホールド時間†

例えばＤフリップフロップ（Ｄ−ＦＦ）は、 クロックの立ち上がりエッジ（あるいは立ち下がりエッジ）に 同期して入力信号を読み取り、次のエッジが来るまでその値を保持します。

理想的には、エッジの「直前の一瞬」の値を読み取って、 エッジの「直後」から正しい値を出力するのですが・・・。

実際のＦＦは「一瞬」で値を読み取れるわけではないため、 エッジの前後の短い時間の間に入力信号が変化してしまうと、 正しい値を読み取れず、出力が不定になってしまいます。

そこで、ＦＦを正しく使うためにはクロックエッジ前後のある一定期間に 入力信号が変化しないよう回路を組みます。 一方ＦＦは、その一定期間に入力信号が変化しないときに限って動作が保証されています。

ＦＦが正しく動作するために、
クロックエッジの「直前」に設けられた入力信号の変化禁止時間を最小セットアップ時間、
クロックエッジの「直後」に設けられた入力信号の変化禁止時間を最小ホールド時間、
とそれぞれ呼びます。

入力信号がこれらの最小値よりも大きなセットアップ時間・ホールド時間を持つときにのみ ＦＦが正しく動作する、と言い換えてもＯＫです。

ＦＦに同期信号が入力される場合†

下図で説明します。

上段部分はＦＦに入力されるクロック信号です。

中段はクロックの立ち上がりで動作する Ｄ−ＦＦ に、 クロックに同期した信号 (sync) が入力される状況を表しています。

入力信号はクロックの立ち上がりに同期して直前のラッチから出力されますが、 いくつかのゲートや配線を通るため、無視できない量の遅延時間の後にＦＦの入力に到達します。

この遅延時間は、信号経路に含まれる（複数の）ゲートを通過するのに掛かる時間と、 それらを繋ぐ配線を通過するのに掛かる時間の和になります。

クロック周期から遅延時間を引き算したものがセットアップ時間になります。 回路が複雑になり、あるいは信号経路が長くなりすぎて、遅延時間が大きくなると、 直後のＦＦのセットアップ時間が短くなり、もし最小セットアップ時間を下回ると、 素子の動作がおかしくなります。

一方でホールド時間については、入力が同期信号で限り通常あまり考慮する必要はありません。 というのも、ラッチの出力はクロックエッジと同時に変化する訳では無く、 内部に有限のゲート遅延を持つためです。ＦＦに規定される最小ホールド時間は非常に短いため、 大抵ＦＦの出力遅延だけでホールド時間の制約を満たしてしまいます。

ＦＦに非同期信号が入力される場合†

上図の下段はクロックに同期しない信号が入力される場合です。

この場合、入力信号はクロックタイミングとは無関係に変化します。 したがって、最小セットアップ時間あるいは最小ホールド時間の規定に違反して、 クロックエッジ付近で値が変化する状況が起きてしまいます。

セットアップ時間やホールド時間が守られず、エッジ付近で入力信号が変化すると、 ＦＦが不安定な状況に陥り、出力信号の値が比較的長い時間（数 ns 程度）に渡り、 ばたばたと振動してしまうことがあります。

図では黄色の矢印の時刻にセットアップ時間の違反が起きており、 そのせいで次クロックの出力値が長い間発信している様子を書いているつもりです。 この振動は数 ns の時間を掛けて徐々に 0 に収まっていきます。

このように出力信号がふらついている間に別のラッチがこの信号を読もうとすると、 その結果が１と読まれるか０と読まれるか定まらないことになります。 この状態が、悪名高い(?)メタステーブル状態です。

メタステーブル状態の引き起こす問題†

一見すると、 「そもそも１つめのFFが０と１とを切り替わる最中に値を読んだのだから、 出力が０でも１でもどちらに解釈されたって大きな差は無いじゃん」 という結論になってしまいそうな所です。

しかし、実際にはメタステーブル状態は２つの意味で問題を引き起こします。

• 後段に複数のＦＦがあると、それぞれが異なる値となる場合がある
• 後段のＦＦにもメタステーブル状態が伝播する場合がある

注意点†

忘れてはいけないのは、２つのＦＦ間の配線が長い場合、 この回路はメタステーブルを取り除く役には立たないという点です。 遅延時間が長ければ、１つ目のＦＦのメタステーブルが２つ目に伝播して、 ２つ目もメタステーブルになってしまう可能性が高くなります。

「２重ＦＦ回路では、２つのＦＦを可能な限り近くに配置する」 を鉄則として覚えておかなければなりませんん。

このために入れてあるのが、上記コードの IOB 制約と RLOC 制約です。 ２つのＦＦが必ず同じスライスに入るように設定しています。

ISE の Language Templates にあるコードでは RLOC の代わりに HBLKNM で配置制約を掛けようとしているのですが、Spartan 3A DSP 向けに実際に コンパイルしてみたところ WARNING:ConstraintSystem:119 が出てうまく行きませんでした。 http://japan.xilinx.com/support/answers/34088.htm によれば、 「HBLKNM をネットに設定すると、パッドにしか伝搬されません」 とのことなので、ここでは HBLKNM ではなく RLOC で指定しています。

ASYNC_REG は、シミュレーション方法を規定するための制約です。 通常、シミュレーション中にセットアップ・ホールド時間違反が起きた場合、 ＦＦの出力は不定値 X になります。その結果、多くの場合に下流の回路は X だらけとなり、以降のシミュレーションができなくなってしまいます。 ASYNC_REG が付いていると、セットアップ・ホールド時間違反が起きた場合、 書き込み前の値が保持されるため X は発生せず、シミュレーションに支障をきたしません。

ただこの場合にも、 セットアップ・ホールド時間違反が起きた旨のメッセージがログに出力されるため、、 シミュレーションの方針によってはこの種のエラーが数百も溜まってしまいます。 これでは他の重要なエラーが見づらくなってしまうので、 どうにかならないものか、まだ解決策を探しているところです。

ERROR:Pack:2811 - Directed packing was unable to obey the user design
   constraints (MACRONAME=writer_tx_req_ff, RLOC=X0Y0) which requires the
   combination of the symbols listed below to be packed into a single SLICE
   component.

   The directed pack was not possible because: The two registers have different
   set/reset signals.
   The symbols involved are:
   	FLOP symbol "writer/tx_req_ff/temp1" (Output Signal = writer/tx_req_ff/temp1)
   	FLOP symbol "writer/tx_req_ff/temp2" (Output Signal = tx_req<1>)

Mapping completed.
See MAP report file "main_map.mrp" for details.
Problem encountered during the packing phase.

// この回路は初期のもので下に問題点と改善案が書かれています
module double_ff(
    (* IOB="FALSE", TIG="TRUE" *) input idata,
    input oclk,
    output odata
);
    wire temp;

    (* RLOC="X0Y0", ASYNC_REG="TRUE" *)
    FDRSE #(
        .INIT(1'b0)     // Initial value of register (1'b0 or 1'b1)
    ) double_ff_temp0 (
        .Q(temp),       // Data output
        .C(oclk),       // Clock input
        .CE(1'b1),      // Clock enable input
        .D(idata),      // Data input
        .R(1'b0),       // Synchronous reset input
        .S(1'b0)        // Synchronous set input
    );

    (* RLOC="X0Y0" *)
    FDRSE #(
        .INIT(1'b0)     // Initial value of register (1'b0 or 1'b1)
    ) double_ff_temp1 (
        .Q(odata),      // Data output
        .C(oclk),       // Clock input
        .CE(1'b1),      // Clock enable input
        .D(temp),       // Data input
        .R(1'b0),       // Synchronous reset input
        .S(1'b0)        // Synchronous set input
    );

endmodule

   (* ASYNC_REG="TRUE", SHIFT_EXTRACT="NO", HBLKNM="sync_reg" *) reg [1:0] sreg;                                                                           
   always @(posedge clk) begin
      sync_out <= sreg[1];
      sreg <= {sreg[0], async_in};
   end

LANG:xlinix_xcf
INST "*/double_ff_temp0" TNM = "double_ff_temp0";
TIMESPEC TS_DOUBLE_FF = TO "double_ff_temp0" TIG;

LANG:xilinx_xcf
INST "*/double_ff_temp0" TNM = "double_ff_temp0";
INST "*/double_ff_temp1" TNM = "double_ff_temp1";
TIMESPEC TS_DOUBLE_FF = TO "double_ff_temp0" TIG;
TIMESPEC TS_DOUBLE_FF = FROM "double_ff_temp0" TO "double_ff_temp1" ??ns;

現時点での最善案をまとめました†

電気回路/HDL/コード中に制約を書くときの注意点 に上記 double_ff に対する制約の与え方について考察した結果と、現時点での最善案をまとめました。

重要な指針†

これまでの考察で、以下の重要な指針を得ました。

1. 非同期信号をそのまま使うな
2. 非同期信号を１段ＦＦに通しただけの信号は後段のつなぎ方に気をつけろ
   • 複数のラッチを繋ぐような使い方はＮＧ
   • １つだけＦＦを繋ぐなら問題ない
   • １つだけＦＦを繋ぐときも遅延が長いとＮＧ
3. 非同期信号を２段ＦＦに通せば十分安定

複数の信号を一度に入力する場合†

上記回路を次のように複数信号に拡張しても、 必ずしも正しくデータが受け渡されないことに注意が必要です。

module double_ff #(           // この回路はバグの元
    parameter DATA_BITS = 8
) (
    input clk,
    input [DATA_BITS-1:0] idata,
    output [DATA_BITS-1:0] reg odata
);
    reg [DATA_BITS-1:0] temp;
    always @(clk) begin
        temp <= idata;
        odata <= temp;
    end
endmodule

外部からの信号が最小セットアップ・ホールド時間に違反するタイミングで切り替わると、 個々のビットがそれぞれ少しだけ異なるタイミングで読まれるため、 全体として意味のある値を読み取ることができないのです。

このように複数の信号線を一括して受け渡すために、次の回路があります。

動作タイミング図†

• req -> req1 -> req2 の２段ＦＦは req2 が確定信号なので、これを元に temp を更新する
• temp 更新と同じタイミングで ack を立てる
• ack -> ack1 -> ack2 の２段ＦＦは ack2 が確定信号なので、これを元に odata を更新する
• odata 更新と同じタイミングで req を下げる
• req -> req1 -> req2 の２段ＦＦは req2 が確定信号なので、これを元に temp を更新する
• temp 更新と同じタイミングで ack を下げる
• ack -> ack1 -> ack2 の２段ＦＦは ack2 が確定信号なので、これを元に odata を更新する
• odata 更新と同じタイミングで req を上げる

の繰り返しです。

iclk の３周期と oclk の３周期を足した程度の頻度に一回、 入力側から出力側へ値が渡されます。

Verilog コード†

インスタンシエーション時にパラメータでバス幅を変えられるので、 いろんな用途に使えると思います。

module synchronize #(
    parameter DATA_BITS = 8
) (
    input irst,
    input iclk,
    input [DATA_BITS-1:0] idata,
    input orst,
    input oclk,
    output reg [DATA_BITS-1:0] odata
);
    (* TIG="TRUE" *) reg [DATA_BITS-1:0] temp;

    reg req;
    reg ack;

    wire oclk_ack;
    double_ff ack_ff ( .idata(ack), .oclk(oclk), .odata(oclk_ack) );
    
    always @(posedge oclk)
        if (orst) begin
            req <= 1;
        end else begin
            if ( req == oclk_ack ) begin
                req <= !req;
                odata <= temp;  // interclock signal "temp"
            end
        end
        
    wire iclk_req;
    double_ff req_ff ( .idata(req), .oclk(iclk), .odata(iclk_req) );
    
    always @(posedge iclk)
        if (irst) begin
            ack <= 0;
        end else begin 
            if ( ack != iclk_req ) begin
                ack <= !ack;
                temp <= idata;
            end
        end
        
endmodule

このコードの idata についている TIG 制約は、TIG に関する問題点 に書かれているように上流のピンまで遡って効力を発揮してしまうため、かなり危険です。後でこの点を改善したコードを載せようと思います。

すみません、そもそも idata に TIG は必要なかったですね。 idata の TIG 制約を取り除いた上記のコードで問題は解決されていると思います。

動作タイミング図†

やりたいことの単純さから考えると、かなり重たい動作になってます。

もっと手軽な方法がありそうな予感・・・

Verilog コード†

module interclock_trig(
    input iclk,
    input itrig,
    input oclk,
    output otrig
);
    (* RLOC="X0Y0" *) reg itrig_ex;
    (* TIG="TRUE" *) wire itrig_ex2;
    double_ff req_ff ( .idata(itrig_ex), .oclk(oclk), .odata(itrig_ex2) );
    
    (* RLOC="X0Y0", ASYNC_REG="TRUE" *) reg itrig_ex3;
    always @(posedge iclk)
        itrig_ex3 <= itrig_ex2;

    always @(posedge iclk)
        if (itrig)
            itrig_ex <= 1;
        else
        if(itrig_ex3)
            itrig_ex <= 0;

    reg otrig1, otrig2;
    always @(posedge oclk) begin
        otrig1 <= itrig_ex2;
        otrig2 <= itrig_ex2 & !otrig1;
    end
    assign otrig = otrig2;

endmodule

itrig_ex2 -> itrig_ex3 -> itrig_ex も２段ＦＦの役割を果たしているので、 制約を加えて itrig_ex3 と itrig_ex とが近くに配置されるようにしています。

A -> B -> C の２段ＦＦでは、A に TIG、B と C とに配置制約、 と覚えてしまうのが良さそうですね。

改良案†

上記回路はクロック同期のFFだけを使っていたせいでフラグを下げるところの動作が複雑になっていました。 ラッチをうまく使うことで単純化できました。

まだ工夫の余地はありそうですね。

Verilog コード†

module interclock_trig(
    input iclk,
    input itrig,
    input oclk,
    output otrig
);

    reg itrig1;
    always @(posedge iclk)
        itrig1 <= itrig;

    // SR ラッチ
    reg itrig_ex = 1;
    wire oclk_itrig_ex;
    always @(*)
        if (itrig1)
            itrig_ex = 0;
        else
        if (!oclk_itrig_ex)
            itrig_ex = 1;

    double_ff itrig_ff ( .idata(itrig_ex), .oclk(oclk), .odata(oclk_itrig_ex) );
    
    reg oclk_itrig_ex1;
    always @(posedge oclk)
        oclk_itrig_ex1 <= oclk_itrig_ex;

    assign otrig = !oclk_itrig_ex & oclk_itrig_ex1;

endmodule

さらに改良できないか考察†

コメント欄でアプロさんから ジョンソンカウンタ を用いた ステートマシンへの入力は同期化しなくても良い場合があるため、２ビットのジョンソン カウンタを使ったら回路を改善できるのではないか、というような（？）示唆をいただきました。

ジョンソンカウンタの通常遷移ではカウンタ値が１ビットずつしか変化しないため、 非同期信号を１つのFFで受ける形と見なすことができます。

さらに、その前後のステートで出力値が変化しない設計であれば、 次クロックでも１つのカウンタビットにしか影響が及ばないため、 結果として２重 FF で受けているのと同じ形になるわけです。

このようなわけで、ジョンソンカウンタを用いたステートマシンには 以下の３つの条件を満たす限り、非同期信号を直接入力できます。

• その遷移と次の遷移が共に通常遷移(スキップなし)であること
• その遷移の前後でステートから計算される出力値が変化しないこと
• その遷移で変化するビット値から、次の遷移で変化するビット値までの 信号遅延が十分に小さいこと

そのあたりを踏まえて、上記 改良案 について少々考察してみました。

動作タイミング図†

のようにして、制御側への busy 信号は busy0 と busy5 との論理和で与えれば・・・

と、考えていたのですが、interclock_trig を２個使っちゃえば楽ですね。

Verilog コード†

ほんのちょっとのリソースを省くために、 新しいモジュールを作ってテストするのはあまりメリットが無さそうなので、 start 信号の伝達と、done 信号の伝達とに、 それぞれ interclock_trig を使ってしまうことに決めました。

Verilog コード†

カウンタ比較をバイナリで行っているので、almost full や almost empty なども簡単に追加できます。

full / empty の出力はＦＦから直なので遅延が小さくなっています。
代わりに we や re へのセットアップ時間が多少きつめかもしれません。

module async_fifo #(
    parameter DATA_BITS = 8,
    parameter DEPTH_BITS = 11
) (
    input irst,
    input iclk,
    input [DATA_BITS-1:0] idata,
    input we,
    output reg full,
    input orst,
    input oclk,
    output reg [DATA_BITS-1:0] odata,
    input re,
    output reg empty
);

    // バイナリコード・グレイコードの相互変換

    function [DEPTH_BITS:0] binary2gray;
        input [DEPTH_BITS:0] binary;
        binary2gray = 
            { binary[DEPTH_BITS], binary[DEPTH_BITS-1:0] ^ binary[DEPTH_BITS:1] };
    endfunction

    function [DEPTH_BITS:0] gray2binary;
        input [DEPTH_BITS:0] gray;
        reg [DEPTH_BITS:0] temp, result;
        begin
            temp = gray;
            result = gray;
            while (|temp) begin
                temp = temp >> 1;
                result = result ^ temp;
            end
            gray2binary = result;
        end
    endfunction

    // メモリ

    reg [DATA_BITS-1:0] mem [0:2**DEPTH_BITS-1];
    
    // ポインタ変数
    
    // 深さを 2**DEPTH_BITS-1 ではなく 2**DEPTH_BITS とするために
    // 最上位ビットをフラグとして使っている。
    
    // epmty : rp == wp
    // full  : rp == wp ^ ( 1 << DEPTH_BITS )
    
    reg [DEPTH_BITS:0] rp0; // 現在値
    reg [DEPTH_BITS:0] rp1; // +1
    reg [DEPTH_BITS:0] rpg; // グレイコード
        
    reg [DEPTH_BITS:0] wp0; // 現在値
    reg [DEPTH_BITS:0] wp1; // +1
    reg [DEPTH_BITS:0] wpg; // グレイコード
    
    // ビット幅を指定した 0 と 1
    
    wire [DEPTH_BITS:0] zero = {DEPTH_BITS+1{1'b0}};
    wire [DEPTH_BITS:0] one  = { {DEPTH_BITS{1'b0}}, 1'b1 };
    
    // メモリの読み書き
    // full / empty のチェックは外部回路で行う
    
    always @(posedge iclk)
        if (!irst & we)
            mem[wp0[DEPTH_BITS-1:0]] <= idata;

    wire mem_ce;
    always @(posedge oclk)
        if (mem_ce)         // empty 時に読み出すと書き込みとかぶるので回避する
            odata <= mem[re ? rp1[DEPTH_BITS-1:0] : rp0[DEPTH_BITS-1:0]];

    // カウンタ操作

    always @(posedge iclk)
        if (irst) begin
            wp0 <= zero;
            wp1 <= one;
            wpg <= binary2gray(zero);
        end else 
        if (we) begin
            wp0 <= wp1;
            wp1 <= wp1 + one;
            wpg <= binary2gray(wp1);
        end

    always @(posedge oclk)
        if (orst) begin
            rp0 <= zero;
            rp1 <= one;
            rpg <= binary2gray(zero);
        end else 
        if (re) begin
            rp0 <= rp1;
            rp1 <= rp1 + one;
            rpg <= binary2gray(rp1);
        end
        
    // ２段ＦＦによるポインタの受け渡し
    // 各ＦＦに配置制約を付けるためビット毎に操作している

    wire [DEPTH_BITS:0] iclk_rpg;
    genvar rpg_i;
    generate
        for (rpg_i=0; rpg_i<=DEPTH_BITS; rpg_i=rpg_i+1) begin: rpg_for
            double_ff rpg_ff( .idata(rpg[rpg_i]), .oclk(iclk), .odata(iclk_rpg[rpg_i]) );
        end
    endgenerate
    
    wire [DEPTH_BITS:0] oclk_wpg;
    genvar wpg_i;
    generate
        for (wpg_i=0; wpg_i<=DEPTH_BITS; wpg_i=wpg_i+1) begin: wpg_for
            double_ff wpg_ff( .idata(wpg[wpg_i]), .oclk(oclk), .odata(oclk_wpg[wpg_i]) );
        end
    endgenerate
    
    // グレイコードをバイナリコードに変換
    
    reg [DEPTH_BITS:0] iclk_rp0;
    always @(posedge iclk)
        iclk_rp0 <= gray2binary(iclk_rpg);

    reg [DEPTH_BITS:0] oclk_wp0;
    always @(posedge oclk)
        oclk_wp0 <= gray2binary(oclk_wpg);

    // 次クロックのための full / empty 信号を計算

    wire [DEPTH_BITS:0] mask = ( one << DEPTH_BITS );
    
    wire next_full = we ? ( ( iclk_rp0 ^ mask ) == wp1 ) :
                          ( ( iclk_rp0 ^ mask ) == wp0 ) ;
    always @(posedge iclk)
        if (irst)
            full <= 1'b0;
        else
            full <= next_full;
           
    wire next_empty = re ? ( rp1 == oclk_wp0 ) :
                           ( rp0 == oclk_wp0 ) ;
    always @(posedge oclk)
        if (orst)
            empty <= 1'b1;
        else
            empty <= next_empty;

    // empty 時に読み出すと書き込みとかぶるので回避する
    assign mem_ce = !next_empty;
 
endmodule

テストベンチ†

エラーメッセージの表示は、ISim では $display を ModelSim では $messagelog を使うようになっています。

`define SETUP 1:1:1
`define HOLD  0:0:0
`ifdef XILINX_ISIM
    `define ERROR $display
`else
    `define ERROR $messagelog
`endif

module async_fifo_test;

    localparam DATA_BITS = 8;   // データ幅
    localparam DELAY = 2;       // 信号遅延

    reg irst;
    reg iclk;
    reg orst;
    reg oclk;
    
    wire                 #DELAY full;
    wire                 #DELAY we;
    wire [DATA_BITS-1:0] #DELAY idata;

    wire                 #DELAY empty;
    wire                 #DELAY re;
    wire [DATA_BITS-1:0] #DELAY odata;
    
    // Instantiate the Unit Under Test (UUT)
    async_fifo uut (
        .irst(irst), 
        .iclk(iclk), 
        .idata(idata), 
        .we(we), 
        .full(full), 
        .orst(orst), 
        .oclk(oclk), 
        .odata(odata), 
        .re(re), 
        .empty(empty)
    );

    // 書き込み側のモック
    tranceiver_mock #(.DATA_BITS(DATA_BITS)) tx (
        .rst(irst),
        .clk(iclk),
        .full(full),
        .data(idata),
        .we(we)
    );
    
    // 読み出し側のモック
    receiver_mock #(.DATA_BITS(DATA_BITS)) rx (
        .rst(orst),
        .clk(oclk),
        .empty(empty),
        .re(re),
        .data(odata)
    );
    
    // クロック生成

    integer CLKA = 10;
    integer CLKB = 10;
   
    always #CLKA iclk = !iclk;
    always #CLKB oclk = !oclk;
    
    initial begin
        // Initialize Inputs
        irst = 1;
        iclk = 0;
        orst = 1;
        oclk = 0;

        // Wait 100 ns for global reset to finish
        #100;
        
        // Add stimulus here

        #500; // 初期化時間
        
        // タイミングを測ってリセットを下ろす
        @(posedge iclk) irst = 0;
        @(posedge oclk) orst = 0;
        
        // いくつかのクロックの組み合わせに対してシミュレート
        
        CLKA = 10; CLKB = 10.0; #1000000;
        CLKA = 10; CLKB = 10.1; #1000000;
        CLKA = 11; CLKB = 10.3; #1000000;
        CLKA = 10; CLKB = 30.1; #1000000;
        CLKA = 30; CLKB = 10.1; #1000000;
        $stop;
    end

endmodule

// 送信側モック
module tranceiver_mock #(
    parameter DATA_BITS = 8
) (
    input rst,
    input clk,
    input full,
    output we,
    output reg [DATA_BITS-1:0] data
);
    // 入力信号タイミングチェック
    specify
        $setuphold (posedge clk, full, `SETUP, `HOLD);
    endspecify

    // ランダムなタイミングで
    // ０から１ずつ増やしながら書き込む

    reg rand;
    always @(posedge clk)
        rand <= ($random & 1) == 1;

    assign we = !rst & !full & rand;

    always @(posedge clk) 
        if ( rst ) 
            data <= 0;
        else
        if ( we ) 
            data <= data + 1;

endmodule

// 受信側モック
module receiver_mock #(
    parameter DATA_BITS = 8
) (
    input rst,
    input clk,
    input empty,
    output re,
    input [DATA_BITS-1:0] data
);
    // 入力信号タイミングチェック
    specify
        $setuphold (posedge clk, empty, `SETUP, `HOLD);
        $setuphold (posedge clk, data, `SETUP, `HOLD);
    endspecify

    // ランダムなタイミングで読み出し
    // 値が 0 から順に増えていくことを確認

    reg rand;
    always @(posedge clk)
        rand <= ($random & 1) == 1;

    assign re = !rst & !empty & rand;

    reg [DATA_BITS-1:0] expected = 0;
    always @(posedge clk) begin
        if (rst) begin
            expected <= 0;
        end else begin
            if ( re ) begin
                // 書き込んだデータが正しく読み出せているかチェック
                if ( data != expected )
                    `ERROR("*** ERROR@%0t : for odata, %d expected but %d found", $time, expected, data);
                expected <= expected + 1;
            end
        end
    end
endmodule

性能†

上記の回路では、

    wire mem_ce;
    always @(posedge oclk)
        if (mem_ce)         // empty 時に読み出すと書き込みとかぶるので回避する
            odata <= mem[re ? rp1[DEPTH_BITS-1:0] : rp0[DEPTH_BITS-1:0]];

の部分がボトルネックになっているのですが、これを

    always @(posedge oclk)
        odata <= mem[re ? rp1[DEPTH_BITS-1:0] : rp0[DEPTH_BITS-1:0]];

としてしまえば、最適化によっては Spartan 3A DSP 上で幅 32bit、深さ 512 の FIFO を 200 MHz オーバーでも回せるみたいです？

すべて同期リセット回路にするのが良さそうです†

FPGA 開発を始めた当初（といっても半年くらい前ですが）、リセット信号の取り扱いについて、 あまり深く考えておらず、「何となくリセットが掛かりそうな回路」を書いて満足していました。 しかし、レーシングなどについて勉強してからよく考えてみると、 リセットには慎重な扱いが必要であることが分かってきて、 先週末はプロジェクト内のリセット信号をすべて、 完全な同期リセット回路に書き換える作業を行っていました(2010/06/11)。

非同期リセット回路と同期リセット回路†

良く知られるように、リセット信号を持つ回路の構成方法には、 非同期リセットと同期リセットがあって、 たとえば ISE の Language Template にも両方の形が収録されています。

ＦＰＧＡの部屋でも、 FPGAの非同期リセットと同期リセットの比較 として記事になっていて、同期リセット回路は非同期リセット回路に比べて 回路規模においてお得であるという結論になっていました。

ただよくよく考えてみると、両者の違いは回路規模だけに留まらず、 回路の信頼性にも大きな差があるのではないでしょうか？

非同期リセットで回路を初期化した場合や、 同期リセット回路に非同期なリセット信号を入力して初期化した場合には、 リセットをデアサートするタイミングによっては、 回路が正しくリセットされない場合があるように思えるのです。

リセット信号が非同期だと正しく初期化できない†

例として、次のコードは同期リセットを持つフリーランニングのワンホットコーディング・ ステートマシンのつもりで書いたものです。

reg [3:0] state;
always @(posedge clk)
    if (rst)
        state <= 4'b0001;
    else
        state <= { state[2:0], state[3] };    // ローテート

この rst に、例えばプッシュボタンからの非同期信号をそのまま繋いでしまうと、 タイミングによっては正しくリセットが行われないのではないかと思います。

これは、rst が非同期信号であるために、いわゆるレーシングが生じるためです。

以下にもう少し詳しく考えてみます。

上記 if 文は３項演算子で書くことができて、その場合には次のようになります。

reg [3:0] state;
always @(posedge clk)
    state <= rst ? 4'b0001 : { state[2:0], state[3] };    // ローテート

さらにプリミティブの動作を分かりやすくするためにビット毎に分けると こうなるんだと思います。

reg [3:0] state;
wire [3:0] initial_state = 4'b0001;
wire [3:0] rotated_state = { state[2:0], state[3] };    // ローテート
always @(posedge clk) begin
    state[0] <= rst ? initial_state[0] : rotated_state[0];
    state[1] <= rst ? initial_state[1] : rotated_state[1];
    state[2] <= rst ? initial_state[2] : rotated_state[2];
    state[3] <= rst ? initial_state[3] : rotated_state[3];
end

ここまで書くと、この回路で rst が同期化されていない場合の問題が明らかになります。

1. rst = 1 が数クロック続いて state == 4'b0001 になる
2. rst が 0 に変化する時刻は、ネット遅延により、各ビットで少しだけ異なる
3. rst==0 が state[3:1] にくらべてほんのわずかに速く state[0] に伝わると、
   • state[0] <= rotated_state[0]; // == 1'b0
   • state[1] <= initial_state[1]; // == 1'b0
   • state[2] <= initial_state[2]; // == 1'b0
   • state[3] <= initial_state[3]; // == 1'b0

となる可能性があって、この場合、リセット直後にホットビットが失われてしまい、 回路はまともに動作しません。

リセット信号の同期化†

非同期リセット回路でも、まったく同じ状況が起きますので、 本当に安心してリセットを掛けるには、必ず同期リセット回路にして、 なおかつ リセット信号を同期化してから入力する必要があるんだと思います。

input wire async_rst,
input wire clk,
...

// リセット信号の同期化
wire sync_rst;
double_ff( .idata(async_rst), .oclk(clk), .odata(sync_rst) );

// 同期化されたリセットを、同期リセット回路に入力
reg [3:0] state;
always @(posedge clk)
    if (sync_rst)
        state <= 4'b0001;
    else
        state <= { state[2:0], state[3] };    // ローテート

同じ考え方で、もし回路が複数のクロック信号を持っているならば、 リセット信号もクロックの種類と同じだけの種類用意して、 必ずクロックに同期したリセット信号で回路を初期化する 気遣いが必要になります。

同期化したリセット信号を使っていて、それらの信号に不用意に TIG 制約を付けていなければ、同期リセット回路に間違って異なるクロックに同期した リセット信号を入力してしまったりしても、ツールが遅延時間解析で見つけてくれるので、 うっかりミスも防げます。

リセットの延長†

実際には、リセットをデアサートするタイミングは、 スイッチのチャタリングの影響を軽減する目的や、 ある程度クロックが安定するのを待つ目的で、 カウンタを使って延長するのが良いのだと思います。

そういうわけで、現在私の使っている回路では、リセット生成部分は次のようになっています。

input wire async_rst,
input wire A_clk,
input wire B_clk,
input wire C_clk,
...

// リセット信号の同期化 (A_clk)

wire sync_rst;
double_ff( .idata(async_rst), .oclk(A_clk), .odata(sync_rst) );

// sync_rst_extended は sync_rst が 0 になってから
// A_clk で 2**RESET_COUNTER_BITS クロックだけたってから 0 になる

localparam RESET_COUNTER_BITS = 10;
reg [RESET_COUNTER_BITS-1:0] rst_counter;
reg sync_rst_extended;
always @(posedge A_clk) begin
    if (sync_rst)
        rst_counter <= 0;
    else
    if (! &rst_counter) // 全てのビットが１になったら止まる
        rst_counter <= rst_counter + 1;

    // 全てのビットが１になった次のクロックで下がる
    sync_rst_extended = ! &rst_counter;
end

wire A_rst, B_rst, C_rst; // それぞれ A_clk, B_clk, C_clk に同期したリセット

double_ff( .idata(sync_rst_extended), .oclk(A_clk), .odata(A_rst) );
double_ff( .idata(sync_rst_extended), .oclk(B_clk), .odata(B_rst) );
double_ff( .idata(sync_rst_extended), .oclk(C_clk), .odata(C_rst) );

同期リセット信号ネットの分割†

注意点として、同期リセット信号のネットが大きくなると、 リセット信号のネット遅延がクロック周波数を制限するなどと言う事態になりかねません。

その場合には、モジュール単位で非同期リセット信号からローカルに同期リセット信号を 作れば、個々の同期リセット信号のネットを小さく保てると思います。

上記の synchronize と 非同期 FIFO も†

入力側と出力側とでそれぞれ異なる同期リセット信号を使うように書き直しました。

2bit のジョンソンカウンタベースのステートマシン†

• 2bit のジョンソンカウンタベースのステートマシンなら、非同期の直接入力はOKかと -- [アプロ] 2010-06-07 (月) 14:40:19
• このままだと分かりにくくなりそうだったので、コメント欄をトピックで分けさせていただきました。 -- [武内（管理人）] 2010-06-07 (月) 14:52:15
• で、毎度のことながらアプロさんのご指摘の意味を一発で理解できないでいます。これは、トリガ信号の伝達 あたりの話でしょうか？（はずしている自信大です） -- [武内（管理人）] 2010-06-07 (月) 14:54:22
• 当たりです(笑) 詳しくは、『定本 ASICの論理回路設計』 にノウハウが(^^ゞ -- [アプロ] 2010-06-07 (月) 15:18:16
• おー、当たりましたか（笑　ASICの論理回路設計は持っているので、読み直してみます。 -- [武内（管理人）] 2010-06-07 (月) 15:22:16
• というか、上記回路 の { itrig_ex2, itrig_ex1 } はよく見るとそのままジョンソンカウンタになってますね。ちょこちょこっと手直しすると最適化できそうに思えてきました。 -- [武内（管理人）] 2010-06-07 (月) 15:48:32 あんまり関係ないですね（汗　もう少し落ち着いて考えてみます。
• いろいろ考えてみましたが、結局改善できる点を見つけることができませんでした（泣 -- [武内（管理人）] 2010-06-07 (月) 21:12:40
• あれーっ(笑) ヒントは、『定本 ASICの論理回路設計』 の7,8章を読んでもらえれば(^{♪ 2bit のジョンソンカウンタベースのステートマシンのストップモーションを(})v -- [アプロ] 2010-06-08 (火) 07:49:02
• あ、考えてみた生々しい(?)内容を、さらに改良できないか考察 に書いてみたのでした。最初に示していたコードは、よく見ると 2bit のジョンソンカウンタベースのステートマシンのストップモーションになってるんじゃないかと思うのです。気づいてなかったのですが（汗 -- [武内（管理人）] 2010-06-08 (火) 07:53:58
• で、その周りのコードは、ステートマシンを確実に１度だけ起動するためのラッチだったり、出力パルス幅を１クロック幅にするためのＦＦだったりで、私の力では縮小できなかったというわけです。 -- [武内（管理人）] 2010-06-08 (火) 07:55:36
• うう、もしかして本当にそのものずばりのコードとか本に載ってたりします？（おどおど -- [武内（管理人）] 2010-06-08 (火) 07:56:31
• ちゃんと見ると 初期バージョン も、iclk ドメインと oclk ドメインとでそれぞれ１つずつ 2bit ジョンソンカウンタをストップモーションで回している形になっているんですね。びっくりしました！ -- [武内（管理人）] 2010-06-08 (火) 08:23:47
• 初期バージョンのコードは otrig を reg で作らずに assign otrig = !itrig_ex2 & otrig1 とすることで、少しだけ軽くて速い回路に改善できることに気づきました。 -- [武内（管理人）] 2010-06-08 (火) 08:29:42
• 回路図がずばり(笑) -- [アプロ] 2010-06-08 (火) 08:31:02
• 単純に2bitあればOKではないのかな S0, S1, S2, S3 戻って S0 と遷移するので、S0=>S1 の遷移のストップモーション"トリガ"H"待ち"、S3=>S0 の遷移のストップモーション"トリガ"L"待ち" どうにょろ？ -- [アプロ] 2010-06-08 (火) 09:50:42
• はい、中央で動くステートマシンはほぼそれに近い動作になると思うのですが、上での怪しい考察 によると（かなり自信ないですが）、入出力のクロック周波数が大幅に異なる場合などにも動作する回路を作るには、中心となる２ビットステートマシンの周辺に少しだけ回路を追加する必要があるのではないかと思うのです。あとは、それらをどれだけうまく作れるかなのですが。。。 -- [武内（管理人）] 2010-06-08 (火) 11:09:52
• S2=>S3 の遷移にストップモーションを追加し、時間差分のタイマを入れれば、どーとでもなると思いますが(笑) -- [アプロ] 2010-06-08 (火) 11:57:53
• すみません、根本から確認で、ステートマシンは出力クロック同期を考えているのは正しいでしょうか？何か大きく勘違いしている気がしてきました。 -- [武内（管理人）] 2010-06-08 (火) 12:06:57
• 非同期の信号を受けて、自分のクロックに引き込む側を考えています。基本的に、S0=>S1，S3=>S0 のストップモーションでよいと思います。相手が速い場合は、S0=>S1のストップモーションだけでよい筈です。ただし、相手側でパルス幅を広くする必要があります。 -- [アプロ] 2010-06-08 (火) 12:58:15
• そうですよね。直接繋いだ場合、相手がパルスを広くする必要と、スタティックハザードを出さない必要があるんだと思います。 -- [武内（管理人）] 2010-06-08 (火) 14:21:11
• また、本当にストップモーションのステートマシンとするためには、非同期信号から数えて１つ目のＦＦと２つ目のＦＦとの間に LUT(?) を入れることになるので、mtbf 的に上記回路が（無視できる程度かもしれませんが）多少なりとも有利なのだと思っています。 -- [武内（管理人）] 2010-06-08 (火) 14:27:13
• S0="00", S1="01", S2="11", S3="10" になります。[1:0] jon_reg ; S0=>S1 は、[0] にいたずらする。S3=>S0 は、[1] にいたずらします -- [アプロ] 2010-06-08 (火) 15:27:45
• S0=>S1 は非同期入力を使っているため、[0] は短時間メタステーブルになる可能性があると思います。で、そのメタステーブル信号は次の S1=>S2 の遷移が jon_reg[0]==1'b0 && jon_reg[1]==1'b0 の結果として起きることから、AND を１回通って次の FF である [1] に到達すると考えられます(ANDはLUTに実装される？)。これに対して上記の案では、itrig_ex1 がメタステーブルになったとしても itrig_ex2 までのパスに何のロジックも入らないため、mtbf 的に有利ではないかと考えました。 -- [武内（管理人）] 2010-06-08 (火) 16:21:26
• jon_reg[0] がメタ・ステープルになっても、jon_reg[1] が受け付けなければ、jon_reg[0] の状態が変化しないと思います。S1=>S2 の遷移は、jon_reg[0]=1 の時に、次のクロックで、jon_reg[1]が"1"になることです -- [アプロ] 2010-06-08 (火) 18:39:24
• この小さなコメント欄での分かりづらい議論に突き合って下さりありがとうございます。しかも、上で私が書き間違えたために話がおかしくなってしまいました。どうもすみません。 -- [武内（管理人）] 2010-06-08 (火) 19:08:18
• S0=>S1 は非同期入力を使っているため、[0] は短時間メタステーブルになる可能性がある、というのは正しいとして、次の S1=>S2 の遷移は jon_reg[1:0]==2'b01 の条件で起きるので、プリミティブに直せば if (jon_reg[1]==1'b0 && jon_reg[0]==1'b1) jon_reg[1] <= 1'b1; という回路になりますね。先ほどは誤って 2'b00 としてしまいました。 -- [武内（管理人）] 2010-06-08 (火) 19:10:36
• jon_reg[0] のメタステーブルが伝わって jon_reg[1] までもがメタステーブルに陥ってしまう可能性の高さは jon_reg[0] から jon_reg[1] までの遅延時間に依存していて、この遅延が長いほど(低確率とはいえ)メタステーブルが伝播しやすくなってしまいます。 -- [武内（管理人）] 2010-06-08 (火) 19:14:08
• if (jon_reg[1]==1'b0 && jon_reg[0]==1'b1) jon_reg[1] <= 1'b1; の場合の遅延時間は AND が１つだけなので決して大きくはないのですが、上記の回路 では間に１つもロジックがなく、遅延は極小化できていると思ったのでした。 -- [武内（管理人）] 2010-06-08 (火) 19:16:25
• 「非同期信号は２段のＦＦで受けよ」という話でも、通常それら２つのＦＦ間の遅延に関する注意は声高に言われないのですが、本当は非同期信号をＦＦで受けた場合には常に、１段目と２段目のＦＦ間の遅延時間をできる限り短く保つ努力が必要なのかな、と、、、少し気にしすぎなのかもしれませんが。 -- [武内（管理人）] 2010-06-08 (火) 19:21:51
• うわ、コメント欄で書く分量じゃないですね（汗 -- [武内（管理人）] 2010-06-08 (火) 19:23:02
• しかも、これだけ書き込んでから、ストップモーションの無いステートではジョンソンカウンタを進めるのに AND を取る必要が無いことに今頃気づきました（滝汗 -- [武内（管理人）] 2010-06-08 (火) 19:31:36
• mtbf 云々については私の勘違いと言うことで、そっとしておいて下さい（乾笑 -- [武内（管理人）] 2010-06-08 (火) 19:34:10
• 後でもう一度、ステートマシンを本当のジョンソンカウンタで作ったときに itrig_ex3 を取り除けないかどうか、考えてみようと思います。 -- [武内（管理人）] 2010-06-08 (火) 20:00:35

一括でのTIG制約†

• ブログでは、非同期FIFOで異なるクロックから信号を受渡しているので、一括でTIG制約をかけても問題ないと思います。 -- [marsee] 2010-05-19 (水) 04:56:53
• そうですね。時と場合でいろいろな方法があって、何がよいのか常に迷っているような状況です・・・ -- [武内（管理人）] 2010-05-19 (水) 15:20:43