Synthesis of Sequential Logic — Explained循序邏輯的合成 — 詳解順序論理の合成 — 詳解

1. Flip-Flop Inference: What Turns a Variable into Storage1. 正反器推論：什麼會把變數變成儲存元件1. フリップフロップ推論：変数が記憶素子になる条件

Lecture 5 dealt with combinational synthesis, where every output is a pure function of the current inputs and the only thing that can go wrong is an accidental latch. This lecture adds the one ingredient that makes a digital system a system rather than a calculator: memory. From here on, the circuit's output depends not only on what you present at the inputs but on what you presented at every earlier clock edge, and that history lives in flip-flops.第 5 講處理的是組合邏輯合成，那裡每個輸出都是當前輸入的純函數，唯一會出錯的地方就是意外產生的閂鎖。這一講加入了讓數位系統成為系統而不只是計算器的那項要素：記憶。從這裡開始，電路的輸出不只取決於你現在送進輸入端的值，還取決於你在之前每一個時脈邊緣所送進的值，而這段歷史就存在正反器裡。第 5 講では組合せ論理の合成を扱った。そこではすべての出力が現在の入力の純粋な関数であり、唯一の落とし穴は偶発的なラッチだけだった。本講では、ディジタルシステムを単なる計算器ではなくシステムたらしめる唯一の要素、すなわち記憶を加える。ここから先、回路の出力は入力に今与えた値だけでなく、過去のすべてのクロックエッジで与えた値にも依存する。そしてその履歴はフリップフロップの中に宿る。

The deceptively short slide for this is the one that says a register variable in a behaviour becomes a flip-flop if it is “aligned with the clock behaviours” and “assigned value by some assignments”. That single sentence is the contract between you and the synthesiser, and almost every sequential-synthesis bug a student meets is a violation of it. The whole of this first section is spent unpacking it.對應這件事的投影片短得令人誤會：它說行為描述中的 register 變數若「與時脈行為對齊」且「由某些指派賦值」，就會成為正反器。這一句話就是你與合成器之間的契約，而學生遇到的循序合成錯誤幾乎每一個都是違反了它。整個第一節就是在把這句話拆開來講。これに対応するスライドは、誤解を招くほど短い。曰く、ビヘイビア記述中の register 変数は「クロック動作に整合している」かつ「何らかの代入で値を与えられている」ならフリップフロップになる、と。この一文があなたと合成器のあいだの契約であり、学生が出会う順序回路合成のバグはほとんどすべてこの契約の違反である。第 1 節はまるごと、この一文をほどくために費やす。

1.1 What a synthesiser really does with an always block1.1 合成器對一個 always 區塊到底做了什麼1.1 合成器は always ブロックに対して実際に何をするのか

The first thing to understand is that a logic synthesiser does not execute your Verilog. A simulator does: it maintains an event queue, wakes behaviours when their event controls fire, evaluates right-hand sides, schedules updates, and so on. A synthesiser does something quite different and much more limited. It pattern-matches your source against a small catalogue of templates, and for each template it knows a corresponding piece of hardware. Everything outside that catalogue is either rejected or, worse, accepted and mapped onto hardware whose simulation behaviour does not match your RTL.首先要理解的是：邏輯合成器並不會執行你的 Verilog。模擬器才會：它維護事件佇列、在事件控制觸發時喚醒行為、計算右手邊、排程更新，依此類推。合成器做的事相當不同，而且受限得多。它把你的原始碼拿去比對樣板——對照一份很小的樣板目錄，而每一個樣板它都知道對應到哪一塊硬體。落在目錄之外的東西不是被拒絕，就是更糟：被接受並對映到一塊模擬行為與你的 RTL 不一致的硬體。まず理解すべきは、論理合成器はあなたの Verilog を実行しないということである。実行するのはシミュレータのほうだ。シミュレータはイベントキューを保持し、イベント制御が発火したらビヘイビアを起こし、右辺を評価し、更新をスケジュールする。合成器がするのはまったく別の、はるかに限定された仕事である。合成器はソースを小さなテンプレートの目録に対してパターンマッチし、各テンプレートに対応するハードウェアを知っている。目録の外にあるものは拒否されるか、さらに悪いことに、受理されたうえでシミュレーション動作が RTL と一致しないハードウェアに写像される。

The catalogue for sequential logic is tiny. There are essentially three entries:循序邏輯的樣板目錄非常小，基本上只有三項：順序論理のテンプレート目録はごく小さい。実質的に三項目しかない。

• Edge-sensitive template. An always block whose event control contains at least one posedge or negedge. Everything assigned inside becomes the output of an edge-triggered flip-flop clocked by the edge signal, unless the tool can prove the variable never needs to survive the edge.邊緣敏感樣板。事件控制中至少含一個 posedge 或 negedge 的 always 區塊。裡面被指派的所有變數都會成為由該邊緣信號驅動的邊緣觸發正反器的輸出，除非工具能證明該變數不需要跨過邊緣存活。エッジ感応テンプレート。イベント制御に posedge または negedge を少なくとも一つ含む always ブロック。内部で代入される変数はすべて、そのエッジ信号でクロックされるエッジトリガ・フリップフロップの出力になる。ただし、その変数がエッジをまたいで保持される必要がないとツールが証明できる場合を除く。
• Level-sensitive template. An always block with a pure level sensitivity list (always @(a or b) or always @*). Variables assigned on every path through the block become wires; variables not assigned on some path become latches. This is the Lecture 5 material.位準敏感樣板。感應列中只有位準的 always 區塊（always @(a or b) 或 always @*）。在區塊的每一條路徑上都被指派的變數成為連線；在某條路徑上沒有被指派的變數則成為閂鎖。這是第 5 講的內容。レベル感応テンプレート。感度リストがレベルだけの always ブロック（always @(a or b) や always @*）。ブロック内のすべての経路で代入される変数は配線になり、ある経路で代入されない変数はラッチになる。これは第 5 講で扱った内容である。
• Continuous assignment. assign always produces combinational logic (or a tri-state driver), never storage.連續指派。assign 永遠產生組合邏輯（或三態驅動器），絕不產生儲存元件。連続代入。assign は常に組合せ論理（あるいはトライステートドライバ）を生み、記憶素子を生むことはない。

Notice what this means in practice: the decision “flip-flop or not” is taken almost entirely by the shape of the event control, before the tool has even looked at the body. The body only decides which variables inside an edge-sensitive block can be optimised back down to wires. If you write always @(posedge clk), you have already committed to a register bank; the only remaining question is how wide it is.注意這在實務上代表什麼：「要不要正反器」這個決定幾乎完全由事件控制的形狀決定，工具甚至還沒看過區塊本體就已經決定了。本體只決定邊緣敏感區塊裡哪些變數可以被最佳化回連線。只要你寫下 always @(posedge clk)，你就已經承諾了一排暫存器；剩下的問題只是它有多寬。これが実務上どういう意味かに注意してほしい。「フリップフロップにするかどうか」の判断は、ほぼ完全にイベント制御の形で決まり、ツールが本体を見るより前に決まっている。本体が決めるのは、エッジ感応ブロック内のどの変数が配線まで最適化し戻せるか、それだけだ。always @(posedge clk) と書いた時点で、あなたはすでにレジスタ群を確約している。残る問いはその幅だけである。

1.2 The commonly synthesised sequential blocks1.2 常見的可合成循序區塊1.2 よく合成される順序回路ブロック

Before the rules, the inventory. The slide lists the sequential structures that cell-based synthesis is routinely asked to produce. It is worth reading as a map of the rest of the lecture, because every one of them is just flip-flops plus a particular combinational cone in front of the D pins.在談規則之前，先清點一下庫存。投影片列出了 cell-based 合成經常被要求產生的循序結構。這份清單值得當成本講其餘部分的地圖來讀，因為其中每一項都只是正反器加上 D 腳前面某個特定的組合邏輯錐。規則に入る前に、まず在庫を数えておく。スライドには、セルベース合成が日常的に生成を求められる順序構造が列挙されている。この一覧は本講の残りの地図として読む価値がある。どの項目も、結局はフリップフロップと D ピンの前に置かれた特定の組合せ論理コーンにすぎないからだ。

Two entries on that list deserve a flag straight away. The transparent latch is there because latches are legitimate library cells that you sometimes want deliberately — in a clock-gating cell, in a pulse-latch datapath, in a retention register. What Lecture 5 warned against is the accidental latch produced by an incomplete combinational description, not latches as such. And the clock generator is there with a large asterisk: on an ASIC you do not synthesise clock generation out of standard cells, you instantiate a PLL or a clock-divider macro and let clock-tree synthesis own the net. A divider built from ordinary flip-flops whose Q drives another flip-flop's clock pin is exactly the ripple-counter structure of Section 5, with all of its problems.這份清單裡有兩項要馬上標註。透通閂鎖會在上面，是因為閂鎖是合法的函式庫單元，有時你是刻意要用它的——在 clock-gating cell 裡、在 pulse-latch 資料路徑裡、在保持暫存器裡。第 5 講警告的是組合邏輯描述不完整所造成的意外閂鎖，而不是閂鎖本身。而時脈產生器則要加上一個大大的星號：在 ASIC 上你不會用標準單元去合成時脈產生，你會實例化一顆 PLL 或除頻巨集，然後讓時脈樹合成去擁有那條網路。用普通正反器搭出來、Q 直接去驅動另一顆正反器時脈腳的除頻器，正好就是第 5 節的漣波計數器結構，連同它所有的問題。この一覧のうち二つは、すぐに旗を立てておく価値がある。トランスペアレントラッチが載っているのは、ラッチが正当なライブラリセルであり、意図して使いたい場面があるからだ——クロックゲーティングセル、パルスラッチ・データパス、リテンションレジスタなど。第 5 講が戒めたのは、組合せ記述の不完全さが生む偶発的なラッチであって、ラッチそのものではない。そしてクロック生成器には大きな注釈が付く。ASIC では標準セルからクロック生成を合成したりはしない。PLL か分周マクロをインスタンス化し、そのネットはクロックツリー合成に委ねる。普通のフリップフロップで組み、Q が別のフリップフロップのクロックピンを駆動する分周器は、まさに第 5 節のリプルカウンタ構造そのものであり、その問題もすべて引き継ぐ。

1.3 The inference rule itself1.3 推論規則本身1.3 推論規則そのもの

Here is the rule stated carefully enough to be useful:把規則講得夠精確、好用的版本是這樣：役に立つ程度にきちんと述べると、規則はこうなる。

Condition 1 is the one the slide states. Condition 2 is the one the slide leaves implicit by saying “assigned value by some assignments”, and it is the one that actually does the work. Consider the difference between these two blocks:條件 1 就是投影片講出來的那一條。條件 2 則是投影片用「由某些指派賦值」含糊帶過的那一條，而它才是真正在幹活的那一條。比較這兩個區塊的差別：条件 1 はスライドが述べているほうである。条件 2 はスライドが「何らかの代入で値を与えられている」と言って暗黙に済ませているほうで、実際に働いているのはこちらだ。次の二つのブロックの違いを見てほしい。

always @ (posedge clk) begin
  t = a & b;        // written first
  y <= t | c;       // then read
end
// 1 flip-flop: y. t is an AND gate.

always @ (posedge clk) begin
  y <= t | c;       // read first
  t = a & b;        // written afterwards
end
// 2 flip-flops: y and t.

Both blocks are edge-sensitive and both assign t, so condition 1 is satisfied in each. The difference is condition 2. On the left, t is written before it is read, so its value at the start of the block is irrelevant: nothing in the circuit ever needs yesterday's t, and the tool collapses it into the combinational cone feeding y's D pin. On the right, t is read before it is written, so y is a function of t's value at the previous clock edge — and the only way hardware remembers a previous value is with a flip-flop. The tool must allocate one.兩個區塊都是邊緣敏感的，也都指派了 t，所以條件 1 在兩邊都成立。差別在條件 2。左邊的 t 先寫後讀，所以它在區塊開始時的值無關緊要：電路裡沒有任何東西需要昨天的 t，於是工具把它收進餵給 y 的 D 腳的組合邏輯錐裡。右邊的 t 先讀後寫，於是 y 是 t 在前一個時脈邊緣的值的函數——而硬體要記住前一個值的唯一辦法就是正反器。工具非配一顆不可。どちらのブロックもエッジ感応で、どちらも t に代入しているので、条件 1 は両方で満たされる。違いは条件 2 にある。左では t は読まれる前に書かれるので、ブロック開始時点の値はどうでもよい。回路のどこも昨日の t を必要としないので、ツールはそれを y の D ピンを駆動する組合せコーンに畳み込む。右では t は書かれる前に読まれるので、y は直前のクロックエッジにおける t の値の関数になる——そしてハードウェアが過去の値を覚える唯一の手段はフリップフロップである。ツールは一つ割り当てざるを得ない。

This is why experienced designers call the test “read-before-write”. Write-before-read gives you a wire; read-before-write gives you storage. It is a purely syntactic test applied to the straight-line order of blocking assignments, and it is deterministic: two different synthesisers will agree.這就是為什麼老練的設計者把這個判準叫做「read-before-write」。先寫後讀給你連線，先讀後寫給你儲存元件。它是套用在阻斷式指派直線順序上的純語法判準，而且是確定性的：兩套不同的合成器會得到一致的結論。だからこそ経験を積んだ設計者はこの判定を「read-before-write」と呼ぶ。書いてから読めば配線、読んでから書けば記憶素子になる。これはブロッキング代入の直線的な順序に適用される純粋に構文的な判定であり、決定的である。異なる二つの合成器が同じ結論に達する。

Non-blocking assignments sidestep the question entirely. The semantics of <= are that every right-hand side in the block is evaluated using the values that existed at the edge, and all the left-hand sides are updated afterwards. There is no ordering to analyse. Every target of a non-blocking assignment in an edge-sensitive block is, by construction, read-before-write with respect to the edge, so every one of them becomes a flip-flop. That predictability is the entire reason the coding guideline “use <= for clocked logic” exists.非阻斷式指派則完全繞過了這個問題。<= 的語義是：區塊中所有右手邊都用邊緣當下存在的值計算，然後所有左手邊才一起更新。沒有順序可分析。邊緣敏感區塊中每一個非阻斷式指派的目標，就其構造而言，相對於該邊緣都是先讀後寫，所以每一個都會變成正反器。這種可預測性正是「時脈邏輯請用 <=」這條撰碼準則存在的全部理由。ノンブロッキング代入はこの問いを完全に回避する。<= の意味論は、ブロック内のすべての右辺がエッジ時点で存在した値を用いて評価され、そのあとで左辺がまとめて更新される、というものだ。解析すべき順序が存在しない。エッジ感応ブロック内のノンブロッキング代入の対象は、構成上すべてそのエッジに対して read-before-write であり、したがってすべてフリップフロップになる。この予測可能性こそが「クロック同期論理には <= を使え」というコーディング指針が存在する理由のすべてである。

1.4 Flip-flop, wire or latch — the full decision1.4 正反器、連線或閂鎖 — 完整的決策1.4 フリップフロップ、配線、ラッチ — 判断の全体像

Put the combinational rules from Lecture 5 next to the sequential rules from this one and you get a complete picture. The table below is worth memorising, because exam questions about “what does this infer?” are always one of these six cells.把第 5 講的組合邏輯規則和這一講的循序邏輯規則並排放在一起，整張圖就完整了。下面這張表值得背起來，因為考題問「這會推論出什麼？」時，答案永遠是這六格之一。第 5 講の組合せ論理の規則と本講の順序論理の規則を並べると、全体像が完成する。下の表は暗記する価値がある。「これは何を推論するか」という試験問題の答えは、必ずこの六つのセルのどれかだからだ。

The row that students find most surprising is the third one. In a combinational block, failing to assign a variable on some path means “hold the old value”, and the only hardware that holds a value without a clock is a latch. In an edge-triggered block, failing to assign on some path also means “hold the old value” — but holding a value across a clock edge is precisely what a flip-flop does. So the same source-level sin produces a disaster in one context and a perfectly ordinary load-enable register in the other. Section 4.4 is built entirely around that distinction.學生覺得最意外的是第三列。在組合區塊裡，某條路徑上沒有指派某個變數，意思是「保持舊值」，而沒有時脈卻能保持值的硬體只有閂鎖。在邊緣觸發區塊裡，某條路徑上沒有指派同樣意味著「保持舊值」——但跨越時脈邊緣保持值正是正反器在做的事。所以同一個原始碼層面的「罪」，在一個情境下是災難，在另一個情境下只是一顆再普通不過的載入致能暫存器。4.4 節整節就是圍著這個區別建起來的。学生がいちばん意外に思うのは三行目である。組合せブロックでは、ある経路で変数に代入しないことは「古い値を保持する」を意味し、クロックなしで値を保持できるハードウェアはラッチしかない。エッジトリガブロックでも、ある経路で代入しないことは同じく「古い値を保持する」を意味する——が、クロックエッジをまたいで値を保持するのはまさにフリップフロップの仕事である。つまり、ソース上の同じ「罪」が、一方の文脈では災厄を、他方ではごく当たり前のロードイネーブル付きレジスタを生む。4.4 節はまるごとこの区別の上に組み立てられている。

The fifth row is the combinational loop. always @* y = y + 1; is legal Verilog and will hang most simulators; in synthesis it produces either an error or an unconstrained asynchronous feedback path that static timing analysis will flag as a loop and break arbitrarily. If a timing report ever contains the phrase “combinational loop detected, loop broken at pin X”, you have written this by accident.第五列是組合迴路。always @* y = y + 1; 是合法的 Verilog，而且會讓多數模擬器當掉；在合成時它不是產生錯誤，就是產生一條未受約束的非同步回授路徑，靜態時序分析會把它標為迴路並任意地切斷它。如果時序報告裡出現「combinational loop detected, loop broken at pin X」這句話，那就是你不小心寫出了這個。五行目は組合せループである。always @* y = y + 1; は合法な Verilog であり、たいていのシミュレータをハングさせる。合成ではエラーになるか、制約のない非同期フィードバック経路が生じ、スタティックタイミング解析がそれをループとして報告し任意の箇所で切断する。タイミングレポートに「combinational loop detected, loop broken at pin X」という文が現れたら、あなたはこれを事故で書いてしまっている。

1.5 Worked example: the synchronous swap1.5 範例演練：同步交換1.5 演習例：同期スワップ

The slide's example is a two-bit register pair that can be set to one of two fixed patterns or, failing that, swapped. It is a good example precisely because the swap is the case where blocking and non-blocking assignments give genuinely different hardware.投影片的例子是一對兩位元的暫存器，可以被設成兩種固定的圖樣之一，否則就交換彼此的值。它之所以是好例子，正是因為「交換」這個情況下阻斷式與非阻斷式指派會給出真正不同的硬體。スライドの例は 2 ビットのレジスタ対で、二つの固定パターンのいずれかに設定するか、どちらでもなければ互いの値を入れ替える。これが良い例なのは、まさにスワップこそブロッキング代入とノンブロッキング代入が本当に異なるハードウェアを生む場面だからである。

module swap_synch (set1, set2, clk, data_a, data_b);
  output data_a, data_b;
  input  clk, set1, set2;
  reg    data_a, data_b;

  always @ (posedge clk)
    begin
      if (set1)      begin data_a <= 1; data_b <= 0; end
      else if (set2) begin data_a <= 0; data_b <= 1; end
      else
        begin
          data_b <= data_a;
          data_a <= data_b;
        end
    end
endmodule

Work through the inference. Both data_a and data_b are assigned inside an edge-sensitive behaviour, so condition 1 holds. Both are read in the else branch, so condition 2 holds. Two flip-flops. Each flip-flop's D input is whatever the if/else if/else chain selects, and a priority chain of two conditions over three mutually exclusive outcomes is exactly a 4-to-1 multiplexer addressed by the concatenation {set1, set2}:把推論走一遍。data_a 與 data_b 都在邊緣敏感的行為裡被指派，條件 1 成立。兩者都在 else 分支裡被讀取，條件 2 成立。兩顆正反器。每顆正反器的 D 輸入就是 if／else if／else 鏈所選出的值，而兩個條件、三個互斥結果的優先鏈，正好就是一顆由串接值 {set1, set2} 定址的 4 對 1 多工器：推論を順に追ってみよう。data_a と data_b はどちらもエッジ感応ビヘイビア内で代入されるので条件 1 が成り立つ。どちらも else 分岐で読まれるので条件 2 も成り立つ。フリップフロップは二つ。各フリップフロップの D 入力は if／else if／else 連鎖が選ぶ値であり、三つの排他的な結果に対する二条件の優先連鎖は、まさに連結 {set1, set2} でアドレスされる 4 対 1 マルチプレクサである。

The 11 column is the one people get wrong. The description is a priority chain, not a parallel case: when both set signals are asserted, set1 wins because it is tested first. The synthesiser encodes that priority by making mux inputs 2 and 3 identical, which means the mux select only really needs set1 and set2 & ~set1 — and that is why the gate-level netlist on the slide shows an inverter, a NAND and a NOR per bit rather than a literal four-input multiplexer cell. The tool has flattened the mux into a two-level gate network and then mapped it onto whatever the library offers cheaply.大家最常搞錯的是 11 這一欄。這段描述是優先鏈，不是平行的 case：當兩個 set 信號同時被確立時，set1 贏，因為它先被測試。合成器把這個優先次序編碼成「多工器的第 2 與第 3 個輸入相同」，這表示多工器的選擇訊號其實只需要 set1 與 set2 & ~set1——而這正是投影片上的閘級 netlist 每一位元顯示一顆反相器、一顆 NAND 和一顆 NOR，而不是一顆字面上的四輸入多工器單元的原因。工具已經把多工器壓平成兩層閘網路，再把它對映到函式庫中便宜的任何東西上。みなが間違えるのは 11 の列である。この記述は並列 case ではなく優先連鎖だ。二つの set 信号が同時にアサートされると、先に判定される set1 が勝つ。合成器はこの優先度を、マルチプレクサの入力 2 と 3 を同一にすることで符号化する。つまりマルチプレクサの選択信号は実質 set1 と set2 & ~set1 だけで足りる——スライドのゲートレベル・ネットリストが、文字どおりの 4 入力マルチプレクサセルではなく、1 ビットあたりインバータ 1 個と NAND 1 個、NOR 1 個を示しているのはそのためだ。ツールはマルチプレクサを 2 段のゲート網に平坦化し、ライブラリが安く提供するものへ写像したのである。

Now replace the two non-blocking assignments in the else branch with blocking ones:現在把 else 分支裡的兩個非阻斷式指派換成阻斷式：次に、else 分岐の二つのノンブロッキング代入をブロッキング代入に置き換えてみる。

else begin
  data_b <= data_a;
  data_a <= data_b;
end
// both RHS sampled at the edge
// a' = b, b' = a

else begin
  data_b = data_a;
  data_a = data_b;
end
// executes in order:
// b := a, then a := b (= a)
// a' = a, b' = a — no swap

In the blocking version, data_b is written and then immediately read, so it is write-before-read and collapses to a wire; data_a ends up assigned its own value, which the tool simplifies to a feedback. You would see this in the area report as one flip-flop where you expected two, and in simulation as both outputs stuck equal. This is the single most common sequential-Verilog bug and it is worth recognising from its symptom: a shift register that does not shift, a swap that does not swap, a pipeline whose stages all contain the same value.在阻斷式版本裡，data_b 被寫入之後馬上被讀取，所以它是先寫後讀，塌縮成一條連線；data_a 最後被指派成它自己的值，工具會把它簡化成回授。你會在面積報告裡看到一顆正反器，而你原本期待兩顆；在模擬裡則看到兩個輸出永遠相等。這是最常見的循序 Verilog 錯誤，值得從症狀認出來：不會移位的移位暫存器、不會交換的交換、每一級都裝著同一個值的管線。ブロッキング版では、data_b は書かれた直後に読まれるので write-before-read となり配線に潰れる。data_a は結局自分自身の値を代入されるので、ツールはそれをフィードバックに簡約する。面積レポートには、二つ期待していたところに一つのフリップフロップが現れ、シミュレーションでは両出力が常に等しくなる。これは順序 Verilog でもっとも多いバグであり、症状から見抜けるようにしておく価値がある。シフトしないシフトレジスタ、入れ替わらないスワップ、全段が同じ値を保持するパイプライン。

1.6 How inference goes wrong, and how it shows up1.6 推論怎麼出錯，又會怎麼現形1.6 推論はどう狂い、どう表に出るか

Four failure modes account for most of the trouble, and each has a distinctive signature in a tool report.四種失敗模式佔了大部分的麻煩，而每一種在工具報告裡都有獨特的特徵。トラブルの大半は四つの失敗モードで説明がつき、それぞれツールのレポートに固有の痕跡を残す。

(a) Too few flip-flops(a) 正反器太少(a) フリップフロップが少なすぎる

Cause: blocking assignments in a cascade, as above. Symptom: the synthesis area or resource report lists fewer sequential cells than you expect. If you intended an n-stage shift register and the report says one DFFQX1, stop and look at the assignment operators before you look at anything else. In simulation the symptom is that all stages change together.成因：如前所述，串接中用了阻斷式指派。症狀：合成的面積或資源報告列出的循序單元比你預期的少。如果你想要的是 n 級移位暫存器，而報告說只有一顆 DFFQX1，那就先停下來看指派運算子，什麼都先不要看。在模擬裡的症狀是所有級一起變動。原因：前述のとおり、カスケードでブロッキング代入を使っている。症状：合成の面積・リソースレポートに並ぶ順序セルが期待より少ない。n 段のシフトレジスタのつもりでレポートに DFFQX1 が一つしかなければ、他を見る前にまず代入演算子を見ること。シミュレーション上の症状は、全段が一斉に変化することである。

(b) Too many flip-flops(b) 正反器太多(b) フリップフロップが多すぎる

Cause: a temporary read before it is written, usually because statements got reordered during editing, or because a variable is assigned in one branch and read in another. Symptom: the register count is higher than the architectural state you can name, and the extra registers often have tool-generated names. In simulation the symptom is an extra cycle of latency somewhere in a datapath.成因：某個暫時值在被寫入之前先被讀取，通常是因為編輯時把敘述順序調動了，或是某個變數在一個分支被指派、在另一個分支被讀取。症狀：暫存器數量高於你叫得出名字的架構狀態，而多出來的暫存器常常帶著工具自動產生的名字。在模擬裡的症狀是資料路徑某處多了一個週期的延遲。原因：一時変数が書かれる前に読まれている。たいていは編集中に文の順序が入れ替わったか、ある分岐で代入し別の分岐で読んでいるためだ。症状：レジスタ数が、名前を挙げられるアーキテクチャ上の状態より多く、余分なレジスタにはツール生成の名前が付いていることが多い。シミュレーション上の症状は、データパスのどこかでレイテンシが 1 サイクル増えることである。

(c) Multiple drivers(c) 多重驅動(c) 多重ドライバ

Cause: the same reg assigned in two different always blocks. Verilog allows this — a simulator simply applies whichever assignment executes last — but hardware cannot have two flip-flops driving one net. Symptom: an outright synthesis error, usually worded “net ... has multiple drivers” or “variable is assigned in more than one block”. The fix is always to merge the blocks or to introduce separate variables and an explicit multiplexer.成因：同一個 reg 在兩個不同的 always 區塊裡被指派。Verilog 允許這樣——模擬器只會採用最後執行的那個指派——但硬體不可能讓兩顆正反器驅動同一條網路。症狀：直接的合成錯誤，措辭通常是「net ... has multiple drivers」或「variable is assigned in more than one block」。修法永遠是把區塊合併，或是改用不同的變數再加一顆明確的多工器。原因：同じ reg を二つの別々の always ブロックで代入している。Verilog はこれを許す——シミュレータは最後に実行された代入を採用するだけだ——が、ハードウェアでは二つのフリップフロップが一本のネットを駆動することはできない。症状：明確な合成エラーで、文言はたいてい「net ... has multiple drivers」か「variable is assigned in more than one block」。直し方は常に、ブロックを統合するか、変数を分けて明示的なマルチプレクサを置くかである。

(d) An accidental gated clock(d) 意外的閘控時脈(d) 偶発的なゲーテッドクロック

Cause: an expression in the edge qualifier, e.g. always @(posedge (clk & en)), or using a flip-flop output as another flip-flop's clock. Symptom: the netlist shows a logic gate driving a clock pin; clock-tree synthesis then has to treat that gate's output as a new clock, static timing analysis needs a create_generated_clock constraint that nobody wrote, and the DFT flow cannot shift the scan chain through the gated domain. Symptom in the timing report: unconstrained paths, or a clock named something like clk_gated_i_n3 that you did not define. The correct way to express “only update when enabled” is an if (en) inside the block — then the tool can choose between a feedback mux and a proper integrated clock-gating cell, and it will tell timing analysis what it did.成因：在邊緣修飾詞裡放了運算式，例如 always @(posedge (clk & en))，或是拿某顆正反器的輸出去當另一顆正反器的時脈。症狀：netlist 裡出現一顆邏輯閘驅動著時脈腳；接著時脈樹合成必須把那顆閘的輸出當成一個新時脈，靜態時序分析需要一條沒人寫的 create_generated_clock 約束，而 DFT 流程無法把掃描鏈推過那個被閘控的區域。在時序報告裡的症狀是：未受約束的路徑，或是出現一個你沒定義過、名字長得像 clk_gated_i_n3 的時脈。要表達「只有致能時才更新」，正確的寫法是在區塊裡放一個 if (en)——這樣工具就能在回授多工器與正規的整合式時脈閘控單元之間選擇，而且它會把自己做了什麼告訴時序分析。原因：エッジ修飾子の中に式を書いている（たとえば always @(posedge (clk & en))）、あるいはフリップフロップの出力を別のフリップフロップのクロックに使っている。症状：ネットリストで論理ゲートがクロックピンを駆動している。するとクロックツリー合成はそのゲート出力を新しいクロックとして扱わねばならず、スタティックタイミング解析は誰も書いていない create_generated_clock 制約を必要とし、DFT フローはゲートされた領域にスキャンチェーンを通せなくなる。タイミングレポート上の症状は、制約のない経路、あるいは定義した覚えのない clk_gated_i_n3 のような名前のクロックである。「イネーブル時のみ更新」を正しく表現する方法は、ブロック内に if (en) を置くことだ。そうすればツールはフィードバック・マルチプレクサか、きちんとした集積クロックゲーティングセルかを選べるし、何をしたかをタイミング解析に伝えてくれる。

// (a)
always @ (posedge clk) begin t = a & b; y <= t | c; end
// (b)
always @ (posedge clk) begin y <= t | c; t = a & b; end
// (c)
always @ (posedge clk) begin q1 <= d; q2 <= q1; q3 <= q2; end
// (d)
always @ (posedge clk) begin q1 = d; q2 = q1; q3 = q2; end
// (e)
always @ (posedge clk) if (en) q1 <= d;
// (f)
always @ (posedge clk) begin q1 <= d; end
always @ (posedge clk) begin q1 <= ~d; end

2. Reset: Synchronous, Asynchronous, and the Release Problem2. 重置：同步、非同步，以及解除時的問題2. リセット：同期・非同期と解除時の問題

Reset is the part of sequential design that looks trivial on a slide and consumes weeks of schedule on a real chip. The RTL difference between the two styles is one line. The consequences reach into area, into every setup path in the design, into clock-tree synthesis, into static timing analysis, into design-for-test, and into a class of silicon failures that only shows up at temperature corners. This section goes through all of it.重置是循序設計中在投影片上看起來無足輕重、在真實晶片上卻吃掉好幾週時程的那一塊。兩種風格在 RTL 上的差別只有一行。後果卻延伸到面積、設計中每一條 setup 路徑、時脈樹合成、靜態時序分析、可測試性設計，以及一整類只在溫度 corner 才現形的矽上失效。本節會把這些全部走一遍。リセットは、スライド上では取るに足らなく見えて実際のチップでは何週間もの日程を食い潰す、順序設計のその部分である。二つの方式の RTL 上の差は 1 行。その帰結は面積、設計中のあらゆるセットアップ経路、クロックツリー合成、スタティックタイミング解析、テスト容易化設計、そして温度コーナーでしか現れない一群のシリコン故障にまで及ぶ。本節ではそのすべてを辿る。

2.1 Event control sensitive to more than one edge2.1 對多於一個邊緣敏感的事件控制2.1 複数のエッジに感応するイベント制御

The slide states three rules for a behaviour whose event control contains more than one edge:投影片為事件控制含有多於一個邊緣的行為訂了三條規則：スライドは、イベント制御に複数のエッジを含むビヘイビアについて三つの規則を挙げている。

• an if statement must be the first statement in the behaviour;if 敘述必須是該行為的第一個敘述；if 文がビヘイビアの最初の文でなければならない。
• the synchronising signal (the clock) is not tested explicitly in the body of the if;同步信號（時脈）在 if 的本體中不會被明確測試；同期用信号（クロック）は if の本体で明示的に判定されない。
• by default, the last branch describes the synchronous activity.依照慣例，最後一個分支描述的是同步的活動。既定では、最後の分岐が同期動作を記述する。

These are not stylistic preferences, they are the exact shape of the template. Understanding why they exist makes them easy to remember.這些不是風格偏好，而是樣板的精確形狀。理解它們為什麼存在，就很容易記住。これらは文体の好みではなく、テンプレートの正確な形そのものである。なぜ存在するのかを理解すれば覚えるのは簡単だ。

A standard-cell library contains flip-flops with asynchronous clear and/or preset pins. Those pins are not clocked: pulling CLR low forces Q to 0 immediately, regardless of the clock, through a direct path into the feedback loop of the slave latch. There is no logic in front of them except, at most, an inverter for polarity. So when the synthesiser sees always @(posedge clk or posedge rst), it must decide which of the two edge signals is the clock and which is the asynchronous control, and then it must map the asynchronous one onto a pin that has absolute priority and no data.標準單元函式庫裡有附非同步清除與／或預設腳的正反器。那些腳不受時脈控制：把 CLR 拉低會透過一條直接進入從閂鎖回授迴路的路徑，不管時脈如何立刻把 Q 強制為 0。它們前面沒有任何邏輯，頂多一顆調整極性的反相器。所以當合成器看到 always @(posedge clk or posedge rst) 時，它必須決定兩個邊緣信號中哪一個是時脈、哪一個是非同步控制，然後把非同步的那個對映到一支具有絕對優先權且沒有資料的接腳上。標準セルライブラリには、非同期クリアやプリセットのピンを備えたフリップフロップがある。これらのピンはクロックに従わない。CLR を低に引けば、スレーブラッチのフィードバックループへ直接入る経路を通って、クロックに関係なく Q は即座に 0 に強制される。その前段には、せいぜい極性合わせのインバータ以外の論理はない。したがって合成器は always @(posedge clk or posedge rst) を見たとき、二つのエッジ信号のどちらがクロックでどちらが非同期制御かを決め、非同期のほうを絶対優先かつデータを持たないピンへ写像しなければならない。

The template makes that decision mechanical. The first statement must be an if whose condition tests one of the edge signals. That signal is the asynchronous control; the branch body is what the control forces. Everything that remains after the priority chain has tested all the asynchronous controls — the final else — is by elimination the clocked behaviour. The clock is never tested because there is nothing to test: by the time control reaches the last branch, the only reason the behaviour could have woken is the clock edge.樣板讓這個決定變得機械化。第一個敘述必須是一個 if，其條件測試其中一個邊緣信號。那個信號就是非同步控制；分支本體就是該控制所強制的結果。等優先鏈把所有非同步控制都測試完之後剩下來的——也就是最後的 else——以排除法推斷就是時脈行為。時脈從來不被測試，因為根本沒什麼好測：當控制流走到最後一個分支時，這個行為會被喚醒的唯一理由就是時脈邊緣。テンプレートはこの判断を機械的にする。最初の文は、いずれかのエッジ信号を判定する条件をもつ if でなければならない。その信号が非同期制御であり、分岐の本体がその制御の強制する結果である。優先連鎖がすべての非同期制御を判定し終えて残るもの——最後の else——が、消去法によりクロック同期動作ということになる。クロックが判定されないのは、判定すべきものが何もないからだ。制御が最後の分岐に達した時点で、このビヘイビアが起動されえた理由はクロックエッジ以外にない。

Three corollaries follow immediately, and all three are examinable:從這裡立刻推出三個推論，三個都會考：ここから直ちに三つの系が導かれ、どれも試験に出る。

Second: you cannot put anything before the if. A statement placed ahead of it would have to execute on both the clock edge and the reset edge, which no library cell can do. Third: you cannot have more asynchronous controls than the library has pins. Two edges (clock plus one reset) is always safe; three edges (clock, set and clear) is safe only if the library has a set-reset flip-flop and your priority order matches the cell's. Four edges is nothing at all — the tool will simply refuse.第二：if 之前不能放任何東西。放在它前面的敘述勢必要在時脈邊緣和重置邊緣兩種情況下都執行，而沒有任何函式庫單元做得到。第三：非同步控制的數量不能超過函式庫提供的接腳數。兩個邊緣（時脈加一個重置）永遠安全；三個邊緣（時脈、set 和 clear）只有在函式庫有 set-reset 正反器、而且你的優先次序與該單元一致時才安全。四個邊緣則完全不可能——工具會直接拒絕。第二に、if の前には何も置けない。その手前に置かれた文は、クロックエッジでもリセットエッジでも実行されねばならず、そんなライブラリセルは存在しない。第三に、非同期制御の数はライブラリのピン数を超えられない。二つのエッジ（クロックとリセット一本）は常に安全。三つのエッジ（クロック、セット、クリア）は、ライブラリにセットリセット付きフリップフロップがあり、かつ優先順位がそのセルと一致する場合にのみ安全である。四つのエッジは論外で、ツールはそのまま拒否する。

2.2 The two netlists, side by side2.2 兩種 netlist 並排比較2.2 二つのネットリストを並べて比べる

The slide shows the two four-bit registers that differ only in the event control. Reproduce them carefully, because the body is identical — the entire difference in hardware comes from the sensitivity list.投影片展示了兩個只在事件控制上不同的四位元暫存器。請仔細讀，因為本體完全相同——硬體上的全部差異都來自感應列。スライドには、イベント制御だけが異なる二つの 4 ビットレジスタが示されている。注意深く読んでほしい。本体は同一であり、ハードウェア上の差はすべて感度リストから生じている。

module reg_4_a (Data_in, clock, reset, Data_out);
  input  [3:0] Data_in;
  input        clock, reset;
  output [3:0] Data_out;
  reg    [3:0] Data_out;

  always @ (posedge clock or posedge reset)
    begin
      if (reset == 1'b1) Data_out <= 4'b0;
      else               Data_out <= Data_in;
    end
endmodule

module reg_4_b (Data_in, clock, reset, Data_out);
  input  [3:0] Data_in;
  input        clock, reset;
  output [3:0] Data_out;
  reg    [3:0] Data_out;

  always @ (posedge clock)
    begin
      if (reset == 1'b1) Data_out <= 4'b0;
      else               Data_out <= Data_in;
    end
endmodule

In reg_4_a, reset never appears in the data path. It is wired directly to the CLR pin of four flip-flops. The D pin of each flip-flop is connected straight to the corresponding bit of Data_in; there is no logic between them at all. In reg_4_b, reset is just another data input: the synthesiser builds D = Data_in & ~reset (one AND-with-inverted-input, or a 2:1 multiplexer, per bit) and uses plain flip-flops with no CLR pin.在 reg_4_a 裡，reset 從來不出現在資料路徑上。它直接接到四顆正反器的 CLR 腳。每顆正反器的 D 腳直接接到 Data_in 的對應位元；兩者之間完全沒有邏輯。在 reg_4_b 裡，reset 只是另一個資料輸入：合成器建出 D = Data_in & ~reset（每位元一顆「一端反相的 AND」，或一顆 2:1 多工器），並使用沒有 CLR 腳的普通正反器。reg_4_a では reset はデータパスに一度も現れない。四つのフリップフロップの CLR ピンへ直結される。各フリップフロップの D ピンは Data_in の対応ビットへそのまま接続され、あいだに論理は一切ない。reg_4_b では reset は単なるもう一つのデータ入力である。合成器は D = Data_in & ~reset（ビットあたり反転入力付き AND 一つ、または 2:1 マルチプレクサ一つ）を構築し、CLR ピンのない素のフリップフロップを使う。

2.3 Area, timing and the reset tree2.3 面積、時序與重置樹2.3 面積、タイミング、リセットツリー

Now the trade-offs, one axis at a time.現在一軸一軸地看取捨。ここからトレードオフを一軸ずつ見ていく。

Cell area單元面積セル面積

A flip-flop with asynchronous clear is physically bigger than one without — typically 10–25 % more area in a modern standard-cell library, because the clear transistor stack has to be strong enough to overpower the feedback inverter in the slave latch. A synchronous-reset design uses the smaller plain cell but pays for a gate per bit in front of it. Which wins depends on the library and the fanin: for a wide register with nothing else in its D cone, the extra AND gates can cost more than the bigger flip-flops; for a register whose D input is already the output of a deep logic cone, the synthesiser can often absorb the reset term into the existing last-level gate for free. The honest answer is “measure it”, but as a rule of thumb the two styles land within a few per cent of each other on area.附非同步清除的正反器在實體上比沒有的大——在現代標準單元函式庫裡通常多出 10–25 % 的面積，因為清除用的電晶體堆疊必須強到足以壓過從閂鎖裡的回授反相器。同步重置的設計用的是比較小的普通單元，但每一位元前面要付出一顆閘。哪一邊划算取決於函式庫和扇入：對於 D 錐裡什麼都沒有的寬暫存器，多出來的 AND 閘可能比較大的正反器還貴；對於 D 輸入本來就是一個深邏輯錐輸出的暫存器，合成器往往可以免費把重置項吸收進既有的最後一層閘裡。誠實的回答是「量一量」，但經驗法則是：兩種風格在面積上的差距通常落在百分之幾以內。非同期クリア付きフリップフロップは、ない場合より物理的に大きい——現代の標準セルライブラリでは面積にして通常 10–25 % 増である。クリア用のトランジスタ列が、スレーブラッチのフィードバック・インバータを押し切れるだけの強さを要するからだ。同期リセット方式は小さな素のセルを使うが、ビットあたり 1 ゲートを前段に支払う。どちらが勝つかはライブラリとファンインによる。D コーンに他に何もない広いレジスタでは、追加の AND ゲートのほうが大きなフリップフロップより高くつくことがある。D 入力がすでに深い論理コーンの出力であるレジスタなら、合成器はリセット項を既存の最終段ゲートに無償で吸収できることが多い。正直な答えは「測れ」だが、経験則としては両方式の面積差は数パーセント以内に収まる。

Data-path timing資料路徑時序データパスのタイミング

This is where the difference is real. The setup constraint for a flip-flop pair is差異真正發生作用的是這裡。一對正反器的 setup 約束是本当に差が出るのはここである。フリップフロップ対のセットアップ制約は次式で与えられる。

With synchronous reset, the reset gate is part of $t_{\text{logic}}$ on every single path into every single register. If the reset gate costs 60 ps and you are closing timing at a 1 ns period, you have just given away 6 % of the cycle, chip-wide, to a signal that is inactive for all but the first microsecond of the chip's life. With asynchronous reset, $t_{\text{logic}}$ is untouched: reset enters through a pin that is not in the D-to-Q path at all. For a design that is timing-critical everywhere, this alone decides the question.用同步重置時，重置閘是每一條進入每一顆暫存器的路徑上 $t_{\text{logic}}$ 的一部分。如果重置閘要花 60 ps，而你正在 1 ns 的週期下收時序，你就等於把整顆晶片 6 % 的週期，送給了一個除了晶片生命最初一微秒以外都不作用的訊號。用非同步重置時，$t_{\text{logic}}$ 完全沒被動到：重置是從一支根本不在 D 到 Q 路徑上的接腳進去的。對一個處處都時序吃緊的設計來說，光這一點就能決定答案。同期リセットでは、リセットゲートはすべてのレジスタへ入るすべての経路上で $t_{\text{logic}}$ の一部になる。リセットゲートが 60 ps かかり、1 ns の周期でタイミングを収束させようとしているなら、チップの寿命の最初の 1 マイクロ秒を除いてずっと非活性な信号に、サイクルの 6 % をチップ全体で明け渡したことになる。非同期リセットなら $t_{\text{logic}}$ は手つかずだ。リセットは D-Q 経路にまったく含まれないピンから入る。どこもかしこもタイミングが厳しい設計では、この一点だけで答えが決まる。

Reset-tree routing重置樹的繞線リセットツリーの配線

The asynchronous style buys its timing advantage by creating a second enormous net. Every flip-flop in the design has its CLR pin connected to reset, so the reset net has the same fanout as the clock. It must be buffered into a tree, that tree consumes routing resources and cells, and — the part people forget — the tree has skew. Two flip-flops at opposite corners of a block may see the reset edge hundreds of picoseconds apart. For the assertion edge that is harmless: everybody gets cleared, just not at exactly the same instant, and nothing is sampling. For the deassertion edge it is a correctness problem, which is the whole of Sections 2.4 and 2.5.非同步風格是靠製造出第二棵巨大的網路，才買到它的時序優勢。設計中每一顆正反器的 CLR 腳都接到 reset，所以重置網路的扇出和時脈一樣大。它必須被緩衝成一棵樹，那棵樹吃掉繞線資源和單元，而且——大家最容易忘記的部分——那棵樹有歪斜。位於區塊兩個對角的兩顆正反器，看到重置邊緣的時間可能差到數百皮秒。對確立邊緣而言這沒有害處：大家都被清除，只是不在同一瞬間，而且當下沒有人在取樣。對解除邊緣而言這就是正確性問題，而這正是 2.4 與 2.5 兩節的全部內容。非同期方式は、巨大な第二のネットを作ることでタイミング上の優位を買っている。設計中のすべてのフリップフロップの CLR ピンが reset に接続されるので、リセットネットのファンアウトはクロックと同じになる。これはツリーにバッファリングされねばならず、そのツリーは配線資源とセルを消費し、そして——みなが忘れる点だが——ツリーにはスキューがある。ブロックの対角にある二つのフリップフロップは、リセットのエッジを数百ピコ秒ずれて見ることがある。アサート側のエッジではこれは無害だ。全員がクリアされ、ただ同じ瞬間ではないというだけで、誰もサンプルしていない。デアサート側のエッジでは正しさの問題になる。それが 2.4 節と 2.5 節のすべてである。

With synchronous reset the net is still high fanout, but it is an ordinary timed signal: the tool buffers it like any other, static timing analysis constrains it like any other, and skew on it is absorbed by the normal setup/hold machinery.用同步重置時，那條網路一樣是高扇出，但它是一條普通的受時序約束的訊號：工具像對待其他訊號一樣把它緩衝，靜態時序分析像對待其他訊號一樣約束它，而它上面的歪斜會被一般的 setup/hold 機制吸收掉。同期リセットでも、そのネットは依然として高ファンアウトだが、普通にタイミングを取られる信号である。ツールは他の信号と同様にバッファリングし、スタティックタイミング解析も他と同様に制約し、そのスキューは通常の setup/hold の仕組みが吸収する。

Behaviour without a clock沒有時脈時的行為クロックがないときの振る舞い

An asynchronous reset works when the clock is not running. That matters more than it sounds. At power-up the PLL has not locked; during a low-power shutdown the clock is gated off; during a hardware recovery from a hung state the clock source may be the thing that failed. In all of those situations a synchronous reset does nothing at all, because there is no edge to carry it. This is the single strongest argument for an asynchronous assertion, and it is why nearly every real ASIC uses asynchronous assert plus synchronous release (Section 2.6).非同步重置在時脈沒在跑的時候照樣有效。這件事比聽起來重要得多。上電時 PLL 還沒鎖定；低功耗關斷期間時脈被閘掉；從當掉狀態做硬體復原時，時脈源本身可能就是壞掉的那個。在上述所有情況下，同步重置什麼也做不到，因為沒有邊緣可以載送它。這是非同步確立最強的一項論據，也是為什麼幾乎每一顆真實的 ASIC 都採用非同步確立加同步釋放（2.6 節）。非同期リセットはクロックが動いていなくても効く。これは聞こえ以上に重要だ。電源投入時には PLL がまだロックしていない。低消費電力のシャットダウン中はクロックがゲートで止められている。ハングからのハードウェア復帰では、クロック源そのものが壊れた当人かもしれない。これらいずれの場面でも、同期リセットはまったく何もできない。運んでくれるエッジが存在しないからだ。これが非同期アサートを支持する最強の論拠であり、ほぼすべての実用 ASIC が非同期アサート＋同期リリース（2.6 節）を採る理由である。

Design for test可測試性設計テスト容易化設計

During scan shift, the asynchronous reset must be held inactive, otherwise shifting a pattern through the chain would be destroyed by a stray reset pulse. DFT insertion therefore adds a multiplexer or an AND gate into the reset tree, controlled by the test mode pin. This is standard and automated, but it means the reset tree is not a straight wire in the final netlist, and it adds a constraint: the reset must be controllable from a primary input. A synchronous reset needs no such treatment — it is just data, and scan handles data.在掃描移位期間，非同步重置必須被維持在非作用狀態，否則一道雜散的重置脈衝就會毀掉正在鏈中移位的圖樣。因此 DFT 插入會在重置樹裡加一顆多工器或一顆 AND 閘，由測試模式接腳控制。這是標準且自動化的流程，但它意味著最終 netlist 裡的重置樹不是一條直通的線，而且多了一項約束：重置必須能從主要輸入控制。同步重置不需要這種處理——它只是資料，而掃描本來就在處理資料。スキャンシフト中、非同期リセットは非活性に保たれねばならない。さもないとチェーンを通しているパターンが迷子のリセットパルスで破壊される。そのため DFT 挿入はリセットツリーにテストモードピンで制御されるマルチプレクサか AND ゲートを追加する。これは標準的で自動化された処理だが、最終ネットリストのリセットツリーが素通しの配線ではないことを意味し、「リセットは一次入力から制御可能でなければならない」という制約も加わる。同期リセットにはそうした処置は要らない——ただのデータであり、スキャンはデータを扱うものだからだ。

Simulation and X-propagation模擬與 X 傳播シミュレーションと X 伝播

A gate-level simulation that starts with all flip-flops at x will clean up as soon as an asynchronous reset is applied, before any clock edge. With synchronous reset you need at least one clock edge, and if any part of the design has its clock gated off at that moment, those flip-flops stay x and the x spreads. Teams that use synchronous reset often spend real effort on an “X-propagation” cleanup plan for exactly this reason.一場所有正反器都從 x 開始的閘級模擬，只要一加上非同步重置就會乾淨下來，根本不用等任何時脈邊緣。用同步重置的話你至少需要一個時脈邊緣，而如果設計中某部分在那一刻的時脈正被閘掉，那些正反器就會維持 x，而 x 會擴散出去。採用同步重置的團隊常常為了這個理由在「X 傳播」清理計畫上花掉實實在在的力氣。全フリップフロップが x から始まるゲートレベル・シミュレーションは、非同期リセットを与えた瞬間に、クロックエッジを待たずに片付く。同期リセットでは最低一つのクロックエッジが要り、そのとき設計の一部でクロックがゲートされていれば、そこのフリップフロップは x のまま残り、x は広がっていく。同期リセットを使うチームがまさにこの理由で「X 伝播」対策に実質的な労力を割くのはよくあることだ。

2.4 Recovery and removal: setup and hold for the reset pin2.4 Recovery 與 removal：重置腳的 setup 與 hold2.4 リカバリとリムーバル：リセットピンの setup と hold

An asynchronous reset is asynchronous when it asserts. When it deasserts, the flip-flop is about to resume normal clocked operation, and the internal race between the clearing path and the clocking path reopens. Two timing checks guard that moment, and they are the exact mirror images of setup and hold:非同步重置在確立的時候是非同步的。當它解除時，正反器即將恢復正常的時脈運作，而清除路徑與時脈路徑之間的內部競爭又重新打開。有兩項時序檢查守著這一刻，而它們正好是 setup 與 hold 的鏡像：非同期リセットが非同期なのはアサートするときである。デアサートするとき、フリップフロップは通常のクロック動作に戻ろうとしており、クリア経路とクロック経路のあいだの内部レースが再び開く。その瞬間を守るタイミングチェックが二つあり、それぞれ setup と hold のちょうど鏡像になっている。

Read them as a pair. Recovery says: if you want the clock edge to take effect normally, the reset must have been released at least $t_{rec}$ before the edge, so that the internal clear node has had time to settle. It is a setup check on the asynchronous pin. Removal says: if you want the reset to take effect and not be disturbed, the reset must stay asserted for at least $t_{rem}$ after the edge. It is a hold check on the asynchronous pin.請把兩者當成一對來讀。Recovery 說：如果你要讓時脈邊緣正常生效，重置必須在邊緣之前至少 $t_{rec}$ 就已經被釋放，好讓內部的清除節點有時間安定。它是非同步接腳上的 setup 檢查。Removal 說：如果你要讓重置生效而且不被干擾，重置必須在邊緣之後至少再維持 $t_{rem}$ 的確立。它是非同步接腳上的 hold 檢查。この二つは対にして読むこと。リカバリはこう言う。クロックエッジを正常に効かせたいなら、内部のクリアノードが落ち着く時間を確保するため、リセットはエッジの少なくとも $t_{rec}$ 前に解除されていなければならない。これは非同期ピンに対するセットアップ検査である。リムーバルはこう言う。リセットを確実に効かせ乱されたくないなら、リセットはエッジの後少なくとも $t_{rem}$ はアサートされたままでなければならない。これは非同期ピンに対するホールド検査である。

Between the two lies a forbidden window of width $t_{rec} + t_{rem}$ around every active clock edge. A reset deassertion that lands inside that window leaves the flip-flop in an indeterminate condition: it may come out of reset on this edge, it may come out on the next one, or it may go metastable and resolve to either value some unpredictable time later.兩者之間，在每一個作用時脈邊緣周圍形成一個寬度為 $t_{rec} + t_{rem}$ 的禁區。落在這個窗口內的重置解除，會讓正反器處於不確定狀態：它可能在這個邊緣脫離重置，可能在下一個邊緣才脫離，也可能進入亞穩態，並在某個不可預測的時間後安定到任一值。両者のあいだには、すべての有効クロックエッジの周りに幅 $t_{rec} + t_{rem}$ の禁止窓がある。その窓の内側に入るリセット解除は、フリップフロップを不定状態に残す。このエッジでリセットから抜けるかもしれないし、次のエッジかもしれないし、メタステーブルになって予測不能な時間ののちにどちらかの値へ落ち着くかもしれない。

In a static timing report, these appear as recovery and removal arcs on the CLR or PRE pin, with the usual slack columns. They are reported only if the reset is a timed signal, which is to say only if it is released synchronously. If you drive the reset straight from a chip pin, the tool has nothing to time it against, and you will typically see the path reported as false_path or simply not reported — which is comfortable and wrong.在靜態時序報告裡，它們會以 CLR 或 PRE 腳上的 recovery 與 removal 弧出現，附上一般的 slack 欄位。只有當重置是一條受時序約束的訊號時才會被報出來，也就是說，只有當它是同步釋放的時候。如果你讓重置直接由晶片接腳驅動，工具沒有東西可以拿來計時，你通常會看到那條路徑被報成 false_path，或根本不被報出來——那很舒服，而且是錯的。スタティックタイミングレポートでは、これらは CLR または PRE ピン上の recovery / removal アークとして、通常のスラック欄とともに現れる。報告されるのはリセットがタイミングの取れた信号であるとき、すなわち同期的に解除されるときだけである。リセットをチップピンから直接駆動すると、ツールには基準にすべきものがなく、その経路はたいてい false_path と報告されるか、そもそも報告されない——心地よいが、間違っている。

2.5 Reset-release metastability2.5 重置解除的亞穩態2.5 リセット解除時のメタステーブル

Now put the recovery window together with the reset-tree skew of Section 2.3, and the real hazard appears.現在把 recovery 窗口和 2.3 節的重置樹歪斜放在一起，真正的危險就出現了。ここでリカバリ窓と 2.3 節のリセットツリー・スキューを重ね合わせると、本当の危険が姿を現す。

Suppose an external pin releases reset at some arbitrary moment, uncorrelated with the clock. Three things can go wrong at once.假設某支外部接腳在某個與時脈無關的任意時刻釋放重置。三件事會同時出錯。外部ピンがクロックと無相関の任意の時点でリセットを解除するとしよう。三つのことが同時に起こりうる。

First, individual metastability. Any flip-flop whose reset release lands inside its recovery/removal window can go metastable. The output hovers near the switching threshold for a time that is unbounded in principle and exponentially distributed in practice. The mean time between failures for a single such event follows the usual form第一，個別的亞穩態。任何一顆正反器，只要它看到的重置釋放落在自己的 recovery／removal 窗口裡，就可能進入亞穩態。輸出會在切換門檻附近徘徊一段原則上無上限、實務上呈指數分布的時間。單一這類事件的平均失效間隔時間遵循常見的形式第一に、個々のメタステーブル。リセット解除が自分のリカバリ／リムーバル窓に入ったフリップフロップは、どれもメタステーブルになりうる。出力はスイッチング閾値付近を、原理的には上限のない、実際には指数分布に従う時間だけ漂う。この種の事象一つあたりの平均故障間隔は、おなじみの形をとる。

where $t_r$ is the resolution time you allow before the value is used, $\tau$ is the flip-flop's regeneration time constant and $T_0$ its metastability window parameter. The practical point is the exponential: every extra $\tau$ of settling time multiplies the MTBF by $e$. One extra clock period of slack is usually worth many orders of magnitude.其中 $t_r$ 是你在使用該值之前允許的解析時間，$\tau$ 是正反器的再生時間常數，$T_0$ 是它的亞穩態窗口參數。實務上的重點在那個指數：每多給一個 $\tau$ 的安定時間，MTBF 就乘上 $e$。多留一個時脈週期的餘裕，通常就值好幾個數量級。ここで $t_r$ は値を使う前に許す分解時間、$\tau$ はフリップフロップの再生時定数、$T_0$ はそのメタステーブル窓パラメータである。実務上の要点は指数にある。整定時間を $\tau$ 一つ分増やすごとに MTBF は $e$ 倍になる。クロック 1 周期分の余裕を足すだけで、たいてい何桁も効く。

Second, skewed release. Even if no flip-flop goes metastable, the reset tree's skew means different flip-flops see the release at different times relative to the same clock edge. Flip-flop A, early in the tree, sees release 200 ps before the edge and comes out of reset on that edge. Flip-flop B, late in the tree, sees release 100 ps after the edge and stays reset for one more cycle. The two are now one cycle out of step.第二，歪斜的釋放。就算沒有任何一顆正反器進入亞穩態，重置樹的歪斜仍意味著不同的正反器相對於同一個時脈邊緣，在不同時刻看到釋放。樹中位置較前的正反器 A 在邊緣前 200 ps 看到釋放，於是在那個邊緣脫離重置。位置較後的正反器 B 在邊緣後 100 ps 才看到釋放，於是又多被重置了一個週期。兩者現在差了一個週期。第二に、ずれた解除。どのフリップフロップもメタステーブルにならなかったとしても、リセットツリーのスキューにより、同じクロックエッジに対して解除を見る時刻がフリップフロップごとに異なる。ツリーの手前にあるフリップフロップ A はエッジの 200 ps 前に解除を見て、そのエッジでリセットを抜ける。奥にあるフリップフロップ B はエッジの 100 ps 後に解除を見るので、もう 1 サイクル長くリセットされたままになる。両者は 1 サイクルずれてしまう。

Third, illegal states. For a datapath register, a one-cycle disagreement usually just corrupts one sample. For a state machine it can be fatal. If a 5-state FSM uses a 3-bit binary encoding and two of its three state bits leave reset a cycle before the third, the machine can start in a code that is not any of its five states. If the case has a sensible default it will recover on the next edge; if it does not, it has latched into a region of the state graph that the designer never drew, and only another reset will get it out. With one-hot encoding this is worse, because there are far more illegal codes.第三，非法狀態。對資料路徑暫存器而言，差一個週期通常只是弄壞一個取樣。對狀態機而言卻可能致命。如果一台 5 狀態的 FSM 用 3 位元二進位編碼，而三個狀態位元中有兩個比第三個早一個週期離開重置，這台機器就可能從一個不屬於它那五個狀態的碼開始跑。如果 case 有合理的 default，它會在下一個邊緣復原；如果沒有，它就鎖進了設計者從未畫過的那塊狀態圖區域，只有再一次重置才能把它弄出來。用 one-hot 編碼時更糟，因為非法碼的數量多得多。第三に、不正状態。データパスのレジスタなら、1 サイクルの食い違いはたいていサンプル一つを壊すだけだ。状態機械では致命的になりうる。5 状態の FSM が 3 ビット二進符号を使い、3 本の状態ビットのうち 2 本が残りの 1 本より 1 サイクル早くリセットを抜けると、機械は五つの状態のどれでもない符号から動き出すことがある。case にまともな default があれば次のエッジで復帰するが、なければ設計者が描いたことのない状態グラフの領域にラッチされ、もう一度リセットするまで抜け出せない。one-hot 符号化では不正符号がはるかに多いぶん、さらに悪い。

2.6 The asynchronous-assert, synchronous-deassert idiom2.6 非同步確立、同步解除的慣用寫法2.6 非同期アサート・同期デアサートの定石

The fix is well established and costs two flip-flops per clock domain. Assert the reset asynchronously, so that it works with no clock; release it synchronously, so that every flip-flop in the domain leaves reset on the same clock edge with a clean recovery margin.修法早已確立，代價是每個時脈域兩顆正反器。以非同步方式確立重置，讓它在沒有時脈時也有效；以同步方式釋放它，讓該域中每一顆正反器都在同一個時脈邊緣、帶著乾淨的 recovery 餘裕離開重置。対処法は確立されており、コストはクロックドメインあたりフリップフロップ 2 個である。リセットは非同期にアサートしてクロックなしでも効くようにし、解除は同期的に行って、そのドメインのすべてのフリップフロップが同一のクロックエッジで、きれいなリカバリ余裕をもってリセットを抜けるようにする。

module reset_sync (
  input  clk,          // the destination domain's clock
  input  arst_n,       // raw asynchronous reset, active low
  output rst_n         // clean reset for this domain
);
  reg sync0, sync1;

  always @ (posedge clk or negedge arst_n)
    if (!arst_n) begin
      sync0 <= 1'b0;
      sync1 <= 1'b0;
    end
    else begin
      sync0 <= 1'b1;          // a constant 1 walks down the chain
      sync1 <= sync0;
    end

  assign rst_n = sync1;
endmodule

Trace what happens. When arst_n falls, both flip-flops clear immediately, with no clock required, so rst_n falls immediately too: assertion is asynchronous. When arst_n rises, the two flip-flops are released from their CLR pins at some arbitrary moment, but their D inputs are a hard-wired 1'b1 and sync0 respectively. The constant 1 now has to be clocked through: sync0 takes it on the first clock edge after release, sync1 on the second. The output rst_n therefore rises on a clock edge, with a full clock period of margin, and every flip-flop fed by it sees the release as a timed, synchronous event: deassertion is synchronous.把過程追一遍。當 arst_n 下降時，兩顆正反器立刻被清除，不需要時脈，所以 rst_n 也立刻下降：確立是非同步的。當 arst_n 上升時，兩顆正反器在某個任意時刻從 CLR 腳被釋放，但它們的 D 輸入分別是硬接的 1'b1 與 sync0。那個常數 1 現在必須被時脈一級一級推過去：sync0 在釋放後的第一個時脈邊緣拿到它，sync1 在第二個邊緣拿到。因此輸出 rst_n 是在某個時脈邊緣上升的，帶著完整一個時脈週期的餘裕，而每一顆由它餵入的正反器看到的都是一個受時序約束的同步事件：解除是同步的。動作を追ってみよう。arst_n が下がると、二つのフリップフロップはクロックなしで直ちにクリアされ、rst_n も直ちに下がる。アサートは非同期である。arst_n が上がると、二つのフリップフロップは任意の時点で CLR ピンから解放されるが、その D 入力はそれぞれハードワイヤの 1'b1 と sync0 である。定数 1 はこれからクロックで送り込まれねばならない。sync0 は解除後の最初のクロックエッジでそれを取り込み、sync1 は二番目のエッジで取り込む。したがって出力 rst_n はクロックエッジ上で、丸 1 周期の余裕をもって立ち上がり、それを受けるすべてのフリップフロップにとって解除はタイミングの取れた同期事象となる。デアサートは同期である。

Two details are easy to get wrong.有兩個細節很容易弄錯。間違えやすい点が二つある。

Why two flip-flops and not one? The first flip-flop's CLR pin is released asynchronously, so it can violate its own recovery time and go metastable. That is unavoidable — something has to be the first thing to see the asynchronous edge. The job of the second flip-flop is to give the first a full clock period to resolve. Plugging $t_r \approx T_{\text{clk}}$ into the MTBF formula is what turns “fails occasionally” into “fails once per geological age”. Fast clocks or aggressive corners sometimes justify three stages.為什麼是兩顆而不是一顆正反器？第一顆正反器的 CLR 腳是被非同步釋放的，所以它自己可能違反自己的 recovery 時間而進入亞穩態。這是躲不掉的——總得有某個東西第一個看到那個非同步邊緣。第二顆正反器的任務就是給第一顆完整一個時脈週期去解開。把 $t_r \approx T_{\text{clk}}$ 代進 MTBF 公式，就是把「偶爾會失效」變成「每一個地質年代失效一次」。快時脈或嚴苛的 corner 有時能正當化三級。なぜ 1 個でなく 2 個なのか。初段フリップフロップの CLR ピンは非同期に解放されるので、それ自身が自分のリカバリ時間を破ってメタステーブルになりうる。これは避けられない——何かが最初に非同期エッジを見る役を負わねばならない。二段目の役目は、初段に丸 1 周期の解消時間を与えることである。MTBF 式に $t_r \approx T_{\text{clk}}$ を代入すれば、「ときどき落ちる」が「地質年代に一度落ちる」に変わる。高速クロックや厳しいコーナーでは 3 段が正当化されることもある。

One synchroniser per clock domain. A chip with four clocks needs four of these, each clocked by its own domain's clock, all fed from the same raw arst_n. Sharing one synchroniser across domains re-creates exactly the problem it was built to solve.每個時脈域一個同步器。一顆有四個時脈的晶片需要四組，各自由自己那個域的時脈驅動，全部餵自同一條原始的 arst_n。跨域共用一組同步器，等於把它當初要解決的問題原封不動地再造一次。同期化回路はクロックドメインごとに一つ。クロックが四つあるチップには四組が必要で、それぞれ自ドメインのクロックで駆動し、すべて同じ生の arst_n から給電する。一組をドメイン間で共用すれば、それが解決するはずだった問題をそっくり再生産することになる。

Once this is in place, the rest of the design uses the clean rst_n in the ordinary asynchronous style, always @(posedge clk or negedge rst_n), and static timing analysis can finally check recovery and removal against a real clock, because the reset now originates at a flip-flop clocked by that clock.這套機制就位之後，設計的其餘部分就用乾淨的 rst_n、以一般的非同步風格 always @(posedge clk or negedge rst_n) 撰寫，而靜態時序分析終於可以對著一個真正的時脈檢查 recovery 與 removal，因為重置現在起源於一顆由該時脈驅動的正反器。この仕組みが入れば、設計の残りはきれいな rst_n を使い、通常の非同期スタイル always @(posedge clk or negedge rst_n) で書けばよい。そしてスタティックタイミング解析はようやく実在のクロックに対してリカバリとリムーバルを検査できる。リセットが、そのクロックで駆動されるフリップフロップから発するようになったからだ。

2.7 Waveform comparison2.7 波形比較2.7 波形の比較

The slide's two waveforms make the pulse-width point concretely. Both circuits have active-high reset, Data_in = 4'd8 held constant, and Data_out starting at 4'dx.投影片的兩張波形把脈寬這件事講得很具體。兩個電路都是高位準作用的重置，Data_in = 4'd8 維持不變，Data_out 從 4'dx 開始。スライドの二つの波形はパルス幅の論点を具体的に示している。どちらの回路も正論理リセットで、Data_in = 4'd8 は一定、Data_out は 4'dx から始まる。

The asymmetry is worth stating plainly, because it is the examinable point. For the asynchronous register the reset pulse can be arbitrarily narrow — down to the library cell's own minimum reset pulse width, which is typically a few tens of picoseconds. For the synchronous register the pulse must contain an active clock edge, with the usual setup and hold margins around it. Since you do not in general know the phase of an external reset relative to the clock, the only safe rule is “longer than one clock period”, and in practice people specify several periods.這個不對稱值得明講，因為它是會考的重點。對非同步暫存器而言，重置脈衝可以任意窄——窄到函式庫單元自身的最小重置脈寬為止，通常是幾十皮秒。對同步暫存器而言，脈衝必須包含一個作用時脈邊緣，而且前後要有通常的 setup 與 hold 餘裕。既然你一般並不知道外部重置相對於時脈的相位，唯一安全的規則就是「比一個時脈週期長」，而實務上大家會規定好幾個週期。この非対称性ははっきり述べておく価値がある。試験に出る要点だからだ。非同期レジスタではリセットパルスはいくらでも細くてよい——ライブラリセル自身の最小リセットパルス幅、通常は数十ピコ秒まで。同期レジスタではパルスは有効クロックエッジを含み、その前後に通常の setup と hold の余裕を要する。外部リセットのクロックに対する位相は一般に分からないので、安全な規則は「クロック 1 周期より長く」だけであり、実務では数周期と規定する。

Notice also what happens after release. In both cases Data_out returns to 4'd8 at the first clock edge for which the reset is inactive. The asynchronous register spends a sub-cycle interval at 4'd0; the synchronous one spends a full cycle there. That difference matters if anything downstream is counting cycles.也請注意釋放之後會發生什麼。兩種情況下，Data_out 都在重置已非作用的第一個時脈邊緣回到 4'd8。非同步暫存器在 4'd0 上待的是不到一個週期的區間；同步的那個則待滿一整個週期。如果下游有東西在數週期，這個差別就會有影響。解除後に何が起きるかにも注意してほしい。どちらの場合も Data_out は、リセットが非活性になった最初のクロックエッジで 4'd8 に戻る。非同期レジスタが 4'd0 に留まるのは 1 周期未満の区間、同期レジスタは丸 1 周期である。下流でサイクルを数えている回路があれば、この差は効いてくる。

3. Registered Combinational Logic3. 暫存化的組合邏輯3. レジスタ付き組合せ論理

The simplest useful sequential structure is a cloud of combinational logic with a register on its output. It is also the structure that every synchronous design is built out of: a chip is nothing but registers separated by logic clouds, and the clock period is the longest such cloud plus the register overhead. The two slide examples are deliberately minimal so that the mapping from source to gates is unambiguous.最簡單而有用的循序結構，就是一團組合邏輯外加一個輸出端的暫存器。它也是每一個同步設計所由建構的結構：一顆晶片無非就是被邏輯雲隔開的暫存器，而時脈週期就是最長的那團雲再加上暫存器的開銷。投影片的兩個例子刻意做得極簡，好讓從原始碼到閘的對映毫無歧義。もっとも単純で有用な順序構造は、組合せ論理の雲とその出力に置かれたレジスタである。これはあらゆる同期設計が組み立てられる構造でもある。チップとは論理の雲で隔てられたレジスタの集まりにすぎず、クロック周期は最長の雲にレジスタのオーバーヘッドを足したものだ。スライドの二例は、ソースからゲートへの写像が一意になるよう意図的に最小限にしてある。

3.1 Example 1 — a registered AND3.1 例一 — 暫存化的 AND3.1 例 1 — レジスタ付き AND

module reg_and (a, b, c, clk, y);
  input  a, b, c, clk;
  output y;
  reg    y;

  always @ (posedge clk)
    begin
      y <= a & b & c;
    end
endmodule

Apply the rule from Section 1.3. The block is edge-sensitive, y is assigned non-blockingly, so y is a flip-flop. Its D input is the expression a & b & c, which is combinational. The result is one three-input AND gate driving one D flip-flop. The three inputs a, b, c are not registered — nothing in the description says to remember them.套用 1.3 節的規則。這個區塊是邊緣敏感的，y 以非阻斷方式被指派，所以 y 是正反器。它的 D 輸入是運算式 a & b & c，那是組合邏輯。結果就是一顆三輸入 AND 閘驅動一顆 D 正反器。三個輸入 a、b、c 沒有被暫存——描述裡沒有任何地方叫它記住它們。1.3 節の規則を当てはめる。このブロックはエッジ感応で、y はノンブロッキングで代入されるので y はフリップフロップになる。その D 入力は式 a & b & c で、これは組合せ論理である。結果は 3 入力 AND ゲート 1 個が D フリップフロップ 1 個を駆動する回路だ。三つの入力 a、b、c はレジスタに入らない——記憶せよと述べた箇所がどこにもないからである。

Two observations that students often need spelled out. First, the declaration reg y; does not by itself create a register: reg in Verilog means “a variable that holds its value between assignments in procedural code”, which is a simulation concept. Whether it becomes hardware storage is decided entirely by the rules of Section 1. A reg assigned in an always @* block is a wire. Second, the port y is declared both output and reg; in IEEE 1364-1995 style that requires two separate declarations, as above. The ANSI-style header of Verilog-2001 lets you write output reg y in the port list, which is less error-prone and which Lecture 7 covers in more detail.有兩點學生常常需要人講明。第一，宣告 reg y; 本身並不會產生暫存器：Verilog 裡的 reg 意思是「在程序式程式碼中兩次指派之間保持其值的變數」，那是一個模擬層面的概念。它會不會變成硬體儲存元件，完全由第 1 節的規則決定。在 always @* 區塊裡被指派的 reg 就是一條連線。第二，埠 y 同時被宣告為 output 與 reg；在 IEEE 1364-1995 風格下這需要兩個分開的宣告，如上所示。Verilog-2001 的 ANSI 風格標頭允許你在埠列表裡直接寫 output reg y，比較不容易出錯，第 7 講會更詳細地談。学生に明示しておく必要のある点が二つある。第一に、reg y; という宣言そのものはレジスタを作らない。Verilog の reg は「手続き的コード中で代入と代入のあいだ値を保持する変数」という意味であり、これはシミュレーション上の概念である。それがハードウェアの記憶素子になるかどうかは、完全に第 1 節の規則が決める。always @* ブロック内で代入される reg は配線である。第二に、ポート y は output と reg の両方で宣言されている。IEEE 1364-1995 のスタイルでは上記のように二つの宣言が必要だ。Verilog-2001 の ANSI スタイルのヘッダならポートリストに output reg y と書けて誤りが減る。これは第 7 講で詳しく扱う。

3.2 Example 2 — a registered multiplexer3.2 例二 — 暫存化的多工器3.2 例 2 — レジスタ付きマルチプレクサ

module mux_reg (a, b, c, d, y, select, clock);
  input  [7:0] a, b, c, d;
  output [7:0] y;
  input  [1:0] select;
  reg    [7:0] y;

  always @ (posedge clock)
    case (select)
      0: y <= a;          // non-blocking
      1: y <= b;          // same result with =
      2: y <= c;
      3: y <= d;
      default: y <= 8'bx;
    endcase
endmodule

Eight flip-flops, one per bit of y, each fed by an 8-bit-wide 4:1 multiplexer that is decoded once from select and shared across all eight slices. The synthesis-result slide confirms exactly that: eight mux4 cells in a column, eight dffp cells behind them, and a small decoder built from an inverter and a few NAND/NOR gates feeding all the mux selects in parallel.八顆正反器，y 的每一位元一顆，各自由一個 8 位元寬的 4:1 多工器餵入，而該多工器的選擇訊號只從 select 解碼一次，由八個切片共用。合成結果的投影片正好證實了這點：一欄八顆 mux4 單元，後面一欄八顆 dffp 單元，再加上一個由反相器與幾顆 NAND／NOR 組成的小解碼器，平行地餵給所有多工器的選擇腳。フリップフロップは 8 個、y の 1 ビットにつき 1 個。各々は 8 ビット幅の 4:1 マルチプレクサに駆動され、その選択信号は select から一度だけデコードされて 8 スライスで共有される。合成結果のスライドはまさにそれを示している。mux4 セルが 8 個縦に並び、その後ろに dffp セルが 8 個、そしてインバータと数個の NAND／NOR からなる小さなデコーダが、すべてのマルチプレクサの選択端を並列に駆動している。

What 8'bx means to a synthesiser8'bx 對合成器的意義8'bx が合成器にとって意味するもの

In simulation, assigning 8'bx propagates unknowns, which is useful: it makes an illegal select visible as X on the output instead of silently producing stale data. In synthesis, x on the right-hand side means don't care. The tool is free to produce whatever output minimises the logic for that input combination. Here the default is actually unreachable — select is two bits wide, and 0, 1, 2, 3 cover all four codes — so it costs nothing either way, and the tool's case analysis will see the case as full and skip the hold-the-previous-value logic.在模擬中，指派 8'bx 會傳播未知值，這很有用：它讓非法的 select 以輸出上的 X 顯現出來，而不是無聲地給出過期的資料。在合成中，右手邊的 x 意思是 don't care。工具可以為那組輸入組合產生任何能讓邏輯最小化的輸出。這裡的 default 其實是不可能到達的——select 只有兩位元寬，而 0、1、2、3 已涵蓋全部四種碼——所以兩種寫法都不花成本，而工具的 case 分析會把這個 case 視為 full，略過「保持前值」的邏輯。シミュレーションでは 8'bx を代入すると不定値が伝播する。これは有用だ。不正な select が、黙って古いデータを出す代わりに出力の X として見えるようになる。合成では右辺の x は don't care を意味する。ツールはその入力組合せに対して論理を最小化する任意の出力を出してよい。ここでの default は実際には到達不能である——select は 2 ビット幅で、0、1、2、3 が四つの符号すべてを覆う——ので、どちらでもコストは変わらず、ツールのケース解析はこの case を full と見なして前値保持の論理を省く。

That reachability matters. If select were three bits and you wrote only four branches plus default: y <= 8'bx;, the four unlisted codes would be don't-cares and the synthesiser could map them onto any of a, b, c, d — whichever is cheapest. Your RTL simulation would show X, your gate simulation would show real data, and the two would mismatch. That is the classic cause of an “RTL and netlist disagree” bug report. If you want the hardware to be predictable for illegal inputs, assign a defined value in the default.那個「可達性」很要緊。如果 select 是三位元，而你只寫了四個分支再加 default: y <= 8'bx;，那四個沒列出來的碼就是 don't-care，合成器可以把它們對映到 a、b、c、d 中任何一個——哪個便宜就用哪個。你的 RTL 模擬會顯示 X，閘級模擬會顯示真實資料，兩者不一致。這就是「RTL 和 netlist 不一致」這類臭蟲報告的經典成因。如果你希望硬體對非法輸入也是可預測的，就在 default 裡指派一個有定義的值。この到達可能性は重要だ。もし select が 3 ビットで、分岐を四つと default: y <= 8'bx; だけ書いたなら、列挙されなかった四つの符号は don't-care となり、合成器はそれらを a、b、c、d のどれに写像してもよい——いちばん安いものに。RTL シミュレーションは X を示し、ゲートシミュレーションは実データを示し、両者は食い違う。「RTL とネットリストが一致しない」というバグ報告の古典的な原因がこれである。不正入力に対してもハードウェアを予測可能にしたいなら、default で定義された値を代入すること。

Why “same result with =”為什麼「用 = 結果相同」なぜ「= でも同じ結果」なのか

The slide's comment is correct here and misleading in general. In this block there is exactly one assignment to y per clock edge, nothing else in the block reads y, and no other variable is involved. Under those conditions blocking and non-blocking assignment produce the same hardware, because the ordering that = imposes has nothing to order against.投影片的註解在這裡是對的，但一般而言會誤導。在這個區塊裡，每個時脈邊緣對 y 只有恰好一次指派，區塊中沒有別的東西讀 y，也沒有其他變數牽涉其中。在這些條件下，阻斷式與非阻斷式指派產生相同的硬體，因為 = 所強加的順序根本沒有對象可排。スライドの注釈はここでは正しいが、一般には誤解を招く。このブロックではクロックエッジごとに y への代入がちょうど一つで、ブロック内の他の何も y を読まず、他の変数も関与しない。その条件下ではブロッキング代入とノンブロッキング代入は同じハードウェアを生む。= が課す順序に、順序づける相手がいないからだ。

The moment a second register appears in the block, that stops being true — Practice 1(c) versus 1(d) is the demonstration. More subtly, it also stops being true across different blocks even when each block has only one assignment. If block A drives q1 with = and block B reads q1 at the same clock edge, the simulator's execution order between the two blocks is unspecified, and you have a simulation race: run the same testbench on two simulators and get two answers. Non-blocking assignment removes the race by construction, because every right-hand side is evaluated before any left-hand side is updated. That is why the guideline is unconditional: clocked logic uses <=, with no exceptions worth arguing about.一旦區塊裡出現第二個暫存器，這就不成立了——練習 1(c) 對照 1(d) 就是示範。更微妙的是，就算每個區塊各自只有一次指派，跨不同區塊時它也不再成立。如果區塊 A 用 = 驅動 q1，而區塊 B 在同一個時脈邊緣讀 q1，兩個區塊之間的模擬器執行順序是未規定的，你就有了一場模擬競爭：同一個測試平台在兩套模擬器上跑會得到兩種答案。非阻斷式指派從構造上消除了這場競爭，因為所有右手邊都在任何左手邊被更新之前就算完了。這就是為什麼那條準則是無條件的：時脈邏輯用 <=，沒有什麼值得爭論的例外。ブロックに二つ目のレジスタが現れた瞬間、それは成り立たなくなる——練習 1(c) と 1(d) の対比が実演である。さらに微妙なことに、各ブロックの代入が一つずつでも、異なるブロックをまたぐと成り立たなくなる。ブロック A が = で q1 を駆動し、ブロック B が同じクロックエッジで q1 を読むなら、両ブロック間のシミュレータの実行順序は未規定であり、シミュレーション・レースが生じる。同じテストベンチを二つのシミュレータで走らせると二つの答えが出る。ノンブロッキング代入は構成上このレースを消す。すべての右辺が、どの左辺が更新されるより前に評価されるからだ。だから指針は無条件である。クロック同期論理には <=、議論に値する例外はない。

3.3 Where the clock period goes3.3 時脈週期花到哪裡去了3.3 クロック周期はどこへ消えるか

Registered logic is the right place to introduce the arithmetic that the rest of the lecture depends on. A path runs from the Q pin of a launching flip-flop, through a combinational cloud, to the D pin of a capturing flip-flop. For that path to work, the data must arrive before the capture edge with enough margin:暫存化的邏輯正是引入本講其餘部分所倚賴之算式的好時機。一條路徑從發射端正反器的 Q 腳出發，穿過一團組合邏輯雲，到達捕捉端正反器的 D 腳。要讓這條路徑成立，資料必須在捕捉邊緣之前帶著足夠餘裕抵達：レジスタ付き論理は、本講の残りが依拠する計算を導入するのにちょうどよい場所である。経路は発射側フリップフロップの Q ピンから出発し、組合せ論理の雲を抜け、捕捉側フリップフロップの D ピンに至る。この経路が成立するには、データが捕捉エッジより前に十分な余裕をもって到着しなければならない。

and it must not arrive too soon after the capture edge, or it will race through and corrupt the value the capturing flip-flop was supposed to hold:而且它不能在捕捉邊緣之後太快抵達，否則它會一路衝過去，破壞捕捉端正反器本來應該保持的值：同時に、捕捉エッジの後早すぎて到着してもいけない。突き抜けて、捕捉側フリップフロップが保持すべきだった値を壊してしまう。

Here $t_{cq}$ is clock-to-Q of the launching flip-flop, $t_{su}$ and $t_h$ are setup and hold of the capturing one, and $t_{\text{skew}}$ is the arrival-time difference of the clock at the two flip-flops (positive when the capture clock is later).這裡 $t_{cq}$ 是發射端正反器的 clock-to-Q，$t_{su}$ 與 $t_h$ 是捕捉端的 setup 與 hold，而 $t_{\text{skew}}$ 是時脈到達兩顆正反器的時間差（捕捉時脈較晚時為正）。ここで $t_{cq}$ は発射側フリップフロップの clock-to-Q、$t_{su}$ と $t_h$ は捕捉側の setup と hold、$t_{\text{skew}}$ は二つのフリップフロップへのクロック到着時刻の差（捕捉クロックが遅いとき正）である。

Three things follow that matter for the rest of this lecture. First, the setup constraint scales with the period: if the design is too slow you can always slow the clock down. Second, the hold constraint does not — $T_{\text{clk}}$ does not appear in it, so a hold violation is a functional failure that no clock frequency can fix, and the only repair is to add delay (buffers) to the short path. Third, $t_{cq} + t_{su}$ is a fixed tax paid once per register stage; it is the reason the pipelining speed-up in Section 6 has a ceiling.由此得出三件對本講其餘部分重要的事。第一，setup 約束隨週期縮放：如果設計太慢，你永遠可以把時脈放慢。第二，hold 約束不會——$T_{\text{clk}}$ 根本沒出現在裡面，所以 hold 違規是任何時脈頻率都救不了的功能性失效，唯一的修法是在那條短路徑上加延遲（緩衝器）。第三，$t_{cq} + t_{su}$ 是每一級暫存器都要繳一次的固定稅；這就是第 6 節的管線加速有上限的原因。ここから、本講の残りに効いてくる三点が導かれる。第一に、セットアップ制約は周期に比例する。設計が遅すぎるならクロックを遅くすればいつでも救える。第二に、ホールド制約はそうではない——$T_{\text{clk}}$ が式に現れないので、ホールド違反はどんなクロック周波数でも直らない機能故障であり、唯一の対処は短い経路に遅延（バッファ）を足すことだ。第三に、$t_{cq} + t_{su}$ はレジスタ段ごとに一度支払う固定の税であり、第 6 節のパイプライン高速化に天井がある理由でもある。

A worked example with plausible 65 nm numbers: $t_{cq} = 120$ ps, $t_{su} = 60$ ps, $t_h = 40$ ps, clock skew 50 ps, and a logic cloud whose maximum delay is 1.2 ns and minimum delay 0.15 ns. Setup requires $T \ge 120 + 1200 + 60 - 50 = 1330$ ps, so the design runs at at most 752 MHz. Hold requires $120 + 150 = 270 \ge 40 + 50 = 90$ ps, which passes with 180 ps of slack. Add a synchronous reset gate to the cloud and the maximum delay becomes perhaps 1.26 ns, pushing the limit down to 723 MHz — the 4 % that Section 2.3 was talking about.用 65 nm 的合理數字做一個演練：$t_{cq} = 120$ ps、$t_{su} = 60$ ps、$t_h = 40$ ps、時脈歪斜 50 ps，邏輯雲的最大延遲 1.2 ns、最小延遲 0.15 ns。Setup 要求 $T \ge 120 + 1200 + 60 - 50 = 1330$ ps，所以設計最高跑到 752 MHz。Hold 要求 $120 + 150 = 270 \ge 40 + 50 = 90$ ps，以 180 ps 的 slack 通過。在雲裡加一顆同步重置閘，最大延遲大概變成 1.26 ns，把上限壓到 723 MHz——正是 2.3 節講的那 4 %。65 nm のもっともらしい数値で一例を計算してみる。$t_{cq} = 120$ ps、$t_{su} = 60$ ps、$t_h = 40$ ps、クロックスキュー 50 ps、論理雲の最大遅延 1.2 ns、最小遅延 0.15 ns。セットアップは $T \ge 120 + 1200 + 60 - 50 = 1330$ ps を要求するので、動作上限は約 752 MHz。ホールドは $120 + 150 = 270 \ge 40 + 50 = 90$ ps を要求し、180 ps のスラックで通る。雲に同期リセット用ゲートを足すと最大遅延はおよそ 1.26 ns になり、上限は 723 MHz まで下がる——2.3 節が言っていた 4 % である。

4. Shift Registers, Rotators and Load Registers4. 移位暫存器、旋轉器與載入暫存器4. シフトレジスタ、ローテータ、ロードレジスタ

Everything in this section is the same hardware — a bank of flip-flops — differing only in what is wired to the D inputs. That is worth keeping in mind as a unifying idea: a shift register is a register whose D inputs come from its neighbours' Q outputs; a rotator is a shift register whose chain is closed into a ring; a load register is a register with a multiplexer deciding between “new data” and “what I already have”.本節裡的每一樣東西都是同一種硬體——一排正反器——差別只在 D 輸入接了什麼。這個統一的想法值得放在心上：移位暫存器就是 D 輸入來自鄰居 Q 輸出的暫存器；旋轉器就是把鏈頭尾接成環的移位暫存器；載入暫存器就是前面加一顆多工器、在「新資料」與「我原本就有的東西」之間做選擇的暫存器。本節に出てくるものはすべて同じハードウェア——フリップフロップの列——であり、違うのは D 入力に何が繋がっているかだけである。統一的な見方として覚えておく価値がある。シフトレジスタとは D 入力が隣の Q 出力から来るレジスタ、ローテータとはチェーンを環に閉じたシフトレジスタ、ロードレジスタとは「新しいデータ」と「いま持っているもの」をマルチプレクサで選ぶレジスタである。

4.1 The plain shift register4.1 單純的移位暫存器4.1 素のシフトレジスタ

module Shift_reg4 (Data_in, Data_out, clock, reset);
  input       Data_in, clock, reset;
  output      Data_out;
  reg   [3:0] Data_reg;

  assign Data_out = Data_reg[0];

  always @ (negedge reset or posedge clock)
    begin
      if (reset == 1'b0) Data_reg <= 4'b0;        // active low, asynchronous
      else               Data_reg <= {Data_in, Data_reg[3:1]};
    end
endmodule

Four points to extract from eight lines.從八行程式碼裡可以抽出四個重點。8 行のコードから四つの要点を取り出せる。

The reset is active low and asynchronous. negedge reset in the event control paired with if (reset == 1'b0) in the body — polarity matched, exactly as Section 2.1 requires. This is the convention most real designs use, named rst_n or reset_n, because CMOS reset-generation circuits naturally produce an active-low signal and because a floating or unpowered net tends to sit low, which puts the chip in reset rather than running wild.重置是低位準作用且非同步的。事件控制裡的 negedge reset 搭配本體裡的 if (reset == 1'b0)——極性一致，正是 2.1 節所要求的。這是多數真實設計採用的慣例，名字叫 rst_n 或 reset_n，因為 CMOS 的重置產生電路天生產出低位準作用的訊號，也因為浮接或未供電的網路傾向停在低位準，那會讓晶片進入重置而不是亂跑。リセットは負論理かつ非同期である。イベント制御の negedge reset と本体の if (reset == 1'b0) が対になっている——極性が一致しており、2.1 節の要求どおりだ。これは実際の設計の多くが採る慣習で、名前は rst_n や reset_n とされる。CMOS のリセット生成回路が自然に負論理の信号を出すこと、そして浮いたネットや非給電のネットが低位に落ち着きやすく、その結果チップが暴走せずリセットに入ることが理由である。

The shift direction. {Data_in, Data_reg[3:1]} builds a 4-bit value whose top bit is the new input and whose lower three bits are the old bits 3, 2, 1. So bit 3 receives Data_in, bit 2 receives old bit 3, bit 1 receives old bit 2, bit 0 receives old bit 1. Data enters at the most significant end and walks down towards bit 0. Since Data_out taps bit 0, the module is a four-clock delay line: whatever you present at Data_in appears at Data_out four rising edges later.移位方向。{Data_in, Data_reg[3:1]} 組出一個 4 位元值，最高位是新的輸入，較低三位是舊的第 3、2、1 位。所以位元 3 收到 Data_in，位元 2 收到舊的位元 3，位元 1 收到舊的位元 2，位元 0 收到舊的位元 1。資料從最高位端進入，往位元 0 的方向往下走。既然 Data_out 取的是位元 0，這個模組就是一條四拍的延遲線：你在 Data_in 放進去的東西，會在四個上升緣之後出現在 Data_out。シフトの向き。{Data_in, Data_reg[3:1]} は、最上位が新しい入力、下位 3 ビットが古いビット 3、2、1 である 4 ビット値を作る。つまりビット 3 は Data_in を、ビット 2 は古いビット 3 を、ビット 1 は古いビット 2 を、ビット 0 は古いビット 1 を受け取る。データは最上位側から入り、ビット 0 に向かって下へ進む。Data_out はビット 0 を取り出すので、このモジュールはクロック 4 拍の遅延線である。Data_in に与えたものは立ち上がりエッジ 4 回後に Data_out に現れる。

Why non-blocking is mandatory here. The concatenation reads Data_reg[3:1] while assigning Data_reg[3:0]. With <= the right-hand side is sampled at the edge, so every bit sees its neighbour's old value and the shift is a true shift. Write = instead and the four bits are still assigned as one vector in one statement, so this particular line happens to survive — but split it into four separate statements with = and you get the Practice 1(d) disaster.為什麼這裡非用非阻斷式不可。這個串接在指派 Data_reg[3:0] 的同時讀取 Data_reg[3:1]。用 <= 時右手邊在邊緣被取樣，所以每一位元看到的都是鄰居的舊值，移位才是真正的移位。改寫成 = 的話，這四個位元仍然是在一個敘述裡以一個向量被指派的，所以這一行剛好活得下來——但把它拆成四個分開的 = 敘述，你就得到練習 1(d) 的災難。なぜここでノンブロッキングが必須なのか。この連結は Data_reg[3:0] へ代入しながら Data_reg[3:1] を読んでいる。<= なら右辺はエッジでサンプルされるので、各ビットは隣の古い値を見て、シフトは本物のシフトになる。= に替えても、4 ビットは一つの文で一つのベクタとして代入されるので、この行はたまたま生き延びる——が、= で四つの別々の文に分ければ練習 1(d) の惨事になる。

What the netlist looks like. Four flip-flops with asynchronous clear, Q of each wired directly to D of the next, no logic in between whatsoever. This is the cheapest sequential structure there is, which is why shift registers are the default implementation of delay lines, serial interfaces, and the synchronisers of Section 2.6.netlist 長什麼樣。四顆附非同步清除的正反器，每一顆的 Q 直接接到下一顆的 D，中間完全沒有邏輯。這是現存最便宜的循序結構，也是為什麼移位暫存器是延遲線、序列介面以及 2.6 節同步器的預設實作方式。ネットリストの姿。非同期クリア付きフリップフロップ 4 個、各々の Q が次の D に直結し、あいだに論理はまったくない。これは存在する中でもっとも安い順序構造であり、シフトレジスタが遅延線、シリアルインタフェース、そして 2.6 節の同期化回路の既定の実装である理由でもある。

4.2 Shift register with judgement4.2 會做判斷的移位暫存器4.2 判断を伴うシフトレジスタ

The second example attaches a small decision to the chain.第二個例子在鏈上附加了一個小小的判斷。二つ目の例は、チェーンに小さな判断を付け加えたものである。

module shifter_1 (Data_in, clock, reset, sig_d, new_signal);
  input  Data_in, clock, reset;
  output sig_d, new_signal;
  reg    sig_a, sig_b, sig_c, sig_d, new_signal;

  always @ (posedge reset or posedge clock)
    begin
      if (reset == 1'b1)
        begin
          sig_a <= 0; sig_b <= 0; sig_c <= 0; sig_d <= 0;
          new_signal <= 0;
        end
      else
        begin
          sig_a <= Data_in;
          sig_b <= sig_a;
          sig_c <= sig_b;
          sig_d <= sig_c;
          new_signal <= (~sig_a) & sig_b;
        end
    end
endmodule

Five flip-flops: four for the chain and a fifth for new_signal. The chain is written as four separate non-blocking statements rather than one concatenation, which is the more readable style and which works for exactly the reason given in Section 1.3 — the right-hand sides are all sampled at the edge, so sig_b gets the old sig_a.五顆正反器：四顆給鏈，第五顆給 new_signal。鏈是寫成四個分開的非阻斷式敘述，而不是一個串接，這是比較易讀的風格，而它之所以能用，理由正是 1.3 節講的——所有右手邊都在邊緣被取樣，所以 sig_b 拿到的是舊的 sig_a。フリップフロップは 5 個。4 個がチェーン、5 個目が new_signal 用である。チェーンは連結ではなく四つの独立したノンブロッキング文として書かれている。こちらのほうが読みやすく、しかも成り立つ理由はまさに 1.3 節の説明どおり——右辺はすべてエッジでサンプルされるので、sig_b は古い sig_a を受け取る。

The interesting line is the last one. At any moment sig_a holds the most recent sample and sig_b the one before it, so (~sig_a) & sig_b is true exactly when the stream went 1 then 0. The module is a falling-edge detector. In the netlist this is one inverter, one two-input AND, and one flip-flop — which is precisely what the slide circles in blue on the schematic.有意思的是最後一行。在任何時刻 sig_a 保存的是最新的取樣，sig_b 是前一個，所以 (~sig_a) & sig_b 恰好在串流走了 1 然後 0 時為真。這個模組是一個下降緣偵測器。在 netlist 裡這就是一顆反相器、一顆兩輸入 AND 和一顆正反器——正是投影片在電路圖上用藍色圈起來的那一塊。面白いのは最後の行である。任意の時点で sig_a は最新のサンプル、sig_b はその一つ前を保持しているので、(~sig_a) & sig_b は入力列が 1 のあと 0 になったときちょうど真になる。このモジュールは立ち下がりエッジ検出器である。ネットリスト上ではインバータ 1 個、2 入力 AND 1 個、フリップフロップ 1 個——スライドが回路図上で青く囲んでいるのがまさにこれだ。

Why register the detector output at all? Because the alternative, assign new_signal = ~sig_a & sig_b;, produces a combinational output that can glitch: sig_a and sig_b change at the same clock edge, but not at exactly the same instant, so if sig_a falls a few picoseconds before sig_b falls, the AND gate briefly sees (~0) & 1 = 1 and emits a spike. Inside a synchronous design that spike is harmless — it settles long before the next edge. Driven off-chip, or used as an asynchronous clear somewhere, it is a disaster. Registering costs one flip-flop and one clock cycle of latency and removes the problem entirely. This is the same Mealy-versus-Moore argument that Section 7 makes for state machines, in miniature.為什麼要把偵測器輸出暫存起來？因為另一種寫法 assign new_signal = ~sig_a & sig_b; 會產生一個可能出現毛刺的組合輸出：sig_a 與 sig_b 在同一個時脈邊緣改變，但不會在完全相同的瞬間，所以如果 sig_a 比 sig_b 早幾皮秒下降，AND 閘就會短暫看到 (~0) & 1 = 1 而送出一根尖波。在同步設計內部那根尖波無害——它早在下一個邊緣之前就安定了。但若驅動到晶片外，或是被拿去當某處的非同步清除，那就是災難。暫存只花一顆正反器和一個時脈週期的延遲，卻徹底消除這個問題。這就是第 7 節為狀態機所做的那個 Mealy 對 Moore 論證的迷你版。そもそもなぜ検出器の出力をレジスタで受けるのか。代案の assign new_signal = ~sig_a & sig_b; は、グリッチを出しうる組合せ出力になるからだ。sig_a と sig_b は同じクロックエッジで変化するが、まったく同じ瞬間ではない。sig_a が sig_b より数ピコ秒早く落ちると、AND ゲートは一瞬 (~0) & 1 = 1 を見てスパイクを出す。同期設計の内部ならこのスパイクは無害で、次のエッジのはるか前に収まる。チップ外へ出す場合や、どこかの非同期クリアに使う場合は大惨事だ。レジスタで受ければフリップフロップ 1 個とレイテンシ 1 サイクルの代償で問題は完全に消える。これは第 7 節が状態機械について述べるミーリ対ムーアの議論の縮小版である。

One caution the slide does not mention: an edge detector only works on a signal that is already synchronous to clock. If Data_in comes from another clock domain or from a chip pin, sig_a can go metastable, and the detector will happily report edges that never happened. The fix is the same two-flip-flop synchroniser as in Section 2.6, placed in front of the detector — which, conveniently, the first two stages of this very chain already are, provided you take the detector from sig_b and sig_c rather than sig_a and sig_b.投影片沒提到的一個警告：邊緣偵測器只對已經與 clock 同步的訊號有效。如果 Data_in 來自另一個時脈域或來自晶片接腳，sig_a 可能進入亞穩態，偵測器就會興高采烈地報出從未發生過的邊緣。修法就是 2.6 節那個兩級正反器同步器，放在偵測器前面——方便的是，這條鏈的前兩級本來就是，只要你改從 sig_b 與 sig_c（而不是 sig_a 與 sig_b）取偵測訊號就行。スライドが触れていない注意点が一つある。エッジ検出器は、すでに clock に同期した信号に対してしか機能しない。Data_in が別のクロックドメインやチップピンから来る場合、sig_a はメタステーブルになりうるし、検出器は起きてもいないエッジを嬉々として報告する。対処は 2.6 節と同じ 2 段フリップフロップの同期化回路を検出器の前に置くこと——好都合なことに、このチェーンの最初の 2 段がすでにそれであり、検出を sig_a と sig_b ではなく sig_b と sig_c から取ればよい。

4.3 The “barrel” shifter with loading data4.3 可載入資料的「barrel」移位器4.3 データをロードできる「barrel」シフタ

module barrel_shifter (Data_out, Data_in, load, clock, reset);
  output [7:0] Data_out;
  input  [7:0] Data_in;
  input        load, clock, reset;
  reg    [7:0] Data_out;

  always @ (posedge reset or posedge clock)
    begin
      if      (reset == 1'b1) Data_out <= 8'b0;
      else if (load  == 1'b1) Data_out <= Data_in;
      else                    Data_out <= {Data_out[6:0], Data_out[7]};
    end
endmodule

Work the concatenation out bit by bit, because the direction is the examinable detail. {Data_out[6:0], Data_out[7]} places old bits 6 down to 0 in positions 7 down to 1, and old bit 7 in position 0. So every bit moves up one position and the top bit wraps around to the bottom: a rotate left by one. The slide's example confirms it:把串接一位元一位元算出來，因為方向才是會考的細節。{Data_out[6:0], Data_out[7]} 把舊的位元 6 到 0 放進位置 7 到 1，把舊的位元 7 放進位置 0。所以每一位元都往上移一格，而最高位繞回到最低位：這是左旋轉一位。投影片的例子證實了這點：連結をビットごとに展開してみよう。向きこそが試験に出る細部だからだ。{Data_out[6:0], Data_out[7]} は古いビット 6〜0 を位置 7〜1 に、古いビット 7 を位置 0 に置く。つまり各ビットは 1 つ上へ動き、最上位が最下位へ回り込む。1 ビット左回転である。スライドの例がそれを裏づけている。

Each bit gets a 2:1 multiplexer in front of its flip-flop — load ? Data_in[i] : Data_out[i-1 mod 8] — and the flip-flop has an asynchronous clear. Eight muxes, eight flip-flops, one inverter on the reset. The synthesis-result slide shows exactly that: a column of eight mux2_a cells feeding a column of eight flip-flops, with the wrap-around wire from bit 7 running back to bit 0.每一位元的正反器前面都有一顆 2:1 多工器——load ? Data_in[i] : Data_out[i-1 mod 8]——而正反器帶有非同步清除。八顆多工器、八顆正反器，重置上一顆反相器。合成結果的投影片顯示的正是這樣：一欄八顆 mux2_a 單元餵給一欄八顆正反器，還有那條從位元 7 繞回位元 0 的環繞線。各ビットのフリップフロップの前には 2:1 マルチプレクサが置かれる——load ? Data_in[i] : Data_out[i-1 mod 8]——そしてフリップフロップは非同期クリア付きだ。マルチプレクサ 8 個、フリップフロップ 8 個、リセットにインバータ 1 個。合成結果のスライドはまさにそれを示す。mux2_a セルが 8 個並んでフリップフロップ 8 個を駆動し、ビット 7 からビット 0 へ戻る回り込み配線がある。

4.4 The parallel-load register, and the missing else4.4 並列載入暫存器，以及那個不見的 else4.4 パラレルロードレジスタと、欠けた else

module Par_load_reg4 (Data_out, Data_in, load, clock, reset);
  input  [3:0] Data_in;
  input        load, clock, reset;
  output [3:0] Data_out;
  reg    [3:0] Data_out;

  always @ (posedge reset or posedge clock)
    begin
      if      (reset == 1'b1) Data_out <= 4'b0;
      else if (load  == 1'b1) Data_out <= Data_in;
      // no final else -- and that is deliberate
    end
endmodule

This is the module that exists to make one point, and the point is important enough that it is worth restating in three different ways.這個模組的存在是為了講一個重點，而那個重點重要到值得用三種不同的方式重說一遍。このモジュールは一つの要点を述べるために存在しており、その要点は三通りに言い直す価値があるほど重要である。

There is no final else. When reset is low and load is low, the behaviour assigns nothing, so Data_out keeps its value. In a level-sensitive block that would be a catastrophe: holding a value without a clock requires a transparent latch, and the tool would build four of them, and Lecture 5 spent several slides explaining why that is a bug. In an edge-triggered block it is completely routine: holding a value across a clock edge is the definition of a flip-flop, so nothing extra is needed. The tool implements the hold either as a feedback multiplexer (load ? Data_in : Data_out) in front of a plain flip-flop, which is what the slide's schematic shows, or by picking an enable flip-flop from the library, or — for a wide enough bank — by inserting an integrated clock-gating cell so that the clock itself is suppressed when load is low.沒有最後的 else。當 reset 為低而 load 也為低時，這個行為什麼都不指派，所以 Data_out 保持它的值。在位準敏感區塊裡那會是場災難：沒有時脈卻要保持值就需要透通閂鎖，工具會蓋出四顆，而第 5 講花了好幾張投影片解釋為什麼那是錯誤。在邊緣觸發區塊裡這完全是家常便飯：跨越時脈邊緣保持值正是正反器的定義，所以不需要任何額外的東西。工具會把這個保持實作成普通正反器前面的一顆回授多工器（load ? Data_in : Data_out），也就是投影片電路圖畫的那樣；或是從函式庫挑一顆致能型正反器；或者——當暫存器排夠寬時——插入一顆整合式時脈閘控單元，在 load 為低時直接把時脈本身擋掉。最後の else がない。reset が低で load も低のとき、このビヘイビアは何も代入しないので Data_out は値を保持する。レベル感応ブロックならこれは災厄だ。クロックなしで値を保持するにはトランスペアレントラッチが要り、ツールは 4 個こしらえる。第 5 講はそれがバグである理由に何枚もスライドを費やした。エッジトリガブロックではまったく日常的である。クロックエッジをまたいで値を保持することはフリップフロップの定義そのものなので、余計なものは要らない。ツールはこの保持を、素のフリップフロップの前のフィードバック・マルチプレクサ（load ? Data_in : Data_out、スライドの回路図が示すもの）として実装するか、ライブラリのイネーブル付きフリップフロップを選ぶか、あるいは——十分広いレジスタ群なら——集積クロックゲーティングセルを挿入して load が低のときクロック自体を止める。

The clock-gating option deserves a note because it changes the timing picture. A feedback mux puts a multiplexer in the D path of every bit, which costs area and a little setup margin but leaves the clock alone. An integrated clock-gating cell removes the mux, saves dynamic power on every cycle the register is not loading, and — this is the catch — creates a gated clock that clock-tree synthesis and static timing analysis must handle, with its own setup and hold requirements on the enable signal. Tools do this automatically above a configurable register width (eight or sixteen bits is typical), and it is the single largest dynamic-power saving available in a synchronous design. The difference from the accidental gated clock of Section 1.6 is that here the tool built it, knows about it, and constrained it.時脈閘控這個選項值得加註，因為它改變了時序的樣貌。回授多工器在每一位元的 D 路徑上放一顆多工器，花掉面積和一點 setup 餘裕，但不動時脈。整合式時脈閘控單元拿掉了多工器，在暫存器沒有載入的每一個週期省下動態功耗，而且——這是陷阱——造出一個閘控時脈，時脈樹合成與靜態時序分析都必須處理它，並對致能訊號施加它自己的 setup 與 hold 要求。工具在暫存器寬度超過某個可設定的門檻（八或十六位元是典型值）之後會自動這麼做，而這是同步設計中可取得的最大一筆動態功耗節省。它與 1.6 節那個意外閘控時脈的差別在於：這裡是工具蓋的、工具知道它存在、而且工具約束了它。クロックゲーティングという選択肢はタイミングの様相を変えるので注記しておく。フィードバック・マルチプレクサは全ビットの D 経路にマルチプレクサを置き、面積とわずかなセットアップ余裕を消費するが、クロックには触れない。集積クロックゲーティングセルはマルチプレクサを取り除き、レジスタがロードしていないサイクルごとに動的電力を節約し、そして——ここが落とし穴だが——ゲーテッドクロックを作る。クロックツリー合成とスタティックタイミング解析はそれを扱わねばならず、イネーブル信号には固有の setup と hold の要求が生じる。ツールは設定可能なレジスタ幅（8 ビットや 16 ビットが典型）を超えると自動的にこれを行い、同期設計で得られる動的電力削減としては最大のものである。1.6 節の偶発的ゲーテッドクロックとの違いは、ここではツールが自分で作り、把握し、制約していることだ。

always @ (posedge reset or posedge clock)
  if      (reset == 1'b1) Data_out <= 4'b0;   // async, highest priority
  else if (load  == 1'b1) Data_out <= Data_in;
  else if (clr   == 1'b1) Data_out <= 4'b0;   // sync clear
  // still no final else: hold

5. Ripple and Ring Counters5. 漣波計數器與環形計數器5. リプルカウンタとリングカウンタ

Counters are the first place in this lecture where a perfectly correct Verilog description produces a circuit that an ASIC methodology will reject. Both of the slide's counters work; one of them is a structure you should recognise so that you can avoid it.計數器是本講中第一個「完全正確的 Verilog 描述卻產生出 ASIC 方法論會拒絕的電路」的地方。投影片的兩個計數器都能動；其中一個是你應該認得出來、好讓自己避開的結構。カウンタは本講で初めて、まったく正しい Verilog 記述が ASIC の方法論に拒絶される回路を生む場所である。スライドの二つのカウンタはどちらも動く。片方は、避けられるように見分けがつくようにしておくべき構造だ。

5.1 The ripple counter5.1 漣波計數器5.1 リプルカウンタ

module ripple_counter (clock, toggle, reset, count);
  input        clock, toggle, reset;
  output [3:0] count;
  reg    [3:0] count;
  wire         c0, c1, c2;

  assign c0 = count[0];
  assign c1 = count[1];
  assign c2 = count[2];

  always @ (posedge reset or posedge clock)
    if      (reset  == 1'b1) count[0] <= 1'b0;
    else if (toggle == 1'b1) count[0] <= ~count[0];

  always @ (posedge reset or negedge c0)
    if      (reset  == 1'b1) count[1] <= 1'b0;
    else if (toggle == 1'b1) count[1] <= ~count[1];

  always @ (posedge reset or negedge c1)
    if      (reset  == 1'b1) count[2] <= 1'b0;
    else if (toggle == 1'b1) count[2] <= ~count[2];

  always @ (posedge reset or negedge c2)
    if      (reset  == 1'b1) count[3] <= 1'b0;
    else if (toggle == 1'b1) count[3] <= ~count[3];
endmodule

Four separate behaviours, one per bit. Each is a textbook toggle flip-flop: when enabled, invert. The thing to notice is the second signal in each event control. Stage 0 is clocked by clock. Stage 1 is clocked by the falling edge of count[0]. Stage 2 by the falling edge of count[1], and stage 3 by the falling edge of count[2]. Nothing except stage 0 is connected to the real clock at all.四個分開的行為，每位元一個。每一個都是教科書式的 toggle 正反器：被致能時就反相。要注意的是每個事件控制裡的第二個訊號。第 0 級由 clock 驅動。第 1 級由 count[0] 的下降緣驅動。第 2 級由 count[1] 的下降緣，第 3 級由 count[2] 的下降緣。除了第 0 級之外，沒有任何一級接到真正的時脈。ビットごとに一つ、計四つの独立したビヘイビア。いずれも教科書的なトグル・フリップフロップで、イネーブル時に反転する。注目すべきは各イベント制御の二番目の信号だ。第 0 段は clock で駆動される。第 1 段は count[0] の立ち下がり、第 2 段は count[1] の立ち下がり、第 3 段は count[2] の立ち下がりで駆動される。第 0 段以外、本物のクロックに繋がっているものは一つもない。

Why does this count? A toggle flip-flop that inverts on every enabled clock produces an output at exactly half the input frequency. Chain four of them and you get divisions by 2, 4, 8 and 16 — which, read as a binary word, is an up-counter. The choice of negedge rather than posedge as the inter-stage trigger is what makes it count up: bit $i+1$ must toggle when bit $i$ goes from 1 to 0, which is precisely when a binary carry propagates out of position $i$. Trigger on posedge instead and you get a down-counter.為什麼它會計數？一顆在每個被致能的時脈都反相的 toggle 正反器，產生的輸出頻率恰好是輸入的一半。把四顆串起來就得到除 2、4、8、16——把它們當成二進位字來讀，就是一個上數計數器。選 negedge 而不是 posedge 當作級間觸發，正是讓它往上數的原因：位元 $i+1$ 必須在位元 $i$ 從 1 變 0 時反轉，而那正好是二進位進位從位置 $i$ 傳出去的時刻。改成 posedge 觸發就得到下數計數器。なぜ数えられるのか。イネーブルされたクロックごとに反転するトグル・フリップフロップは、入力のちょうど半分の周波数の出力を生む。これを 4 段つなげば 2、4、8、16 分周が得られ、二進語として読めばアップカウンタになる。段間トリガに posedge ではなく negedge を選ぶことこそが上へ数える理由だ。ビット $i+1$ はビット $i$ が 1 から 0 になるとき反転しなければならず、それはまさに二進のキャリーが位置 $i$ から出ていく瞬間である。posedge でトリガすればダウンカウンタになる。

The toggle input is a count enable; the intermediate wires c0, c1, c2 exist only because the original Verilog-1995 rules do not let you put a bit-select of a reg directly in an edge qualifier in all tools, so the code aliases them to nets first. Note also that each stage has an incomplete if — when toggle is low nothing is assigned, so the bit holds, exactly as in Section 4.4.toggle 輸入是計數致能；中間的連線 c0、c1、c2 之所以存在，只是因為原本的 Verilog-1995 規則並不是在所有工具裡都允許你把 reg 的位元選擇直接放進邊緣修飾詞，所以程式碼先把它們別名成網路。另外注意每一級都有一個不完整的 if——當 toggle 為低時什麼都不指派，所以該位元保持，和 4.4 節完全一樣。toggle 入力はカウントイネーブルである。中間の配線 c0、c1、c2 が存在するのは、もともとの Verilog-1995 の規則では reg のビット選択をエッジ修飾子に直接書くことが全ツールで許されるわけではないからで、コードはまずそれらをネットに別名付けしている。また各段には不完全な if がある点にも注意——toggle が低のときは何も代入されないので、そのビットは保持される。4.4 節とまったく同じだ。

The synthesis result on the slide shows what you would expect: each toggle flip-flop realised as a plain D flip-flop with an XOR at its D pin computing toggle ^ Q, an inverter on the reset, and — the significant part — the clock pin of each stage driven by the previous stage's Q through an inverter.投影片上的合成結果正如你所預期：每顆 toggle 正反器被實現成一顆普通 D 正反器，D 腳上掛一顆算 toggle ^ Q 的 XOR，重置上一顆反相器，而——這是關鍵部分——每一級的時脈腳是由前一級的 Q 經過一顆反相器驅動的。スライドの合成結果は予想どおりである。各トグル・フリップフロップは、D ピンで toggle ^ Q を計算する XOR を伴う素の D フリップフロップとして実現され、リセットにはインバータが付く。そして——ここが肝心だが——各段のクロックピンは前段の Q がインバータを介して駆動している。

5.2 Why ripple counters hurt5.2 漣波計數器為何難用5.2 リプルカウンタが痛い理由

The circuit is small: four flip-flops, four XORs, three inverters, and no carry logic at all. A synchronous four-bit counter needs an incrementer, which for four bits is about the same size, but the gap widens quickly with width — a 32-bit ripple counter is still 32 toggle cells, while a 32-bit synchronous counter needs a real carry chain. So why does every ASIC design guide forbid ripple counters? Five reasons, in roughly descending order of how much trouble they cause.這個電路很小：四顆正反器、四顆 XOR、三顆反相器，完全沒有進位邏輯。一個同步四位元計數器需要一個遞增器，四位元時大小差不多，但差距會隨位元寬度迅速拉開——32 位元的漣波計數器仍然只是 32 顆 toggle 單元，而 32 位元的同步計數器需要一條真正的進位鏈。那為什麼每一份 ASIC 設計指南都禁止漣波計數器？五個理由，大致依照惹麻煩的程度由大到小排列。この回路は小さい。フリップフロップ 4 個、XOR 4 個、インバータ 3 個、キャリー論理はゼロ。同期 4 ビットカウンタにはインクリメンタが要り、4 ビットなら大きさはほぼ同じだが、幅が増えると差は急速に開く——32 ビットのリプルカウンタは依然トグルセル 32 個だが、32 ビットの同期カウンタには本物のキャリーチェーンが必要だ。ではなぜ、どの ASIC 設計指針もリプルカウンタを禁じるのか。理由は五つ、引き起こす面倒の大きい順におおむね並べる。

(a) The bits do not change together(a) 各位元不會一起改變(a) ビットが同時に変化しない

Each stage adds one clock-to-Q delay before the next stage even sees its clock edge. For a 4-bit counter the worst case — the transition from 0111 to 1000, where the carry ripples all the way — takes $4\,t_{cq}$ to settle. With $t_{cq} = 150$ ps that is 600 ps, which is a large fraction of a fast clock period. Any logic that reads count must wait for all of it, and the counter's maximum frequency is bounded by $n\,t_{cq}$ rather than by one stage.每一級都在下一級看到自己的時脈邊緣之前，先加上一個 clock-to-Q 延遲。對一個 4 位元計數器，最糟情況——從 0111 到 1000，進位一路傳到底——要花 $4\,t_{cq}$ 才安定。取 $t_{cq} = 150$ ps 就是 600 ps，那在快時脈下佔週期的一大部分。任何讀 count 的邏輯都必須等完這段時間，而計數器的最高頻率受限於 $n\,t_{cq}$ 而不是單一級。各段は、次の段が自分のクロックエッジを見るより前に clock-to-Q 遅延を一つ足す。4 ビットカウンタの最悪ケース——キャリーが端まで伝わる 0111 から 1000 への遷移——は整定に $4\,t_{cq}$ かかる。$t_{cq} = 150$ ps なら 600 ps で、高速クロックでは周期のかなりの割合を占める。count を読む論理はすべてその全部を待たねばならず、カウンタの最高周波数は 1 段ではなく $n\,t_{cq}$ で律速される。

(b) Decoding produces glitches(b) 解碼會產生毛刺(b) デコードがグリッチを生む

During that settling window the counter passes through values that are not in its intended sequence. Going from 0111 to 1000, bit 0 falls first (0110), then bit 1 (0100), then bit 2 (0000), then bit 3 rises (1000). A comparator watching for count == 4'b0000 will fire a spurious pulse. A one-hot decoder will light up three wrong outputs in turn. In a synchronous design those spikes are filtered by the next register stage, but if the decode drives anything asynchronous — a write-enable, a reset, an off-chip strobe — it is a real failure.在那段安定窗口裡，計數器會經過一些不在它預定序列中的值。從 0111 走到 1000 時，位元 0 先落（0110），接著位元 1（0100），接著位元 2（0000），最後位元 3 升起（1000）。一個在等 count == 4'b0000 的比較器會送出一道假脈衝。一個 one-hot 解碼器會依序點亮三個錯誤的輸出。在同步設計裡那些尖波會被下一級暫存器濾掉，但如果那個解碼去驅動任何非同步的東西——寫入致能、重置、晶片外的 strobe——那就是真正的失效。その整定の窓のあいだ、カウンタは本来の計数列にない値を通過する。0111 から 1000 へ向かうとき、まずビット 0 が落ち（0110）、次にビット 1（0100）、次にビット 2（0000）、最後にビット 3 が立つ（1000）。count == 4'b0000 を監視する比較器は偽のパルスを出す。one-hot デコーダは誤った出力を順に三つ点灯させる。同期設計内ならこれらのスパイクは次段のレジスタが濾過するが、そのデコードが非同期の何か——ライトイネーブル、リセット、チップ外ストローブ——を駆動するなら、本物の故障である。

(c) Static timing analysis cannot see it properly(c) 靜態時序分析看不清楚它(c) スタティックタイミング解析がきちんと見られない

Every stage after the first is clocked by a net that the tool did not know was a clock. To analyse the design at all you must declare three create_generated_clock constraints, one per stage, each derived from the previous. Those generated clocks have no clock tree, so their skew relative to the main clock is whatever the placement happened to produce; cross-domain paths between stages become unconstrained or falsely violated; and every time the design is re-placed, the numbers move. Most teams simply ban the structure rather than maintain the constraints.第一級之後的每一級，都是由工具原本不知道是時脈的網路所驅動。光是要能分析這個設計，你就必須宣告三條 create_generated_clock 約束，每級一條，各自由前一級導出。那些衍生時脈沒有時脈樹，所以它們相對於主時脈的歪斜就是擺放結果碰巧給出的值；級與級之間的跨域路徑會變成未受約束或假違規；而且每次重新擺放，數字就會跑掉。多數團隊乾脆禁用這個結構，而不是去維護那些約束。初段より後のすべての段は、ツールがクロックだと知らなかったネットで駆動される。設計を解析できるようにするだけでも、段ごとに一本、前段から導出した create_generated_clock 制約を三本宣言しなければならない。それらの生成クロックにはクロックツリーがないので、主クロックに対するスキューは配置がたまたま生んだ値になる。段間のドメイン跨ぎ経路は制約なしか偽違反になり、再配置のたびに数値が動く。ほとんどのチームは制約を保守するより、この構造を禁止するほうを選ぶ。

(d) Design for test falls apart(d) 可測試性設計崩潰(d) テスト容易化設計が破綻する

Scan insertion stitches flip-flops into shift chains, and every flip-flop in a chain must share a clock. A ripple counter puts each bit in its own clock domain, so either you get four one-element chains (unacceptable overhead) or the stages are left out of scan entirely (unacceptable coverage). Fault coverage reports will show the counter as a hole.掃描插入會把正反器縫成移位鏈，而鏈中每一顆正反器都必須共用同一個時脈。漣波計數器把每一位元放進它自己的時脈域，所以你要嘛得到四條只有一個元素的鏈（開銷不可接受），要嘛那些級完全被排除在掃描之外（覆蓋率不可接受）。故障覆蓋率報告會把這個計數器顯示成一個洞。スキャン挿入はフリップフロップをシフトチェーンに縫い込むが、一本のチェーンのフリップフロップはすべて同じクロックを共有しなければならない。リプルカウンタは各ビットを固有のクロックドメインに置くので、要素 1 個のチェーンが 4 本できる（オーバーヘッドが許容不能）か、段がスキャンから完全に外される（カバレッジが許容不能）かのどちらかになる。故障カバレッジのレポートには、このカウンタが穴として現れる。

(e) The reset is asynchronous to everything(e) 重置對所有東西都是非同步的(e) リセットがすべてに対して非同期になる

Because the stages have no common clock, there is no clock edge at which they all leave reset. Section 2.5's reset-release analysis has nothing to work with.因為各級沒有共同的時脈，所以根本不存在一個「大家一起離開重置」的時脈邊緣。2.5 節的重置釋放分析在這裡沒有任何著力點。各段に共通のクロックがないので、全員がリセットを抜ける単一のクロックエッジというものが存在しない。2.5 節のリセット解除の解析は、ここでは手がかりを持たない。

always @ (posedge clk or negedge rst_n)
  if      (!rst_n)  count <= 4'b0;
  else if (toggle)  count <= count + 1'b1;   // one clock, all bits

That version has all four flip-flops on the same clock, one carry chain of combinational logic in front of them, a single clock domain for STA and scan, and — because all four bits change at the same edge — a settling time of $t_{cq}$ plus the incrementer delay rather than $4\,t_{cq}$. It is bigger in gate count and smaller in every other sense. Ripple counters survive in two niches: very low-power always-on timers where the dynamic power of a synchronous carry chain matters more than anything else, and discrete logic, where the inter-stage delay is swamped by board parasitics anyway.那個版本讓四顆正反器都在同一個時脈上，前面擺一條組合邏輯的進位鏈，對 STA 與掃描而言只有單一時脈域，而且——因為四個位元都在同一個邊緣改變——安定時間是 $t_{cq}$ 加上遞增器延遲，而不是 $4\,t_{cq}$。它在閘數上比較大，在其他每一個意義上都比較小。漣波計數器只在兩個利基中存活：極低功耗的常開計時器，那裡同步進位鏈的動態功耗比什麼都重要；以及分立邏輯，那裡級間延遲反正會被板子的寄生效應淹沒。その版では 4 個のフリップフロップが同一クロック上にあり、その前に組合せ論理のキャリーチェーンが一本置かれ、STA にもスキャンにも単一のクロックドメインしかない。そして——4 ビットが同じエッジで変化するので——整定時間は $4\,t_{cq}$ ではなく $t_{cq}$ にインクリメンタの遅延を足したものになる。ゲート数では大きく、他のあらゆる意味では小さい。リプルカウンタが生き残るニッチは二つ。同期キャリーチェーンの動的電力が何より効く超低消費電力の常時オンタイマと、段間遅延がどうせ基板の寄生に埋もれるディスクリート論理である。

5.3 The ring counter5.3 環形計數器5.3 リングカウンタ

module ring_counter (count, enable, clock, reset);
  output [7:0] count;
  input        enable, reset, clock;
  reg    [7:0] count;

  always @ (posedge reset or posedge clock)
    if      (reset  == 1'b1) count <= 8'b0000_0001;
    else if (enable == 1'b1) count <= {count[6:0], count[7]};
endmodule

Structurally this is the rotate register of Section 4.3 with a different reset value, and that reset value is the whole point. Starting from 8'b0000_0001, rotating left gives 0000_0010, 0000_0100, …, 1000_0000, and then back to 0000_0001. A single 1 walks around the ring, taking eight clocks per lap. Eight flip-flops, eight states, and each state is already decoded: count[k] is high if and only if the machine is in state $k$. There is no decoder, so there are no decoding glitches, and the state outputs are flip-flop outputs so they are clean enough to drive anything.結構上這就是 4.3 節那個旋轉暫存器，只是換了重置值，而那個重置值正是整件事的重點。從 8'b0000_0001 開始，左旋轉得到 0000_0010、0000_0100、…、1000_0000，然後回到 0000_0001。一個孤單的 1 繞著環走，每一圈八個時脈。八顆正反器、八個狀態，而每個狀態都已經解碼好了：count[k] 為高，若且唯若機器處於狀態 $k$。沒有解碼器，所以沒有解碼毛刺，而且狀態輸出本身就是正反器輸出，乾淨到足以驅動任何東西。構造としてはこれは 4.3 節の回転レジスタそのもので、違うのはリセット値だけ——そしてそのリセット値こそが要点である。8'b0000_0001 から始めて左回転すると 0000_0010、0000_0100、…、1000_0000、そして 0000_0001 に戻る。たった一つの 1 が環を巡り、一周に 8 クロックかかる。フリップフロップ 8 個、状態 8 個、しかも各状態はすでにデコード済みだ。count[k] が高であるのは、機械が状態 $k$ にあるとき、かつそのときに限る。デコーダがないのでデコードのグリッチもなく、状態出力はフリップフロップ出力そのものなので何を駆動するにも十分きれいである。

That makes a ring counter the natural choice for a timing generator — the “gate generator”, “pulse generator” and “timing generator” entries in the Section 1.2 inventory are usually ring counters. It is also exactly a one-hot state machine with a fixed, cyclic transition graph, which is why Section 8 can treat one-hot encoding and ring counters as the same idea.這使環形計數器成為時序產生器的自然選擇——1.2 節清單裡的「閘控產生器」、「脈衝產生器」和「時序產生器」通常就是環形計數器。它同時也正是一台具有固定循環轉移圖的 one-hot 狀態機，這就是為什麼第 8 節可以把 one-hot 編碼和環形計數器當成同一個想法來談。そのためリングカウンタはタイミング生成器の自然な選択肢になる——1.2 節の一覧にある「ゲート生成器」「パルス生成器」「タイミング生成器」はたいていリングカウンタである。また、固定の巡回遷移グラフをもつ one-hot 状態機械そのものでもあり、第 8 節が one-hot 符号化とリングカウンタを同じ考えとして扱えるのはそのためだ。

The reset value needs a preset, not a clear重置值需要的是 preset，不是 clearリセット値に必要なのは clear ではなく preset

Seven of the eight flip-flops reset to 0 and are implemented with asynchronously-clearable cells. Bit 0 resets to 1, which needs an asynchronously presettable cell — DFFS rather than DFFR, or in the slide's library dffspb_a next to seven dffqpb_a. If the library has no preset flip-flop, the tool has to invert the bit's polarity internally and add inverters at its inputs and outputs, which is why a one-hot reset value is marginally more expensive than an all-zeros one. Some designs dodge this by resetting to all zeros and treating that as an extra ninth “idle” state, seeding the 1 with a separate start pulse.八顆正反器中有七顆重置為 0，用可非同步清除的單元實現。位元 0 重置為 1，需要一顆可非同步預設的單元——DFFS 而不是 DFFR，在投影片的函式庫裡就是一顆 dffspb_a 旁邊七顆 dffqpb_a。如果函式庫沒有 preset 型正反器，工具就必須在內部把那一位元的極性反過來，並在它的輸入與輸出端加反相器，這就是為什麼 one-hot 的重置值會比全零的重置值稍微貴一點。有些設計會繞過這點：重置成全零，把那當成額外的第九個「閒置」狀態，再用一道獨立的啟動脈衝去種下那個 1。8 個のフリップフロップのうち 7 個は 0 にリセットされ、非同期クリア可能なセルで実装される。ビット 0 は 1 にリセットされるので、非同期プリセット可能なセルが要る——DFFR ではなく DFFS、スライドのライブラリでいえば dffqpb_a 7 個の隣に dffspb_a 1 個である。ライブラリにプリセット付きフリップフロップがなければ、ツールはそのビットの極性を内部で反転し、入力と出力にインバータを足さねばならない。one-hot のリセット値が全ゼロよりわずかに高くつくのはこのためだ。全ゼロにリセットしてそれを九つ目の「アイドル」状態と見なし、別途の起動パルスで 1 を植え付けることでこれを回避する設計もある。

It is not self-correcting它不會自我修正自己修正しない

This is the examinable weakness. The ring counter has $2^8 = 256$ possible flip-flop states but only 8 of them are legal. The rotate operation maps every state to another state with the same number of ones, so the 256 states decompose into closed orbits: the all-zeros state is a fixed point, the all-ones state is a fixed point, and every other population count forms one or more cycles. If noise, a reset-release skew, or a single-event upset puts two ones into the register, the pattern simply rotates forever with two ones in it, and every downstream decoder sees two states active simultaneously. Nothing in the circuit pulls it back; only reset recovers.這是會考的弱點。環形計數器有 $2^8 = 256$ 種可能的正反器狀態，但其中只有 8 種是合法的。旋轉運算把每個狀態對映到另一個具有相同 1 的個數的狀態，所以這 256 個狀態會分解成封閉的軌道：全零狀態是一個不動點，全一狀態是一個不動點，而其他每一種 1 的個數都形成一個或多個循環。如果雜訊、重置釋放的歪斜，或一次單事件翻轉把兩個 1 放進暫存器裡，那個圖樣就會帶著兩個 1 永遠旋轉下去，而每一個下游解碼器都會同時看到兩個狀態是作用中的。電路裡沒有任何東西會把它拉回來；只有 reset 能救。これが試験に出る弱点である。リングカウンタには $2^8 = 256$ 通りのフリップフロップ状態がありうるが、合法なのはそのうち 8 通りだけだ。回転操作は各状態を同じ 1 の個数をもつ別の状態へ写すので、256 状態は閉じた軌道に分解される。全ゼロ状態は不動点、全 1 状態も不動点、それ以外の各 1 個数は一つ以上の巡回をなす。ノイズやリセット解除のスキュー、あるいは単一事象アップセットがレジスタに 1 を二つ入れてしまうと、そのパターンは 1 を二つ抱えたまま永遠に回り続け、下流のデコーダはどれも二つの状態が同時に有効だと見る。回路の中にそれを引き戻すものは何もない。救えるのは reset だけである。

If that matters, make it self-correcting by feeding bit 0 with the NOR of the other seven bits instead of with bit 7:如果這件事要緊，就把位元 0 的輸入改成其他七個位元的 NOR，而不是位元 7，讓它能自我修正：それが問題になるなら、ビット 0 の入力をビット 7 ではなく他の 7 ビットの NOR にして、自己修正するようにすればよい。

always @ (posedge clk or negedge rst_n)
  if      (!rst_n) count <= 8'b0000_0001;
  else if (enable) count <= {count[6:0], ~|count[7:1]};

Now any state with two or more ones loses one every lap until exactly one remains, and the all-zeros state injects a 1 at the bottom. The cost is one 7-input NOR in the path to bit 0, which also makes that one path slower than the other seven.現在任何有兩個以上 1 的狀態，每繞一圈就少掉一個，直到剛好剩下一個為止；而全零狀態會在最低位注入一個 1。代價是位元 0 的路徑上多了一顆 7 輸入 NOR，這也讓那條路徑比其他七條慢。こうすると、1 が二つ以上ある状態は一周ごとに一つずつ失い、ちょうど一つ残るまで減っていく。そして全ゼロ状態には最下位に 1 が注入される。代償はビット 0 への経路に入る 7 入力 NOR 1 個で、その経路だけが他の七本より遅くなる。

Ring versus Johnson versus binary環形、Johnson 與二進位的比較リング対ジョンソン対二進

A Johnson (twisted-ring, Moebius) counter feeds back the complement of the top bit: count <= {count[6:0], ~count[7]}. Starting from all zeros it fills with ones from the bottom, then empties again, giving $2n$ states from $n$ flip-flops instead of $n$. Its outputs still change one bit at a time, so decoding is still glitch-free, and a Johnson state can be decoded with a two-input gate rather than the $n$-input gate a binary counter would need. The slide's encoding table shows the Johnson sequence for 16 states from 8 bits. The price is the same lack of self-correction and the same poor state-per-flip-flop efficiency.Johnson（扭環、Moebius）計數器回授的是最高位的補數：count <= {count[6:0], ~count[7]}。從全零開始，它會從最低位開始填滿 1，然後再排空，於是 $n$ 顆正反器給出 $2n$ 個狀態而不是 $n$ 個。它的輸出一次仍然只變動一個位元，所以解碼仍然無毛刺，而且一個 Johnson 狀態可以用兩輸入閘解碼，不像二進位計數器需要 $n$ 輸入閘。投影片的編碼表列出了 8 位元 16 狀態的 Johnson 序列。代價是同樣缺乏自我修正，以及同樣糟糕的「每顆正反器能表示幾個狀態」效率。ジョンソン（ツイストリング、メビウス）カウンタは最上位ビットの補数を帰還させる：count <= {count[6:0], ~count[7]}。全ゼロから始めると下位から 1 で埋まり、やがてまた空になるので、$n$ 個のフリップフロップから $n$ ではなく $2n$ 個の状態が得られる。出力は依然として一度に 1 ビットしか変化しないのでデコードはグリッチフリーのままで、しかもジョンソン状態は、二進カウンタが $n$ 入力ゲートを要するところを 2 入力ゲートでデコードできる。スライドの符号化表は 8 ビットで 16 状態のジョンソン系列を示している。代償は、同じく自己修正がないことと、同じくフリップフロップあたりの状態数の効率が悪いことである。

6. Pipelining a 16-bit Adder6. 16 位元加法器的管線化6. 16 ビット加算器のパイプライン化

Pipelining is the one architectural transformation in this lecture. Everything else maps a description onto hardware; pipelining changes the hardware deliberately, trading a resource you have (latency, registers) for one you want (clock frequency, throughput). The slide's vehicle is a 16-bit adder, which is small enough to analyse completely.管線化是本講中唯一一項架構層次的變換。其他所有東西都是把描述對映到硬體；管線化則是刻意改變硬體，拿你手上有的資源（延遲、暫存器）去換你想要的資源（時脈頻率、吞吐量）。投影片的載具是一個 16 位元加法器，小到足以被完整分析。パイプライン化は本講で唯一のアーキテクチャ変換である。他はすべて記述をハードウェアへ写すだけだが、パイプライン化はハードウェアそのものを意図的に変え、手持ちの資源（レイテンシ、レジスタ）を欲しい資源（クロック周波数、スループット）と交換する。スライドの題材は 16 ビット加算器で、完全に解析できるほど小さい。

6.1 The flat 16-bit adder6.1 平坦的 16 位元加法器6.1 フラットな 16 ビット加算器

The starting point is two 8-bit adders chained through the carry: the low adder takes a[7:0], b[7:0] and c_in and produces sum[7:0] plus a carry; that carry feeds the high adder's c_in, which produces sum[15:8] and c_out.起點是兩個 8 位元加法器以進位串接：低位加法器吃 a[7:0]、b[7:0] 與 c_in，產生 sum[7:0] 外加一個進位；那個進位餵給高位加法器的 c_in，產生 sum[15:8] 與 c_out。出発点は、キャリーで連結した二つの 8 ビット加算器である。下位の加算器は a[7:0]、b[7:0]、c_in を取り、sum[7:0] とキャリーを出す。そのキャリーが上位加算器の c_in に入り、sum[15:8] と c_out を生む。

The critical path is the carry. In a ripple-carry structure the carry has to walk from bit 0 to bit 15 before sum[15] is final, so the delay is roughly proportional to the word length. Writing the two 8-bit blocks as separate modules does not change that; it just makes the chain visible. With the setup equation from Section 3.3,關鍵路徑是進位。在漣波進位結構裡，進位必須從位元 0 一路走到位元 15，sum[15] 才算定案，所以延遲大致與字長成正比。把兩個 8 位元區塊寫成分開的模組並不會改變這件事；那只是讓鏈變得看得見而已。套用 3.3 節的 setup 方程式，クリティカルパスはキャリーである。リプルキャリー構造では、キャリーがビット 0 からビット 15 まで歩き切らないと sum[15] は確定しないので、遅延はおおむね語長に比例する。二つの 8 ビットブロックを別々のモジュールとして書いてもそれは変わらない。連鎖が目に見えるようになるだけだ。3.3 節のセットアップ式を当てはめると、

Take plausible numbers: $t_{cq} = 150$ ps, $t_{su} = 80$ ps, and an 8-bit carry chain $t_{\text{add8}} = 2.0$ ns. Then $T_{\text{flat}} = 0.15 + 4.0 + 0.08 = 4.23$ ns, a maximum frequency of about 236 MHz. If the specification says 400 MHz, the adder is the problem and something has to change.代入合理的數字：$t_{cq} = 150$ ps、$t_{su} = 80$ ps，8 位元進位鏈 $t_{\text{add8}} = 2.0$ ns。那麼 $T_{\text{flat}} = 0.15 + 4.0 + 0.08 = 4.23$ ns，最高頻率約 236 MHz。如果規格要求 400 MHz，加法器就是問題所在，必須有所改變。もっともらしい数値を入れてみる。$t_{cq} = 150$ ps、$t_{su} = 80$ ps、8 ビットのキャリーチェーンは $t_{\text{add8}} = 2.0$ ns。すると $T_{\text{flat}} = 0.15 + 4.0 + 0.08 = 4.23$ ns、最高周波数は約 236 MHz。仕様が 400 MHz を要求するなら、問題は加算器であり、何かを変えねばならない。

6.2 Cutting the critical path6.2 切開關鍵路徑6.2 クリティカルパスを切る

There are two ways to make a long combinational path fit in a shorter period. You can make the logic faster — replace ripple carry with carry-lookahead, carry-select or a parallel-prefix adder, which turns the $O(n)$ delay into $O(\log n)$ at the cost of area. Or you can cut the path with a register and accept that the answer now takes two cycles to come out. Pipelining is the second option, and its great virtue is that it works on any long path, not just on paths with a known fast algorithm.要讓一條長的組合路徑塞進較短的週期，有兩條路。你可以把邏輯變快——用超前進位、進位選擇或平行前綴加法器取代漣波進位，把 $O(n)$ 的延遲變成 $O(\log n)$，代價是面積。或者你可以用暫存器把路徑切開，接受答案現在要兩個週期才出得來。管線化是第二條路，它最大的優點是：它對任何長路徑都有效，不只是對那些已知有快速演算法的路徑。長い組合せ経路を短い周期に収める方法は二つある。論理を速くする——リプルキャリーをキャリールックアヘッド、キャリーセレクト、あるいは並列プレフィックス加算器に置き換え、$O(n)$ の遅延を面積と引き換えに $O(\log n)$ にする。もう一つは、レジスタで経路を切り、答えが出るのに 2 サイクルかかることを受け入れる。パイプライン化は後者であり、その大きな美点はどんな長い経路にも効くこと、速いアルゴリズムが知られている経路に限らないことである。

The slide's pipeline has three register banks:投影片的管線有三排暫存器：スライドのパイプラインにはレジスタ段が三つある。

• IR, the input register, 33 bits: it captures c_in and all four bytes of a and b.IR，輸入暫存器，33 位元：它捕捉 c_in 以及 a 和 b 的全部四個位元組。IR、入力レジスタ、33 ビット：c_in と、a と b の 4 バイトすべてを取り込む。
• PR, the pipeline register, 25 bits: it holds the finished low-byte result (8 sum bits plus the carry out of the low byte) and the two high bytes, which have simply been waiting.PR，管線暫存器，25 位元：它保存已經算完的低位元組結果（8 個和位元加上低位元組的進位輸出），以及一直在等待的那兩個高位元組。PR、パイプラインレジスタ、25 ビット：完成した下位バイトの結果（和 8 ビットと下位バイトからのキャリー）と、ただ待っていた上位 2 バイトを保持する。
• OR, the output register, 17 bits: the final {c_out, sum[15:0]}.OR，輸出暫存器，17 位元：最終的 {c_out, sum[15:0]}。OR、出力レジスタ、17 ビット：最終的な {c_out, sum[15:0]}。

Between IR and PR sits one 8-bit adder doing the low byte. Between PR and OR sits a second 8-bit adder doing the high byte with the stored carry. No single combinational path now contains more than one 8-bit carry chain, soIR 與 PR 之間坐著一個做低位元組的 8 位元加法器。PR 與 OR 之間坐著第二個 8 位元加法器，拿儲存起來的進位去做高位元組。現在沒有任何單一組合路徑包含超過一條 8 位元進位鏈，所以IR と PR のあいだには下位バイトを処理する 8 ビット加算器が、PR と OR のあいだには保存されたキャリーを使って上位バイトを処理する二つ目の 8 ビット加算器が座っている。これで単一の組合せ経路に 8 ビットのキャリーチェーンが二本入ることはなくなり、

The key structural idea — and the thing students most often get wrong when asked to pipeline something — is that data which is not used in stage 1 must still be registered through stage 1. The high bytes of a and b are not needed until stage 2, but they cannot simply be taken from the module inputs at stage 2, because by then the inputs have moved on to the next operand pair. They have to travel down the pipeline alongside the data that is being worked on. That is what PR[L3:R3] <= IR[L4:R4] and PR[L2:R2] <= IR[L3:R3] are doing: pure delay, no logic. Forget them and the adder computes the low byte of one operand pair with the high byte of another.關鍵的結構性想法——也是學生被要求把東西管線化時最常弄錯的一點——是：在第 1 級用不到的資料，仍然必須被暫存著穿過第 1 級。a 與 b 的高位元組要到第 2 級才用得到，但你不能在第 2 級直接從模組輸入去拿，因為到那時候輸入已經換成下一對運算元了。它們必須跟著正在被處理的資料一起沿管線往下走。這就是 PR[L3:R3] <= IR[L4:R4] 與 PR[L2:R2] <= IR[L3:R3] 在做的事：純延遲、沒有邏輯。忘了它們，加法器就會拿某一對運算元的低位元組去配另一對的高位元組。肝心な構造上の考え——そしてパイプライン化を課されたときに学生がもっとも間違える点——は、第 1 段で使わないデータも第 1 段をレジスタで通さねばならないことである。a と b の上位バイトは第 2 段まで不要だが、第 2 段でモジュール入力からそのまま取ることはできない。そのときには入力が次のオペランド対に移っているからだ。処理中のデータと並んでパイプラインを下っていく必要がある。PR[L3:R3] <= IR[L4:R4] と PR[L2:R2] <= IR[L3:R3] がしているのはそれだ。純粋な遅延であり、論理はない。これを忘れると、加算器はあるオペランド対の下位バイトを別の対の上位バイトと組み合わせて計算する。

6.3 The Verilog, decoded6.3 逐行拆解 Verilog6.3 Verilog を読み解く

The slide's code uses a wall of parameter declarations to name the bit ranges. That is good practice — change size and the whole thing re-sizes — but it makes the code hard to read until you substitute the numbers. Here it is with every parameter evaluated for size = 16.投影片的程式碼用一整面牆的 parameter 宣告去命名位元範圍。那是好習慣——改 size 整個東西就跟著改大小——但在你把數字代進去之前，程式碼很難讀。這裡是把每個參數都以 size = 16 算出來的版本。スライドのコードはビット範囲に名前を付けるために parameter 宣言の壁を使っている。よい習慣だ——size を変えれば全体がリサイズされる——が、数値を代入するまではコードが読みにくい。ここでは size = 16 として全パラメータを展開した版を示す。

module add_16_pipe (c_out, sum, a, b, c_in, clock);
  parameter size   = 16;
  parameter half   = size / 2;        // 8
  parameter double = 2 * size;        // 32
  parameter triple = 3 * half;        // 24
  parameter size1  = half - 1;        // 7   -- top of a half word
  parameter size2  = size - 1;        // 15  -- top of a full word
  parameter size3  = half + 1;        // 9
  parameter R1 = 1;                   // 1   IR field: a[7:0]  = IR[8:1]
  parameter L1 = half;                // 8
  parameter R2 = size3;               // 9   IR field: b[7:0]  = IR[16:9]
  parameter L2 = size;                // 16
  parameter R3 = size + 1;            // 17  IR field: a[15:8] = IR[24:17]
  parameter L3 = size + half;         // 24
  parameter R4 = double - half + 1;   // 25  IR field: b[15:8] = IR[32:25]
  parameter L4 = double;              // 32

  input  [size2:0]  a, b;             // [15:0]
  input             c_in, clock;
  output [size2:0]  sum;              // [15:0]
  output            c_out;
  reg    [double:0] IR;               // [32:0]  = 1 + 8 + 8 + 8 + 8
  reg    [triple:0] PR;               // [24:0]  = 9 + 8 + 8
  reg    [size:0]   OR;               // [16:0]  = 1 + 16

  assign {c_out, sum} = OR;

  always @ (posedge clock) begin
    // ---- stage 0: load the input register -------------------
    IR[0]     <= c_in;                // IR[0]     = c_in
    IR[L1:R1] <= a[size1:0];          // IR[8:1]   = a[7:0]
    IR[L2:R2] <= b[size1:0];          // IR[16:9]  = b[7:0]
    IR[L3:R3] <= a[size2:half];       // IR[24:17] = a[15:8]
    IR[L4:R4] <= b[size2:half];       // IR[32:25] = b[15:8]

    // ---- stage 1: low byte adds, high bytes just wait -------
    PR[L3:R3]  <= IR[L4:R4];          // PR[24:17] = b[15:8], delayed
    PR[L2:R2]  <= IR[L3:R3];          // PR[16:9]  = a[15:8], delayed
    PR[half:0] <= IR[L2:R2] + IR[L1:R1] + IR[0];
                                      // PR[8:0] = b[7:0] + a[7:0] + c_in
                                      // 9 bits: PR[8] is the carry, PR[7:0] the sum

    // ---- stage 2: high byte adds with the stored carry ------
    OR <= {{1'b0, PR[L3:R3]} + {1'b0, PR[L2:R2]} + PR[half], PR[size1:0]};
  end
endmodule

The bit-field map is the part worth memorising, because once you see it the code is obvious:值得背下來的是這張位元欄位對照表，因為一旦你看懂它，程式碼就一目了然：暗記する価値があるのはこのビットフィールド対応表である。これが見えればコードは自明になる。

Total register cost: $33 + 25 + 17 = 75$ flip-flops, where the flat version needed only the 17 output bits. That is the price of the pipeline, and it is a big relative increase for something as small as an adder. For a wide multiplier or an FFT butterfly, where the logic dwarfs the registers, the ratio is much more favourable — which is why pipelining is ubiquitous in communication datapaths and rare in small control logic.暫存器總成本：$33 + 25 + 17 = 75$ 顆正反器，而平坦版本只需要那 17 個輸出位元。這就是管線的代價，對加法器這麼小的東西來說，相對增幅非常大。對一個寬乘法器或一個 FFT 蝶形運算來說，邏輯遠遠大過暫存器，比例就好看得多——這就是為什麼管線化在通訊資料路徑中無所不在，在小型控制邏輯中卻很罕見。レジスタの総コストは $33 + 25 + 17 = 75$ 個のフリップフロップで、フラット版は出力の 17 ビットだけで済んでいた。これがパイプラインの代価であり、加算器のように小さな回路では相対的な増加が非常に大きい。幅の広い乗算器や FFT バタフライのように論理がレジスタを圧倒する回路なら比率ははるかに有利になる——パイプライン化が通信データパスで遍在し、小さな制御論理ではまれである理由だ。

6.4 The two 1'b0 constants — the slide is wrong6.4 那兩個 1'b0 常數 — 投影片錯了6.4 二つの 1'b0 定数 — スライドは間違っている

The slide carries a handwritten annotation pointing at the two {1'b0, ...} concatenations in the last line, reading “Both 1'b0 should be removed.” Follow that instruction and the adder stops producing a carry out. Here is why, and the rule involved is one of the most frequently examined corners of Verilog.投影片上有一條手寫註記指著最後一行裡那兩個 {1'b0, ...} 串接，寫著「Both 1'b0 should be removed.」。照著那條指示做，加法器就不再產生進位輸出了。以下是原因，而牽涉到的那條規則是 Verilog 最常被考的角落之一。スライドには最終行の二つの {1'b0, ...} 連結を指して「Both 1'b0 should be removed.」という手書きの注記がある。その指示に従うと、加算器はキャリー出力を出さなくなる。以下がその理由であり、関わる規則は Verilog でもっとも頻繁に試験に出る隅の一つである。

Apply that here. PR[L3:R3] is PR[24:17], eight bits. PR[L2:R2] is PR[16:9], eight bits. PR[half] is PR[8], one bit.把這套規則用在這裡。PR[L3:R3] 是 PR[24:17]，八位元。PR[L2:R2] 是 PR[16:9]，八位元。PR[half] 是 PR[8]，一位元。これをここに当てはめる。PR[L3:R3] は PR[24:17] で 8 ビット。PR[L2:R2] は PR[16:9] で 8 ビット。PR[half] は PR[8] で 1 ビットである。

As written, with the zero extensions: {1'b0, PR[24:17]} is nine bits and so is {1'b0, PR[16:9]}. The widest operand of the addition is nine bits, so the whole sum is evaluated at nine bits. The largest possible value is $0\text{-}11111111 + 0\text{-}11111111 + 1 = 255 + 255 + 1 = 511$, which is exactly $2^9 - 1$ — it fits in nine bits with nothing lost. Concatenated with the eight bits of PR[7:0], that gives a 17-bit value, which is precisely the width of OR. Bit 16 is the carry out. Correct.照原樣寫、含零延展時：{1'b0, PR[24:17]} 是九位元，{1'b0, PR[16:9]} 也是。加法中最寬的運算元是九位元，所以整個和都以九位元計算。可能的最大值是 $0\text{-}11111111 + 0\text{-}11111111 + 1 = 255 + 255 + 1 = 511$，恰好是 $2^9 - 1$——九位元剛好裝得下，什麼都沒掉。再與 PR[7:0] 的八位元串接，就得到一個 17 位元的值，正是 OR 的寬度。位元 16 就是進位輸出。正確。そのまま、ゼロ拡張ありの場合：{1'b0, PR[24:17]} は 9 ビット、{1'b0, PR[16:9]} も 9 ビットである。加算のもっとも広いオペランドは 9 ビットなので、和全体が 9 ビットで評価される。最大値は $0\text{-}11111111 + 0\text{-}11111111 + 1 = 255 + 255 + 1 = 511$ で、ちょうど $2^9 - 1$——9 ビットに収まり、失われるものはない。これを PR[7:0] の 8 ビットと連結すれば 17 ビット値になり、まさに OR の幅である。ビット 16 がキャリー出力だ。正しい。

With the zero extensions removed: the widest operand is eight bits, so the addition is evaluated at eight bits and the carry out of bit 7 is simply discarded. The concatenation is now $8 + 8 = 16$ bits, assigned to a 17-bit register, so it is zero-extended on the left and OR[16] — that is, c_out — is permanently 0. A 16-bit adder that can never report an overflow. Wrong.把零延展拿掉時：最寬的運算元是八位元，所以加法以八位元計算，位元 7 的進位輸出直接被丟掉。串接現在是 $8 + 8 = 16$ 位元，被指派給一個 17 位元的暫存器，於是左邊補零，OR[16]——也就是 c_out——永遠是 0。一個永遠無法回報溢位的 16 位元加法器。錯誤。ゼロ拡張を取り除いた場合：もっとも広いオペランドは 8 ビットなので加算は 8 ビットで評価され、ビット 7 のキャリー出力はそのまま捨てられる。連結はいまや $8 + 8 = 16$ ビットで、17 ビットのレジスタに代入されるため左側はゼロ拡張され、OR[16]——すなわち c_out——は永久に 0 になる。オーバーフローを決して報告できない 16 ビット加算器である。誤り。

The cleanest repair, if you dislike relying on a subtle width rule, is to split the assignment so that the context does the work:如果你不喜歡依賴一條微妙的寬度規則，最乾淨的修法是把指派拆開，讓上下文去做這件事：微妙な幅の規則に頼るのが嫌なら、もっともきれいな対処は代入を分割して文脈に仕事をさせることである。

OR <= {{1'b0, PR[L3:R3]}
     +  {1'b0, PR[L2:R2]}
     +  PR[half], PR[size1:0]};

OR[size:half] <= PR[L3:R3]
               + PR[L2:R2]
               + PR[half];       // 9-bit target
OR[size1:0]   <= PR[size1:0];    // 8-bit target

Both synthesise to the same hardware. The right-hand version cannot be misread, which is worth more than the one saved line.兩者合成出來的硬體相同。右邊那個版本不可能被誤讀，而那比省下來的那一行更有價值。どちらも同じハードウェアに合成される。右の版は誤読のしようがなく、その価値は節約できる 1 行よりも大きい。

6.5 Latency, throughput and the limit of pipelining6.5 延遲、吞吐量與管線化的極限6.5 レイテンシ、スループット、パイプライン化の限界

Two numbers describe a pipeline and they move in opposite directions.有兩個數字描述一條管線，而它們往相反方向移動。パイプラインを記述する数は二つあり、両者は逆方向に動く。

For the slide's adder, $N_{\text{stages}} = 3$ (IR, PR, OR) and $T_{\text{pipe}} = 2.23$ ns, so latency is 6.69 ns while the flat adder's latency was 4.23 ns. Read that again: pipelining made each individual answer arrive later in absolute time. What it bought is that a new answer arrives every 2.23 ns instead of every 4.23 ns, so the sustained rate nearly doubled. For a communication datapath processing a continuous sample stream, that is exactly the trade you want. For a latency-critical control loop, it is exactly the trade you do not want.對投影片的加法器而言，$N_{\text{stages}} = 3$（IR、PR、OR）而 $T_{\text{pipe}} = 2.23$ ns，所以延遲是 6.69 ns，而平坦加法器的延遲只有 4.23 ns。再讀一次：管線化讓每一個個別的答案在絕對時間上更晚抵達。它買到的是：新答案每 2.23 ns 就來一個，而不是每 4.23 ns，所以持續速率幾乎翻倍。對一條處理連續取樣串流的通訊資料路徑來說，那正是你要的交換。對一個延遲吃緊的控制迴路來說，那正是你不要的交換。スライドの加算器では $N_{\text{stages}} = 3$（IR、PR、OR）、$T_{\text{pipe}} = 2.23$ ns なのでレイテンシは 6.69 ns、一方フラット加算器のレイテンシは 4.23 ns だった。もう一度読んでほしい。パイプライン化は個々の答えの到着を絶対時間では遅くした。得たのは、新しい答えが 4.23 ns ごとではなく 2.23 ns ごとに届くこと、つまり持続レートがほぼ倍になったことだ。連続サンプル列を処理する通信データパスにはまさに望ましい取引であり、レイテンシが致命的な制御ループにはまさに望ましくない取引である。

The speed-up from splitting one stage into $k$ equal stages is把一級切成 $k$ 個相等的級，加速比是1 段を $k$ 個の等しい段に分けたときの高速化率は

The register overhead $t_{cq} + t_{su}$ never goes away, so the speed-up saturates. With the numbers above, $t_{cq} + t_{su} = 230$ ps and $t_{\text{logic}} = 4.0$ ns, so the ceiling is $4.23/0.23 \approx 18.4\times$ — but you would need infinitely many stages to get there. Two stages give $4.23/2.23 = 1.90\times$; four stages give $4.23/1.23 = 3.44\times$; eight give $4.23/0.73 = 5.79\times$. Each doubling of stages buys less than the previous one, while the register area and the latency grow linearly. Real designs stop when the stage delay is somewhere around three to five times the register overhead, because past that point you are paying a full register bank for a few per cent of frequency.暫存器的開銷 $t_{cq} + t_{su}$ 永遠不會消失，所以加速比會飽和。用上面的數字，$t_{cq} + t_{su} = 230$ ps 而 $t_{\text{logic}} = 4.0$ ns，所以天花板是 $4.23/0.23 \approx 18.4\times$——但你需要無限多級才到得了。兩級給 $4.23/2.23 = 1.90\times$；四級給 $4.23/1.23 = 3.44\times$；八級給 $4.23/0.73 = 5.79\times$。級數每加倍一次，買到的都比前一次少，而暫存器面積與延遲卻線性成長。真實設計會在級延遲大約是暫存器開銷的三到五倍時停手，因為過了那一點，你是在用一整排暫存器換百分之幾的頻率。レジスタのオーバーヘッド $t_{cq} + t_{su}$ は決して消えないので、高速化率は飽和する。上の数値では $t_{cq} + t_{su} = 230$ ps、$t_{\text{logic}} = 4.0$ ns なので上限は $4.23/0.23 \approx 18.4\times$——だがそこへ達するには無限段が要る。2 段で $4.23/2.23 = 1.90\times$、4 段で $4.23/1.23 = 3.44\times$、8 段で $4.23/0.73 = 5.79\times$。段数を倍にするたび得られるものは前回より小さくなり、レジスタ面積とレイテンシは線形に増える。実際の設計は、段遅延がレジスタ・オーバーヘッドの 3〜5 倍あたりになったところで手を止める。それを越えると、数パーセントの周波数のためにレジスタ 1 段ぶんを丸ごと払うことになるからだ。

Two further realities temper the formula. First, you can rarely split a cloud into exactly equal parts; the clock period is set by the longest stage, so an unbalanced split wastes the slack in the short stages. Second, pipelining a feedback loop is not possible without changing the algorithm — an accumulator cannot simply be cut in half, because the next result depends on the current one. Techniques like carry-save accumulation or loop unrolling exist for exactly that reason, and they belong to Lecture 8's design examples.還有兩個現實因素會調和這個公式。第一，你很少能把一團邏輯雲切成完全相等的幾份；時脈週期由最長的那一級決定，所以不均勻的切法會浪費掉短級裡的餘裕。第二，不改演算法就無法把回授迴路管線化——累加器不能直接對半切，因為下一個結果取決於當前這一個。進位保留累加、迴圈展開之類的技巧正是為此而存在，而它們屬於第 8 講的設計範例。この式を和らげる現実がさらに二つある。第一に、論理の雲をきっかり等分できることはまれだ。クロック周期は最長の段で決まるので、不均等な分割は短い段のスラックを捨てることになる。第二に、アルゴリズムを変えずにフィードバックループをパイプライン化することはできない。アキュムレータは単純に半分に切れない。次の結果が今の結果に依存するからだ。キャリーセーブ加算やループ展開といった技法はまさにそのために存在し、それらは第 8 講の設計例に属する。

7. Finite State Machines: Mealy and Moore End to End7. 有限狀態機：Mealy 與 Moore 完整走一遍7. 有限状態機械：ミーリとムーアを端から端まで

A finite state machine is the general form of everything in this lecture. A shift register is an FSM whose state graph is a line; a ring counter is an FSM whose graph is a cycle; a pipeline is an FSM whose state is the data in flight. What makes the general case worth a section of its own is that the designer, rather than the structure, chooses the state graph — and that two different but equally valid choices of where to put the output produce circuits with measurably different behaviour.有限狀態機是本講中所有東西的一般形式。移位暫存器是狀態圖為一條線的 FSM；環形計數器是狀態圖為一個環的 FSM；管線是以「在途資料」為狀態的 FSM。一般情形之所以值得獨立成節，是因為狀態圖是由設計者而不是由結構決定的——而「把輸出放在哪裡」這兩種不同但同樣有效的選擇，會產生行為上可量測地不同的電路。有限状態機械は、本講のすべてを包含する一般形である。シフトレジスタは状態グラフが一直線の FSM、リングカウンタは状態グラフが巡回の FSM、パイプラインは飛行中のデータを状態とする FSM である。一般の場合が独立した節に値するのは、状態グラフを構造ではなく設計者が選ぶからであり、そして「出力をどこに置くか」という異なるが等しく妥当な二つの選択が、測定可能なほど振る舞いの異なる回路を生むからである。

7.1 Modelling guidelines and where they come from7.1 建模準則，以及它們從哪裡來7.1 モデリングの指針と、その出どころ

The slide gives one requirement, a list of options and three recommendations. Taken in order:投影片給了一條要求、一份選項清單和三條建議。依序來看：スライドは要求を一つ、選択肢の一覧、そして推奨を三つ挙げている。順に見ていこう。

Make sure the description is complete. Complete means: every state in the enumeration appears in the case; every state assigns next_state for every value of every input; and there is a default. The hardware reason is the one from Lecture 5. The next-state block is combinational, so any path through it that does not assign next_state means “hold”, which means a latch. A latch in the next-state path of an FSM is not merely wasteful — it creates a transparent window during which the next-state value can follow the inputs, so the state register can capture something that was never a legal next state.確保描述是完整的。完整的意思是：列舉中的每一個狀態都出現在 case 裡；每一個狀態對每一個輸入的每一種值都指派 next_state；而且有 default。硬體上的理由就是第 5 講那一條。次態區塊是組合的，所以任何一條沒有指派 next_state 的路徑都意味著「保持」，也就意味著閂鎖。FSM 次態路徑上的閂鎖不只是浪費——它製造出一個透通窗口，在那段期間次態值可以跟著輸入跑，於是狀態暫存器可能捕捉到一個從來不是合法次態的值。記述が完全であることを確かめる。完全とは、列挙したすべての状態が case に現れ、各状態がすべての入力のすべての値に対して next_state を代入し、かつ default があることをいう。ハードウェア上の理由は第 5 講と同じだ。次状態ブロックは組合せなので、そこを通るどの経路でも next_state を代入しなければ「保持」を意味し、それはラッチを意味する。FSM の次状態経路にあるラッチは単に無駄なだけではない。次状態の値が入力に追従できる透過窓を作り、その結果、状態レジスタが合法な次状態ではなかった値を取り込みうる。

Possible modelling options. The slide lists continuous assignments, a behaviour whose event control is an event-or of the state and the inputs, functions, and an external module. These are four ways of expressing the same combinational function, and the choice is one of taste except for one thing: whatever you choose, its sensitivity must be complete. A continuous assignment and a function call inside an always @* are automatically complete. A hand-written sensitivity list, always @(state_reg or in_bit), is complete only as long as nobody adds an input and forgets to update it — which is why always @* (Verilog-2001) exists and why you should use it.可能的建模選項。投影片列出了連續指派、事件控制為「狀態與輸入的 event-or」的行為、函式，以及外部模組。這四種是表達同一個組合函數的四種方式，選哪一種是品味問題，只有一件事例外：不論你選哪一種，它的敏感性都必須完整。連續指派與放在 always @* 裡的函式呼叫自動就是完整的。手寫的感應列 always @(state_reg or in_bit) 只有在沒人新增輸入卻忘了更新它的前提下才完整——這就是 always @*（Verilog-2001）存在的原因，也是你應該用它的原因。とりうるモデリングの選択肢。スライドは連続代入、状態と入力の event-or をイベント制御とするビヘイビア、関数、外部モジュールを挙げる。これらは同一の組合せ関数を表す四つの書き方であり、どれを選ぶかは好みの問題だ。ただし一点だけ例外がある。何を選ぶにせよ、その感度は完全でなければならない。連続代入と always @* 内の関数呼び出しは自動的に完全である。手書きの感度リスト always @(state_reg or in_bit) が完全なのは、誰も入力を追加して更新を忘れないあいだだけだ——always @*（Verilog-2001）が存在する理由であり、それを使うべき理由でもある。

Use separate behaviours for the state register and the next-state logic. This is the two-block template. The reason is that the two pieces are different kinds of hardware with different templates: one is edge-sensitive and becomes flip-flops, the other is level-sensitive and becomes gates. Writing them together forces the tool to disentangle them and forces you to reason about blocking versus non-blocking in the same breath as about state transitions. Separating them makes each block match exactly one template.狀態暫存器與次態邏輯請用分開的行為。這就是兩區塊樣板。理由是這兩塊是種類不同的硬體，對應不同的樣板：一個是邊緣敏感、會變成正反器，另一個是位準敏感、會變成閘。把它們寫在一起，會逼工具去把它們拆開，也逼你在思考狀態轉移的同時還要思考阻斷與非阻斷。分開寫，每個區塊就剛好對應一個樣板。状態レジスタと次状態論理は別々のビヘイビアに分ける。これが二ブロック・テンプレートである。理由は、この二つが異なる種類のハードウェアであり、対応するテンプレートも違うからだ。片方はエッジ感応でフリップフロップになり、もう片方はレベル感応でゲートになる。一緒に書けばツールに両者をほどく手間をかけさせ、あなたには状態遷移を考えるのと同じ息でブロッキングか否かを考えさせることになる。分ければ各ブロックがちょうど一つのテンプレートに一致する。

Use non-blocking assignments for the state register, because they are order-independent (Section 1.3), and never mix blocking and non-blocking assignments to the same variable in the same behaviour. That last rule is not a style preference: the IEEE standard leaves the result unspecified, different simulators resolve it differently, and synthesis tools generally refuse.狀態暫存器請用非阻斷式指派，因為它們與順序無關（1.3 節），而且絕不要在同一個行為裡對同一個變數混用阻斷式與非阻斷式指派。最後那條不是風格偏好：IEEE 標準把結果定為未規定，不同模擬器的解法不同，而合成工具通常會直接拒絕。状態レジスタにはノンブロッキング代入を使う。順序に依存しないからだ（1.3 節）。そして同一ビヘイビア内で同じ変数にブロッキングとノンブロッキングを混ぜてはならない。最後の規則は文体の好みではない。IEEE 標準は結果を未規定とし、シミュレータごとに解決が異なり、合成ツールはたいてい拒否する。

7.2 The sequence detector7.2 序列偵測器7.2 シーケンス検出器

The specification on the slide:投影片上的規格：スライドにある仕様：

• Synchronously read a serial bit stream.同步讀取一串序列位元流。シリアルなビット列を同期的に読み込む。
• Assert the output after two successive 0s or two successive 1s have been detected.偵測到連續兩個 0 或連續兩個 1 之後確立輸出。連続する二つの 0 または連続する二つの 1 を検出したら出力をアサートする。
• Active on the rising edge of the clock.在時脈上升緣作用。クロックの立ち上がりエッジで動作する。
• The testbench changes the input stream on the falling edge, so that it is stable and settled at every rising edge.測試平台在下降緣改變輸入串流，使它在每個上升緣都已穩定安定。テストベンチは立ち下がりエッジで入力列を変化させ、すべての立ち上がりエッジで安定しているようにする。

That last point deserves a moment. Changing stimulus on the opposite edge from the one the design uses is the standard way to write a testbench for a synchronous design, and Lecture 2 makes the same point. It gives the design half a clock period of setup margin and half a period of hold margin in simulation, so you never have to reason about race conditions between the testbench and the device under test. It also means that in any waveform you look at, the value of in_bit during a clock period is exactly the value that will be sampled at the end of that period.最後這一點值得停一下。在與設計所使用的邊緣相反的那個邊緣上改變激勵，是為同步設計撰寫測試平台的標準做法，第 2 講也講了同一件事。它在模擬中給了設計半個時脈週期的 setup 餘裕和半個週期的 hold 餘裕，所以你永遠不必去推敲測試平台與待測裝置之間的競爭條件。它也意味著：在你看的任何波形裡，某個時脈週期內 in_bit 的值，正好就是那個週期結束時會被取樣到的值。最後の点は少し立ち止まる価値がある。設計が使うのとは反対のエッジで刺激を変えるのは、同期設計のテストベンチを書く標準的なやり方で、第 2 講も同じことを述べている。シミュレーション上、設計にクロック半周期ぶんのセットアップ余裕とホールド余裕を与えるので、テストベンチと被試験回路のあいだの競合条件を考えなくて済む。また、どの波形を見ても、あるクロック周期中の in_bit の値が、その周期の終わりにサンプルされる値そのものだということも意味する。

Now the two machine types:接著是兩種機器類型：続いて二つの機械の型：

7.3 The state table7.3 狀態表7.3 状態表

Before any Verilog, derive the states. The machine has to remember enough of the past to decide whether the next bit completes a pair. “Enough of the past” is: what was the last bit, and have I already seen a run of two? That gives five states:在寫任何 Verilog 之前，先導出狀態。這台機器必須記住足夠多的過去，才能判斷下一個位元是否湊成一對。「足夠多的過去」就是：上一個位元是什麼，以及我是不是已經看到一段長度二的連續。這給出五個狀態：Verilog を書く前に、まず状態を導く。この機械は、次のビットが対を完成させるかどうかを判断できるだけの過去を覚えていなければならない。「十分な過去」とは、直前のビットが何だったか、そしてすでに長さ 2 の連続を見たかどうかである。これで五つの状態が得られる。

A common first attempt uses only four states, dropping start_state and resetting into read_1_zero. That is wrong in a detectable way: after reset the machine would behave as though it had already seen a 0, so a single 0 as the very first bit would be reported as a pair. The fifth state exists precisely to encode “I have no history yet”.常見的第一次嘗試只用四個狀態，去掉 start_state 而把重置落在 read_1_zero。那是以一種可偵測的方式出錯：重置後機器的行為會像是它已經看過一個 0，於是最前面那一個單獨的 0 就會被報成一對。第五個狀態存在的目的，正是為了編碼「我還沒有任何歷史」。よくある最初の試みは状態を四つだけにし、start_state を省いて read_1_zero にリセットするというものだ。これは検出可能な形で誤っている。リセット後、機械はすでに 0 を一つ見たかのように振る舞うので、先頭の単独の 0 が対として報告されてしまう。五つ目の状態は、まさに「まだ履歴がない」を符号化するために存在する。

Note also that read_2_zero means “two or more”, not “exactly two”. Its self-loop on input 0 keeps asserting the output, so a run of five zeros produces four consecutive assertions. That is the specification the slides implement; if you wanted “exactly two, then stop”, the self-loop would go to a sixth state with output 0.另外注意 read_2_zero 的意思是「兩個或更多」，不是「剛好兩個」。它在輸入 0 上的自迴圈會持續確立輸出，所以連續五個零會產生四次連續的確立。這就是投影片所實作的規格；如果你要的是「剛好兩個然後停」，那個自迴圈就該指向第六個輸出為 0 的狀態。また read_2_zero が意味するのは「2 個以上」であって「ちょうど 2 個」ではない点に注意。入力 0 での自己ループが出力をアサートし続けるので、0 が 5 個続けば 4 回連続でアサートされる。これがスライドの実装する仕様である。「ちょうど 2 個で止める」が欲しければ、その自己ループは出力 0 の六つ目の状態へ向かうべきだ。

The complete transition table. The next-state column is identical for Mealy and Moore — the machines differ only in the output column.完整的轉移表。次態那一欄對 Mealy 與 Moore 是相同的——兩台機器只在輸出欄上有差別。完全な遷移表。次状態の列はミーリとムーアで同一である——二つの機械が異なるのは出力の列だけだ。

Read the last two columns carefully. They contain the same pattern of ones, but they refer to different instants: the Mealy column says “during the clock period in which this row's input is presented”, while the Moore column says “during the clock period after that input has been absorbed”. That one-period shift is the entire difference between the two machines, and Section 7.6 draws it.請仔細讀最後兩欄。它們含有相同的 1 的圖樣，但指的是不同的時刻：Mealy 那一欄說的是「在這一列的輸入被送進來的那個時脈週期內」，而 Moore 那一欄說的是「在那個輸入被吸收之後的那個時脈週期內」。那一個週期的位移就是兩台機器全部的差別，而 7.6 節會把它畫出來。最後の二列は注意深く読んでほしい。1 の並びは同じだが、指している瞬間が違う。ミーリの列は「この行の入力が与えられているクロック周期のあいだ」を、ムーアの列は「その入力が取り込まれた後のクロック周期のあいだ」を言っている。この 1 周期のずれが二つの機械の差のすべてであり、7.6 節でそれを図にする。

7.4 The Mealy machine in Verilog7.4 Verilog 中的 Mealy 機7.4 Verilog によるミーリ機械

module seq_det_mealy_1exp (clock, reset, in_bit, out_bit);
  input       clock, reset, in_bit;
  output      out_bit;
  reg   [2:0] state_reg, next_state;
  parameter start_state = 3'b000;
  parameter read_1_zero = 3'b001;
  parameter read_1_one  = 3'b010;
  parameter read_2_zero = 3'b011;
  parameter read_2_one  = 3'b100;

  // ---- state register: clocked, non-blocking, async reset ----
  always @ (posedge clock or posedge reset)
    if (reset == 1) state_reg <= start_state;
    else            state_reg <= next_state;

  // ---- next-state logic: combinational, blocking ----
  always @ (state_reg or in_bit)
    case (state_reg)
      start_state: if (in_bit == 0) next_state = read_1_zero; else
                   if (in_bit == 1) next_state = read_1_one;  else
                                    next_state = start_state;
      read_1_zero: if (in_bit == 0) next_state = read_2_zero; else
                   if (in_bit == 1) next_state = read_1_one;  else
                                    next_state = start_state;
      read_2_zero: if (in_bit == 0) next_state = read_2_zero; else
                   if (in_bit == 1) next_state = read_1_one;  else
                                    next_state = start_state;
      read_1_one:  if (in_bit == 0) next_state = read_1_zero; else
                   if (in_bit == 1) next_state = read_2_one;  else
                                    next_state = start_state;
      read_2_one:  if (in_bit == 0) next_state = read_1_zero; else
                   if (in_bit == 1) next_state = read_2_one;  else
                                    next_state = start_state;
      default:                      next_state = start_state;
    endcase

  // ---- output logic: Mealy, depends on state AND input ----
  assign out_bit = ((((state_reg == read_1_zero) || (state_reg == read_2_zero)) && (in_bit == 0)) ||
                    (((state_reg == read_1_one)  || (state_reg == read_2_one))  && (in_bit == 1))) ? 1 : 0;
endmodule

Four things in this code are worth naming explicitly, because they are the habits the slide's recommendations are trying to instil.這段程式碼裡有四件事值得明確點名，因為它們正是投影片那些建議想要養成的習慣。このコードには明示的に名指しする価値のある点が四つある。スライドの推奨が身につけさせようとしている習慣そのものだからだ。

The triple if. Each state tests in_bit == 0, then in_bit == 1, then falls through to a final else. For a one-bit signal that looks redundant — surely it is either 0 or 1? In simulation it need not be: in_bit can be x or z, and in_bit == 0 and in_bit == 1 are both false in that case, because == returns x for an unknown operand and if treats x as false. So the final else catches the unknown and parks the machine in start_state. In synthesis the branch is unreachable and costs nothing. This is a deliberate, cheap, defensive idiom and it is the reason the code looks more verbose than it needs to be.三重 if。每個狀態都先測 in_bit == 0，再測 in_bit == 1，然後落到最後的 else。對一個一位元訊號來說這看起來多餘——它不是 0 就是 1 吧？在模擬裡未必：in_bit 可以是 x 或 z，而那種情況下 in_bit == 0 與 in_bit == 1 兩者都為假，因為 == 對未知運算元回傳 x，而 if 把 x 當成假。所以最後的 else 接住了未知值，把機器停在 start_state。在合成時那個分支不可達，不花任何成本。這是一個刻意的、便宜的防禦性慣用寫法，也是這段程式碼看起來比必要更囉嗦的原因。三重の if。各状態はまず in_bit == 0 を、次に in_bit == 1 を判定し、最後の else に落ちる。1 ビット信号には冗長に見える——0 か 1 のどちらかに決まっているのでは？ シミュレーションではそうとは限らない。in_bit は x や z になりうるし、その場合 in_bit == 0 と in_bit == 1 はどちらも偽である。== は不定オペランドに対して x を返し、if は x を偽として扱うからだ。したがって最後の else が不定値を受け止め、機械を start_state に留める。合成時この分岐は到達不能でコストはゼロ。これは意図的で安価な防御的定型であり、このコードが必要以上に冗長に見える理由である。

Both blocks target different variables. state_reg is written only in the clocked block; next_state only in the combinational one. Neither variable has two drivers, and no variable is written with both = and <=. This is exactly the slide's third recommendation.兩個區塊各自指派不同的變數。state_reg 只在時脈區塊裡被寫；next_state 只在組合區塊裡被寫。沒有任何變數有兩個驅動源，也沒有任何變數同時用 = 與 <= 被寫。這正是投影片的第三條建議。二つのブロックは別々の変数を対象にしている。state_reg はクロック同期ブロックでのみ、next_state は組合せブロックでのみ書かれる。ドライバが二つある変数はなく、= と <= の両方で書かれる変数もない。これはスライドの三つ目の推奨そのものである。

The default. The state variable is three bits, so there are eight codes and only five are used. Without the default, the three unused codes would leave next_state unassigned, and the tool would build a latch. With it, the machine is guaranteed to return to start_state from any illegal code within one clock — which, as Section 2.5 noted, is exactly the insurance you want against reset-release skew.那個 default。狀態變數是三位元，所以有八種碼而只用了五種。沒有 default 的話，那三種沒用到的碼會讓 next_state 沒被指派，工具就會蓋出閂鎖。有了它，機器保證能在一個時脈內從任何非法碼回到 start_state——而如 2.5 節所述，那正是你想要用來防範重置釋放歪斜的保險。その default。状態変数は 3 ビットなので符号は八つあり、使うのは五つだけだ。default がなければ、未使用の三つの符号で next_state が代入されず、ツールはラッチを作る。あれば、機械はどんな不正符号からも 1 クロック以内に start_state へ戻ることが保証される——2.5 節で述べたとおり、リセット解除のスキューに対して欲しい保険そのものだ。

out_bit is a wire. It is declared only as output, not as reg, because it is driven by a continuous assignment. Mixing that up — declaring it reg and then using assign — is a compile error.out_bit 是一條連線。它只被宣告成 output，沒有宣告成 reg，因為它是由連續指派驅動的。把這點搞混——宣告成 reg 之後又用 assign——是編譯錯誤。out_bit は配線である。連続代入で駆動されるので、output としてのみ宣言され、reg としては宣言されない。これを取り違えて reg と宣言したうえで assign を使うのはコンパイルエラーである。

Simulation trace模擬軌跡シミュレーションのトレース

Apply the slide's stimulus, in_bit = 0011_1000_1 with the leftmost bit first, and reset released before the first edge. Remember the convention: the input shown for period $k$ is the one present throughout period $k$ and sampled at the edge that ends it.套用投影片的激勵 in_bit = 0011_1000_1，最左邊的位元先進，並在第一個邊緣之前解除重置。記住那個慣例：顯示在週期 $k$ 的輸入，就是整個週期 $k$ 都存在、並在結束該週期的那個邊緣被取樣的值。スライドの刺激 in_bit = 0011_1000_1 を、左端のビットから順に与え、最初のエッジの前にリセットを解除する。慣例を思い出すこと。周期 $k$ に示される入力は、周期 $k$ のあいだずっと存在し、その周期を終わらせるエッジでサンプルされる値である。

Check the assertions against the stream by hand. The pairs of adjacent equal bits are at positions (1,2), (3,4), (4,5), (6,7) and (7,8) — five pairs. The Mealy row has ones in periods 2, 4, 5, 7, 8: the period in which the second member of each pair is present at the input. The Moore row has ones in periods 3, 5, 6, 8, 9: exactly one period later in every case. Five detections, five assertions, both machines correct, both machines different.用手把這些確立對照著串流檢查一遍。相鄰相等位元的配對出現在位置 (1,2)、(3,4)、(4,5)、(6,7) 與 (7,8)——五對。Mealy 那一列在週期 2、4、5、7、8 為 1：也就是每一對的第二個成員出現在輸入端的那個週期。Moore 那一列在週期 3、5、6、8、9 為 1：每一次都恰好晚一個週期。五次偵測、五次確立，兩台機器都正確，兩台機器都不一樣。アサートを入力列と突き合わせて手で確認してみよう。隣り合う等しいビットの対は位置 (1,2)、(3,4)、(4,5)、(6,7)、(7,8) の五組である。ミーリの行は周期 2、4、5、7、8 で 1 になる。各対の二番目の要素が入力に現れている周期だ。ムーアの行は周期 3、5、6、8、9 で 1 になる。どの場合もちょうど 1 周期遅い。検出 5 回、アサート 5 回、どちらの機械も正しく、どちらの機械も違う。

7.5 The Moore machine7.5 Moore 機7.5 ムーア機械

The canonical Moore structure, which the slide draws as three boxes, is worth internalising because it is the picture every synchronous controller fits into:投影片畫成三個方塊的那個典型 Moore 結構，值得內化，因為它是每一個同步控制器都能套進去的圖：スライドが三つの箱として描く標準的なムーア構造は、内面化する価値がある。あらゆる同期コントローラが収まる図だからだ。

In Verilog, the Moore machine is byte-for-byte the Mealy machine with one line changed.在 Verilog 裡，Moore 機就是把 Mealy 機改掉一行，其餘一個位元組都不差。Verilog では、ムーア機械はミーリ機械の 1 行を変えただけで、あとは 1 バイトも違わない。

module seq_det_moore_1exp (clock, reset, in_bit, out_bit);
  ... // declarations identical to seq_det_mealy_1exp

  always @ (posedge clock or posedge reset)      // identical
    if (reset == 1) state_reg <= start_state;
    else            state_reg <= next_state;

  always @ (state_reg or in_bit)                 // identical
    case (state_reg)
      ... // exactly the same ten transitions
    endcase

  // ---- the only difference: no in_bit in the output ----
  assign out_bit = ((state_reg == read_2_zero) || (state_reg == read_2_one)) ? 1 : 0;
endmodule

Everything that makes the two machines different fits in that one expression. The Mealy output names in_bit; the Moore output does not. In gates, the Mealy output is a six-term function of four variables (three state bits and the input); the Moore output is a two-term function of three state bits — and with the right encoding, as Section 8 shows, it can be a single wire.讓兩台機器不同的一切，都塞在那一個運算式裡。Mealy 的輸出提到 in_bit；Moore 的輸出沒有。在閘的層次上，Mealy 輸出是四個變數（三個狀態位元加輸入）的六項函數；Moore 輸出是三個狀態位元的兩項函數——而用對編碼的話，如第 8 節所示，它可以只是一條線。二つの機械を違えるものはすべて、その一つの式に収まっている。ミーリ出力は in_bit を名指しし、ムーア出力はしない。ゲートのレベルでは、ミーリ出力は 4 変数（状態 3 ビットと入力）の 6 項関数、ムーア出力は状態 3 ビットの 2 項関数である——そして第 8 節で示すように、符号化を選べばただの配線 1 本にもなりうる。

It follows that the Moore version's state sequence is identical to the Mealy version's, cycle for cycle. The machines agree about everything except when they say so. That is what the slide's comparison waveform shows: state_reg is drawn twice with the same values, while out_bit_mealy and out_bit_moore are offset.由此可知 Moore 版本的狀態序列與 Mealy 版本完全相同，一個週期都不差。兩台機器對每件事都同意，除了「什麼時候說出來」。這就是投影片那張比較波形所顯示的：state_reg 被畫了兩次、值相同，而 out_bit_mealy 與 out_bit_moore 彼此錯開。したがってムーア版の状態系列はミーリ版と完全に同一で、1 サイクルの違いもない。二つの機械はいつそれを告げるかを除けば、すべてについて一致している。スライドの比較波形が示しているのはそれだ。state_reg は同じ値で二度描かれ、out_bit_mealy と out_bit_moore だけがずれている。

7.6 The output difference, in detail7.6 輸出差異的細部7.6 出力の違いを詳しく

Now the engineering consequences, which are what the slide means by calling Moore “better”.接著是工程上的後果，也就是投影片說 Moore「比較好」時所指的東西。続いて工学上の帰結、すなわちスライドがムーアを「より良い」と呼ぶときに意味していることを見る。

(a) Timing of the output(a) 輸出的時序(a) 出力のタイミング

A Moore output is a decode of flip-flop outputs. Its launch point is a clock edge, so static timing analysis can constrain it like any other path: launch at the state register, propagate through G, capture wherever it goes. A Mealy output has a path that starts at in_bit — which may be a chip pin — and ends at the output, with no register anywhere in between. At a module boundary that path is an input-to-output combinational arc, and constraining it requires knowing the external arrival time and the external required time. At a chip boundary it is an impossible-to-constrain pad-to-pad path. This is the single most practical reason to prefer Moore.Moore 輸出是正反器輸出的解碼。它的發射點是一個時脈邊緣，所以靜態時序分析可以像約束任何其他路徑那樣約束它：從狀態暫存器發射，穿過 G，在它去的地方被捕捉。Mealy 輸出有一條從 in_bit 開始的路徑——而 in_bit 可能是一支晶片接腳——一路到輸出，中間沒有任何暫存器。在模組邊界上，那是一條 input 到 output 的組合弧，要約束它就得知道外部的到達時間與外部的要求時間。在晶片邊界上，那是一條不可能約束的 pad 到 pad 路徑。這是偏好 Moore 最實際的一個理由。ムーア出力はフリップフロップ出力のデコードである。発射点がクロックエッジなので、スタティックタイミング解析は他の経路と同様に制約できる。状態レジスタから発射し、G を通り、行き先で捕捉される。ミーリ出力には in_bit——これはチップピンかもしれない——から始まり、途中にレジスタを一つも挟まずに出力へ至る経路がある。モジュール境界ではそれは input から output への組合せアークであり、制約するには外部の到着時刻と要求時刻を知らねばならない。チップ境界では制約不能なパッド間経路になる。これがムーアを選ぶもっとも実務的な理由である。

(b) Glitches(b) 毛刺(b) グリッチ

A Moore output changes only in response to a state change, which happens once per clock edge; between edges it is static. A Mealy output changes whenever in_bit changes, and in_bit can change at any time — including in the middle of a period, and including transiently if it is itself the output of some other combinational logic. A glitch on in_bit becomes a glitch on out_bit.Moore 輸出只在狀態改變時才改變，而狀態改變每個時脈邊緣發生一次；在邊緣之間它是靜止的。Mealy 輸出只要 in_bit 改變就會改變，而 in_bit 可以在任何時候改變——包括週期中途，也包括在它本身是某段組合邏輯輸出時那種短暫的改變。in_bit 上的毛刺會變成 out_bit 上的毛刺。ムーア出力は状態変化に応じてのみ変化し、状態変化はクロックエッジごとに 1 回起こる。エッジとエッジのあいだでは静止している。ミーリ出力は in_bit が変わるたびに変化し、in_bit はいつでも変わりうる——周期の途中でも、またそれ自体が別の組合せ論理の出力であれば一過性にも。in_bit 上のグリッチは out_bit 上のグリッチになる。

Whether that matters depends on the consumer. If out_bit feeds a flip-flop clocked by the same clock, the glitch is sampled only at the edge, by which time it has settled, and nothing is wrong. If out_bit drives an asynchronous input — a clear pin, a RAM write strobe, an off-chip enable — the glitch is a real pulse and can do real damage. The symptom is a signal that shows a narrow spike on a scope but nothing in simulation, because RTL simulation with zero delays does not produce the glitch at all.這要不要緊，取決於消費者是誰。如果 out_bit 餵給一顆由同一時脈驅動的正反器，毛刺只在邊緣被取樣，那時它早已安定，沒有任何問題。如果 out_bit 驅動一個非同步輸入——清除腳、RAM 寫入 strobe、晶片外的致能——那道毛刺就是一個真實的脈衝，可以造成真實的傷害。症狀是：示波器上看得到一根窄窄的尖波，模擬裡卻什麼都沒有，因為零延遲的 RTL 模擬根本不會產生那個毛刺。それが問題になるかどうかは受け手次第である。out_bit が同じクロックのフリップフロップに入るなら、グリッチはエッジでしかサンプルされず、その頃には収まっているので何も問題はない。out_bit が非同期入力——クリアピン、RAM のライトストローブ、チップ外のイネーブル——を駆動するなら、そのグリッチは実在のパルスであり、実害を与えうる。症状は、オシロでは細いスパイクが見えるのにシミュレーションには何も出ないことだ。遅延ゼロの RTL シミュレーションはそもそもグリッチを生まないからである。

(c) Latency and state count(c) 延遲與狀態數(c) レイテンシと状態数

The Mealy machine responds one cycle earlier. In a protocol where a response must be asserted in the same cycle as the request, that cycle is not negotiable. Mealy machines also often need fewer states than the equivalent Moore machine, because information that a Moore machine must encode in a state can be read directly from the input. For this particular detector the state counts happen to be equal; for others — a machine that outputs a function of a wide input word, say — a Moore implementation would need a state per output value.Mealy 機早一個週期回應。在某些協定裡，回應必須與請求在同一個週期內被確立，那一個週期是沒得商量的。Mealy 機往往也比等價的 Moore 機需要更少的狀態，因為 Moore 機必須編進狀態裡的資訊，Mealy 機可以直接從輸入讀。對這個特定的偵測器來說，兩者的狀態數恰好相等；對別的機器——比方說一台輸出是寬輸入字之函數的機器——Moore 實作會需要每個輸出值一個狀態。ミーリ機械は 1 サイクル早く応答する。要求と同じサイクルで応答をアサートしなければならないプロトコルでは、その 1 サイクルに交渉の余地はない。ミーリ機械は等価なムーア機械より状態数が少なくて済むことも多い。ムーア機械が状態に符号化せねばならない情報を、ミーリ機械は入力から直接読めるからだ。この検出器ではたまたま状態数が等しいが、別の機械——たとえば幅の広い入力語の関数を出力する機械——ではムーア実装は出力値ごとに状態を要する。

(d) The compromise: a registered Mealy output(d) 折衷方案：把 Mealy 輸出暫存起來(d) 折衷案：ミーリ出力をレジスタで受ける

You can have both. Compute the Mealy output function, then register it:你可以兩者兼得。先算出 Mealy 輸出函數，再把它暫存：両取りはできる。ミーリ出力関数を計算し、それをレジスタで受ければよい。

always @ (posedge clock or posedge reset)
  if (reset) out_bit <= 1'b0;
  else       out_bit <= mealy_function(next_state_decision, in_bit);

The output is now a flip-flop output: glitch-free, cleanly constrained, launched by a clock edge. But because the function is computed from the current input and registered immediately, the result appears one cycle after the input — the same timing as a Moore output. For this detector the registered-Mealy machine and the Moore machine produce identical waveforms, which is not a coincidence: a registered Mealy machine is a Moore machine whose state has been augmented with the output bit. The general lesson is that “Mealy versus Moore” is really a question about where you put the register, and you get to choose.輸出現在是一個正反器輸出：無毛刺、乾淨地被約束、由時脈邊緣發射。但因為那個函數是從當前輸入算出來並立刻被暫存的，結果會在輸入之後一個週期才出現——時序和 Moore 輸出一樣。對這個偵測器而言，暫存化 Mealy 機與 Moore 機產生完全相同的波形，這不是巧合：一台暫存化的 Mealy 機就是一台把輸出位元併進狀態裡的 Moore 機。一般性的教訓是：「Mealy 對 Moore」其實是在問你把暫存器放在哪裡，而那是你可以選的。出力はこれでフリップフロップ出力になる。グリッチがなく、きれいに制約でき、クロックエッジで発射される。ただし関数は現在の入力から計算されて直ちにレジスタに入るので、結果は入力の 1 サイクル後に現れる——ムーア出力と同じタイミングだ。この検出器ではレジスタ付きミーリ機械とムーア機械は同一の波形を出すが、これは偶然ではない。レジスタ付きミーリ機械とは、状態に出力ビットを足したムーア機械なのである。一般的な教訓は、「ミーリ対ムーア」とは結局レジスタをどこに置くかという問いであり、それは自分で選べるということだ。

7.7 Coding templates: one, two, three and four blocks7.7 撰碼樣板：一、二、三與四個區塊7.7 コーディング・テンプレート：1・2・3・4 ブロック

Industry practice has converged on a small number of FSM templates, usually named by how many always blocks they use. All of them produce correct hardware; they differ in readability, in how easy it is to change the machine later, and in how many ways they can be got wrong.業界實務已經收斂到少數幾種 FSM 樣板，通常以它們用了幾個 always 區塊來命名。它們全都產生正確的硬體；差別在可讀性、在之後要改機器時有多容易，以及有多少種把它寫錯的方式。業界の実務は少数の FSM テンプレートに収束しており、たいてい always ブロックをいくつ使うかで呼ばれる。どれも正しいハードウェアを生む。違うのは可読性、後から機械を変更する容易さ、そして間違え方の種類の多さである。

Two-always (the slide's template)兩 always（投影片的樣板）2 always（スライドのテンプレート）

reg [2:0] state_reg, next_state;

always @ (posedge clock or posedge reset)        // 1: state register (sequential)
  if (reset) state_reg <= start_state;
  else       state_reg <= next_state;

always @*                                        // 2: next state + output (combinational)
  begin
    next_state = state_reg;                      // default: hold — kills latch inference
    out_bit    = 1'b0;                           // default: deasserted
    case (state_reg)
      read_1_zero: begin
                     if (!in_bit) begin next_state = read_2_zero; out_bit = 1'b1; end
                     else               next_state = read_1_one;
                   end
      ...
      default:     next_state = start_state;
    endcase
  end

The crucial habit here is the pair of default assignments at the top of the combinational block. Because every variable is assigned before the case runs, no path through the block can leave anything unassigned, so no latch can be inferred no matter how incomplete the case becomes during later editing. It also makes the code shorter, because branches only mention what differs from the default. This single idiom eliminates the most common FSM bug class.這裡關鍵的習慣是組合區塊最上面那一組預設指派。因為每個變數在 case 跑之前就已經被指派，所以通過這個區塊的任何路徑都不可能留下未指派的東西，於是不論之後編輯把 case 弄得多不完整，都不會推論出閂鎖。它也讓程式碼變短，因為各分支只需要提到與預設不同的部分。光是這一個慣用寫法，就消滅了最常見的那一類 FSM 錯誤。ここで肝心な習慣は組合せブロックの先頭に置く既定代入の組である。case が走る前にすべての変数が代入されるので、このブロックを通るどの経路も未代入のものを残しえない。したがって後の編集で case がどれほど不完全になってもラッチは推論されない。分岐は既定と異なる部分だけ書けばよいのでコードも短くなる。この定型一つで、FSM のバグのうちもっとも多い一群が消える。

Three-always三 always3 always

Split the combinational block into next-state logic and output logic:把組合區塊拆成次態邏輯與輸出邏輯：組合せブロックを次状態論理と出力論理に分ける。

always @ (posedge clock or posedge reset)        // 1: state register
  if (reset) state_reg <= start_state; else state_reg <= next_state;

always @*                                        // 2: next-state logic only
  begin
    next_state = state_reg;
    case (state_reg) ... endcase
  end

always @*                                        // 3: output logic only
  out_bit = (state_reg == read_2_zero) || (state_reg == read_2_one);

This is the style that makes the Mealy/Moore distinction visible at a glance: block 3's sensitivity tells you immediately which kind of machine you have. If it reads only state_reg the machine is Moore; if it also reads in_bit it is Mealy. Changing the machine from one to the other means editing one block. For anything beyond a toy FSM this is the template to use.這種風格讓 Mealy／Moore 的區別一眼可辨：第 3 個區塊的感應列立刻告訴你手上是哪一種機器。如果它只讀 state_reg，機器是 Moore；如果它也讀 in_bit，就是 Mealy。要把機器從一種改成另一種，只需要編輯一個區塊。對任何超出玩具規模的 FSM，這就是該用的樣板。この書き方ならミーリとムーアの違いは一目でわかる。第 3 ブロックの感度リストがどちらの機械かを即座に教えてくれる。state_reg しか読まなければムーア、in_bit も読めばミーリだ。一方から他方へ変えるには 1 ブロックを編集すればよい。おもちゃ規模を超える FSM なら、使うべきはこのテンプレートである。

Four-always (three plus a registered output)四 always（三個再加一個暫存化輸出）4 always（3 つ＋レジスタ付き出力）

Add a fourth, clocked block that registers the output, giving the registered-Mealy behaviour of Section 7.6(d). Common in designs where the FSM drives something timing-critical or off-chip.加上第四個、時脈驅動的區塊去暫存輸出，得到 7.6(d) 的暫存化 Mealy 行為。在 FSM 要驅動某個時序吃緊或晶片外的東西時很常見。出力をレジスタで受ける 4 つ目のクロック同期ブロックを加えると、7.6(d) のレジスタ付きミーリの振る舞いになる。FSM がタイミングに厳しいものやチップ外のものを駆動する設計でよく使われる。

One-always一 always1 always

always @ (posedge clock or posedge reset)        // everything in one clocked block
  if (reset) begin state_reg <= start_state; out_bit <= 1'b0; end
  else case (state_reg)
    read_1_zero: if (!in_bit) begin state_reg <= read_2_zero; out_bit <= 1'b1; end
                 else         begin state_reg <= read_1_one;  out_bit <= 1'b0; end
    ...
  endcase

There is no next_state variable; the machine writes state_reg directly. This style is compact, it cannot infer a latch (the block is edge-sensitive, so an unassigned path simply holds), and the output is automatically registered. Its drawbacks are that the output is always one cycle late — you cannot write a plain Mealy machine this way — and that it is easy to forget to assign out_bit in some branch and get a sticky output. It is popular for small controllers and for anyone who has been burned by latches.這裡沒有 next_state 變數；機器直接寫 state_reg。這種風格很精簡，它不可能推論出閂鎖（區塊是邊緣敏感的，所以未指派的路徑單純就是保持），而且輸出自動被暫存。它的缺點是輸出永遠晚一個週期——你沒辦法用這種方式寫出一台純粹的 Mealy 機——而且很容易在某個分支忘了指派 out_bit，結果得到一個黏住的輸出。它在小型控制器中很受歡迎，也受到所有被閂鎖燙過手的人歡迎。ここには next_state 変数がなく、機械は state_reg を直接書く。この書き方はコンパクトで、ラッチを推論しえない（ブロックがエッジ感応なので、未代入の経路は単に保持になる）。出力も自動的にレジスタで受けられる。欠点は、出力が常に 1 サイクル遅れること——この書き方では素のミーリ機械は書けない——と、どこかの分岐で out_bit の代入を忘れて出力が貼り付いてしまいやすいことだ。小規模なコントローラで、そしてラッチで痛い目を見た人たちに人気がある。

7.8 Approach II: the implicit state machine Non-portable7.8 方法二：隱含式狀態機 不可移植7.8 アプローチ II：暗黙の状態機械 移植性なし

The slides finish the FSM material with a completely different way of writing the same detector. Instead of enumerating states and transitions, the code describes the sequence of operations and lets the position in the code be the state.投影片用一種完全不同的方式寫出同一個偵測器，作為 FSM 內容的收尾。程式碼不去列舉狀態與轉移，而是描述操作的順序，讓程式碼中的位置本身成為狀態。スライドは FSM の話題を、同じ検出器をまったく別の書き方で示して締めくくる。状態と遷移を列挙する代わりに、コードは操作の順序を記述し、コード中の位置そのものを状態とする。

module seq_det_mealy_1imp (clock, reset, in_bit, out_bit);
  input  clock, reset, in_bit;
  output out_bit;
  reg    last_bit, this_bit, flag;
  wire   out_bit;

  always begin: wrapper_for_synthesis
    @ (posedge clock /* or posedge reset */) begin: machine
      if (reset == 1) begin
        last_bit = 0;
        this_bit = 0;
        flag     = 0;
        disable machine; end
      else begin                                           // 1
        last_bit = this_bit;
        this_bit = in_bit;
        forever
          @ (posedge clock /* or posedge reset */) begin  // 2
            if (reset == 1) begin
              last_bit = 0;
              this_bit = 0;
              flag     = 0;
              disable machine; end
            else begin
              last_bit = this_bit;
              this_bit = in_bit;
              flag     = 1; end
          end                                              // 2
      end                                                  // 1
    end   // machine
  end     // wrapper_for_synthesis

  assign out_bit = (flag && (this_bit == last_bit) && (this_bit == in_bit));
endmodule

How it works. The outer always has no event control of its own; it is an infinite loop whose body is the named block machine. The first statement inside is an event control, so execution blocks there until a rising clock edge. On that edge, if reset is asserted the three registers are cleared and disable machine aborts the named block, which returns control to the top of the always and parks it at the first @ again. Otherwise the code records the first bit and enters a forever loop that waits for every subsequent clock edge, shifting this_bit into last_bit and setting flag.它怎麼運作。外層的 always 自己沒有事件控制；它是一個無窮迴圈，本體是具名區塊 machine。裡面的第一個敘述就是一個事件控制，所以執行會卡在那裡，直到時脈上升緣到來。在那個邊緣上，如果重置被確立，三個暫存器就被清除，而 disable machine 中止這個具名區塊，把控制交還到 always 的最上面，再次停在第一個 @。否則程式碼記下第一個位元，進入一個 forever 迴圈，等待其後每一個時脈邊緣，把 this_bit 移進 last_bit 並設定 flag。動作の仕組み。外側の always はそれ自体のイベント制御をもたない。本体が名前付きブロック machine である無限ループだ。その内側の最初の文がイベント制御なので、実行はクロックの立ち上がりエッジまでそこでブロックする。そのエッジでリセットがアサートされていれば三つのレジスタがクリアされ、disable machine が名前付きブロックを中断して制御を always の先頭へ返し、再び最初の @ で待機させる。そうでなければコードは最初のビットを記録し、以降のすべてのクロックエッジを待つ forever ループに入って、this_bit を last_bit へ送り flag を立てる。

Where the state lives. Three places. Two bits of it are explicit, in last_bit and this_bit. One more bit is flag, which says “at least two bits have been read” and suppresses a false detection on the very first bit — it plays exactly the role of start_state in the explicit machine. And a fourth bit of state is implicit: whether the behaviour is waiting at the first @ or at the @ inside the forever. That implicit bit is why the synthesis result on the slide contains a flip-flop labelled multiple_wait_state — the tool had to materialise the program counter.狀態住在哪裡。三個地方。其中兩個位元是明確的，在 last_bit 與 this_bit 裡。再一個位元是 flag，它表示「至少已經讀了兩個位元」，用來壓掉第一個位元上的假偵測——它扮演的角色正好就是明確機器裡的 start_state。而第四個狀態位元是隱含的：這個行為是停在第一個 @，還是停在 forever 裡面那個 @。那個隱含位元就是投影片上的合成結果裡有一顆標著 multiple_wait_state 的正反器的原因——工具必須把程式計數器具體化出來。状態はどこにあるか。三か所である。うち 2 ビットは明示的で、last_bit と this_bit にある。もう 1 ビットは flag で、「少なくとも 2 ビット読んだ」ことを表し、最初のビットでの誤検出を抑える——明示的な機械における start_state とまったく同じ役割だ。そして 4 ビット目の状態は暗黙である。すなわち、このビヘイビアが最初の @ で待っているのか、forever 内の @ で待っているのか。この暗黙のビットこそ、スライドの合成結果に multiple_wait_state というラベルのフリップフロップが含まれる理由である——ツールはプログラムカウンタを実体化せざるを得なかったのだ。

What the output expression really does. This is more subtle than it looks, and it explains the narrow pulses in the slide's waveform. At any moment after an edge, this_bit holds the bit sampled at that edge and last_bit the one before. But in_bit in the output expression is the live input, and the testbench moves it on the falling edge. So within one clock period:那個輸出運算式真正在做什麼。這比看起來微妙，而且它解釋了投影片波形裡那些窄脈衝。在邊緣之後的任何時刻，this_bit 保存的是那個邊緣取樣到的位元，last_bit 保存的是前一個。但輸出運算式裡的 in_bit 是即時的輸入，而測試平台在下降緣搬動它。所以在一個時脈週期內：その出力式が実際に何をしているか。見た目より微妙であり、スライドの波形にある細いパルスの説明にもなる。エッジ後の任意の時点で、this_bit はそのエッジでサンプルしたビットを、last_bit はその一つ前を保持する。だが出力式中の in_bit はいま現在の入力であり、テストベンチはそれを立ち下がりエッジで動かす。したがって 1 クロック周期の中では：

• First half (after the rising edge, before the falling edge): in_bit still equals the value just sampled, so this_bit == in_bit is trivially true and out_bit reduces to flag && (this_bit == last_bit) — the last two sampled bits were equal. This is the genuine detection.前半（上升緣之後、下降緣之前）：in_bit 仍然等於剛剛被取樣的值，所以 this_bit == in_bit 自明為真，out_bit 退化成 flag && (this_bit == last_bit)——也就是最後兩個被取樣的位元相等。這是真正的偵測。前半（立ち上がりエッジの後、立ち下がりエッジの前）：in_bit はまだサンプルしたばかりの値に等しいので this_bit == in_bit は自明に真となり、out_bit は flag && (this_bit == last_bit) に帰着する——直近 2 つのサンプル済みビットが等しいということだ。これが本来の検出である。
• Second half (after the falling edge): in_bit has become the next bit, so out_bit additionally requires that bit to match too — effectively testing for three equal bits in a row.後半（下降緣之後）：in_bit 已經變成下一個位元，所以 out_bit 額外要求那個位元也要相符——實際上變成在測試「連續三個相等的位元」。後半（立ち下がりエッジの後）：in_bit は次のビットになっているので、out_bit はそのビットの一致も追加で要求する——事実上、等しいビットが 3 つ続くことを判定している。

The consequence is that a detection produces a half-period pulse when the run stops at two, and a full-period pulse when the run continues to three. That is exactly the irregular pulse width visible on the slide's waveform, and it is a different output specification from either the explicit Mealy or the explicit Moore machine. If this were a real design, the extra (this_bit == in_bit) term would be a bug.結果就是：當連續只停在兩個時，偵測產生一道半週期的脈衝；當連續延伸到三個時，產生一道整週期的脈衝。這正是投影片波形上看得到的不規則脈寬，而它是一套與明確 Mealy 機或明確 Moore 機都不同的輸出規格。如果這是真實設計，多出來的 (this_bit == in_bit) 項就是一個錯誤。その結果、連続が 2 個で止まるときの検出は半周期のパルスを、連続が 3 個まで続くときは 1 周期ぶんのパルスを生む。スライドの波形に見える不揃いなパルス幅はまさにこれであり、明示的なミーリ機械ともムーア機械とも異なる出力仕様になっている。これが実際の設計なら、余分な (this_bit == in_bit) の項はバグである。

There is one honest argument in its favour. For a machine whose job is a long, mostly linear sequence — a bus protocol, a memory initialisation routine, a test pattern generator — the implicit style is far more readable than twenty explicit states whose only purpose is to count. Behavioural-synthesis tools and high-level-synthesis flows exist precisely to exploit that. But in the RTL world you write the explicit machine, and if the sequence is long you write it as a counter plus a small FSM rather than as twenty states.有一個誠實的論點支持它。對於一台工作是跑一段長而幾乎線性之序列的機器——匯流排協定、記憶體初始化常式、測試圖樣產生器——隱含式風格遠比二十個唯一用途是計數的明確狀態好讀。行為合成工具與高階合成流程的存在，正是為了利用這一點。但在 RTL 的世界裡你要寫明確的機器，而如果序列很長，你會把它寫成一個計數器加一台小 FSM，而不是二十個狀態。これを支持するまっとうな論拠が一つある。長くほぼ直線的な系列をこなすのが仕事の機械——バスプロトコル、メモリ初期化ルーチン、テストパターン生成器——では、暗黙のスタイルは、数えるためだけに存在する 20 個の明示的状態よりはるかに読みやすい。ビヘイビア合成ツールや高位合成フローはまさにそれを活かすために存在する。だが RTL の世界では明示的な機械を書く。系列が長いなら、20 状態ではなくカウンタ＋小さな FSM として書くのだ。

module det (clock, reset, in_bit, out_bit);
  input  clock, reset, in_bit;
  output out_bit;
  reg [1:0] state, next;
  reg out_bit;
  parameter S0 = 2'b00, S1 = 2'b01, S2 = 2'b10;

  always @ (posedge clock)
    state = next;

  always @ (state)
    case (state)
      S0: if (in_bit) next = S1;
      S1: if (in_bit) next = S2; else next = S0;
      S2: begin next = S2; out_bit = 1; end
    endcase
endmodule

module det (clock, reset_n, in_bit, out_bit);
  input      clock, reset_n, in_bit;
  output reg out_bit;
  reg  [1:0] state, next;
  parameter S0 = 2'b00, S1 = 2'b01, S2 = 2'b10;

  always @ (posedge clock or negedge reset_n)        // sequential
    if (!reset_n) state <= S0;
    else          state <= next;

  always @*                                          // combinational
    begin
      next    = state;                               // defaults first
      out_bit = 1'b0;
      case (state)
        S0:      if (in_bit) next = S1;
        S1:      if (in_bit) next = S2; else next = S0;
        S2:      begin out_bit = 1'b1; next = in_bit ? S2 : S0; end
        default: next = S0;
      endcase
    end
endmodule

8. State Encoding8. 狀態編碼8. 状態符号化

The state diagram says what the machine does; the encoding says what bit patterns the flip-flops hold. The two are independent — any encoding implements any diagram — and the choice changes flip-flop count, logic depth, power and robustness without changing the behaviour at all. In the sequence detector the encoding was fixed by five parameter declarations, and changing those five lines is the entire exercise.狀態圖說的是這台機器做什麼；編碼說的是正反器裡裝著什麼位元圖樣。兩者是獨立的——任何編碼都能實現任何狀態圖——而這個選擇會改變正反器數量、邏輯深度、功耗與強健性，卻完全不改變行為。在序列偵測器裡，編碼是由五條 parameter 宣告定死的，而改那五行就是這整件事的全部。状態図は機械が何をするかを述べ、符号化はフリップフロップがどんなビットパターンを保持するかを述べる。両者は独立で——どの符号化でもどの状態図も実装できる——その選択はフリップフロップ数、論理深度、電力、堅牢性を変えるが、振る舞いはまったく変えない。シーケンス検出器では符号化は五つの parameter 宣言で固定されており、その 5 行を変えることが作業のすべてである。

8.1 The four encodings8.1 四種編碼8.1 四つの符号化

Each column is generated by a different rule.每一欄都由一條不同的規則產生。各列は異なる規則で生成されている。

Binary is just the state index written in base two. It uses the theoretical minimum number of flip-flops, $\lceil\log_2 N\rceil$, and nothing else about it is special.二進位就是把狀態索引寫成二進位。它用掉理論上最少的正反器數 $\lceil\log_2 N\rceil$，除此之外沒有什麼特別的。二進は状態の添字を 2 進で書いただけである。理論上最小のフリップフロップ数 $\lceil\log_2 N\rceil$ を使い、それ以外に特筆すべき点はない。

One-hot gives each state its own flip-flop and guarantees that exactly one is set. It uses $N$ flip-flops, which is the maximum any sensible encoding uses, and in exchange the logic becomes trivial: testing “am I in state $k$?” is reading one wire, and the next-state equation for bit $k$ is simply the OR of the conditions on all arcs entering state $k$.One-hot 給每個狀態一顆自己的正反器，並保證恰好只有一顆被設起來。它用掉 $N$ 顆正反器，那是任何合理編碼會用到的上限，而交換到的是邏輯變得極其簡單：測試「我在不在狀態 $k$？」就是讀一條線，而位元 $k$ 的次態方程式就只是所有進入狀態 $k$ 之弧的條件的 OR。ワンホットは各状態に専用のフリップフロップを与え、ちょうど一つだけが立つことを保証する。使うフリップフロップは $N$ 個で、まともな符号化が使う最大値だが、引き換えに論理が極めて単純になる。「状態 $k$ にいるか」を調べるのは配線 1 本を読むことであり、ビット $k$ の次状態方程式は状態 $k$ に入るすべてのアークの条件の OR にすぎない。

Gray code arranges the $2^n$ patterns so that consecutive codes differ in exactly one bit. The standard construction is the reflected binary code, obtained from the binary value $b$ as $g = b \oplus (b \gg 1)$ — check it against the table: for $b = 7 = 0111$, $b \gg 1 = 0011$ and the XOR is $0100$, which is the table's entry. It uses the same $\lceil\log_2 N\rceil$ flip-flops as binary.格雷碼把 $2^n$ 個圖樣排成使連續兩個碼恰好只差一個位元。標準做法是反射二進碼，由二進位值 $b$ 算出 $g = b \oplus (b \gg 1)$——拿表來對照看看：$b = 7 = 0111$ 時 $b \gg 1 = 0011$，XOR 得到 $0100$，正是表上的那一項。它用掉和二進位一樣的 $\lceil\log_2 N\rceil$ 顆正反器。グレイ符号は $2^n$ 個のパターンを、連続する符号がちょうど 1 ビットだけ異なるように並べる。標準的な構成は反射二進符号で、二進値 $b$ から $g = b \oplus (b \gg 1)$ として得られる——表で確かめてほしい。$b = 7 = 0111$ なら $b \gg 1 = 0011$、XOR は $0100$ で、表の値と一致する。フリップフロップ数は二進と同じ $\lceil\log_2 N\rceil$ である。

Johnson (twisted ring) shifts the complement of the top bit into the bottom, producing $2n$ codes from $n$ flip-flops: the register fills with ones from the bottom and then empties from the bottom. Like Gray, consecutive codes differ in one bit; unlike Gray, the code is not dense — the table's 16 states need 8 bits where binary would need 4.Johnson（扭環）把最高位的補數移進最低位，用 $n$ 顆正反器產生 $2n$ 個碼：暫存器從底部開始填滿 1，然後再從底部開始排空。和格雷碼一樣，連續兩個碼只差一位；和格雷碼不同的是，這個碼並不稠密——表上的 16 個狀態要用 8 個位元，而二進位只要 4 個。ジョンソン（ツイストリング）は最上位ビットの補数を最下位へシフトし、$n$ 個のフリップフロップから $2n$ 通りの符号を作る。レジスタは下から 1 で埋まり、また下から空になる。グレイと同じく連続する符号は 1 ビットしか違わないが、グレイと違って符号は密ではない——表の 16 状態には 8 ビットを要し、二進なら 4 ビットで済む。

8.2 Choosing one8.2 如何選擇8.2 どれを選ぶか

Flip-flops versus logic正反器與邏輯的取捨フリップフロップ対論理

The headline trade is between sequential area and combinational area. For the five-state detector, binary needs 3 flip-flops and one-hot needs 5 — two extra flip-flops, perhaps 50 µm² in a mature process. In exchange, the Moore output goes from a comparison against two 3-bit codes to state_reg[3] | state_reg[4], a single OR gate. For five states that is roughly a wash. For twenty states it is not: binary needs 5 flip-flops and a next-state cone that is a function of all five bits plus the inputs, with a logic depth of three or four levels; one-hot needs 20 flip-flops but each next-state bit is an OR of a handful of arc conditions, depth one or two. One-hot wins on speed almost always and loses on area once $N$ gets large.最主要的取捨是循序面積對組合面積。對五狀態的偵測器，二進位需要 3 顆正反器，one-hot 需要 5 顆——多兩顆，在成熟製程裡大概 50 µm²。交換到的是：Moore 輸出從「比對兩個 3 位元碼」變成 state_reg[3] | state_reg[4]，一顆 OR 閘。對五個狀態來說大致打平。對二十個狀態就不是了：二進位要 5 顆正反器，而次態邏輯錐是那五個位元加上輸入的函數，邏輯深度三到四層；one-hot 要 20 顆正反器，但每個次態位元只是少數幾個弧條件的 OR，深度一到兩層。One-hot 幾乎永遠在速度上勝出，而一旦 $N$ 變大就在面積上落敗。主たるトレードオフは順序回路面積と組合せ回路面積のあいだにある。5 状態の検出器では二進は 3 個、ワンホットは 5 個のフリップフロップを要する——2 個増で、成熟プロセスならおよそ 50 µm²。引き換えに、ムーア出力は 2 つの 3 ビット符号との比較から state_reg[3] | state_reg[4]、すなわち OR ゲート 1 個になる。5 状態ではほぼ互角だ。20 状態ではそうはいかない。二進はフリップフロップ 5 個に加え、次状態コーンが 5 ビット全部と入力の関数となり論理深度は 3〜4 段。ワンホットはフリップフロップ 20 個だが、各次状態ビットはごく少数のアーク条件の OR で深さ 1〜2 段である。ワンホットは速度ではほぼ常に勝ち、$N$ が大きくなると面積で負ける。

FPGA versus ASICFPGA 與 ASICFPGA と ASIC

On an FPGA the decision is nearly automatic. Flip-flops are free — every logic cell contains one whether you use it or not — while routing and LUT levels are the scarce resource. One-hot minimises both, so FPGA synthesis tools default to it for machines up to a few dozen states. On an ASIC, flip-flops cost real area and real leakage power, so the default is binary and one-hot is used selectively for the critical machine.在 FPGA 上這個決定幾乎是自動的。正反器是免費的——每個邏輯單元裡都有一顆，你用不用都在——而稀缺資源是繞線與 LUT 層數。One-hot 把兩者都最小化，所以 FPGA 合成工具對幾十個狀態以內的機器預設就用它。在 ASIC 上，正反器要花真實的面積與真實的漏電功耗，所以預設是二進位，而 one-hot 只被選擇性地用在關鍵的那台機器上。FPGA ではこの判断はほぼ自動である。フリップフロップは無料だ——各ロジックセルに使っても使わなくても一つ入っている——一方で希少資源は配線と LUT の段数である。ワンホットは両方を最小化するので、FPGA の合成ツールは数十状態までの機械には既定でこれを選ぶ。ASIC ではフリップフロップが実面積と実リーク電力を消費するので、既定は二進で、ワンホットは重要な機械に選択的に使う。

Power功耗電力

Dynamic power is proportional to the number of nodes that toggle. One-hot toggles exactly two flip-flops per transition regardless of $N$. Binary toggles between one and $\lceil\log_2 N\rceil$, averaging about two for a random walk but spiking on carry-like transitions such as 0111 → 1000. Gray toggles exactly one, which is why Gray-coded counters are standard in always-on, power-critical blocks. But in a machine with many flip-flops, one-hot's advantage in switching is offset by its disadvantage in leakage, so the honest answer again depends on $N$ and on the duty cycle.動態功耗與翻轉的節點數成正比。One-hot 每次轉移恰好翻轉兩顆正反器，與 $N$ 無關。二進位翻轉的數量在 1 到 $\lceil\log_2 N\rceil$ 之間，隨機遊走下平均大約兩個，但在像 0111 → 1000 這種進位式轉移時會爆衝。格雷碼恰好翻轉一個，這就是為什麼格雷編碼的計數器在常開、功耗吃緊的區塊裡是標準做法。但在正反器很多的機器裡，one-hot 在切換上的優勢會被它在漏電上的劣勢抵銷，所以誠實的答案又一次取決於 $N$ 和工作週期。動的電力はトグルするノード数に比例する。ワンホットは $N$ によらず遷移ごとにちょうど 2 個のフリップフロップをトグルする。二進は 1 から $\lceil\log_2 N\rceil$ のあいだでトグルし、ランダムウォークなら平均 2 程度だが、0111 → 1000 のようなキャリー的遷移では跳ね上がる。グレイはちょうど 1 なので、グレイ符号カウンタは常時オンで電力に厳しいブロックの定番である。ただしフリップフロップの多い機械では、ワンホットのスイッチング上の利点がリーク上の不利に相殺されるので、正直な答えはまた $N$ とデューティ次第になる。

Glitches and clock-domain crossing毛刺與跨時脈域グリッチとクロックドメイン跨ぎ

If a state vector is read by logic in another clock domain, the fact that only one bit changes per step becomes a correctness property rather than a power optimisation. With binary coding, a receiver sampling 0111 → 1000 asynchronously can latch any of 0000, 1111 or anything in between, because the four bits do not settle simultaneously. With Gray coding only one bit is in flight, so the receiver sees either the old value or the new one — never a third. This is exactly why FIFO read and write pointers are Gray coded, and it is the main reason Gray appears in this table at all.如果狀態向量會被另一個時脈域的邏輯讀取，「每一步只有一個位元改變」就從功耗最佳化變成一項正確性性質。用二進位編碼時，一個非同步取樣 0111 → 1000 的接收端可能鎖到 0000、1111 或介於其間的任何值，因為四個位元不會同時安定。用格雷碼時只有一個位元在飛，所以接收端看到的不是舊值就是新值——絕不會是第三個值。這正是為什麼 FIFO 的讀寫指標要用格雷編碼，也是格雷碼之所以會出現在這張表裡的主要理由。状態ベクタが別のクロックドメインの論理に読まれる場合、「1 ステップで 1 ビットしか変わらない」ことは電力最適化ではなく正しさの性質になる。二進符号では、0111 → 1000 を非同期にサンプルする受信側は 0000 や 1111、あるいはその中間の何かをラッチしうる。4 ビットが同時に落ち着かないからだ。グレイ符号なら飛んでいるビットは 1 本だけなので、受信側は古い値か新しい値のどちらかしか見ない——第三の値は決して現れない。FIFO の読み書きポインタがグレイ符号である理由がこれであり、グレイがそもそもこの表に載っている主な理由でもある。

Telling the tool告訴工具你要什麼ツールに指示する

You can impose an encoding by writing the parameter values yourself, as the slides do, or you can declare the states symbolically and let synthesis choose with an attribute such as // synopsys state_vector or an fsm_encoding directive. Tools can also re-encode a machine you wrote in binary into one-hot if that meets timing better. Be aware of the consequence: if the tool re-encodes, the state codes in the netlist no longer match your RTL, so a gate-level waveform will not show the values you expect and any testbench that pokes at state_reg will break. For a machine whose encoding matters — one that crosses domains, or whose outputs must be a particular decode — pin the encoding explicitly and disable re-encoding.你可以像投影片那樣自己寫 parameter 的值來強制編碼，也可以用符號方式宣告狀態，再用 // synopsys state_vector 這類屬性或 fsm_encoding 指示詞讓合成去選。工具甚至可以把你用二進位寫的機器重新編碼成 one-hot，如果那樣比較容易收時序。要注意後果：如果工具重新編碼，netlist 裡的狀態碼就不再和你的 RTL 一致，閘級波形不會顯示你預期的值，任何會去戳 state_reg 的測試平台都會壞掉。對於編碼本身很重要的機器——會跨域的，或輸出必須是某個特定解碼的——請明確釘死編碼並停用重新編碼。スライドのように parameter の値を自分で書いて符号化を強制してもよいし、状態を記号的に宣言して // synopsys state_vector のような属性や fsm_encoding ディレクティブで合成に選ばせてもよい。ツールは、そのほうがタイミングを満たすなら、二進で書いた機械をワンホットへ再符号化することさえできる。その帰結に注意すること。ツールが再符号化すると、ネットリスト中の状態符号は RTL と一致しなくなり、ゲートレベル波形は期待した値を示さず、state_reg を突くテストベンチはすべて壊れる。符号化そのものが重要な機械——ドメインを跨ぐもの、出力が特定のデコードでなければならないもの——では、符号化を明示的に固定し再符号化を禁止すること。

8.3 Illegal states and recovery8.3 非法狀態與復原8.3 不正状態と復帰

Every encoding except a perfectly dense binary one leaves unused codes, and the sparser the encoding the more of them there are.除了完全稠密的二進位之外，每一種編碼都會留下沒用到的碼，而編碼越稀疏，剩下的就越多。完全に密な二進を除けば、どの符号化も未使用の符号を残し、符号化が疎であるほどその数は増える。

A machine can land in an illegal code three ways: reset-release skew (Section 2.5), a single-event upset from a cosmic ray or alpha particle, or a setup violation on a marginal path. Once there, what happens depends entirely on your default.機器會落進非法碼有三種途徑：重置釋放的歪斜（2.5 節）、宇宙射線或 α 粒子造成的單事件翻轉，或是某條邊緣路徑上的 setup 違規。一旦到了那裡，接下來會怎樣完全取決於你的 default。機械が不正符号に落ちる道は三つある。リセット解除のスキュー（2.5 節）、宇宙線やアルファ粒子による単一事象アップセット、そして際どい経路でのセットアップ違反である。いったんそこへ落ちたあと何が起きるかは、あなたの default 次第で完全に決まる。

With default: next_state = start_state; every illegal code maps to the reset state, so the machine recovers within one clock and the damage is bounded to whatever it did while confused. Without a default, the next-state logic for an illegal code is whatever the minimisation happened to produce — possibly a legal state, possibly a self-loop that locks the machine up until the next system reset. The cost of the default is a few gates; the cost of omitting it is a field failure that requires a power cycle. There is no reason not to write it.有 default: next_state = start_state; 時，每一個非法碼都對映到重置狀態，所以機器在一個時脈內復原，損害被限制在它神智不清期間所做的那些事。沒有 default 時，非法碼的次態邏輯就是邏輯最小化剛好產生出來的東西——可能是某個合法狀態，也可能是一個自迴圈，把機器鎖死到下一次系統重置為止。寫那個 default 的代價是幾顆閘；不寫的代價是一次需要斷電重開的現場失效。沒有理由不寫。default: next_state = start_state; があれば、どの不正符号もリセット状態へ写るので機械は 1 クロック以内に復帰し、被害は混乱していたあいだにしたことに限られる。default がなければ、不正符号に対する次状態論理は論理最小化がたまたま生んだものになる——合法な状態かもしれないし、次のシステムリセットまで機械をロックする自己ループかもしれない。default を書く代価はゲート数個、書かない代価は電源再投入を要する現場故障である。書かない理由はない。

parameter start_state = 5'b00001;
parameter read_1_zero = 5'b00010;
parameter read_1_one  = 5'b00100;
parameter read_2_zero = 5'b01000;
parameter read_2_one  = 5'b10000;

assign out_bit = state_reg[3] | state_reg[4];   // Moore: one OR gate

assign next_state[3] = (state_reg[1] & ~in_bit)    // from read_1_zero on 0
                     | (state_reg[3] & ~in_bit);   // self loop on 0
// = ~in_bit & (state_reg[1] | state_reg[3])  -- two gates, one level

9. Summary, Traps and Checklist9. 總結、陷阱與檢查清單9. まとめ・落とし穴・チェックリスト

9.1 Exam traps9.1 考試陷阱9.1 試験の落とし穴

The questions that catch people are nearly always one of these.會坑到人的題目幾乎永遠是下面這幾種之一。引っかかる問題はほぼ必ず次のどれかである。

1. “How many flip-flops?” Apply the two conditions of Section 1.3, then check the blocking assignments for read-before-write. A cascade of blocking assignments in a clocked block gives one flip-flop, not n.「有幾顆正反器？」套用 1.3 節的兩個條件，然後檢查阻斷式指派有沒有先讀後寫。時脈區塊裡一串阻斷式指派給你的是一顆正反器，不是 n 顆。「フリップフロップは何個か」1.3 節の二条件を当てはめ、次にブロッキング代入の read-before-write を確認する。クロック同期ブロック内のブロッキング代入の連鎖が与えるのはフリップフロップ1 個であって n 個ではない。
2. Missing else. In a clocked block it is an enable; in a combinational block it is a latch. Always say which kind of block you are looking at before answering.缺少的 else。在時脈區塊裡它是致能；在組合區塊裡它是閂鎖。回答之前，一定要先說出你看的是哪一種區塊。欠けた else。クロック同期ブロックではイネーブル、組合せブロックではラッチになる。答える前に、見ているのがどちらの種類のブロックかを必ず言うこと。
3. Reset polarity versus edge. negedge reset must pair with if (reset == 1'b0). The Shift_reg4 example uses active-low reset while every other module in the lecture uses active-high; questions love to mix them.重置極性與邊緣。negedge reset 必須搭配 if (reset == 1'b0)。Shift_reg4 那個例子用的是低位準作用的重置，而本講其他每個模組用的都是高位準作用；考題最愛把它們混在一起。リセットの極性とエッジ。negedge reset は if (reset == 1'b0) と組にしなければならない。Shift_reg4 の例は負論理リセットを使い、本講の他のモジュールはすべて正論理である。試験問題はこれを混ぜるのが大好きだ。
4. Reset pulse width. Asynchronous: arbitrarily narrow. Synchronous: must contain a rising clock edge, so longer than one period. And a synchronous reset does nothing at all when the clock is stopped.重置脈寬。非同步：可以任意窄。同步：必須包含一個時脈上升緣，所以要長於一個週期。而且時脈停止時，同步重置什麼也做不到。リセットのパルス幅。非同期：いくらでも細くてよい。同期：立ち上がりクロックエッジを含まねばならないので 1 周期より長く必要。そしてクロックが止まっていれば同期リセットは何もできない。
5. Shift direction. Decode the concatenation bit by bit. {Data_in, Data_reg[3:1]} shifts towards the LSB; {Data_out[6:0], Data_out[7]} rotates towards the MSB.移位方向。把串接一位元一位元解開。{Data_in, Data_reg[3:1]} 往 LSB 方向移；{Data_out[6:0], Data_out[7]} 往 MSB 方向旋轉。シフトの向き。連結をビットごとに読み解くこと。{Data_in, Data_reg[3:1]} は LSB 方向へシフトし、{Data_out[6:0], Data_out[7]} は MSB 方向へ回転する。
6. “Barrel shifter”. The slide's module is a rotate-by-one register. A real barrel shifter is $\log_2 n$ stages of multiplexers and is purely combinational.「Barrel shifter」。投影片的模組是一個單位旋轉暫存器。真正的 barrel shifter 是 $\log_2 n$ 級的多工器，而且是純組合的。「バレルシフタ」。スライドのモジュールは 1 ビット回転レジスタである。本物のバレルシフタは $\log_2 n$ 段のマルチプレクサであり、純粋に組合せ回路である。
7. Ripple counter intermediates. Going from 0111 to 1000 it passes through 0110, 0100, 0000. Any decode of those bits glitches.漣波計數器的中間值。從 0111 走到 1000 時，它會經過 0110、0100、0000。任何對那些位元的解碼都會出毛刺。リプルカウンタの中間値。0111 から 1000 へ向かう途中、0110、0100、0000 を通過する。それらのビットをデコードすれば必ずグリッチする。
8. Self-determined widths. Operands inside { } are evaluated at their own width. An addition inside a concatenation loses its carry unless you widen the operands — which is why the two 1'b0 in the pipelined adder must stay.自決寬度。{ } 裡面的運算元以自己的寬度求值。串接裡的加法會丟掉進位，除非你把運算元加寬——這就是管線化加法器裡那兩個 1'b0 必須留下的原因。自己決定の幅。{ } の中のオペランドは自分の幅で評価される。連結内の加算は、オペランドを広げない限りキャリーを失う——パイプライン加算器の二つの 1'b0 を残さねばならない理由である。
9. Latency versus throughput. A three-stage pipeline produces one result per cycle but each individual result arrives three cycles after its operands — sometimes later in absolute time than the unpipelined version.延遲對吞吐量。三級管線每個週期產出一個結果，但每一個個別結果都在它的運算元之後三個週期才抵達——在絕對時間上有時還比未管線化的版本更晚。レイテンシ対スループット。3 段パイプラインはサイクルごとに結果を 1 個出すが、個々の結果はそのオペランドの 3 サイクル後に届く——絶対時間ではパイプライン化しない版より遅いことすらある。
10. Mealy versus Moore timing. Same state sequence, same detections, output offset by exactly one clock period. Mealy asserts while the completing input is present; Moore asserts after the edge that absorbs it.Mealy 對 Moore 的時序。相同的狀態序列、相同的偵測，輸出恰好差一個時脈週期。Mealy 在完成配對的輸入還在時就確立；Moore 在吸收它的那個邊緣之後才確立。ミーリ対ムーアのタイミング。状態系列も検出も同じで、出力はちょうど 1 クロック周期ずれる。ミーリは対を完成させる入力が存在している最中にアサートし、ムーアはそれを取り込むエッジの後にアサートする。
11. Where the glitch is. A Mealy output can glitch because it is combinationally connected to the input; a Moore output cannot, because it is a decode of flip-flops.毛刺在哪裡。Mealy 輸出會有毛刺，因為它與輸入之間是組合連接的；Moore 輸出不會，因為它是正反器的解碼。グリッチはどこにあるか。ミーリ出力は入力と組合せ的につながっているのでグリッチしうる。ムーア出力はフリップフロップのデコードなのでグリッチしない。
12. Ring counters are not self-correcting. Rotation preserves the number of ones, so an extra one circulates for ever. Only reset — or a NOR-feedback modification — recovers.環形計數器不會自我修正。旋轉保持 1 的個數，所以多出來的那個 1 會永遠循環下去。只有重置——或是加上 NOR 回授的修改——才能救回來。リングカウンタは自己修正しない。回転は 1 の個数を保つので、余分な 1 は永遠に巡り続ける。復帰できるのはリセットか、NOR 帰還を加える改変だけである。

9.2 Checklist9.2 檢查清單9.2 チェックリスト

reg [2:0] state_reg, next_state;

always @ (posedge clock or negedge reset_n)     // 1. state register
  if (!reset_n) state_reg <= S0;
  else          state_reg <= next_state;

always @*                                       // 2. next-state logic
  begin
    next_state = state_reg;                     // default: hold
    case (state_reg)
      S0: if (go) next_state = S1;
      S1: next_state = S2;
      S2: if (done) next_state = S0;
      default: next_state = S0;                 // illegal-state recovery
    endcase
  end

assign out = (state_reg == S2);                 // 3. Moore output

If you take one idea away from this lecture, make it this: the synthesiser is a pattern matcher, and every rule in these thirty-seven slides is a description of one pattern. The event control picks the template, the assignment operator decides the ordering semantics, the completeness of the branches decides whether a value has to be remembered, and the placement of the output decides whether a signal is clean. None of it is arbitrary, and none of it requires memorisation once you can picture the flip-flop the tool is about to allocate.如果你只從這一講帶走一個想法，請讓它是這個：合成器是一台樣板比對機，而這三十七張投影片裡的每一條規則都是對某一個樣板的描述。事件控制挑選樣板，指派運算子決定順序語義，分支的完整性決定某個值是否必須被記住，而輸出的擺放位置決定一條訊號乾不乾淨。這裡面沒有一件事是任意的，而一旦你能在腦中看見工具即將配出來的那顆正反器，就沒有一件事需要死背。本講から一つだけ持ち帰るなら、これにしてほしい。合成器はパターンマッチャであり、この 37 枚のスライドにある規則はどれも一つのパターンの記述である。イベント制御がテンプレートを選び、代入演算子が順序の意味論を決め、分岐の完全性が値を記憶する必要があるかを決め、出力の置き場所が信号のきれいさを決める。どれ一つとして恣意的なものはなく、ツールがこれから割り当てようとしているフリップフロップを思い描けるようになれば、どれ一つとして丸暗記は要らない。