Synthesis of Language Constructs, Explained語言構件的合成，逐項解說言語構文の合成、詳細解説

1. How a Synthesiser Reads Verilog1. 合成器如何閱讀 Verilog1. 合成器は Verilog をどう読むか

Lecture 7 is, on the slides, a list. Nets are retained or eliminated; integers default to thirty-two bits; x is allowed here and not there; this operator becomes combinational logic and that one becomes muxes. Read as a list it is impossible to remember and even harder to apply, because every entry is the conclusion of an argument whose premises are not on the slide. This page supplies the premises. Every rule in the lecture follows from one of three facts: a standard-cell library contains only a few hundred fixed gate shapes, a synthesiser is a compiler that must produce a finite netlist from a finite source text, and silicon carries only two voltages plus the absence of a driver. Once you have those three facts in mind, almost nothing in the lecture needs to be memorised; it can be re-derived.第 7 講在投影片上就是一張清單。net 有的保留、有的被消除；integer 預設三十二位元；x 這裡能用、那裡不能用；這個運算子變成組合邏輯、那個運算子變成多工器。當成清單來背，既記不住，更難應用，因為每一條都是某個論證的結論，而論證的前提並不在投影片上。本頁要補上那些前提。這一講的每一條規則都源自三項事實之一：標準元件庫裡只有數百種固定的閘形狀；合成器是一個編譯器，必須從有限的原始碼產生有限的 netlist；而矽晶片上只有兩種電壓，外加「沒有驅動源」這個狀態。只要把這三項事實放在心裡，這一講幾乎沒有什麼需要死記，都可以重新推導出來。第 7 講はスライド上ではひとつのリストである。net は残されるか除去されるか、integer は既定で 32 ビット、x はここでは許されるがあそこでは許されない、この演算子は組合せ論理になりあの演算子はマルチプレクサになる。リストとして読むと覚えることは不可能で、適用するのはさらに難しい。各項目は、前提がスライドに載っていない議論の結論だからである。本ページはその前提を補う。この講義の規則はすべて三つの事実のいずれかから導かれる。スタンダードセルライブラリには数百種の固定したゲート形状しかないこと、合成器は有限のソーステキストから有限のネットリストを生成しなければならないコンパイラであること、そしてシリコンは二つの電圧とドライバ不在しか運べないこと。この三つを念頭に置けば、この講義で暗記すべきものはほとんどなく、すべて再導出できる。

1.1 Three passes, not one1.1 不是一個步驟，而是三個1.1 一つではなく三つのパス

It helps enormously to stop thinking of synthesis as a single translation step. A cell-based synthesiser such as Design Compiler, Genus or Vivado's synthesis engine does three distinguishable things, and nearly every rule in this lecture belongs to exactly one of them.把合成想成單一的翻譯步驟，是很大的阻礙。像 Design Compiler、Genus 或 Vivado 合成引擎這類 cell-based 合成器，會做三件可以分開來看的事，而這一講幾乎每一條規則都正好屬於其中一件。合成を単一の変換ステップと考えるのをやめると理解が大きく進む。Design Compiler、Genus、Vivado の合成エンジンといったセルベース合成器は、区別できる三つの仕事を行い、この講義のほぼすべての規則はそのいずれか一つに属する。

The first pass is elaboration. The tool reads the text, applies compiler directives, resolves parameters, works out the width and signedness of every expression, builds the module hierarchy and expands anything that can be expanded statically: generate blocks, parameterised widths, tasks, functions and static loops. After elaboration there is no such thing as a for loop and no such thing as a task call. There is only a flat soup of assignments. This pass is why a loop whose trip count the compiler cannot compute is fatal, why a task has to be inlined, why `define works and why an integer starts out thirty-two bits wide.第一個階段是展開（elaboration）。工具讀入文字、套用編譯指令、解析參數、算出每個運算式的位寬與有號性、建立模組階層，並把所有能在靜態期展開的東西展開：generate 區塊、參數化位寬、task、function，以及靜態迴圈。展開之後，世界上不再有 for 迴圈，也不再有 task 呼叫，只剩下一鍋扁平的指定敘述。這個階段解釋了為什麼編譯器算不出迴圈次數就是致命錯誤、為什麼 task 必須被內聯、為什麼 `define 有效，以及為什麼 integer 一開始就是三十二位元寬。第一のパスはエラボレーションである。ツールはテキストを読み、コンパイラ指令を適用し、パラメータを解決し、すべての式のビット幅と符号属性を決定し、モジュール階層を構築し、静的に展開できるものをすべて展開する。generate ブロック、パラメータ化された幅、タスク、関数、そして静的ループである。エラボレーション後には for ループもタスク呼び出しも存在しない。あるのは代入のフラットなスープだけである。このパスがあるからこそ、コンパイラが反復回数を計算できないループは致命的であり、タスクはインライン展開されねばならず、`define が機能し、integer が 32 ビット幅から始まるのである。

The second pass is inference, sometimes called RTL synthesis or generic mapping. The tool looks at the elaborated assignments and decides which storage elements are implied — flip-flops, latches, tri-state drivers — and builds a technology-independent network of generic operators: a generic adder, a generic comparator, a generic multiplexer, a generic register. This pass is where the x/z rules, the event-control rules and the blocking/non-blocking distinction live. Lectures 5 and 6 of this course are almost entirely about this pass; Lecture 7 is about what it does to each individual language construct.第二個階段是推論（inference），有時稱為 RTL 合成或泛用對應。工具檢視展開後的指定敘述，判斷隱含了哪些儲存元件 — 正反器、閂鎖、三態驅動器 — 並建立一個與製程無關的泛用運算子網路：泛用加法器、泛用比較器、泛用多工器、泛用暫存器。x/z 規則、事件控制規則，以及阻塞式與非阻塞式的區別，都住在這個階段。本課程的第 5、6 講幾乎完全在講這個階段；第 7 講則是講它對每一個個別語言構件做了什麼。第二のパスは推論（inference）で、RTL 合成あるいはジェネリックマッピングとも呼ばれる。ツールはエラボレーション済みの代入を見て、どの記憶素子が暗示されているか — フリップフロップ、ラッチ、トライステートドライバ — を判断し、テクノロジ非依存のジェネリック演算子のネットワークを構築する。ジェネリック加算器、ジェネリック比較器、ジェネリックマルチプレクサ、ジェネリックレジスタである。x/z の規則、イベント制御の規則、ブロッキングとノンブロッキングの区別はすべてこのパスに属する。本科目の第 5 講と第 6 講はほぼ全体がこのパスの話であり、第 7 講はそれが個々の言語構文に対して何をするかの話である。

The third pass is optimisation and technology mapping. The generic network is flattened into Boolean equations where profitable, restructured against the timing constraints, and then covered with real library cells — a NAND2X1 here, a DFFRPQ there, a carry-select adder from the DesignWare library instead of the generic one. This pass is why internal nets disappear, why an integer that only ever holds values below eight shrinks to three bits, why a don't care is valuable, and why the same source text can produce two visibly different schematics on two different runs, as the lecture's two synthesis results for the same 4-to-1 multiplexer demonstrate.第三個階段是最佳化與製程對應。泛用網路在有利時被攤平成布林方程式，依時序限制重新結構化，然後用真實的庫元件覆蓋 — 這裡放一顆 NAND2X1、那裡放一顆 DFFRPQ，用 DesignWare 庫裡的 carry-select 加法器取代泛用加法器。這個階段解釋了為什麼內部 net 會消失、為什麼只存放小於八的值的 integer 會縮成三位元、為什麼 don't care 很有價值，以及為什麼同一份原始碼在兩次執行中可以產生兩張明顯不同的電路圖 — 正如這一講對同一個 4 對 1 多工器給出的兩種合成結果所示。第三のパスは最適化とテクノロジマッピングである。ジェネリックネットワークは有利な箇所でブール式に平坦化され、タイミング制約に対して再構成され、実在のライブラリセルで覆われる。ここに NAND2X1、あそこに DFFRPQ、ジェネリック加算器の代わりに DesignWare ライブラリのキャリーセレクト加算器、といった具合である。このパスがあるから内部 net は消え、8 未満の値しか保持しない integer は 3 ビットに縮み、ドントケアに価値が生まれ、同じソーステキストが二回の実行で見た目の異なる回路図を生む。講義が同じ 4 対 1 マルチプレクサについて二つの合成結果を示しているとおりである。

1.2 The synthesisable subset1.2 可合成子集1.2 合成可能サブセット

Verilog, as standardised in IEEE 1364, is a simulation language. It was designed to describe the behaviour of a digital system over time for an event-driven simulator, and a great deal of it describes things no circuit can do: wait an arbitrary number of nanoseconds, print a message, read a file, hold a real number, compare against an unknown. The synthesisable subset is the fragment of the language for which a sensible, deterministic, finite circuit exists. Everything Lecture 7 marks as unsupported is unsupported for one of exactly two reasons: either the construct has no finite hardware realisation at all, or it has one but the realisation would depend on information the tool does not have.Verilog 在 IEEE 1364 中標準化，本質上是一種模擬語言。它的設計目的是為事件驅動模擬器描述數位系統隨時間的行為，其中有很大一部分描述的是任何電路都做不到的事：等待任意奈秒數、印出訊息、讀檔、保存實數、拿未知值去比較。可合成子集就是語言中「存在一個合理、確定且有限的電路」的那一塊。第 7 講標示為不支援的每一項，不支援的理由恰好只有兩種：要嘛該構件根本沒有有限的硬體實現，要嘛有，但實現方式取決於工具手上沒有的資訊。IEEE 1364 で標準化された Verilog はシミュレーション言語である。イベント駆動シミュレータ向けにディジタルシステムの時間的ふるまいを記述するために設計されており、その大部分はどんな回路にもできないことを記述する。任意のナノ秒数だけ待つ、メッセージを印字する、ファイルを読む、実数を保持する、未知値と比較する、といったことである。合成可能サブセットとは、妥当で決定的かつ有限な回路が存在する言語の断片のことである。第 7 講が非対応と記すものはすべて、二つの理由のいずれかで非対応となる。その構文に有限のハードウェア実現がまったく存在しないか、存在するがその実現がツールの持たない情報に依存するかである。

real is in the first category. A floating-point variable would need a floating-point unit, and Verilog gives no indication of precision, rounding mode or exception behaviour, so no tool guesses. A non-static loop is in the first category too: the circuit size would depend on the data, and circuits have a fixed size. Delay controls are in the second category: #5 means five time units, and the tool has no idea how many gate delays that is in the final technology, so it either ignores the delay or — worse, and the lecture explicitly warns about this — reinterprets it as a clock boundary.real 屬於第一類。浮點變數需要一個浮點運算單元，而 Verilog 完全沒有指出精度、捨入模式或例外行為，所以沒有工具會去猜。非靜態迴圈也屬於第一類：電路大小會取決於資料，但電路的大小是固定的。延遲控制屬於第二類：#5 代表五個時間單位，工具根本不知道在最終製程裡那是幾個閘延遲，所以它要嘛忽略這個延遲，要嘛 — 更糟，而且這一講明確提出警告 — 把它重新解釋成一個時脈邊界。real は第一のカテゴリに属する。浮動小数点変数には浮動小数点ユニットが必要だが、Verilog は精度も丸めモードも例外動作も示さないため、どのツールも推測しない。非静的ループも第一のカテゴリである。回路規模がデータに依存してしまうが、回路の規模は固定だからである。遅延制御は第二のカテゴリに属する。#5 は 5 時間単位を意味するが、それが最終テクノロジで何ゲート遅延に当たるかツールには分からない。そのため遅延を無視するか、あるいは — さらに悪く、講義が明示的に警告しているとおり — それをクロック境界と読み替えてしまう。

A useful habit is to ask, for every construct you are tempted to write, "what finite collection of library cells has exactly this behaviour?" If you cannot answer, neither can the tool, and it will either error out or do something arbitrary. The painful case is the second one, because the design will then simulate correctly before synthesis and fail after it.一個很有用的習慣是，對每一個你想寫下的構件自問：「哪一組有限的庫元件，行為恰好就是這樣？」如果你答不出來，工具也答不出來，它要嘛報錯，要嘛做出某種任意的行為。麻煩的是後者，因為這樣的設計在合成前模擬正確，合成後卻會失效。有用な習慣は、書こうとするすべての構文について「ライブラリセルのどんな有限の集まりが、ちょうどこのふるまいを持つのか」と自問することである。答えられないならツールにも答えられず、エラーを出すか恣意的な何かをする。厄介なのは後者である。その設計は合成前には正しくシミュレーションされ、合成後に破綻するからである。

1.3 What "cost" means here1.3 這裡的「成本」指什麼1.3 ここでの「コスト」の意味

Throughout this page the cost of a construct is given in two currencies. Area is counted in two-input gate equivalents (GE), where one GE is roughly the area of a two-input NAND cell. On a typical standard-cell library a two-input NAND or NOR is 1 GE, an inverter about 0.7, a two-input XOR or XNOR about 2 to 2.5, a two-to-one multiplexer about 2 to 3, a full adder about 5 to 7, and a positive-edge D flip-flop with asynchronous reset about 5 to 6. Delay is counted in levels of logic, meaning the number of gates on the longest input-to-output path, because within one technology the delay of a path is roughly proportional to its depth once fanout is accounted for.本頁一律用兩種貨幣來標示構件的成本。面積以二輸入等效閘（GE）計算，一個 GE 約等於一顆二輸入 NAND 的面積。在典型的標準元件庫中，二輸入 NAND 或 NOR 約 1 GE，反相器約 0.7，二輸入 XOR 或 XNOR 約 2 到 2.5，二對一多工器約 2 到 3，全加器約 5 到 7，帶非同步重置的正緣觸發 D 型正反器約 5 到 6。延遲以邏輯層級數計算，也就是從輸入到輸出最長路徑上的閘數；因為在同一製程內，一旦把扇出納入考量，路徑延遲大致與其深度成正比。本ページでは構文のコストを常に二つの通貨で示す。面積は 2 入力ゲート等価（GE）で数え、1 GE はおよそ 2 入力 NAND セルの面積である。典型的なスタンダードセルライブラリでは、2 入力 NAND または NOR が 1 GE、インバータが約 0.7、2 入力 XOR または XNOR が約 2〜2.5、2 対 1 マルチプレクサが約 2〜3、全加算器が約 5〜7、非同期リセット付き立ち上がりエッジ D フリップフロップが約 5〜6 である。遅延は論理段数、すなわち入力から出力までの最長経路上のゲート数で数える。一つのテクノロジ内では、ファンアウトを考慮すれば経路遅延はおおむねその深さに比例するからである。

These numbers are deliberately coarse. The point is never the third significant figure; the point is the scaling law. A ripple-carry adder grows as $O(n)$ in both area and delay. A carry-look-ahead adder trades area for depth and grows as $O(n\log n)$ in area with $O(\log n)$ delay. An array multiplier is $O(n^2)$ in area. A barrel shifter is $O(n\log n)$. A restoring divider built combinationally is $O(n^2)$ in both. Knowing which exponent attaches to which operator is what lets you look at an RTL line and predict, without running the tool, whether it will cost you ten gates or ten thousand.這些數字刻意取得很粗略。重點從來不是第三位有效數字，而是尺度律。漣波進位加法器在面積與延遲上都是 $O(n)$ 成長。超前進位加法器拿面積換深度，面積 $O(n\log n)$、延遲 $O(\log n)$。陣列乘法器面積是 $O(n^2)$。桶式移位器是 $O(n\log n)$。用組合邏輯做的回復式除法器兩者皆為 $O(n^2)$。知道哪個指數配哪個運算子，才能讓你看著一行 RTL，不必跑工具就預測它要花你十個閘還是一萬個閘。これらの数値は意図的に粗い。要点は有効数字 3 桁目ではなく、スケーリング則である。リップルキャリー加算器は面積・遅延ともに $O(n)$ で増える。キャリー先見加算器は面積と深さを交換し、面積 $O(n\log n)$、遅延 $O(\log n)$ となる。アレイ乗算器は面積が $O(n^2)$。バレルシフタは $O(n\log n)$。組合せ回路として作った引き戻し除算器は両方とも $O(n^2)$ である。どの指数がどの演算子に付くかを知っていれば、RTL の一行を見ただけで、ツールを走らせずに 10 ゲートで済むのか 1 万ゲートかかるのかを予測できる。

2. Net Variables and Register Variables2. net 變數與 register 變數2. net 変数と register 変数

Verilog's two families of data objects, nets and variables, exist because the language models two different physical ideas. A net is a connection — a piece of metal with one or more drivers — and its value is continuously resolved from whatever drives it. A variable (declared reg, integer, real and so on) is a piece of storage in the simulator that holds the last value procedurally written to it. Synthesis treats the two families almost identically, which surprises students, and the surprises are exactly what the first two slides of this lecture are about.Verilog 的兩大類資料物件 — net 與變數 — 之所以存在，是因為這個語言要模擬兩種不同的物理概念。net 是一條連線 — 一段帶有一個或多個驅動源的金屬 — 它的值由驅動它的東西持續解析而來。變數（宣告為 reg、integer、real 等）則是模擬器裡的一塊儲存空間，保存最後一次以程序方式寫入的值。合成對這兩類的處理幾乎完全相同，這常讓學生意外，而這些意外正是這一講前兩張投影片的主題。Verilog のデータオブジェクトの二つの系統、net と変数が存在するのは、この言語が二つの異なる物理的概念をモデル化しているからである。net は接続 — 一つ以上のドライバを持つ金属配線 — であり、その値は駆動するものから連続的に解決される。変数（reg、integer、real などで宣言）はシミュレータ内の記憶領域で、手続き的に最後に書き込まれた値を保持する。合成はこの二つをほぼ同一に扱い、それが学生を驚かせる。その驚きこそ、この講義の最初の 2 枚のスライドの主題である。

2.1 Nets that survive and nets that vanish2.1 留下來的 net 與消失的 net2.1 残る net と消える net

The lecture's first rule is that nets declared as input or output ports are retained, while internal nets may be eliminated by logic optimisation. Both halves of that statement follow from the mapping pass.這一講的第一條規則是：宣告為 input 或 output 埠的 net 會被保留，而內部 net 可能被邏輯最佳化消除。這句話的兩半都源自對應階段。講義の最初の規則は、input または output ポートとして宣言された net は残されるが、内部 net は論理最適化によって除去されうる、というものである。この言明の両半分とも、マッピングパスから導かれる。

A port is part of the module's interface, and the interface is a contract. Something outside the module — another module, a pad cell, the test bench, the place-and-route tool's floorplan — refers to that port by name. If the optimiser deleted a port because the logic inside happened not to use it, every netlist consumer downstream would break: the instantiating module's port connection list would no longer match, the gate-level test bench would fail to bind, the formal equivalence check would report a different interface. So ports are frozen. The lecture makes this point with the ALU example in which the input s2 ends up driving nothing at all after optimisation, yet still appears as a dangling port on the schematic. A dangling input port is not a bug in the tool; it is the tool obeying the contract.埠是模組介面的一部分，而介面是一份契約。模組外部的某樣東西 — 另一個模組、一顆 pad cell、測試平台、place-and-route 工具的 floorplan — 會用名字去指涉那個埠。如果最佳化器只因為模組內部剛好沒用到就刪掉一個埠，下游每一個 netlist 使用者都會壞掉：實例化模組的埠連接清單不再吻合、閘級測試平台綁不上去、形式等價檢查會回報介面不同。所以埠被凍結。這一講用 ALU 範例說明這點：輸入 s2 在最佳化後完全沒有驅動任何東西，卻仍以一個懸空的埠出現在電路圖上。懸空的輸入埠不是工具的錯誤，而是工具在遵守契約。ポートはモジュールのインタフェースの一部であり、インタフェースは契約である。モジュールの外側にある何か — 別のモジュール、パッドセル、テストベンチ、配置配線ツールのフロアプラン — がそのポートを名前で参照する。内部の論理がたまたま使っていないという理由で最適化器がポートを削除したら、下流のネットリスト利用者はすべて壊れる。インスタンス化側のポート接続リストが一致しなくなり、ゲートレベルのテストベンチはバインドできず、形式等価性検査は異なるインタフェースを報告する。だからポートは凍結される。講義はこの点を ALU の例で示す。入力 s2 は最適化後に何も駆動しなくなるが、それでも回路図上に宙に浮いたポートとして現れる。宙に浮いた入力ポートはツールのバグではなく、ツールが契約を守っている姿である。

An internal net has no such contract. If you write wire t = a & b; assign y = t | c; the net t exists only so that you could name the intermediate result. After the optimiser flattens the two equations into $y = ab + c$ and covers it with, say, a single AND-OR-INVERT cell plus an inverter, there is no wire in the netlist corresponding to t at all — the signal lives inside a cell, between two transistor stacks, where no probe can reach it. The net has been absorbed. This is normal and desirable: absorbing intermediate nets is precisely how multi-level logic optimisation reduces area.內部 net 沒有這樣的契約。如果你寫 wire t = a & b; assign y = t | c;，net t 存在的唯一理由只是讓你能替中間結果取名字。等最佳化器把兩條方程式攤平成 $y = ab + c$，再用比方說一顆 AND-OR-INVERT 元件加一顆反相器來覆蓋，netlist 裡就完全沒有對應 t 的連線了 — 那個訊號住在元件內部、兩組電晶體堆疊之間，任何探針都碰不到。這條 net 被吸收了。這是正常而且值得期待的：吸收中間 net 正是多層邏輯最佳化降低面積的手段。内部 net にはそのような契約がない。wire t = a & b; assign y = t | c; と書いたとき、net t は中間結果に名前を付けられるようにするためだけに存在する。最適化器が二つの式を $y = ab + c$ に平坦化し、たとえば AND-OR-INVERT セル一個とインバータ一個で覆ってしまえば、ネットリストに t に対応する配線はまったく存在しない。その信号はセルの内部、二つのトランジスタスタックの間にあり、どんなプローブも届かない。net は吸収されたのである。これは正常かつ望ましい。中間 net の吸収こそ、多段論理最適化が面積を削減する方法そのものだからである。

It becomes a problem only when you wanted to see that net — for debug, for a scan observation point, for a manual clock gate, or because you are hand-instantiating a cell and need the connection to survive. That is what the lecture's third bullet refers to: "the user may force a net to exist by special instructions provided in the synthesis tool". The mechanism is tool-specific and attribute-based. In Design Compiler one writes set_dont_touch on the net, or marks the signal /* synopsys keep_signal_name */; in Vivado the attribute is (* keep = "true" *) or (* dont_touch = "true" *); in Genus it is set_dont_touch as well. These are not Verilog. They are directives to a particular tool, and a design that depends on them is less portable than one that does not.只有當你本來就想看到那條 net 時，它才會變成問題 — 為了除錯、為了一個掃描觀測點、為了手動插時脈閘，或因為你正在手工實例化某顆元件而需要那個連接存活下來。這正是這一講第三個要點所指的：「使用者可以用合成工具提供的特殊指令強迫一條 net 存在」。這個機制因工具而異，而且是以屬性為基礎。在 Design Compiler 裡要對該 net 下 set_dont_touch，或把訊號標上 /* synopsys keep_signal_name */；在 Vivado 裡屬性是 (* keep = "true" *) 或 (* dont_touch = "true" *)；在 Genus 裡同樣是 set_dont_touch。這些都不是 Verilog，而是給特定工具的指令；依賴它們的設計，可攜性比不依賴的差。問題になるのは、その net を見たかった場合だけである。デバッグのため、スキャンの観測点のため、手動クロックゲートのため、あるいはセルを手でインスタンス化していてその接続を残す必要があるため、といった場合である。これが講義の三つ目の項目が指すところで、「合成ツールが提供する特別な指示によって、ユーザは net を強制的に存在させられる」。この仕組みはツール固有で、属性に基づく。Design Compiler では net に set_dont_touch を書くか、信号に /* synopsys keep_signal_name */ を付ける。Vivado では属性が (* keep = "true" *) または (* dont_touch = "true" *)、Genus でも同じく set_dont_touch である。これらは Verilog ではなく、特定のツールへの指令である。これらに依存する設計は、依存しない設計より可搬性が低い。

2.2 wand and wor become gates2.2 wand 與 wor 會變成閘2.2 wand と wor はゲートになる

The net types wand and wor describe a net with several drivers whose values are resolved by a wired-AND or wired-OR rule rather than by the usual conflict rule. Historically this described a real electrical arrangement: several open-collector or open-drain transistors pulling a line down against a pull-up resistor gave a wired-AND for active-high data, or a wired-OR for active-low data. In a modern cell-based CMOS flow that arrangement does not exist. There is no pull-up resistor in a standard-cell library, and a net with two actively driving CMOS outputs is a short circuit.net 型態 wand 與 wor 描述的是一條有多個驅動源的 net，其值不是用一般的衝突規則，而是用 wired-AND 或 wired-OR 規則來解析。歷史上這描述的是真實的電氣配置：幾顆開集極或開汲極電晶體把一條線往下拉、對抗一顆提升電阻，對高態有效的資料就是 wired-AND，對低態有效的資料就是 wired-OR。在現代 cell-based CMOS 流程裡，這種配置並不存在。標準元件庫裡沒有提升電阻，而一條接了兩個主動驅動 CMOS 輸出的 net 就是短路。net 型 wand と wor は、複数のドライバを持ち、その値が通常の衝突規則ではなくワイヤード AND／ワイヤード OR の規則で解決される net を記述する。歴史的にはこれは実在の電気的構成を表していた。複数のオープンコレクタまたはオープンドレインのトランジスタがプルアップ抵抗に抗して線を引き下げ、正論理データならワイヤード AND、負論理データならワイヤード OR になった。現代のセルベース CMOS フローにこの構成は存在しない。スタンダードセルライブラリにプルアップ抵抗はなく、CMOS 出力が二つアクティブに駆動する net は短絡である。

So the synthesiser does the obvious thing: it collects the drivers and replaces the resolution function with an explicit gate. A wand with $k$ drivers becomes a $k$-input AND; a wor with $k$ drivers becomes a $k$-input OR. The cost is the cost of that gate — for $k$ drivers, roughly $k-1$ two-input gates arranged in a tree of depth $\lceil \log_2 k \rceil$, which the mapper may of course cover with wider library cells. The behaviour is the same for 0 and 1; it differs for x and z, but since the netlist has no x, that difference does not matter after synthesis.所以合成器做的是顯而易見的事：把所有驅動源收集起來，用一個明確的閘取代解析函式。有 $k$ 個驅動源的 wand 變成一個 $k$ 輸入 AND；有 $k$ 個驅動源的 wor 變成一個 $k$ 輸入 OR。成本就是那個閘的成本 — $k$ 個驅動源大約是 $k-1$ 顆二輸入閘排成深度 $\lceil \log_2 k \rceil$ 的樹，當然對應器可能改用更寬的庫元件來覆蓋。對 0 與 1 而言行為完全相同；對 x 與 z 則不同，但既然 netlist 裡沒有 x，合成後那個差異就無關緊要。そこで合成器は当然のことをする。ドライバを集め、解決関数を明示的なゲートで置き換えるのである。ドライバが $k$ 個の wand は $k$ 入力 AND になり、$k$ 個の wor は $k$ 入力 OR になる。コストはそのゲートのコスト、すなわち $k$ 個のドライバに対しておよそ $k-1$ 個の 2 入力ゲートが深さ $\lceil \log_2 k \rceil$ の木に並ぶ分である。もちろんマッパはより多入力のライブラリセルで覆うこともある。0 と 1 に対するふるまいは同じで、x と z では異なるが、ネットリストに x は存在しないので合成後その差は問題にならない。

wand  busy;             // three units, each pulls busy low when idle
assign busy = unit0_busy;
assign busy = unit1_busy;
assign busy = unit2_busy;
// synthesises to: busy = unit0_busy & unit1_busy & unit2_busy

The practical advice is to write the AND yourself. The wired form saves nothing, surprises readers, and multiple continuous assignments to one name trip up lint rules and some tools' multi-driver checks. The reason the lecture mentions it at all is that legacy code — especially code imported from a board-level or TTL-era description — still contains it, and you need to recognise that it is harmless rather than a multi-driver error.實務上的建議是自己把 AND 寫出來。wired 形式什麼也沒省到，會讓讀者困惑，而且對同一個名字做多次連續指定會觸發 lint 規則與某些工具的多驅動源檢查。這一講之所以要提它，是因為舊程式碼 — 尤其是從板級或 TTL 時代描述移植過來的程式碼 — 仍然含有它，你必須認得出那是無害的，而不是多驅動源錯誤。実務的な助言は、AND を自分で書くことである。ワイヤード形式は何も節約せず、読み手を驚かせ、一つの名前への複数の連続代入は lint ルールや一部ツールのマルチドライバ検査に引っかかる。講義がこれに触れるのは、レガシーコード — とくにボードレベルや TTL 時代の記述から取り込まれたコード — にいまだ残っているからで、それがマルチドライバのエラーではなく無害であると見分けられる必要がある。

2.3 Register variables and the thirty-two-bit integer2.3 register 變數與三十二位元的 integer2.3 register 変数と 32 ビットの integer

The word reg is the single worst-chosen keyword in Verilog. It does not mean register. It means "an object that can be the target of a procedural assignment", and whether it becomes a flip-flop, a latch or a plain wire is decided by the inference pass according to the rules covered in Lectures 5 and 6: it becomes a flip-flop if it must hold a value across a clock edge, a latch if a combinational process can finish without assigning it, and a wire if every read in every pass is preceded by a write in the same pass. Section 10 of this page will show a reg declared in the counting-ones example that produces no storage at all.reg 這個字是 Verilog 裡選得最糟的關鍵字。它不是指暫存器。它的意思是「可以當成程序式指定目標的物件」，而它究竟變成正反器、閂鎖或單純的 wire，是由推論階段依第 5、6 講講過的規則決定：若它必須跨越時脈邊界保存值就變成正反器；若組合程序可能在沒有指定它的情況下結束就變成閂鎖；若每一條路徑上的每一次讀取之前都有同一條路徑上的寫入，就只是一條 wire。本頁第 10 節會示範一個在「數 1 的個數」範例裡宣告的 reg，它完全不產生任何儲存元件。reg は Verilog でもっとも選択を誤ったキーワードである。これはレジスタを意味しない。「手続き代入の対象になりうるオブジェクト」という意味であり、それがフリップフロップになるかラッチになるか単なる wire になるかは、第 5 講と第 6 講で扱った規則に従って推論パスが決める。クロックエッジをまたいで値を保持しなければならないならフリップフロップ、組合せプロセスが代入せずに終わりうるならラッチ、あらゆるパスで読み出しの前に同じパス内の書き込みがあるなら wire である。本ページの第 10 節では、1 の個数を数える例で宣言された reg が記憶素子をまったく生まないことを示す。

An integer is a reg with two extra properties: it is thirty-two bits wide and it is signed. Both matter. The width matters because the inference pass builds whatever the elaborated expression width demands. If you writeinteger 是一種多了兩個性質的 reg：它是三十二位元寬，而且是有號的。兩者都很要緊。位寬要緊，是因為推論階段會照展開後的運算式位寬去建硬體。如果你寫integer は二つの性質を追加した reg である。32 ビット幅で、かつ符号付きである。どちらも重要である。幅が重要なのは、推論パスがエラボレーション後の式幅が要求するものをそのまま構築するからである。次のように書けば

integer k;
always @(posedge clk) begin
  k = k + 1;
  q <= k[1:0];
end

then after elaboration there is a thirty-two-bit incrementer feeding thirty-two flip-flops, of which only two are read. The lecture's second bullet says the size "may be reduced in the optimisation process", and that is true here: the mapping pass performs constant and unused-bit propagation, discovers that bits 2 through 31 of k can never influence any output, and sweeps them away, leaving a two-bit counter. But the word is may, and the conditions under which it works are narrower than students expect. The sweep succeeds when the unused bits are provably unobservable. It fails the moment the wide value escapes — through a port, through a comparison against a wide constant, or into an expression whose width the tool must preserve — and then you really do get thirty-two flip-flops and a thirty-two-bit carry chain for a counter that needed two.展開之後就會有一個三十二位元的遞增器驅動三十二顆正反器，而其中只有兩顆被讀取。這一講第二個要點說，大小「在最佳化過程中可能被縮減」，這裡確實如此：對應階段執行常數與未使用位元的傳播，發現 k 的第 2 到 31 位永遠不可能影響任何輸出，就把它們掃掉，只剩一個兩位元計數器。但那個字是可能，而它生效的條件比學生以為的窄得多。只有當未使用的位元可被證明無法觀測時，掃除才會成功。一旦這個寬值逸出 — 經由一個埠、經由與一個寬常數的比較，或進入一個工具必須保留其位寬的運算式 — 掃除就失敗，於是一個只需要兩位元的計數器，你真的會拿到三十二顆正反器加一條三十二位元的進位鏈。エラボレーション後には 32 ビットのインクリメンタが 32 個のフリップフロップを駆動し、そのうち読まれるのは 2 個だけとなる。講義の二つ目の項目はサイズが「最適化の過程で削減されうる」と述べており、ここではそのとおりである。マッピングパスは定数伝播と未使用ビットの伝播を行い、k のビット 2〜31 がどの出力にも影響しえないと気づいて掃き出し、2 ビットカウンタを残す。しかし言葉は「されうる」であり、それが働く条件は学生が思うより狭い。掃き出しが成功するのは未使用ビットが観測不能だと証明できるときだけである。その広い値が逃げ出した瞬間 — ポートを通って、広い定数との比較を通って、あるいはツールが幅を保たねばならない式の中へ — 掃き出しは失敗し、2 ビットで済むカウンタに対して本当に 32 個のフリップフロップと 32 ビットのキャリーチェーンを得ることになる。

The fix is in the third bullet: declare things with the width you mean. reg [1:0] k; states the intent, is independent of tool cleverness, documents the design, and makes the wrap-around behaviour explicit rather than accidental. Reserve integer for loop indices in static loops, where it disappears at elaboration anyway and where its thirty-two-bit range conveniently removes any risk of the index wrapping before the loop terminates.解法在第三個要點：用你真正需要的位寬去宣告。reg [1:0] k; 明確表達意圖，不依賴工具聰不聰明，同時替設計留下文件，並把回繞行為變成明示而非偶然。把 integer 留給靜態迴圈的迴圈索引用 — 那裡它在展開時反正會消失，而它三十二位元的範圍剛好消除了索引在迴圈結束前回繞的風險。解決策は三つ目の項目にある。意図した幅で宣言することである。reg [1:0] k; は意図を明示し、ツールの賢さに依存せず、設計を文書化し、ラップアラウンドのふるまいを偶然ではなく明示的なものにする。integer は静的ループのループインデックスに限って使うとよい。そこではどのみちエラボレーション時に消えるし、32 ビットという範囲はループ終了前にインデックスがラップする危険を都合よく取り除いてくれる。

Sized constants有指定位寬的常數サイズ指定付きの定数

The same bullet applies to literals, and this is the more common bug. An unsized decimal literal such as 9 is, by IEEE 1364, a thirty-two-bit signed quantity. In most contexts Verilog's expression-width rules rescue you, because the width of a binary operation is the maximum of the widths of its operands and of the assignment target, so assign y = x + 9; with y and x four bits wide builds a four-bit adder. But three situations break that rescue, and each produces a real and surprising hardware cost.同一個要點也適用於文字常數，而這是更常見的錯誤。像 9 這樣未指定位寬的十進位常數，依 IEEE 1364 是一個三十二位元的有號量。在大多數情境下，Verilog 的運算式位寬規則會救你，因為二元運算的位寬是其運算元與指定目標位寬的最大值，所以 assign y = x + 9; 在 y 與 x 都是四位元時會建出一個四位元加法器。但有三種情況會讓這份救援失效，而每一種都造成真實且令人意外的硬體成本。同じ項目はリテラルにも当てはまり、こちらのほうが頻出するバグである。9 のようなサイズ指定のない 10 進リテラルは、IEEE 1364 では 32 ビットの符号付き量である。多くの文脈では Verilog の式幅規則が救ってくれる。二項演算の幅はオペランドと代入先の幅の最大値だからで、y と x が 4 ビットなら assign y = x + 9; は 4 ビット加算器を作る。しかしこの救済が崩れる状況が三つあり、どれも現実的で驚くようなハードウェアコストを生む。

The first is a self-determined context — a concatenation. {a, 9} is not {a, 4'd9}; it is {a, 32'd9}, a bus thirty-two bits longer than you wanted. The second is an unsized x or z literal: 'bx fills the target width, but 4'bx is 4'bxxxx while a bare 1'bx in a wide context zero-extends. The third, and the nastiest, is signedness. Unsized decimal literals are signed; sized literals are unsigned unless you write 's. Mixing them silently changes a whole expression's signedness, because in Verilog an expression is unsigned if any operand is unsigned, and the sign rule then governs how every operand is extended.第一種是自決定情境 — 串接。{a, 9} 不是 {a, 4'd9}，而是 {a, 32'd9}，一條比你想要的多了三十二位元的匯流排。第二種是未指定位寬的 x 或 z 常數：'bx 會填滿目標位寬，但 4'bx 等於 4'bxxxx，而在寬情境中單獨的 1'bx 會做零擴展。第三種也是最惡劣的一種，是有號性。未指定位寬的十進位常數是有號的；有指定位寬的常數除非你寫 's，否則是無號的。把它們混用會悄悄改變整個運算式的有號性，因為在 Verilog 裡只要任何一個運算元是無號的，整個運算式就是無號的，而這條符號規則接著決定每個運算元如何被擴展。第一は自己決定文脈 — 連結である。{a, 9} は {a, 4'd9} ではなく {a, 32'd9} であり、望んだより 32 ビット長いバスになる。第二はサイズ指定のない x や z のリテラルである。'bx は対象幅を埋めるが、4'bx は 4'bxxxx であり、広い文脈に置かれた裸の 1'bx はゼロ拡張される。第三はもっとも厄介な符号属性である。サイズ指定のない 10 進リテラルは符号付き、サイズ指定付きリテラルは 's を書かない限り符号なしである。これらを混ぜると式全体の符号属性が黙って変わる。Verilog ではどれか一つでもオペランドが符号なしなら式は符号なしとなり、その符号規則が各オペランドの拡張方法を支配するからである。

2.4 real, time and realtime2.4 real、time 與 realtime2.4 real、time、realtime

The lecture states flatly that real, time and realtime are not supported, and the reason is the one given in section 1.2. A real is a double-precision floating-point number in the simulator. Realising it would require the tool to invent a floating-point format, a rounding mode, denormal handling and exception semantics that the source text never specified, and then to instantiate an FPU costing tens of thousands of gates for what the designer probably thought was a convenience. A time or realtime variable holds simulation time, which exists only inside the simulator's event queue; there is no corresponding physical quantity in the finished chip.這一講直截了當地指出 real、time 與 realtime 不被支援，理由就是 1.2 節給的那個。real 在模擬器裡是一個雙精度浮點數。要把它實現出來，工具必須憑空發明原始碼從未指定的浮點格式、捨入模式、非正規數處理與例外語意，然後為設計者大概只是圖個方便的東西，實例化一個要花上數萬個閘的 FPU。time 或 realtime 變數保存的是模擬時間，那只存在於模擬器的事件佇列裡；完成的晶片上沒有對應的物理量。講義は real、time、realtime が非対応だと端的に述べており、その理由は 1.2 節で示したものである。real はシミュレータ内の倍精度浮動小数点数である。これを実現するには、ソーステキストが一度も指定していない浮動小数点形式、丸めモード、非正規数の扱い、例外意味論をツールが発明したうえで、設計者がおそらく便利さのつもりで書いたものに対して数万ゲート規模の FPU をインスタンス化しなければならない。time や realtime 変数はシミュレーション時刻を保持するが、それはシミュレータのイベントキューの中にしか存在せず、完成したチップに対応する物理量はない。

These types remain perfectly legal and extremely useful outside the synthesisable part of the design. Test benches use real for computing expected analogue values, for signal-to-noise ratio checks on a communication data path, and for timing measurements; they use time with $time and $realtime for latency instrumentation. Lecture 2 of this course covers that usage. The discipline is simply to keep them on the test-bench side of the boundary and out of any module that will be handed to the synthesiser.這些型態在設計的可合成部分之外仍然完全合法，而且極為有用。測試平台用 real 計算期望的類比值、對通訊資料路徑做訊號雜訊比檢查，以及做時序量測；也用 time 搭配 $time 與 $realtime 做延遲量測。本課程第 2 講涵蓋這類用法。紀律很簡單：把它們留在測試平台這一側，不要讓它們出現在任何要交給合成器的模組裡。これらの型は設計の合成可能部分の外側では完全に合法で、きわめて有用である。テストベンチは期待されるアナログ値の計算、通信データパスの信号対雑音比チェック、タイミング測定に real を使い、レイテンシ計測には $time／$realtime とともに time を使う。本科目の第 2 講がその用法を扱う。守るべき規律は単純で、それらを境界のテストベンチ側にとどめ、合成器に渡すモジュールには入れないことである。

The same reasoning extends to several things the slide does not list but that belong in the same category: system tasks such as $display, $monitor and $finish (ignored or rejected, with the standard exception of $signed, $unsigned and the $clog2-style elaboration-time functions, which are compile-time computations rather than runtime behaviour); file I/O; force and release; named events; and initial blocks, which describe power-up behaviour that an ASIC flip-flop simply does not have. An FPGA flow is more permissive about initial because the bitstream can preload the flip-flops, which is one of the few genuine differences between the ASIC and FPGA synthesisable subsets.同樣的道理也延伸到幾件投影片沒列、但屬於同一類的東西：系統任務如 $display、$monitor 與 $finish（被忽略或拒絕，標準的例外是 $signed、$unsigned 以及 $clog2 這類在展開期求值的函式，它們是編譯期計算而非執行期行為）；檔案 I/O；force 與 release；具名事件；以及 initial 區塊 — 它描述的是 ASIC 正反器根本沒有的上電行為。FPGA 流程對 initial 較為寬容，因為位元流可以預載正反器，這是 ASIC 與 FPGA 可合成子集之間少數幾個真正的差異之一。同じ理屈は、スライドに列挙されていないが同じカテゴリに属するいくつかのものにも及ぶ。$display、$monitor、$finish といったシステムタスク（無視されるか拒否される。標準的な例外は $signed、$unsigned および $clog2 系のエラボレーション時関数で、これらは実行時のふるまいではなくコンパイル時の計算である）、ファイル I/O、force と release、名前付きイベント、そして ASIC のフリップフロップには存在しない電源投入時のふるまいを記述する initial ブロックである。FPGA フローは initial により寛容である。ビットストリームがフリップフロップをプリロードできるからで、これは ASIC と FPGA の合成可能サブセットの数少ない本質的な差の一つである。

(a) wire [3:0] y;  assign y = a + 1;
(b) wire [35:0] z; assign z = {a, 32};
(c) integer n;     always @(posedge clk) n = n + 1;  assign flag = n[3];
(d) wire [4:0] s;  assign s = a + b;
(e) reg signed [3:0] p; wire [3:0] q; assign r = (p < q);

3. x and z in a Two-Valued World3. 二值世界裡的 x 與 z3. 2 値の世界における x と z

This is the part of Lecture 7 that most reliably costs marks, and it is also the part where the slide's bullet list is most compressed. The slide says: the only allowable uses of x are in casex, in casez and in the defaults of conditionals; the only allowable use of z is in constructs implying a tri-state output. Underneath those two sentences sit a semantic distinction that the Verilog language itself blurs, a classic simulation-divergence trap, and a genuinely useful optimisation lever. Take them in order.這是第 7 講最常讓人失分的部分，也是投影片條列壓縮得最嚴重的部分。投影片說：x 唯一允許的用法是在 casex、casez 以及條件式的預設分支中；z 唯一允許的用法是在隱含三態輸出的構件中。這兩句話底下藏著一個連 Verilog 語言本身都模糊掉的語意區別、一個經典的模擬分歧陷阱，以及一個真正有用的最佳化槓桿。依序來看。ここは第 7 講でもっとも確実に点を失う部分であり、スライドの箇条書きがもっとも圧縮されている部分でもある。スライドはこう述べる。x が許されるのは casex、casez、および条件文のデフォルトの中だけ。z が許されるのはトライステート出力を暗示する構文の中だけ、と。この 2 文の下には、Verilog 言語自身がぼかしている意味論的区別、古典的なシミュレーション乖離の罠、そして本当に有用な最適化の梃子が潜んでいる。順に見ていく。

3.1 Why silicon has no x3.1 為什麼矽晶片裡沒有 x3.1 シリコンに x が存在しない理由

Verilog's four values are 0, 1, x and z, and only three of them describe anything physical. A 0 is a node held near ground by a conducting pull-down stack. A 1 is a node held near the supply by a conducting pull-up stack. A z is a node held by nothing at all, because every driver attached to it is off — the output of a disabled tri-state buffer, or a bus nobody is currently driving. Those three are states a voltmeter could distinguish.Verilog 的四個值是 0、1、x 與 z，其中只有三個描述實際存在的物理狀態。0 是被導通的下拉堆疊拉到接近地的節點。1 是被導通的上拉堆疊拉到接近電源的節點。z 是完全沒有東西在保持的節點，因為接到它的每個驅動源都關閉了 — 例如一顆被禁用的三態緩衝器的輸出，或一條目前沒人驅動的匯流排。這三個是電壓表分辨得出來的狀態。Verilog の 4 値は 0、1、x、z であり、物理的な何かを記述するのはそのうち 3 つだけである。0 は導通したプルダウンスタックによってグラウンド付近に保たれたノード。1 は導通したプルアップスタックによって電源付近に保たれたノード。z は何にも保持されていないノードで、接続されたドライバがすべてオフだからである — 無効化されたトライステートバッファの出力や、現在誰も駆動していないバスがそれに当たる。この 3 つは電圧計で区別できる状態である。

An x is not a state. It is the simulator's way of saying "I do not know what this is". It appears when a flip-flop has not been reset and so has no defined initial content; when two drivers fight and the resolved value is genuinely indeterminate; when a timing check fails; or when an unknown propagates through a gate. A real node, at any instant, is at some voltage. It is never "unknown" — our model is uncertain, the silicon is not. This single observation is the whole of the x-rules.x 不是一個狀態。它是模擬器說「我不知道這是什麼」的方式。它出現在正反器尚未重置因而沒有定義好的初始內容時；兩個驅動源相爭、解析後的值真的不確定時；時序檢查失敗時；或未知值穿過一個閘傳播時。真實的節點在任何瞬間都處於某個電壓，它永遠不會是「未知」 — 不確定的是我們的模型，不是矽。這一個觀察就是 x 規則的全部。x は状態ではない。これは「これが何か分からない」とシミュレータが言うための手段である。フリップフロップがリセットされておらず初期値が定義されていないとき、二つのドライバが競合して解決値が本当に不定のとき、タイミングチェックが失敗したとき、あるいは未知値がゲートを通って伝播したときに現れる。実在のノードはどの瞬間にも何らかの電圧にある。決して「未知」ではない — 不確かなのは我々のモデルであって、シリコンではない。この一つの観察が x に関する規則のすべてである。

3.2 x as a don't care, and what the optimiser does with it3.2 把 x 當成 don't care，以及最佳化器拿它做什麼3.2 ドントケアとしての x と、最適化器がそれで何をするか

When you assign x to a variable in the default branch of a conditional, you are making a promise to the tool: "this combination of inputs will never occur, or if it does I do not care what comes out". The tool takes you at your word and treats the corresponding entries of the truth table as don't cares. In classical two-level minimisation these are the $d$ terms of a Karnaugh map, and they are free to be covered or left uncovered, whichever makes the prime implicants larger. In modern multi-level optimisation they become external don't-care sets that the engine uses when resubstituting and simplifying nodes.當你在條件式的預設分支把 x 指定給一個變數，你是在對工具做出承諾：「這組輸入組合永遠不會發生，就算發生了我也不在乎輸出是什麼」。工具會照字面採信，把真值表中對應的項目視為 don't care。在古典的二階最小化裡，這些就是卡諾圖上的 $d$ 項，可以自由決定要不要被涵蓋，哪一種讓質蘊涵項更大就選哪一種。在現代多層最佳化裡，它們變成引擎在重新代換與化簡節點時會用到的外部 don't-care 集合。条件文のデフォルト分岐で変数に x を代入するとき、あなたはツールに約束をしている。「この入力の組合せは決して起こらない、あるいは起きても出力が何であっても構わない」と。ツールはその言葉どおりに受け取り、真理値表の対応する項目をドントケアとして扱う。古典的な 2 段階最小化ではこれがカルノー図の $d$ 項であり、主項が大きくなるほうを選んで覆っても覆わなくてもよい。現代の多段最適化では、ノードの再代入と簡単化の際にエンジンが用いる外部ドントケア集合になる。

The gain can be dramatic. Consider a three-bit opcode with only four defined operations:效果可能非常顯著。考慮一個只定義了四種運算的三位元 opcode：効果は劇的になりうる。定義された演算が 4 つしかない 3 ビットのオペコードを考える。

always @* begin
  case (op)
    3'b111:  y = a & b;
    3'b011:  y = a | b;
    3'b001:  y = a ^ b;
    default: y = 2'b00;    // a real value
  endcase
end

always @* begin
  case (op)
    3'b111:  y = a & b;
    3'b011:  y = a | b;
    3'b001:  y = a ^ b;
    default: y = 2'bx;     // don't care
  endcase
end

The lecture's ALU example on slide 19 is exactly this situation with the bits permuted, and the slide's own parenthetical remark — "note that unused input s2 is retained" — is the observable consequence. All three listed cases have the same value in one select position, the don't cares let the optimiser drop that select bit from the logic, and the port stays behind as a stub for the reasons given in section 2.1.這一講第 19 張投影片的 ALU 範例，就是位元排列不同的同一個情況，而投影片自己那句括號裡的註記 —「注意未使用的輸入 s2 被保留了下來」— 就是可觀測的後果。三個列出的 case 在某個選擇位置上的值相同，don't care 讓最佳化器把那個選擇位元從邏輯中移除，而那個埠因為 2.1 節講的理由，以一個樁的形式留了下來。講義のスライド 19 の ALU の例は、ビットの並びが違うだけで、まさにこの状況である。そしてスライド自身の括弧書き —「未使用の入力 s2 が残っていることに注意」— がその観測可能な帰結である。列挙された 3 つのケースはある選択位置で同じ値を持つため、ドントケアが最適化器にその選択ビットを論理から外させ、ポートは 2.1 節で述べた理由によりスタブとして残るのである。

Both versions above are correct designs. The difference is a trade. The don't-care version is smaller and faster; the fully specified version is deterministic, which means it behaves identically in RTL simulation, in gate simulation and in silicon even when an illegal opcode somehow reaches it. In a communication IC where an opcode might be corrupted by a soft error or by a mis-synchronised control bus, the determinism is often worth the gates. The usual compromise is to specify a real default in control logic that can see illegal inputs, and to use x only in datapath decoders whose inputs are provably constrained.上面兩個版本都是正確的設計。差別是一項取捨。don't-care 版本比較小、比較快；完整指定的版本則是確定性的，意思是即使某個非法 opcode 不知怎地跑了進來，它在 RTL 模擬、閘級模擬與矽晶片上的行為都完全一致。在通訊 IC 裡，opcode 可能被軟錯誤或未同步的控制匯流排破壞，這份確定性往往值得那些閘。常見的折衷是：在看得到非法輸入的控制邏輯裡指定真正的 default，而只在輸入可被證明受限的資料路徑解碼器裡使用 x。上記のどちらの版も正しい設計である。違いはトレードオフにある。ドントケア版は小さく速い。完全指定版は決定的であり、不正なオペコードが何らかの形で到達しても RTL シミュレーション、ゲートシミュレーション、シリコンで同一にふるまう。ソフトエラーや同期の崩れた制御バスによってオペコードが壊れうる通信 IC では、この決定性はしばしばゲート数に見合う。通常の妥協点は、不正入力を見うる制御論理では本物のデフォルトを指定し、入力が制約されていると証明できるデータパスのデコーダにだけ x を使うことである。

3.3 Why if (a == 1'bx) is meaningless3.3 為什麼 if (a == 1'bx) 毫無意義3.3 if (a == 1'bx) が無意味な理由

Students write this line every semester, usually trying to catch an uninitialised value. It is wrong twice over, and the two failures are different, so it is worth separating them carefully.學生每個學期都會寫下這一行，通常是想抓出未初始化的值。它錯了兩次，而且兩種錯法不同，所以值得仔細分開來談。学生は毎学期この行を書く。たいていは未初期化の値を捕まえようとしてのことである。これは二重に誤っており、二つの失敗は性質が異なるので、丁寧に分けて論じる価値がある。

The simulation failure. In IEEE 1364, the equality operators == and != are four-state comparisons that propagate unknowns. If either operand contains an x or a z in any bit position, the result is not 0 and not 1; it is 1'bx. And an if statement treats x exactly as it treats 0 — the condition is false unless it is unambiguously true. Therefore if (a == 1'bx) is false when a is 0, false when a is 1, and false when a is x, because then the comparison returns x which the if rejects. The branch is dead code in every possible case. Worse, it is dead code that looks alive, so the designer believes the check is running.模擬上的失敗。在 IEEE 1364 中，相等運算子 == 與 != 是會傳播未知值的四值比較。只要任一運算元的任一位元含有 x 或 z，結果就既不是 0 也不是 1，而是 1'bx。而 if 敘述對待 x 的方式和對待 0 完全一樣 — 除非條件明確為真，否則就是假。因此 if (a == 1'bx) 在 a 為 0 時是假、a 為 1 時是假、a 為 x 時也是假，因為那時比較回傳 x，而 if 把它拒絕。這個分支在所有可能情況下都是死碼。更糟的是，它是看起來活著的死碼，於是設計者以為這道檢查正在運作。シミュレーション上の失敗。IEEE 1364 では、等価演算子 == と != は未知値を伝播する4 値比較である。どちらかのオペランドのどこか 1 ビットでも x または z を含めば、結果は 0 でも 1 でもなく 1'bx になる。そして if 文は x を 0 とまったく同じに扱う — 明確に真でない限り条件は偽である。したがって if (a == 1'bx) は a が 0 のとき偽、a が 1 のとき偽、a が x のときも偽である。そのとき比較は x を返し、if がそれを拒否するからである。この分岐はあらゆる場合において死んだコードである。さらに悪いことに、生きているように見える死んだコードなので、設計者は検査が働いていると信じてしまう。

if (a == 1'bx)  flag = 1;   // NEVER taken, for any value of a
else            flag = 0;

The synthesis failure. Suppose you repair the simulation problem by using the case-equality operator ===, which does compare x and z literally and returns a definite 0 or 1:合成上的失敗。假設你用 case 相等運算子 === 修好了模擬問題 — 它確實會逐字比較 x 與 z，並回傳明確的 0 或 1：合成上の失敗。ケース等価演算子 === を使ってシミュレーションの問題を直したとしよう。これは x と z を文字どおり比較し、明確な 0 か 1 を返す。

if (a === 1'bx) flag = 1;   // works in simulation, has no hardware
else            flag = 0;

Now the line behaves as intended in RTL simulation but cannot be built. To build it the tool would have to emit a cell that detects "this node is in an unknown state", and no such cell exists, because as section 3.1 argued the state does not exist. Most synthesisers reject === and !== outright with an "operator not supported for synthesis" error. A few accept them and silently constant-fold the comparison against an x literal to the constant 0, which leaves you with flag = 0 hard-wired and a design that behaves differently before and after synthesis. Either way the check you wanted is not in the chip.現在這一行在 RTL 模擬裡如你所願地運作，卻建不出來。要建出它，工具必須產生一顆能偵測「這個節點處於未知狀態」的元件，而這樣的元件並不存在，因為如 3.1 節所論證的，那個狀態並不存在。大多數合成器會直接以「此運算子不支援合成」的錯誤拒絕 === 與 !==。少數工具會接受它們，並悄悄把與 x 常數的比較常數摺疊成常數 0，於是你得到硬接線的 flag = 0，以及一個合成前後行為不同的設計。不論哪一種，你想要的檢查都不在晶片裡。この行は RTL シミュレーションでは意図どおり動くが、作ることはできない。作るにはツールが「このノードは未知状態にある」と検出するセルを出力せねばならないが、3.1 節で論じたようにその状態が存在しない以上、そんなセルも存在しない。ほとんどの合成器は「この演算子は合成に対応していない」というエラーで === と !== をきっぱり拒否する。一部は受け付けたうえで、x リテラルとの比較を黙って定数 0 に畳み込む。その結果 flag = 0 が固定配線され、合成前後でふるまいの異なる設計が残る。いずれにせよ、望んだ検査はチップの中にない。

If what you actually want is to detect an uninitialised or corrupted value in the real chip, you must encode the condition in real bits: add a valid flag that reset clears, use a redundant encoding such as one-hot with an explicit "no state asserted" detector, or add parity or ECC. There is no way around this. Unknown-ness is a property of your model, and only real bits survive synthesis.如果你真正想做的是在實際晶片裡偵測未初始化或損毀的值，你必須把這個條件編碼成真實的位元：加一個重置時清除的 valid 旗標、改用像是 one-hot 這種冗餘編碼並配上明確的「沒有任何狀態被設定」偵測器，或是加上同位元或 ECC。沒有別的辦法。未知性是你的模型的性質，而只有真實的位元能通過合成存活下來。実際のチップで未初期化や破損した値を検出したいのであれば、その条件を実在のビットで符号化しなければならない。リセットでクリアされる valid フラグを追加する、ワンホットのような冗長符号化と「どの状態も立っていない」ことを検出する回路を使う、あるいはパリティや ECC を加える。これを回避する方法はない。未知であることはあなたのモデルの性質であり、合成を生き延びるのは実在のビットだけである。

3.4 casex and casez: what they really do to the comparison3.4 casex 與 casez：它們對比較做了什麼3.4 casex と casez：比較に実際何をするのか

An ordinary case statement compares the case expression against each case item using the four-state identity rule — bit for bit, with x matching only x and z matching only z. casez and casex change that comparison by introducing a mask.一般的 case 敘述會用四值同一性規則，把 case 運算式逐位元與每個 case item 比較 — x 只和 x 相符，z 只和 z 相符。casez 與 casex 則引入一個遮罩來改變這個比較。通常の case 文は、ケース式を各ケースアイテムと 4 値同一性規則で比較する。ビットごとに比較し、x は x とだけ、z は z とだけ一致する。casez と casex はマスクを導入してこの比較を変える。

• casez treats a z value as a don't-care position. Since the literal ? in Verilog is simply another way of writing z, this is what lets you write 4'b1??0. Crucially, the don't care applies whether the z appears in the case item or in the case expression.casez 把 z 值視為 don't-care 位置。由於 Verilog 裡的 ? 常數不過是 z 的另一種寫法，這就是你能寫 4'b1??0 的原因。關鍵在於，不論 z 出現在 case item或 case 運算式，這個 don't care 都成立。casez は z の値をドントケア位置として扱う。Verilog のリテラル ? は z の別表記にすぎないので、これにより 4'b1??0 と書ける。重要なのは、z がケースアイテム側に現れてもケース式側に現れても、このドントケアが適用されることである。
• casex treats both x and z as don't-care positions, again on either side of the comparison.casex 把 x 與 z 都視為 don't-care 位置，同樣不分比較的哪一側。casex は x と z の両方をドントケア位置として扱う。これも比較のどちら側でも同様である。

The right mental model is not "the tool ignores some bits" but "the comparison is performed only on the positions where both sides are 0 or 1". Formally, for a case item $I$ and a case expression $E$ of $n$ bits, define a per-bit mask $m_i$ that is 0 where either $E_i$ or $I_i$ is a wildcard and 1 elsewhere. The item matches when正確的心智模型不是「工具忽略某些位元」，而是「比較只在兩側都是 0 或 1 的位置上進行」。形式上，對一個 $n$ 位元的 case item $I$ 與 case 運算式 $E$，定義逐位元遮罩 $m_i$：當 $E_i$ 或 $I_i$ 任一為萬用字元時為 0，其餘為 1。該 item 相符的條件是正しいメンタルモデルは「ツールが一部のビットを無視する」ではなく「比較は両側がともに 0 か 1 である位置でのみ行われる」である。形式的には、$n$ ビットのケースアイテム $I$ とケース式 $E$ に対し、$E_i$ か $I_i$ のいずれかがワイルドカードであれば 0、それ以外では 1 となるビットごとのマスク $m_i$ を定義する。アイテムが一致するのは次のときである。

In hardware the mask is almost always constant, because the wildcards sit in the literal case items and the case expression is a real signal that can only be 0 or 1. A constant mask costs nothing: the bit positions that are masked out simply have no gate attached to them. So a casez item such as 4'b1??0 becomes a two-input comparison on bits 3 and 0 only — one AND gate with one inverted input, about 1 GE — instead of the four-bit comparison an ordinary case item would need. That is the entire hardware meaning of a wildcard: fewer wires reach the comparator.在硬體裡這個遮罩幾乎永遠是常數，因為萬用字元落在字面的 case item 裡，而 case 運算式是只可能為 0 或 1 的真實訊號。常數遮罩不花任何成本：被遮掉的位元位置根本沒有閘接上去。所以像 4'b1??0 這樣的 casez item 只變成對第 3 位與第 0 位的兩輸入比較 — 一顆帶一個反相輸入的 AND 閘，約 1 GE — 而不是一般 case item 所需的四位元比較。這就是萬用字元在硬體上的全部意義：到達比較器的線變少了。ハードウェアではこのマスクはほぼ常に定数である。ワイルドカードはリテラルのケースアイテム側にあり、ケース式は 0 か 1 しか取りえない実在の信号だからである。定数マスクはコストゼロで、マスクされたビット位置にはそもそもゲートが接続されない。したがって 4'b1??0 のような casez アイテムは、通常の case アイテムが必要とする 4 ビット比較ではなく、ビット 3 とビット 0 だけの 2 入力比較 — 入力の一方を反転した AND ゲート 1 個、約 1 GE — になる。これがワイルドカードのハードウェア上の意味のすべてである。比較器に届く配線が減るのである。

Priority is still priority優先權仍然是優先權優先順位はやはり優先順位である

One further point that the slide does not make and that costs marks: casez and casex items are still evaluated in order. Because wildcards make overlapping items easy to write, a wildcard case statement is almost always a priority encoder, not a parallel multiplexer. The canonical interrupt arbiter makes this obvious:還有一點投影片沒提、卻會讓人失分：casez 與 casex 的 item 仍然是依順序求值的。由於萬用字元讓重疊的 item 很容易寫出來，帶萬用字元的 case 敘述幾乎永遠是一個優先編碼器，而不是平行多工器。典型的中斷仲裁器讓這點一目了然：スライドが述べておらず、しかも失点につながる点がもう一つある。casez と casex のアイテムは依然として順番に評価される。ワイルドカードがあると重なり合うアイテムを書きやすいため、ワイルドカード付きの case 文はほぼ常に並列マルチプレクサではなくプライオリティエンコーダになる。典型的な割り込みアービタを見れば明らかである。

casez (req)                       // req is 4 bits, one bit per requester
  4'b1???: grant = 2'd3;          // highest priority
  4'b01??: grant = 2'd2;
  4'b001?: grant = 2'd1;
  4'b0001: grant = 2'd0;
  default: grant = 2'd0;
endcase

Here req = 4'b1100 matches the first item and also the second, and the first wins. The hardware is a chain of priority logic whose depth grows linearly with the number of items: roughly $k-1$ levels for $k$ items, or about $2k$ GE for a small $k$, compared with the $\log_2 k$ depth of a balanced multiplexer. For a four-way arbiter that is nothing; for a sixty-four-entry wildcard case it is a very long path, and you should instead build an explicit logarithmic priority encoder. Note also that the items above were deliberately written so that they are also mutually exclusive given the leading zeros — had I written 4'b??1? style items the priority behaviour would be much harder to read.這裡 req = 4'b1100 同時符合第一個與第二個 item，而第一個勝出。硬體是一串優先權邏輯，其深度隨 item 數線性成長：$k$ 個 item 大約 $k-1$ 層，小的 $k$ 約 $2k$ GE；相較之下平衡多工器的深度是 $\log_2 k$。對四路仲裁器來說這不算什麼；但對六十四項的萬用字元 case 來說就是一條很長的路徑，這時你應該改建一個明確的對數式優先編碼器。另外請注意，上面的 item 是刻意寫成在既有前導零的前提下彼此互斥的 — 如果我寫成 4'b??1? 這類 item，優先權行為會難讀得多。ここで req = 4'b1100 は最初のアイテムにも 2 番目のアイテムにも一致し、最初が勝つ。ハードウェアはアイテム数とともに深さが線形に増える優先順位論理の連鎖になる。$k$ 個のアイテムでおよそ $k-1$ 段、小さな $k$ なら約 $2k$ GE であり、平衡したマルチプレクサの深さ $\log_2 k$ と対照的である。4 方向のアービタなら問題にならないが、64 エントリのワイルドカード case では非常に長いパスになるので、代わりに明示的な対数段数のプライオリティエンコーダを作るべきである。なお上記のアイテムは、先頭のゼロを所与とすれば互いに排他にもなるよう意図的に書いてある。4'b??1? のような形で書いていたら、優先順位のふるまいはずっと読み取りにくかっただろう。

3.5 The classic casex trap3.5 經典的 casex 陷阱3.5 古典的な casex の罠

Now the trap the slide hints at by listing casex and casez but never distinguishing them. Reread the definition: casex treats x and z as don't cares on either side of the comparison. That symmetry is the bug. Consider:現在來看投影片只把 casex 與 casez 並列、卻從不加以區分所暗示的那個陷阱。重讀定義：casex 把 x 與 z 在比較的兩側都視為 don't care。那個對稱性就是臭蟲。考慮：ここでスライドが casex と casez を並べるだけで区別しないことがほのめかす罠を見る。定義を読み直そう。casex は x と z を比較のどちら側でもドントケアとして扱う。この対称性こそがバグである。次を考える。

always @* begin
  casex (sel)
    4'b1xxx: y = a;
    4'b01xx: y = b;
    4'b001x: y = c;
    4'b0001: y = d;
    default: y = 4'b0;
  endcase
end

always @* begin
  casez (sel)
    4'b1???: y = a;
    4'b01??: y = b;
    4'b001?: y = c;
    4'b0001: y = d;
    default: y = 4'b0;
  endcase
end

Both describe the same priority encoder, and both synthesise to the same netlist. They differ only in RTL simulation, and only when sel itself is not fully defined — which is exactly the situation in the first few nanoseconds after power-up, before reset has propagated, or whenever an upstream flip-flop is unreset.兩者描述的是同一個優先編碼器，也合成出同一份 netlist。它們只在 RTL 模擬中有差別，而且只有當 sel 本身沒有完全定義時才有差別 — 那正是上電後頭幾奈秒、重置尚未傳播開來時的情況，或任何上游正反器未被重置時的情況。どちらも同じプライオリティエンコーダを記述し、同じネットリストに合成される。違いは RTL シミュレーションにのみ現れ、しかも sel 自身が完全には定義されていないときだけである。それはまさに電源投入後の最初の数ナノ秒、リセットが伝播し切る前の状況であり、あるいは上流のフリップフロップがリセットされていないときの状況である。

Suppose sel = 4'bxxxx because the register driving it has not been reset. Under casex the first item 4'b1xxx compares bit 3 of the expression (x) against bit 3 of the item (1), finds an x on the expression side, masks the position, and — since the remaining three positions are wildcards in the item — declares a match. The statement takes the first branch and assigns y = a, cleanly and silently. RTL simulation shows a perfectly healthy multiplexer selecting a. The gate netlist, which has no x and whose sel will be some arbitrary 0/1 pattern, selects whatever that pattern decodes to. The two simulations disagree, and the RTL one is the optimistic liar.假設 sel = 4'bxxxx，因為驅動它的暫存器沒有被重置。在 casex 之下，第一個 item 4'b1xxx 會拿運算式的第 3 位（x）去比對 item 的第 3 位（1），發現運算式側是 x，於是把該位置遮掉，而既然 item 裡其餘三個位置都是萬用字元，它就宣告相符。敘述走進第一個分支，乾淨而安靜地指定 y = a。RTL 模擬顯示一個完全健康、正在選擇 a 的多工器。而閘級 netlist 裡沒有 x，它的 sel 會是某組任意的 0/1 樣式，於是選到那組樣式解碼出來的東西。兩邊的模擬不一致，而說謊的是過度樂觀的 RTL 那一邊。sel = 4'bxxxx だとしよう。それを駆動するレジスタがリセットされていないからである。casex のもとでは、最初のアイテム 4'b1xxx は式のビット 3（x）とアイテムのビット 3（1）を比較し、式側が x であることを見つけてその位置をマスクし、アイテムの残り 3 位置はワイルドカードなので一致を宣言する。文は最初の分岐に入り、きれいに、そして静かに y = a を代入する。RTL シミュレーションは a を選択する完全に健全なマルチプレクサを示す。x を持たず sel が任意の 0/1 パターンになるゲートネットリストは、そのパターンがデコードするものを選ぶ。二つのシミュレーションは食い違い、楽観的な嘘をついているのは RTL のほうである。

Under casez the same stimulus behaves differently and much better. The x on the expression side is not a wildcard for casez — only z is. So bit 3 compares x against 1 and yields x, the item does not definitively match, and the simulator falls through. In fact every item fails, the default is taken, and y gets 4'b0; depending on the simulator and on the exact pattern you may also see x propagate onto y. Either way the unknown is visible rather than hidden.在 casez 之下，同樣的激勵行為不同，而且好得多。對 casez 來說運算式側的 x 不是萬用字元 — 只有 z 是。所以第 3 位拿 x 比對 1 得到 x，該 item 並未確定相符，模擬器就往下掉。事實上每個 item 都失敗，於是走 default，y 得到 4'b0；視模擬器與確切樣式而定，你也可能看到 x 傳播到 y 上。不論哪一種，未知值都是可見的，而不是被藏起來。casez のもとでは同じ刺激に対するふるまいが異なり、はるかに望ましい。casez にとって式側の x はワイルドカードではない — z だけがそうである。したがってビット 3 は x と 1 を比較して x を返し、アイテムは確定的に一致せず、シミュレータは次へ落ちる。実際すべてのアイテムが失敗して default が選ばれ、y には 4'b0 が入る。シミュレータと具体的なパターンによっては x が y に伝播するのも見えるだろう。いずれにせよ未知値は隠されず、目に見える。

There is a smaller cousin of the same trap in casez itself. If the case expression is a bus that can genuinely float — the output of a tri-state bus, for instance — then a z really can reach the expression and casez will mask on it exactly as casex masks on an x. This is rare inside a synchronous block, but it is the reason the careful formulation is "wildcards belong in the items" rather than "casez is safe".同樣的陷阱在 casez 本身也有一個小一號的近親。如果 case 運算式是一條真的可能浮接的匯流排 — 例如三態匯流排的輸出 — 那麼 z 確實可能到達運算式，而 casez 會對它遮罩，就像 casex 對 x 遮罩一樣。這在同步區塊裡很罕見，但這正是為什麼謹慎的說法是「萬用字元屬於 item」，而不是「casez 是安全的」。同じ罠の一回り小さい親類が casez 自身にもある。ケース式が本当にフロートしうるバス — たとえばトライステートバスの出力 — であれば、z は実際に式に到達しうるし、casez は casex が x でマスクするのとまったく同様にそれでマスクする。同期ブロック内ではまれだが、慎重な言い方が「casez は安全である」ではなく「ワイルドカードはアイテムに属する」である理由はここにある。

3.6 z and tri-state outputs3.6 z 與三態輸出3.6 z とトライステート出力

The z rules are shorter because there is only one thing to say: z is the only four-state value that does correspond to a buildable cell, namely a tri-state buffer, and assigning z in a conditional is how you ask for one.z 的規則比較短，因為只有一件事要說：z 是唯一確實對應到某顆可建元件的四值值 — 也就是三態緩衝器 — 而在條件式中指定 z，就是你要求一顆三態緩衝器的方式。z の規則は短い。言うべきことが一つしかないからである。z は実際に構築可能なセル、すなわちトライステートバッファに対応する唯一の 4 値であり、条件文で z を代入することがそれを要求する方法なのである。

assign dout = oe ? data : 8'bz;        // 8 tri-state buffers, enable = oe

The inference rule is precise: in a conditional whose branches are a normal expression and the literal z, the tool instantiates one tri-state driver per bit, with the branch condition driving the enable pin. The slide's wording — "z assigned to wire or reg as the default outcome for a conditional statement" — covers both the continuous-assignment form above and the procedural form inside an always block. The lecture's ALU example uses exactly this: assign alu_out = (en == 1) ? out_int : 2'bz; gives two tri-state buffers between the internal register and the output port.推論規則很精確：在一個分支為正常運算式、另一分支為常數 z 的條件式中，工具會為每個位元實例化一顆三態驅動器，並讓分支條件驅動其致能腳。投影片的用語 —「z 被指定給 wire 或 reg 作為條件敘述的預設結果」— 同時涵蓋上面的連續指定形式與 always 區塊內的程序式形式。這一講的 ALU 範例用的正是這個：assign alu_out = (en == 1) ? out_int : 2'bz; 在內部暫存器與輸出埠之間放了兩顆三態緩衝器。推論規則は明確である。分岐の一方が通常の式、他方がリテラル z である条件文では、ツールはビットごとにトライステートドライバを一つインスタンス化し、分岐条件をそのイネーブルピンに接続する。スライドの表現 —「条件文の既定の結果として wire または reg に z を代入する」— は、上記の連続代入形式と always ブロック内の手続き形式の両方を指す。講義の ALU の例はまさにこれで、assign alu_out = (en == 1) ? out_int : 2'bz; は内部レジスタと出力ポートの間にトライステートバッファを 2 個置く。

A tri-state buffer is not free. On a typical library a tri-state inverter or buffer is about 2 to 3 GE, comparable to a multiplexer, and it is slower than an ordinary buffer because the enable path must gate both the pull-up and the pull-down stack. It also brings three real engineering problems that a multiplexer does not: a floating node has no defined value, so the bus must either be guaranteed always driven or be fitted with a bus holder (a weak keeper, which costs area and fights the drivers during a transition); contention between two drivers that are both enabled is a short circuit that burns current and can damage the chip; and automatic test-pattern generation must prove that no test ever enables two drivers at once, which is hard and sometimes requires extra logic.三態緩衝器不是免費的。在典型的庫裡，一顆三態反相器或緩衝器約 2 到 3 GE，與多工器相當，而且比一般緩衝器慢，因為致能路徑必須同時閘控上拉與下拉堆疊。它還帶來三個多工器沒有的真實工程問題：浮接節點沒有定義好的值，所以匯流排要嘛必須保證永遠有人驅動，要嘛得裝上 bus holder（一個弱保持器，既佔面積又在轉態時與驅動源對抗）；兩個同時致能的驅動源相爭是短路，會燒電流甚至損壞晶片；而自動測試樣式產生必須證明沒有任何測試會同時致能兩個驅動源，這很困難，有時還需要額外邏輯。トライステートバッファは無料ではない。典型的なライブラリではトライステートのインバータやバッファは約 2〜3 GE でマルチプレクサに匹敵し、イネーブル経路がプルアップとプルダウンの両スタックをゲートせねばならないため通常のバッファより遅い。さらにマルチプレクサにはない現実の設計問題を三つ持ち込む。フローティングのノードには定義された値がないため、バスは常に駆動されることを保証するか、バスホルダ（面積を食い、遷移中にドライバと競合する弱いキーパ）を付けるかしなければならない。二つのドライバが同時にイネーブルになる競合は短絡であり、電流を食いチップを損傷しうる。そして自動テストパターン生成は、いかなるテストでも二つのドライバが同時にイネーブルにならないことを証明せねばならず、これは難しく、追加論理を要することもある。

One final subtlety that trips people up: z is legal only as the whole value of a branch, not mixed into an expression. assign y = a & 1'bz; is meaningless, because a tri-state buffer's output cannot be an input to a gate; a gate whose input floats has undefined behaviour and may even draw crowbar current. Similarly assign y = oe ? data : 8'b0; is a multiplexer, not a tri-state, even though it looks almost identical — the difference is entirely whether the else-branch is z or a real value.最後一個會絆倒人的細節：z 只有當成一個分支的整體值時才合法，不能混進運算式裡。assign y = a & 1'bz; 毫無意義，因為三態緩衝器的輸出不能當成閘的輸入；輸入浮接的閘行為未定義，甚至可能產生貫穿電流。同理，assign y = oe ? data : 8'b0; 是多工器而非三態，儘管看起來幾乎一樣 — 差別完全在於 else 分支是 z 還是一個真實的值。最後に人をつまずかせる細かな点がある。z が合法なのは分岐の値全体としてだけで、式の中に混ぜることはできない。assign y = a & 1'bz; は無意味である。トライステートバッファの出力はゲートの入力になりえず、入力がフロートするゲートはふるまいが未定義で、貫通電流を引くことさえあるからである。同様に assign y = oe ? data : 8'b0; はほとんど同じに見えてもトライステートではなくマルチプレクサである。違いはひとえに else 側の分岐が z か実在の値かにある。

(a) assign y = en ? d : 8'bz;
(b) if (sel == 2'bx1) y = a;
(c) case (op) 2'b00: y = a; 2'b01: y = b; default: y = 4'bx; endcase
(d) reg [7:0] r = 8'bx;
(e) casez (req) 4'b1???: g = 0; 4'b01??: g = 1; default: g = 2; endcase
(f) assign busy = (state === 3'bx) ? 1'b1 : 1'b0;
(g) assign y = sel ? 4'bz : 4'bz;
(h) wire [3:0] m = a & 4'b1z1z;

4. Arithmetic Operators4. 算術運算子4. 算術演算子

Slide 5 is four lines long and contains most of what determines whether your data path fits in the budget. It says that adders and subtractors have a variety of possible implementations, ripple-carry and carry-look-ahead among them; that * and / "may not be implemented efficiently as combinational logics"; and that the special cases of multiplying, dividing or taking the remainder by a power of two reduce to shifts and part selects. Each of those deserves unpacking, and before any of them there is a question the slide does not raise at all.第 5 張投影片只有四行，卻包含了決定你的資料路徑能不能塞進預算的大部分內容。它說加法器與減法器有多種可能實現方式，漣波進位與超前進位都在其中；說 * 與 /「may not be implemented efficiently as combinational logics」；並說乘以、除以或對 2 的冪取餘數這些特例會化約成移位與部分選取。每一條都值得拆開來看，而在這之前還有一個投影片完全沒提的問題。スライド 5 は 4 行しかないが、データパスが予算に収まるかどうかを決める要素の大半を含む。加算器と減算器にはリップルキャリーやキャリー先見を含む多様な実装がありうること、* と / は「may not be implemented efficiently as combinational logics」であること、そして 2 のべき乗による乗算・除算・剰余という特殊ケースはシフトと部分選択に帰着すること。そのどれも掘り下げる価値があり、そのすべての前に、スライドがまったく提起しない問いがある。

4.1 Expression width comes first4.1 先決定運算式位寬4.1 まず式のビット幅

Before the tool decides how to build an adder it must decide how wide the adder is, and Verilog's width rules are unusual enough that getting them wrong is the most common cause of a data path that costs twice what it should. The rules, briefly: an expression has a context-determined width equal to the maximum of the widths of all its operands and, for the top-level expression of an assignment, of the assignment target as well; this width is then pushed down into every operand, which is zero- or sign-extended to match. Certain sub-expressions are instead self-determined — the operands of concatenation and replication, the shift amount of a shift, the condition of ?:, and the operands of comparison operators — and are evaluated at their own natural width.在工具決定如何建一個加法器之前，它必須先決定這個加法器多寬，而 Verilog 的位寬規則特殊到「弄錯它」成為資料路徑花費兩倍代價最常見的原因。規則簡述如下：運算式有一個由情境決定的位寬，等於其所有運算元位寬的最大值，而對指定敘述的最上層運算式，還要納入指定目標的位寬；這個位寬接著被往下推到每個運算元，運算元會零擴展或符號擴展以符合它。某些子運算式則是自決定的 — 串接與重複的運算元、移位的位移量、?: 的條件，以及比較運算子的運算元 — 它們依自己的自然位寬求值。ツールが加算器をどう作るか決める前に、その加算器がどれだけ広いかを決めねばならない。Verilog の幅規則は独特で、これを誤ることがデータパスのコストが本来の 2 倍になる最大の原因である。規則を簡潔に述べる。式は文脈決定の幅を持ち、それは全オペランドの幅の最大値であり、代入文の最上位の式では代入先の幅も含める。この幅は各オペランドへ押し下げられ、オペランドはゼロ拡張または符号拡張されて合わせられる。一方、連結と繰り返しのオペランド、シフト量、?: の条件、比較演算子のオペランドは自己決定であり、それぞれの自然な幅で評価される。

The consequence in hardware is direct. In assign s = a + b; with a and b eight bits and s eight bits, the tool builds an eight-bit adder and throws away the carry. With s nine bits, it builds a nine-bit adder and the ninth bit is the carry out. With s sixteen bits, it builds a sixteen-bit adder whose top eight bits are provably zero, and only then relies on constant propagation to sweep them. The intermediate sub-expressions matter too: in assign s = (a + b) >> 1; the shift is applied after the addition has been truncated to the context width, so if s is eight bits you lose the carry before the shift and get the wrong average. The correct eight-bit average of two eight-bit numbers is {1'b0,a} + {1'b0,b} shifted right, or equivalently a nine-bit intermediate.在硬體上的後果很直接。在 assign s = a + b; 中，若 a、b 為八位元而 s 也是八位元，工具建一個八位元加法器並把進位丟掉。若 s 是九位元，它建一個九位元加法器，第九位就是進位輸出。若 s 是十六位元，它建一個十六位元加法器，其高八位可證明為零，然後才靠常數傳播把它們掃掉。中間子運算式同樣重要：在 assign s = (a + b) >> 1; 中，移位是在加法已被截斷到情境位寬之後才套用的，所以若 s 是八位元，你會在移位前就丟掉進位，得到錯誤的平均值。兩個八位元數正確的八位元平均是 {1'b0,a} + {1'b0,b} 再右移，或等價地用一個九位元的中間值。ハードウェア上の帰結は直接的である。assign s = a + b; で a と b が 8 ビット、s も 8 ビットなら、ツールは 8 ビット加算器を作りキャリーを捨てる。s が 9 ビットなら 9 ビット加算器を作り、9 ビット目がキャリー出力になる。s が 16 ビットなら上位 8 ビットがゼロだと証明できる 16 ビット加算器を作り、そのうえで定数伝播に頼って掃き出す。中間の部分式も重要である。assign s = (a + b) >> 1; では、シフトは加算が文脈幅に切り詰められた後に適用されるので、s が 8 ビットならシフト前にキャリーを失い、誤った平均を得る。2 つの 8 ビット数の正しい 8 ビット平均は {1'b0,a} + {1'b0,b} を右シフトしたもの、あるいは同値だが 9 ビットの中間値を使ったものである。

wire [7:0] a, b, avg;
assign avg = (a + b) >> 1;
// 8-bit add: 200+100 = 300 -> 44,
// then >>1 = 22. Expected 150.

wire [7:0] a, b, avg;
wire [8:0] sum = {1'b0,a} + {1'b0,b};
assign avg = sum[8:1];
// 9-bit add keeps the carry;
// the shift is a part select, free.

4.2 Adders: ripple-carry versus carry-look-ahead4.2 加法器：漣波進位與超前進位4.2 加算器：リップルキャリーとキャリー先見

Writing a + b does not pick an adder architecture. It emits a generic add node, and the mapping pass later chooses an implementation from a library of arithmetic generators — DesignWare in the Synopsys flow, ChipWare in the Cadence flow, or the tool's own built-ins — guided by the timing constraint on the path. This is one of the few places where synthesis genuinely does architectural design on your behalf, and it is worth knowing what the choices are.寫下 a + b 並不會挑選加法器架構。它產生的是一個泛用的 add 節點，之後對應階段才會從一組算術產生器庫中 — Synopsys 流程裡的 DesignWare、Cadence 流程裡的 ChipWare，或工具自己的內建產生器 — 依該路徑上的時序限制挑一個實現。這是少數幾個合成真的替你做架構設計的地方，值得知道選項有哪些。a + b と書いても加算器のアーキテクチャは選ばれない。生成されるのはジェネリックな add ノードであり、実装はのちにマッピングパスが算術ジェネレータのライブラリ — Synopsys フローの DesignWare、Cadence フローの ChipWare、あるいはツール内蔵のもの — から、その経路のタイミング制約に導かれて選ぶ。合成が本当にあなたの代わりにアーキテクチャ設計を行う数少ない場面であり、選択肢を知っておく価値がある。

A ripple-carry adder is $n$ full adders chained carry-out to carry-in. Its area is the cleanest possible: $n$ full adders at roughly 5 to 7 GE each, so about $6n$ GE, with no overhead. Its delay is the problem. The carry must propagate through all $n$ stages, so the worst-case path is $n$ carry delays plus one sum delay:漣波進位加法器是把 $n$ 顆全加器的進位輸出接到下一顆的進位輸入串成一串。它的面積是最乾淨的：$n$ 顆全加器，每顆約 5 到 7 GE，所以約 $6n$ GE，沒有額外開銷。問題出在延遲。進位必須走過全部 $n$ 級，所以最差路徑是 $n$ 個進位延遲加一個和延遲：リップルキャリー加算器は $n$ 個の全加算器をキャリー出力からキャリー入力へ鎖状につないだものである。面積は考えうるもっとも素直な形で、$n$ 個の全加算器が各 5〜7 GE、合計で約 $6n$ GE、オーバーヘッドはない。問題は遅延である。キャリーは $n$ 段すべてを伝播せねばならず、最悪経路はキャリー遅延 $n$ 段に和の遅延 1 段を加えたものになる。

For a sixteen-bit adder that is about sixteen levels of logic, which at a typical 65 nm library's fan-out-of-four delay of roughly 25 ps per level is around 0.4 ns — already a significant fraction of a 1 ns clock period, and that is before routing. For a thirty-two-bit adder it is about 0.8 ns and the path is almost certainly critical.對一個十六位元加法器來說那大約是十六層邏輯；以典型 65 nm 庫每層約 25 ps 的 fan-out-of-four 延遲計算，約為 0.4 ns — 在 1 ns 的時脈週期裡已經是很可觀的一部分，而且這還沒算繞線。三十二位元加法器約 0.8 ns，這條路徑幾乎一定會是關鍵路徑。16 ビット加算器ではおよそ 16 段の論理に相当し、典型的な 65 nm ライブラリの段あたり約 25 ps のファンアウト 4 遅延で換算すると約 0.4 ns になる。1 ns のクロック周期のかなりの部分を占めており、しかもこれは配線前の値である。32 ビット加算器なら約 0.8 ns で、この経路はほぼ確実にクリティカルになる。

A carry-look-ahead adder breaks the dependency by computing, for each bit, a generate signal $g_i = a_i b_i$ and a propagate signal $p_i = a_i \oplus b_i$, and then combining them in a tree. In the classical four-bit block form the carries within a block are computed in two levels from the block's $g$ and $p$, and the blocks themselves are chained or combined in a second-level look-ahead. In the modern parallel-prefix form (Kogge–Stone, Brent–Kung, Sklansky, Han–Carlson) the group generate and propagate signals are combined in a prefix tree, giving超前進位加法器打破這個相依性：它為每一位元計算一個產生訊號 $g_i = a_i b_i$ 與一個傳播訊號 $p_i = a_i \oplus b_i$，再用樹狀結構把它們組合起來。在古典的四位元區塊形式中，區塊內的進位由該區塊的 $g$ 與 $p$ 以兩層算出，而區塊本身再串接或以第二層超前進位組合。在現代的平行前綴形式（Kogge–Stone、Brent–Kung、Sklansky、Han–Carlson）中，群組的產生與傳播訊號在一棵前綴樹中組合，得到キャリー先見加算器は、各ビットについて生成信号 $g_i = a_i b_i$ と伝播信号 $p_i = a_i \oplus b_i$ を計算し、それらを木構造で結合することでこの依存関係を断ち切る。古典的な 4 ビットブロック形式では、ブロック内のキャリーはそのブロックの $g$ と $p$ から 2 段で計算され、ブロック自体は連鎖されるか第 2 段の先見で結合される。現代の並列プレフィックス形式（Kogge–Stone、Brent–Kung、Sklansky、Han–Carlson）では、グループの生成・伝播信号がプレフィックスツリーで結合され、次が得られる。

For the same sixteen-bit adder that is about four to five levels instead of sixteen, at perhaps 1.6 to 2.5 times the area. The trade is explicit and the tool makes it for you: with a loose constraint it picks the ripple form and saves area; tighten the constraint and it swaps in a prefix form; tighten it further and it may pick a carry-select adder, which duplicates the upper half of the adder for both possible carry-in values and multiplexes the answer, buying $O(\sqrt{n})$ or $O(\log n)$ delay at roughly double the area.對同一個十六位元加法器來說，層數從十六降到大約四到五層，代價是大約 1.6 到 2.5 倍的面積。這個取捨是明確的，而且是工具替你做的：限制寬鬆時它挑漣波形式以省面積；把限制收緊，它就換成前綴形式；再更緊，它可能挑 carry-select 加法器 — 把加法器上半部針對兩種可能的進位輸入各複製一份再用多工器選答案，用大約兩倍面積換到 $O(\sqrt{n})$ 或 $O(\log n)$ 的延遲。同じ 16 ビット加算器で段数は 16 ではなく 4〜5 段になり、面積はおそらく 1.6〜2.5 倍になる。このトレードオフは明示的で、しかもツールがあなたの代わりに行う。制約が緩ければリップル形式を選んで面積を節約し、制約を締めればプレフィックス形式に入れ替え、さらに締めればキャリーセレクト加算器を選ぶこともある。これは加算器の上位半分をキャリー入力の 2 通りについて複製し、答えをマルチプレクサで選ぶもので、およそ倍の面積で $O(\sqrt{n})$ あるいは $O(\log n)$ の遅延を買う。

The figures are indicative only and vary by a factor of two between libraries, but the ordering and the ratios are robust. The practical lesson is that you influence the choice through create_clock and set_max_delay, not through the RTL, and that if you need a particular architecture — because you are matching a published area figure, or because you need a specific carry-save structure for a multiplier — you must instantiate it, not describe it.這些數字只是指示性的，不同庫之間可能相差兩倍，但排序與比例是穩健的。實務上的教訓是：你是透過 create_clock 與 set_max_delay 影響這個選擇，而不是透過 RTL；而如果你需要某個特定架構 — 因為要對上某篇已發表的面積數據，或因為乘法器需要特定的 carry-save 結構 — 你必須實例化它，而不是描述它。これらの数値はあくまで目安で、ライブラリ間で 2 倍ほど違いうるが、順序と比率は頑健である。実務上の教訓は、選択に影響を与えるのは RTL ではなく create_clock と set_max_delay であること、そして特定のアーキテクチャが必要なら — 公表された面積値に合わせるため、あるいは乗算器に特定のキャリーセーブ構造が必要なため — 記述するのではなくインスタンス化せねばならないことである。

4.3 Subtraction4.3 減法4.3 減算

a - b becomes a + ~b + 1, which is the same adder with the b inputs inverted and the carry-in tied to 1. The inverters cost about $0.7n$ GE and nothing in depth, because they sit in parallel with the generate/propagate computation. So a subtractor is an adder plus about ten per cent, and a block that must do both — an ALU with an add/subtract control — is an adder preceded by $n$ XOR gates (b XOR sub) with sub as the carry-in, costing about $2n$ GE extra and one XOR level of delay.a - b 變成 a + ~b + 1，也就是同一個加法器，只是 b 的輸入被反相、進位輸入綁為 1。那些反相器約花 $0.7n$ GE，深度上不花任何成本，因為它們與產生／傳播的計算並行。所以減法器就是加法器再多約一成；而一個兩者都要做的區塊 — 帶加減控制的 ALU — 則是在加法器前面放 $n$ 顆 XOR 閘（b XOR sub）並以 sub 當進位輸入，額外約 $2n$ GE 與一層 XOR 的延遲。a - b は a + ~b + 1 になる。すなわち b の入力を反転し、キャリー入力を 1 に固定した同じ加算器である。インバータは約 $0.7n$ GE かかるが深さには影響しない。生成／伝播の計算と並列に位置するからである。したがって減算器は加算器プラス約 1 割であり、両方を行うブロック — 加減算制御付きの ALU — は加算器の前に $n$ 個の XOR ゲート（b XOR sub）を置き sub をキャリー入力にしたもので、追加で約 $2n$ GE と XOR 1 段分の遅延がかかる。

This is also why the slide's trick for relational operators works, and why section 6.1 can be short: a comparator is a subtractor whose sum outputs you throw away.這也是投影片對關係運算子那個技巧之所以成立的原因，以及 6.1 節可以寫得很短的原因：比較器就是一個把和輸出丟掉的減法器。これはスライドの関係演算子に関する手口が成り立つ理由でもあり、6.1 節が短くて済む理由でもある。比較器とは和の出力を捨てた減算器にほかならない。

4.4 Multiplication by a variable4.4 乘以變數4.4 変数による乗算

When both operands of * are signals, the tool must build a real multiplier. The slide's warning that this "may not be implemented efficiently as combinational logics" is an understatement worth quantifying.當 * 的兩個運算元都是訊號時，工具必須建一個真正的乘法器。投影片那句「may not be implemented efficiently as combinational logics」的警告是個輕描淡寫，值得量化。* の両オペランドが信号であれば、ツールは本物の乗算器を作らねばならない。スライドの「may not be implemented efficiently as combinational logics」という警告は控えめすぎる表現であり、数値で示す価値がある。

The textbook array multiplier for two $n$-bit unsigned numbers forms $n^2$ partial-product bits with $n^2$ AND gates, then sums the $n$ shifted partial products. Summing them with a carry-save array uses roughly $n^2 - n$ full adders followed by an $n$-bit carry-propagate adder for the final merge. At 1 GE per AND and 6 GE per full adder:教科書上的陣列乘法器對兩個 $n$ 位元無號數，用 $n^2$ 顆 AND 閘形成 $n^2$ 個部分積位元，再把 $n$ 個位移後的部分積相加。用 carry-save 陣列相加大約需要 $n^2 - n$ 顆全加器，最後再接一個 $n$ 位元的進位傳播加法器做最終合併。以每顆 AND 1 GE、每顆全加器 6 GE 計算：教科書的なアレイ乗算器は、2 つの $n$ ビット符号なし数に対し $n^2$ 個の AND ゲートで $n^2$ 個の部分積ビットを作り、$n$ 個のシフトされた部分積を加算する。キャリーセーブアレイで加算するとおよそ $n^2 - n$ 個の全加算器が必要で、最後に $n$ ビットのキャリー伝播加算器でマージする。AND が 1 GE、全加算器が 6 GE とすると：

Numerically: an 8 × 8 multiplier is around 450 GE and fifteen to twenty levels deep; a 16 × 16 is around 1800 GE; a 32 × 32 is around 7000 GE. Compare the 190 GE of a 32-bit ripple adder. One multiply is worth forty adds. That ratio is the number to remember.具體數字：8 × 8 乘法器約 450 GE、深十五到二十層；16 × 16 約 1800 GE；32 × 32 約 7000 GE。對照一下 32 位元漣波加法器的 190 GE。一次乘法抵四十次加法。這個比值就是該記住的數字。数値で言えば、8 × 8 の乗算器は約 450 GE で深さ 15〜20 段、16 × 16 は約 1800 GE、32 × 32 は約 7000 GE である。32 ビットリップル加算器の 190 GE と比べてほしい。乗算 1 回は加算 40 回分に相当する。この比こそ覚えるべき数字である。

A Wallace or Dadda tree reduces the partial-product array in $O(\log n)$ levels of 3:2 compressors instead of $O(n)$ levels of carry-save rows, giving $T = O(\log n)$ at similar or slightly larger area but much worse wiring regularity. Booth recoding (radix-4 is standard) halves the number of partial products to $n/2$, roughly halving the array area at the cost of a recoding stage and of having to handle the −2× and −1× multiples. Combining radix-4 Booth with a Wallace tree and a prefix final adder is what a commercial DesignWare multiplier actually instantiates when the constraint is tight.Wallace 樹或 Dadda 樹用 $O(\log n)$ 層的 3:2 壓縮器來縮減部分積陣列，而不是 $O(n)$ 層的 carry-save 列，得到 $T = O(\log n)$，面積相近或略大，但繞線規律性差得多。Booth 重編碼（基數 4 是標準做法）把部分積數目減半到 $n/2$，大致把陣列面積減半，代價是多一級重編碼，以及必須處理 −2× 與 −1× 這兩個倍數。把基數 4 的 Booth 與 Wallace 樹及前綴式最終加法器結合起來，正是商用 DesignWare 乘法器在限制很緊時實際實例化的東西。Wallace 木や Dadda 木は、部分積アレイを $O(n)$ 段のキャリーセーブ行ではなく $O(\log n)$ 段の 3:2 圧縮器で縮約し、面積は同程度かやや大きいまま $T = O(\log n)$ を得る。ただし配線の規則性はかなり悪くなる。Booth 再符号化（基数 4 が標準）は部分積の数を $n/2$ に半減させ、アレイ面積をほぼ半分にする。その代償は再符号化段と、−2× および −1× の倍数を扱う必要が生じることである。基数 4 Booth と Wallace 木とプレフィックス最終加算器の組合せこそ、制約が厳しいときに商用 DesignWare 乗算器が実際にインスタンス化するものである。

None of that is visible from the RTL. What is visible, and what you control, is whether the multiply is combinational at all. A multiplier is the classic candidate for pipelining: insert a register between the partial-product reduction and the final adder and you roughly halve the critical path at the cost of $2n$ flip-flops and one cycle of latency. Writing that yourself means splitting the operation, since a plain c <= a * b; gives you an unpipelined multiplier in front of a register; retiming (set_optimize_registers in Design Compiler) can move registers you have already provided into the middle of the multiplier, but it cannot invent registers you did not write.這些從 RTL 上都看不出來。看得出來、而且由你控制的，是這個乘法到底是不是組合式的。乘法器是管線化的經典候選：在部分積縮減與最終加法器之間插入一級暫存器，就能把關鍵路徑大致減半，代價是 $2n$ 顆正反器與一個週期的延遲。要自己寫出來就得把這個運算拆開，因為單純的 c <= a * b; 給你的是一個未管線化的乘法器接在暫存器前面；retiming（Design Compiler 裡的 set_optimize_registers）可以把你已經提供的暫存器移進乘法器中間，但它無法憑空發明你沒寫的暫存器。以上はどれも RTL からは見えない。見えるもの、そしてあなたが制御できるものは、その乗算がそもそも組合せ回路かどうかである。乗算器はパイプライン化の典型的な候補で、部分積縮約と最終加算器の間にレジスタを 1 段入れればクリティカルパスはほぼ半減し、代償は $2n$ 個のフリップフロップと 1 サイクルのレイテンシである。自分で書くには演算を分割せねばならない。素朴な c <= a * b; はパイプライン化されていない乗算器をレジスタの手前に置くだけだからである。リタイミング（Design Compiler の set_optimize_registers）はすでに与えたレジスタを乗算器の内部へ移動できるが、書かれていないレジスタを発明することはできない。

4.5 Multiplication by a constant4.5 乘以常數4.5 定数による乗算

The moment one operand is a constant, the whole picture changes, and this is the slide's "special cases" bullet. If the constant is a power of two, the multiply is a shift, and a shift by a constant is not logic at all — it is a renaming of wires. $a \times 8$ is the bus {a, 3'b000}. Zero gates, zero delay.只要有一個運算元是常數，整個局面就改變了，這正是投影片「特例」那一條。如果常數是 2 的冪，乘法就是移位，而常數位移量的移位根本不是邏輯 — 它只是替線重新命名。$a \times 8$ 就是匯流排 {a, 3'b000}。零個閘、零延遲。一方のオペランドが定数になった瞬間、全体像は変わる。これがスライドの「特殊ケース」の項目である。定数が 2 のべき乗なら乗算はシフトであり、定数シフトはそもそも論理ではない — 配線の名前の付け替えにすぎない。$a \times 8$ はバス {a, 3'b000} そのものである。ゲート 0、遅延 0。

If the constant is not a power of two, it is a sum of powers of two, and the multiply becomes a small number of shifted adds. $a \times 10 = a \times 8 + a \times 2 = (a \ll 3) + (a \ll 1)$ — one adder, about $6n$ GE, instead of a full multiplier. $a \times 7$ is better written as $a \times 8 - a = (a \ll 3) - a$, one subtractor, than as $(a\ll2)+(a\ll1)+a$, two adders. That substitution of a subtraction for several additions generalises to canonical signed-digit recoding, in which every run of consecutive ones $0111\ldots1$ is rewritten as $100\ldots0\bar{1}$; the number of adders needed is one less than the number of non-zero CSD digits, and CSD guarantees no two adjacent non-zero digits, so an $n$-bit constant needs at most about $n/2$ adders and on average about $n/3$.如果常數不是 2 的冪，它就是若干個 2 的冪之和，於是乘法變成少數幾次位移後的加法。$a \times 10 = a \times 8 + a \times 2 = (a \ll 3) + (a \ll 1)$ — 一個加法器，約 $6n$ GE，而不是一個完整的乘法器。$a \times 7$ 寫成 $a \times 8 - a = (a \ll 3) - a$（一個減法器）比寫成 $(a\ll2)+(a\ll1)+a$（兩個加法器）更好。用一次減法取代數次加法這個替換可推廣為正則有號數字（CSD）重編碼：每一串連續的 1，$0111\ldots1$，都改寫成 $100\ldots0\bar{1}$；所需加法器數目比非零 CSD 數字的個數少一，而 CSD 保證沒有兩個相鄰的非零數字，所以一個 $n$ 位元常數最多約需 $n/2$ 個加法器，平均約 $n/3$。定数が 2 のべき乗でなければ、それは2 のべき乗の和であり、乗算は少数のシフト加算になる。$a \times 10 = a \times 8 + a \times 2 = (a \ll 3) + (a \ll 1)$ — 完全な乗算器ではなく加算器 1 個、約 $6n$ GE である。$a \times 7$ は $(a\ll2)+(a\ll1)+a$（加算器 2 個）より $a \times 8 - a = (a \ll 3) - a$（減算器 1 個）と書くほうがよい。複数の加算を減算 1 回で置き換えるこの手法は正準符号付き数字（CSD）再符号化に一般化される。連続する 1 の並び $0111\ldots1$ を $100\ldots0\bar{1}$ に書き換えるもので、必要な加算器の数は非零の CSD 桁数より 1 少ない。CSD は隣接する非零桁が生じないことを保証するので、$n$ ビットの定数に必要な加算器は多くても約 $n/2$、平均では約 $n/3$ である。

Every competent synthesiser performs this recoding automatically when it sees a constant operand, so you do not have to write the shifts yourself. There are two reasons to do it anyway. First, it documents the intent, so that a later editor who changes the constant to a signal knows they have just added two thousand gates. Second, and more importantly, the tool can only do it when it can prove the operand is constant; if the coefficient arrives through a port, through a configuration register or through a parameter the tool cannot resolve, you get the full multiplier. In a digital communication chip this is the usual case for filter coefficients, and it is precisely why fixed-coefficient FIR filters are written as shift-add networks (the "multiplierless" or "multiple constant multiplication" literature) while programmable filters pay for real multipliers.任何像樣的合成器看到常數運算元時都會自動做這種重編碼，所以你不必親手寫出那些移位。但仍有兩個理由去寫。第一，它把意圖寫成文件，讓後來把常數改成訊號的編輯者知道自己剛剛加了兩千個閘。第二，也更重要：工具只有在能證明該運算元是常數時才做得到；如果係數是經由一個埠、一個組態暫存器，或一個工具無法解析的參數進來的，你拿到的就是完整的乘法器。在數位通訊晶片裡，濾波器係數通常正是這種情況，這也正是固定係數 FIR 濾波器會寫成移位加法網路（所謂「multiplierless」或「multiple constant multiplication」文獻）、而可程式化濾波器得付出真正乘法器代價的原因。まともな合成器は定数オペランドを見れば自動でこの再符号化を行うので、シフトを自分で書く必要はない。それでも書く理由が二つある。第一に意図が文書化され、のちに定数を信号に変える編集者が、自分がいま 2000 ゲート追加したことを知れる。第二に、こちらがより重要だが、ツールがそれを行えるのはオペランドが定数だと証明できるときだけである。係数がポート経由、コンフィギュレーションレジスタ経由、あるいはツールが解決できないパラメータ経由で来るなら、完全な乗算器が作られる。ディジタル通信チップではフィルタ係数がまさにこの状況であり、固定係数 FIR フィルタがシフト加算ネットワーク（いわゆる multiplierless、multiple constant multiplication の文献）として書かれ、プログラマブルなフィルタが本物の乗算器の代価を払う理由もここにある。

4.6 Division and modulo4.6 除法與取模4.6 除算と剰余

Division by a variable is the worst operator in the language. A combinational restoring divider for $n$-bit operands is $n$ stages, each containing an $n$-bit subtractor and an $n$-bit multiplexer that selects between the difference and the original partial remainder:用變數做除法是這個語言裡最糟的運算子。$n$ 位元運算元的組合式回復型除法器有 $n$ 級，每一級包含一個 $n$ 位元減法器與一個在差值與原來的部分餘數之間做選擇的 $n$ 位元多工器：変数による除算はこの言語で最悪の演算子である。$n$ ビットオペランドの組合せ引き戻し除算器は $n$ 段からなり、各段には $n$ ビットの減算器と、差と元の部分剰余のどちらかを選ぶ $n$ ビットのマルチプレクサが入る。

Note that unlike the multiplier, the delay is also quadratic, because each stage's subtraction must complete before the next stage can begin and each subtraction is itself $O(n)$ if built from a ripple adder. A 16-bit combinational divider is on the order of 2500 GE with a path of well over a hundred levels; a 32-bit one is unsynthesisable in any practical sense. Many tools simply refuse / with a non-constant divisor and emit an error. Those that accept it produce a block that will never meet timing.注意，與乘法器不同，這裡的延遲也是二次的，因為每一級的減法必須完成，下一級才能開始，而若用漣波加法器來建，每次減法本身又是 $O(n)$。一個 16 位元組合式除法器大約是 2500 GE，路徑遠超過一百層；32 位元的在任何實際意義上都不可合成。許多工具對非常數除數的 / 乾脆拒絕並報錯。接受它的那些工具，會產生一個永遠無法滿足時序的區塊。乗算器と違い遅延も二次であることに注意してほしい。各段の減算が終わらないと次の段が始められず、しかもリップル加算器で作れば各減算自体が $O(n)$ だからである。16 ビットの組合せ除算器はおよそ 2500 GE で経路は優に 100 段を超え、32 ビットのものは実用上あらゆる意味で合成不可能である。多くのツールは除数が定数でない / を単に拒否してエラーを出す。受け付けるツールは、決してタイミングを満たさないブロックを生成する。

The correct engineering response is to not do it. Replace the division with a sequential divider that takes $n$ cycles and one subtractor (about $6n + 3n$ GE total, a hundredth of the combinational area); or with a reciprocal multiplication, where you compute $1/b$ once by table lookup plus Newton–Raphson refinement and then multiply, which is how processors do it; or with a Newton–Raphson or CORDIC iteration in a small sequential block; or, very often in communications, by restructuring the algorithm so the division disappears — scaling both sides of a comparison rather than dividing, or working in the log domain.正確的工程回應是：不要這樣做。改用一個花 $n$ 個週期、只需一個減法器的循序除法器（總共約 $6n + 3n$ GE，是組合式面積的百分之一）；或改用倒數乘法 — 先用查表加 Newton–Raphson 修正算出一次 $1/b$，再做乘法，這是處理器的做法；或在一個小的循序區塊裡用 Newton–Raphson 或 CORDIC 迭代；或者 — 在通訊領域中很常見 — 重構演算法讓除法消失，例如把比較式的兩邊同時縮放而不是相除，或改在對數域運算。正しい工学的な対応は、やらないことである。$n$ サイクルと減算器 1 個で済む逐次除算器に置き換える（合計およそ $6n + 3n$ GE で、組合せ版の面積の 100 分の 1）。あるいは逆数乗算に置き換える。$1/b$ をテーブル参照と Newton–Raphson による精密化で一度求めてから乗算するやり方で、プロセッサはこうしている。あるいは小さな逐次ブロックで Newton–Raphson や CORDIC を反復する。あるいは通信分野では非常によくあることだが、アルゴリズムを組み替えて除算そのものを消す。比較の両辺をスケールして割り算を避ける、対数領域で計算する、といった方法である。

Division by a constant power of two is the free case and reduces to a right shift. Division by a general constant is not free but is far cheaper than a divider: $a/c$ can be computed as $(a \times m) \gg s$ for a precomputed magic multiplier $m$ and shift $s$, which costs one constant multiplication. Good synthesisers do this; it is the same transformation a C compiler performs.除以 2 的冪常數是免費的情況，化約成一次右移。除以一般常數不是免費，但遠比除法器便宜：$a/c$ 可以算成 $(a \times m) \gg s$，其中 $m$ 是預先算好的魔術乘數、$s$ 是位移量，成本只是一次常數乘法。好的合成器會這麼做；這和 C 編譯器執行的是同一個變換。2 のべき乗の定数による除算は無料のケースで、右シフトに帰着する。一般の定数による除算は無料ではないが、除算器よりはるかに安い。$a/c$ は、あらかじめ計算したマジック乗数 $m$ とシフト量 $s$ を使って $(a \times m) \gg s$ として計算でき、コストは定数乗算 1 回分である。よい合成器はこれを行う。C コンパイラが行うのと同じ変換である。

The modulo operator % follows the same pattern. By a power of two it is a part select — a % 16 is a[3:0], zero gates, which is the slide's third special case. By a general constant it is a constant division plus a constant multiplication plus a subtraction. By a variable it is a divider, with the divider's cost.取模運算子 % 遵循同樣的模式。對 2 的冪取模是部分選取 — a % 16 就是 a[3:0]，零個閘，這是投影片的第三個特例。對一般常數取模，是一次常數除法加一次常數乘法再加一次減法。對變數取模，就是一個除法器，帶著除法器的成本。剰余演算子 % も同じパターンに従う。2 のべき乗に対する剰余は部分選択であり、a % 16 は a[3:0]、ゲート 0 である。これがスライドの三つ目の特殊ケースである。一般の定数に対しては、定数除算と定数乗算と減算の組合せになる。変数に対しては除算器そのものであり、除算器のコストがかかる。

-5 / 4   =  -1      // truncate toward zero
-5 >>> 2 =  -2      // floor
-5 % 4   =  -1      // sign of dividend
(-5) & 3 =   3      // part select gives the unsigned residue

(a) a * 16
(b) a / 8
(c) a % 32
(d) a * 12
(e) a * 100
(f) (a * 3) / 4
(g) a / b

5. Shift Operators5. 移位運算子5. シフト演算子

Slide 6 says two things: the shift amount, or the number of bits storing it, must be a constant; and within a behavioural block shifts are implemented with shift registers and multiplexers built from low-level gates rather than mapped onto a library shift-register cell. Both statements are true but both are easy to misread, and the underlying hardware distinction — between a shift by a constant and a shift by a signal — is one of the sharpest cost cliffs in the whole language.第 6 張投影片講了兩件事：位移量，或是儲存位移量的位元數，必須是常數；以及在行為區塊內，移位是用低階閘建成的移位暫存器與多工器來實現，而不是對應到庫裡的移位暫存器元件。兩句話都正確，但兩句都容易誤讀，而底層的硬體區別 — 常數移位與訊號移位之間的區別 — 是整個語言裡最陡的成本懸崖之一。スライド 6 は二つのことを述べる。シフト量、あるいはそれを格納するビット数は定数でなければならないこと。そして振る舞いブロック内でのシフトは、ライブラリのシフトレジスタセルにマップされるのではなく、低レベルゲートから作られたシフトレジスタとマルチプレクサで実装されること。どちらも正しいが、どちらも読み違えやすい。そして背後にあるハードウェア上の区別 — 定数によるシフトと信号によるシフトの違い — は、この言語全体でもっとも急峻なコストの崖の一つである。

5.1 A constant shift is a wiring permutation5.1 常數移位只是接線的置換5.1 定数シフトは配線の並べ替えにすぎない

When the shift amount is a literal or an elaboration-time constant, no logic is generated at all. a << 3 is the expression whose bit $i$ is $a_{i-3}$, with zeros below; the synthesiser implements it by connecting the right wires to the right places. There is no gate, no delay beyond the wire itself, and no area beyond routing. The same is true of a >> 3, of part selects, of bit reversals written as a static loop, and of any other fixed permutation of the bits of a bus.當位移量是字面常數或展開期常數時，完全不會產生任何邏輯。a << 3 這個運算式的第 $i$ 位是 $a_{i-3}$，底下補零；合成器實現它的方式就是把對的線接到對的地方。沒有閘、除了線本身沒有延遲、除了繞線沒有面積。a >> 3、部分選取、寫成靜態迴圈的位元反轉，以及任何其他對匯流排位元的固定置換，都是如此。シフト量がリテラルかエラボレーション時定数であれば、論理はまったく生成されない。a << 3 はビット $i$ が $a_{i-3}$ で下位にゼロが入る式であり、合成器は正しい配線を正しい場所につなぐことでこれを実装する。ゲートはなく、配線自体を超える遅延もなく、配線以外の面積もない。a >> 3、部分選択、静的ループとして書かれたビット反転、そしてバスのビットの固定した並べ替えはすべて同様である。

This is why so many of the arithmetic shortcuts in section 4 are described as free. It is also why a constant shift is the right way to express scaling in a fixed-point data path: a Q1.15 value multiplied by a Q1.15 value gives a Q2.30 product, and the renormalisation to Q1.15 is prod[30:15] — a part select, costing nothing, not a division.這就是為什麼第 4 節裡那麼多算術捷徑被描述成免費的。這也是為什麼在定點資料路徑中，用常數移位來表達縮放是正確做法：一個 Q1.15 的值乘以一個 Q1.15 的值得到 Q2.30 的乘積，而正規化回 Q1.15 就是 prod[30:15] — 一次部分選取，不花成本，而不是一次除法。第 4 節の算術的な近道の多くが無料だと説明されるのはこのためである。固定小数点データパスでスケーリングを表すのに定数シフトが正しい方法である理由でもある。Q1.15 の値に Q1.15 の値を掛けると Q2.30 の積になり、Q1.15 への再正規化は prod[30:15] — 除算ではなく部分選択であり、コストはゼロである。

A subtlety: a constant shift that discards bits is free, but a constant shift that widens is free only if the target is wide enough. assign y = a << 3; with y and a both eight bits silently drops the top three bits of a, because the context width is eight. If you wanted the full eleven-bit result the target must be eleven bits wide. Here, as everywhere in Verilog arithmetic, width is decided before structure.一個細節：丟棄位元的常數移位是免費的，但加寬的常數移位只有在目標夠寬時才免費。assign y = a << 3; 若 y 與 a 都是八位元，會悄悄丟掉 a 的最高三位，因為情境位寬是八。如果你要完整的十一位元結果，目標就必須是十一位元寬。在這裡，如同 Verilog 算術的任何地方，位寬永遠在結構之前決定。細かな点が一つある。ビットを捨てる定数シフトは無料だが、広げる定数シフトが無料なのは代入先が十分に広いときだけである。y と a がともに 8 ビットのとき assign y = a << 3; は文脈幅が 8 なので a の上位 3 ビットを黙って落とす。完全な 11 ビットの結果が欲しければ代入先を 11 ビット幅にしなければならない。Verilog の算術ではどこでもそうであるように、ここでも幅は構造より先に決まる。

5.2 A variable shift is a barrel shifter5.2 變數移位就是桶式移位器5.2 変数シフトはバレルシフタである

When the shift amount is a signal, the circuit must be able to produce every possible permutation, and selecting among permutations costs multiplexers. The standard structure is the logarithmic barrel shifter, and its construction follows directly from binary representation of the shift amount: to shift by $s = s_{k-1}\ldots s_1 s_0$, shift conditionally by $2^{k-1}$, then conditionally by $2^{k-2}$, and so on down to conditionally by 1, with each conditional shift controlled by one bit of $s$.當位移量是訊號時，電路必須能產生所有可能的置換，而在置換之間做選擇就要花多工器。標準結構是對數式桶式移位器，它的構造直接來自位移量的二進位表示：要位移 $s = s_{k-1}\ldots s_1 s_0$，就先條件式地移 $2^{k-1}$、再條件式地移 $2^{k-2}$，一路往下到條件式地移 1，每一次條件移位由 $s$ 的一個位元控制。シフト量が信号のとき、回路はあらゆる並べ替えを生成できなければならず、並べ替えの選択にはマルチプレクサが要る。標準的な構造は対数バレルシフタで、その構成はシフト量の 2 進表現から直接導かれる。$s = s_{k-1}\ldots s_1 s_0$ だけシフトするには、まず条件付きで $2^{k-1}$、次に条件付きで $2^{k-2}$、と下りていって最後に条件付きで 1 だけシフトする。各条件シフトは $s$ の 1 ビットが制御する。

Counting is easy once the structure is clear. For an $n$-bit word and a shift amount of $k = \lceil \log_2 n\rceil$ bits there are $k$ stages, each containing $n$ two-to-one multiplexers, so結構一清楚，計數就很容易。對一個 $n$ 位元字與 $k = \lceil \log_2 n\rceil$ 位元的位移量，共有 $k$ 級，每級含 $n$ 顆二對一多工器，所以構造が分かれば数えるのは簡単である。$n$ ビットのワードと $k = \lceil \log_2 n\rceil$ ビットのシフト量に対して段数は $k$、各段に 2 対 1 マルチプレクサが $n$ 個あるので、

For $n = 8$: 24 muxes, about 60 GE, three levels. For $n = 32$: 160 muxes, about 400 GE, five levels. For $n = 64$: 384 muxes, about 960 GE, six levels. Compare the zero gates of a constant shift and you have the cost cliff: changing a >> 3 into a >> s, a one-character edit, turns free wiring into a block the size of two 32-bit adders.$n = 8$ 時：24 顆多工器、約 60 GE、三層。$n = 32$ 時：160 顆多工器、約 400 GE、五層。$n = 64$ 時：384 顆多工器、約 960 GE、六層。對照常數移位的零個閘，成本懸崖就出現了：把 a >> 3 改成 a >> s，一個字元的編輯，就把免費的接線變成兩個 32 位元加法器大小的區塊。$n = 8$ なら 24 個のマルチプレクサ、約 60 GE、3 段。$n = 32$ なら 160 個、約 400 GE、5 段。$n = 64$ なら 384 個、約 960 GE、6 段。定数シフトのゲート数ゼロと比べればコストの崖が見える。a >> 3 を a >> s に変える 1 文字の編集が、無料の配線を 32 ビット加算器 2 個分の大きさのブロックに変えてしまう。

The alternative structure, an $n$-to-1 multiplexer per output bit, needs $n$ multiplexers of $n$ inputs each. A 2:1-mux-based $n$-input mux costs $n-1$ two-to-one muxes, so this arrangement is $n(n-1) = O(n^2)$ — for $n = 32$ that is 992 muxes versus the barrel shifter's 160. It is strictly worse and no tool builds it, but it is a useful thing to be able to dismiss in an exam.另一種結構 — 每個輸出位元用一顆 $n$ 對 1 多工器 — 需要 $n$ 顆各有 $n$ 個輸入的多工器。以 2:1 多工器構成的 $n$ 輸入多工器要花 $n-1$ 顆二對一多工器，所以這個配置是 $n(n-1) = O(n^2)$ — $n = 32$ 時是 992 顆，而桶式移位器只要 160 顆。它嚴格地更差，沒有工具會建它，但能在考試中把它排除掉是很有用的。もう一つの構造、すなわち出力ビットごとに $n$ 対 1 マルチプレクサを置く方式は、$n$ 入力のマルチプレクサを $n$ 個必要とする。2:1 マルチプレクサで作る $n$ 入力マルチプレクサは 2 対 1 を $n-1$ 個使うので、この構成は $n(n-1) = O(n^2)$ となる。$n = 32$ なら 992 個で、バレルシフタの 160 個と比べて厳密に劣る。どのツールもこれを作らないが、試験で却下できるようにしておくと役に立つ。

5.3 What "the shift amount must be a constant" really means5.3 「位移量必須是常數」真正的意思5.3 「シフト量は定数でなければならない」の本当の意味

Read literally, slide 6 would forbid the barrel shifter entirely, which cannot be right — barrel shifters are in every processor and every floating-point normaliser. The bullet is a compressed statement of an older and narrower restriction, and it is worth getting the modern reading right.照字面讀，第 6 張投影片會完全禁止桶式移位器，那不可能對 — 每顆處理器、每個浮點正規化器裡都有桶式移位器。這一條是一個更舊、更窄的限制被壓縮後的說法，值得把現代的讀法弄清楚。文字どおり読めばスライド 6 はバレルシフタを全面的に禁じることになるが、それは正しくありえない。バレルシフタはあらゆるプロセッサ、あらゆる浮動小数点正規化器に入っている。この項目は、より古くより狭い制限を圧縮した言明であり、現代的な読み方を正しく押さえておく価値がある。

One real restriction does survive: the shift amount is a self-determined expression, so its width is its own and it is always treated as unsigned. A negative shift amount is therefore not a shift in the other direction; it is an enormous positive shift that zeroes the result. If you need a bidirectional shift, build two shifters and a multiplexer, or reverse the bus, shift right and reverse back — reversal being free wiring, this costs one extra $n$-bit mux rather than a second shifter.有一條真正的限制確實留了下來：位移量是一個自決定運算式，所以它的位寬是它自己的，而且永遠被當成無號。因此負的位移量不是反方向的移位，而是一個巨大的正位移，會把結果清成零。如果你需要雙向移位，就建兩個移位器加一顆多工器，或者把匯流排反轉、右移、再反轉回來 — 反轉只是免費的接線，所以這只多花一顆 $n$ 位元多工器，而不是第二個移位器。本当の制限が一つだけ残っている。シフト量は自己決定の式なので幅は自身のものであり、常に符号なしとして扱われる。したがって負のシフト量は逆方向のシフトではなく、結果をゼロにする巨大な正のシフトである。双方向シフトが必要なら、シフタを 2 つとマルチプレクサを作るか、バスを反転して右シフトし再び反転する。反転は無料の配線なので、後者の追加コストは 2 つ目のシフタではなく $n$ ビットのマルチプレクサ 1 個で済む。

5.4 Arithmetic shift and signedness5.4 算術移位與有號性5.4 算術シフトと符号属性

IEEE 1364-2001 added <<< and >>>. The left arithmetic shift <<< is identical to <<. The right arithmetic shift >>> fills from the sign bit if and only if the left operand is signed; on an unsigned operand it fills with zeros and is identical to >>. That conditional is a frequent source of bugs, because the signedness of the operand may come from a declaration several lines away, or may have been destroyed by mixing with an unsigned operand as described in section 2.3.IEEE 1364-2001 加入了 <<< 與 >>>。算術左移 <<< 與 << 完全相同。算術右移 >>> 若且唯若左運算元為有號時才以符號位元填補；對無號運算元它填零，與 >> 完全相同。這個條件是錯誤的常見來源，因為運算元的有號性可能來自好幾行之外的宣告，也可能像 2.3 節描述的那樣，因為與無號運算元混用而被破壞掉了。IEEE 1364-2001 は <<< と >>> を追加した。算術左シフト <<< は << と同一である。算術右シフト >>> が符号ビットで埋めるのは左オペランドが符号付きである場合に限る。符号なしオペランドに対してはゼロで埋め、>> と同一になる。この条件はバグの頻出源である。オペランドの符号属性は数行離れた宣言に由来することもあれば、2.3 節で述べたように符号なしオペランドとの混在によって失われていることもあるからである。

In hardware the difference is nothing at all: both are wiring for a constant amount, and for a variable amount both are the same barrel shifter with a different choice of fill. The sign-extending fill costs no extra gates, only a different wire to the vacated mux inputs. So there is never a performance reason to prefer one; there is only a correctness reason to use the one that matches your number format.在硬體上兩者毫無差別：常數位移量時兩者都只是接線，變數位移量時兩者都是同一個桶式移位器，只差填補來源不同。符號擴展的填補不花額外的閘，只是把不同的線接到空出來的多工器輸入。所以永遠沒有效能上的理由去偏好哪一個；只有正確性上的理由 — 要用與你的數值格式相符的那一個。ハードウェア上の差はまったくない。定数シフト量ならどちらも配線であり、変数シフト量ならどちらも同じバレルシフタで埋める値の選び方が違うだけである。符号拡張の埋め込みに追加のゲートはかからず、空いたマルチプレクサ入力に別の配線をつなぐだけである。したがって一方を選ぶ性能上の理由は決してない。あるのは、自分の数値形式に合うほうを使うという正しさの理由だけである。

5.5 A shift register is not a shifter5.5 移位暫存器不是移位器5.5 シフトレジスタはシフタではない

The second half of slide 6 — that shifts inside a behavioural block become "shift registers and multiplexers ... implemented from low-level logic gates, and not necessarily mapped into a library cell of a shift register" — is about a different structure altogether, and the lecture's data_shift example illustrates it.第 6 張投影片的後半 — 行為區塊內的移位會變成「shift registers and multiplexers ... implemented from low-level logic gates, and not necessarily mapped into a library cell of a shift register」— 講的完全是另一種結構，而這一講的 data_shift 範例正好說明了它。スライド 6 の後半 — 振る舞いブロック内のシフトは「shift registers and multiplexers ... implemented from low-level logic gates, and not necessarily mapped into a library cell of a shift register」になる — はまったく別の構造についての話であり、講義の data_shift の例がそれを示している。

module data_shift (data_out, data_in, clk, reset, data_load, SL, SR);
  input  [3:0] data_in;
  input        clk, reset, data_load, SL, SR;
  output [3:0] data_out;
  reg    [3:0] data_out;

  always @ (posedge clk or negedge reset)
    if (reset == 0)  data_out = 0;              else
    if (data_load)   data_out = data_in;        else
    if (SL)          data_out = data_out << 1;  else
    if (SR)          data_out = data_out >> 1;
endmodule

Each << 1 here is a shift by a literal, so it contributes no logic; what costs area is the selection among the five possible next states. The slide's hand-drawn structure shows the result for the least significant bit: three 2:1 multiplexers in a priority chain, with data_load nearest the flip-flop because it has the highest synchronous priority, then SL, then SR, and the hold path threaded back from the flip-flop output. The four possible data sources for bit 0 are data_in[0] (load), a hard zero (shift left brings in a zero at the bottom), data_out[1] (shift right) and data_out[0] itself (hold).這裡每一個 << 1 都是對字面常數的移位，所以不產生任何邏輯；花面積的是在五種可能的下一狀態之間做選擇。投影片手繪的結構顯示最低有效位元的結果：三顆 2:1 多工器排成優先權鏈，data_load 最靠近正反器因為它的同步優先權最高，接著是 SL，再來是 SR，而保持路徑則從正反器輸出繞回來。第 0 位元的四個可能資料來源是 data_in[0]（載入）、一個硬零（左移時底部補零）、data_out[1]（右移），以及 data_out[0] 自己（保持）。ここでの各 << 1 はリテラルによるシフトなので論理を生まない。面積を食うのは 5 通りの次状態のあいだの選択である。スライドの手描きの構造は最下位ビットの結果を示している。3 個の 2:1 マルチプレクサが優先順位の鎖をなし、同期分岐で最優先の data_load がフリップフロップにもっとも近く、次が SL、その次が SR、そしてホールドの経路がフリップフロップ出力から戻されている。ビット 0 の 4 つのデータ源は data_in[0]（ロード）、固定のゼロ（左シフトで下位に入るゼロ）、data_out[1]（右シフト）、そして data_out[0] 自身（ホールド）である。

Per bit the cost is three 2:1 muxes at roughly 2.5 GE each plus one flip-flop with asynchronous reset at roughly 6 GE, so about 13.5 GE per bit and 54 GE for the four-bit unit. The slide's synthesis result shows this covered not as discrete muxes but as AND-OR-INVERT cells feeding the D pins — the function is a four-input select, and an AOI22 plus an inverter covers it in fewer transistors than two separate mux cells. That substitution is exactly what the bullet means by "implemented from low-level logic gates, and not necessarily mapped into a library cell of a shift register".每位元的成本是三顆 2:1 多工器（每顆約 2.5 GE）加一顆帶非同步重置的正反器（約 6 GE），所以每位元約 13.5 GE，四位元單元共約 54 GE。投影片的合成結果顯示它不是被覆蓋成一顆顆獨立的多工器，而是被覆蓋成餵進 D 腳的 AND-OR-INVERT 元件 — 這個函式是一個四輸入選擇，而一顆 AOI22 加一顆反相器覆蓋它所用的電晶體比兩顆獨立的多工器元件更少。那個替換正是這一條所說的「implemented from low-level logic gates, and not necessarily mapped into a library cell of a shift register」。1 ビットあたりのコストは 2:1 マルチプレクサ 3 個（各約 2.5 GE）と非同期リセット付きフリップフロップ 1 個（約 6 GE）で、約 13.5 GE、4 ビットのユニットで約 54 GE となる。スライドの合成結果は、これが個別のマルチプレクサではなく D ピンを駆動する AND-OR-INVERT セルとして覆われることを示している。この関数は 4 入力の選択であり、AOI22 1 個とインバータ 1 個のほうが、独立したマルチプレクサ 2 個よりトランジスタ数が少なくて済むからである。この置き換えこそ、項目が言う「implemented from low-level logic gates, and not necessarily mapped into a library cell of a shift register」の意味である。

Finally, note the use of blocking assignments in a clocked block. The lecture's own example uses =, and because each branch assigns data_out exactly once and the right-hand side reads the pre-edge value (there is no earlier write to data_out in the same pass), the inferred hardware is correct. But it is a race against any other block that reads data_out at the same edge, for the reasons set out in section 8. Write <= in clocked blocks; the lecture's example is from a textbook of the mid-1990s, when the convention was not yet universal.最後，請注意在時脈區塊裡使用了阻塞式指定。這一講自己的範例用的是 =，而因為每個分支都恰好指定 data_out 一次，且右手邊讀到的是邊緣前的值（同一次執行中沒有更早對 data_out 的寫入），所以推論出來的硬體是正確的。但基於第 8 節闡述的理由，它對任何在同一個邊緣讀取 data_out 的其他區塊而言是一場競爭。請在時脈區塊裡寫 <=；這一講的範例出自 1990 年代中期的教科書，當時這個慣例還不普及。最後に、クロックブロック内でブロッキング代入が使われている点に注意してほしい。講義自身の例は = を使っており、各分岐が data_out をちょうど一度代入し、右辺がエッジ前の値を読む（同じパス内に data_out への先行する書き込みがない）ため、推論されるハードウェアは正しい。しかし第 8 節で述べる理由により、同じエッジで data_out を読む他のブロックに対しては競合になる。クロックブロックでは <= を書くこと。講義の例は 1990 年代半ばの教科書のもので、当時この慣習はまだ普遍的ではなかった。

(a) wire [15:0] y = a >> 4;                   // a is [15:0]
(b) wire [15:0] y = a >> s;                   // s is [3:0]
(c) wire [31:0] y = a << s;                   // a is [31:0], s is [4:0]
(d) wire [31:0] y = dir ? (a << s) : (a >> s);
(e) wire [15:0] y = a >> (2*k);               // k is a parameter
(f) wire [15:0] y = {a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],
                     a[8],a[9],a[10],a[11],a[12],a[13],a[14],a[15]};

6. The Remaining Operator Classes6. 其餘的運算子類別6. 残りの演算子クラス

Slides 10 through 17 sweep through relational operators, identity operators, reduction, bitwise and logical operators, the conditional operator, concatenation and the grouping of operators, mostly in a line each. The underlying message of all of them is the same — "translated to Boolean equations and mapped to physical gates" — but the cost of those equations differs by orders of magnitude between classes, and that is what this section quantifies.第 10 到 17 張投影片橫掃關係運算子、同一性運算子、歸約、位元與邏輯運算子、條件運算子、串接，以及運算子的分組，大多一行一個。它們底下的訊息都一樣 —「translated to Boolean equations and mapped to physical gates」— 但這些方程式的成本在不同類別之間相差好幾個數量級，而這正是本節要量化的東西。スライド 10 から 17 は、関係演算子、同一性演算子、リダクション、ビット演算子と論理演算子、条件演算子、連結、そして演算子のグループ化を、ほとんど 1 行ずつで駆け抜ける。その底にあるメッセージはどれも同じ —「translated to Boolean equations and mapped to physical gates」— だが、それらの式のコストはクラス間で桁違いに異なる。本節が定量化するのはそこである。

6.1 Relational operators6.1 關係運算子6.1 関係演算子

Slide 10 gives two implementations for <, >, <= and >=: dedicated combinational logic, or an adder/subtractor whose sign bit is examined. Both are used in practice.第 10 張投影片給了 <、>、<= 與 >= 兩種實現：專用的組合邏輯，或是檢視加法器／減法器的符號位元。兩種在實務上都會用到。スライド 10 は <、>、<=、>= に二つの実装を与える。専用の組合せ論理か、加算器／減算器の符号ビットを見る方法である。どちらも実務で使われる。

The dedicated comparator is a prefix structure much like a carry chain. Working from the most significant bit down, $A > B$ holds if at the highest differing bit position $A$ has a 1 and $B$ a 0. Defining per-bit "greater" $g_i = a_i\overline{b_i}$ and "equal" $e_i = \overline{a_i \oplus b_i}$, the result is $\bigvee_i \bigl(g_i \wedge \bigwedge_{j>i} e_j\bigr)$, which is a prefix-AND of the equal terms combined with the greater terms. Built as a tree this costs about $3n$ to $4n$ GE with $O(\log n)$ depth; built as a ripple it costs about $2n$ GE with $O(n)$ depth. A magnitude comparator is therefore roughly half an adder.專用比較器是一個很像進位鏈的前綴結構。從最高位往下看，$A > B$ 成立的條件是在最高的相異位元位置上 $A$ 為 1 而 $B$ 為 0。定義逐位元的「大於」$g_i = a_i\overline{b_i}$ 與「相等」$e_i = \overline{a_i \oplus b_i}$，結果就是 $\bigvee_i \bigl(g_i \wedge \bigwedge_{j>i} e_j\bigr)$，也就是把相等項的前綴 AND 與大於項組合起來。建成樹狀約花 $3n$ 到 $4n$ GE、深度 $O(\log n)$；建成漣波狀約花 $2n$ GE、深度 $O(n)$。所以一個大小比較器大約是半個加法器。専用比較器はキャリーチェーンによく似たプレフィックス構造である。最上位ビットから下りていくと、$A > B$ が成り立つのは最上位の相違ビット位置で $A$ が 1、$B$ が 0 のときである。ビットごとの「大きい」$g_i = a_i\overline{b_i}$ と「等しい」$e_i = \overline{a_i \oplus b_i}$ を定義すると、結果は $\bigvee_i \bigl(g_i \wedge \bigwedge_{j>i} e_j\bigr)$ であり、等価項のプレフィックス AND と大小項を組み合わせたものになる。木として作れば約 $3n$〜$4n$ GE で深さ $O(\log n)$、リップルとして作れば約 $2n$ GE で深さ $O(n)$ である。したがって大小比較器はおよそ加算器の半分である。

The subtract-and-test-the-sign implementation reuses an adder that the design may already contain, which is why an ALU that already has an adder gets its comparisons nearly free: feed a - b through the existing adder and read one bit. The slide states the criterion as "$A \ge B$ if the sign bit of $A-B$ is 0, and $A < B$ otherwise". That is right for a particular case and wrong in general, and the correction is worth knowing because it is a standard exam trap.相減再看符號的實現方式，重用了設計中可能已經有的加法器，這就是為什麼已經有加法器的 ALU 幾乎可以免費得到比較功能：把 a - b 餵進既有的加法器，再讀一個位元就好。投影片把判準寫成「若 $A-B$ 的符號位元為 0 則 $A \ge B$，否則 $A < B$」。那對某個特定情況是對的，一般情況則是錯的，而這個更正值得知道，因為它是標準的考試陷阱。引き算して符号を見る実装は、設計がすでに持っているかもしれない加算器を再利用する。すでに加算器のある ALU が比較をほぼ無料で得られるのはこのためである。a - b を既存の加算器に通し、1 ビット読むだけでよい。スライドは判定条件を「$A-B$ の符号ビットが 0 なら $A \ge B$、そうでなければ $A < B$」と述べる。これは特定の場合には正しく、一般には誤りである。この訂正は標準的な試験の罠なので知っておく価値がある。

A useful special case: comparison against a constant is much cheaper than comparison against a signal, because the per-bit $g$ and $e$ terms collapse. a > 8'd0 is simply the OR-reduction of a, about 7 GE and three levels for eight bits, not a comparator. a >= 8'd128 is just a[7], free. Whenever a threshold in a communication design can be made a power of two, make it one.一個有用的特例：與常數比較比與訊號比較便宜得多，因為逐位元的 $g$ 與 $e$ 項會塌縮。a > 8'd0 不過是對 a 做 OR 歸約，八位元約 7 GE、三層，而不是一個比較器。a >= 8'd128 就只是 a[7]，免費。在通訊設計中，只要門檻值能設成 2 的冪，就把它設成 2 的冪。有用な特殊ケース：定数との比較は信号との比較よりはるかに安い。ビットごとの $g$ と $e$ の項が縮退するからである。a > 8'd0 は単に a の OR リダクションで、8 ビットなら約 7 GE、3 段であり、比較器ではない。a >= 8'd128 はただの a[7] で無料である。通信設計でしきい値を 2 のべき乗にできるなら、常にそうすること。

6.2 Equality and identity6.2 相等與全等6.2 等価と同一性

The logical equality operators == and != are the cheapest comparison in the language. Equality of two $n$-bit vectors is "no bit differs":邏輯相等運算子 == 與 != 是這個語言裡最便宜的比較。兩個 $n$ 位元向量相等就是「沒有任何位元不同」：論理等価演算子 == と != は、この言語でもっとも安い比較である。2 つの $n$ ビットベクタが等しいとは「どのビットも相違しない」ことである。

That is $n$ XOR gates feeding an $n$-input NOR, so about $2n$ GE for the XORs and $n-1$ two-input gates for the reduction tree — roughly $3n$ GE with $1 + \lceil\log_2 n\rceil$ levels. The lecture's identity_4bit example is exactly this: four XORs into a four-input NOR gives A_noteq_B inverted, and one more inverter gives A_eq_B. About 12 GE for four bits, three levels. Note that the tool produces one comparator and inverts it, rather than two independent cones — common sub-expression elimination at work, and visible in the slide's schematic as the single NOR with a buffer and an inverter on its output.也就是 $n$ 顆 XOR 閘餵進一個 $n$ 輸入 NOR，所以 XOR 約 $2n$ GE，歸約樹用 $n-1$ 顆二輸入閘 — 大約 $3n$ GE，$1 + \lceil\log_2 n\rceil$ 層。這一講的 identity_4bit 範例正是如此：四顆 XOR 進入一個四輸入 NOR 得到反相的 A_noteq_B，再加一顆反相器得到 A_eq_B。四位元約 12 GE、三層。請注意工具產生的是一個比較器再取反，而不是兩個獨立的邏輯錐 — 這是共同子運算式消除在運作，在投影片的電路圖上就是那個輸出端接了一顆緩衝器與一顆反相器的單一 NOR。すなわち $n$ 個の XOR ゲートが $n$ 入力 NOR を駆動する形で、XOR に約 $2n$ GE、リダクションツリーに 2 入力ゲート $n-1$ 個 — 合わせておよそ $3n$ GE、段数は $1 + \lceil\log_2 n\rceil$ である。講義の identity_4bit の例はまさにこれで、XOR 4 個が 4 入力 NOR に入って反転した A_noteq_B を与え、インバータをもう 1 個通すと A_eq_B になる。4 ビットで約 12 GE、3 段である。ツールが 2 つの独立したコーンではなく一つの比較器を作って反転している点に注目してほしい。共通部分式除去が働いており、スライドの回路図では出力にバッファとインバータが付いた単一の NOR として見える。

Equality against a constant is cheaper still: it is an AND of selected bits and their complements, about $n$ GE with $\lceil \log_2 n\rceil$ levels, which is why decoding an opcode is inexpensive and comparing two data words is not.與常數比較相等更便宜：它只是選定位元與其補數的 AND，約 $n$ GE、$\lceil \log_2 n\rceil$ 層，這就是為什麼解碼一個 opcode 很便宜，而比較兩個資料字則不然。定数との等価比較はさらに安い。選ばれたビットとその補数の AND であり、約 $n$ GE、$\lceil \log_2 n\rceil$ 段である。オペコードのデコードが安く、2 つのデータワードの比較がそうでない理由はここにある。

The case-equality operators === and !== were dealt with in section 3.3: they are simulation-only. Slide 10 lists them under "implemented with simple combinational logics", which is the one place in this lecture where the slide is, strictly, incorrect.case 相等運算子 === 與 !== 在 3.3 節已經處理過：它們只能用於模擬。第 10 張投影片把它們列在「implemented with simple combinational logics」底下，那是這一講裡投影片嚴格來說唯一不正確的地方。ケース等価演算子 === と !== は 3.3 節で扱った。これらはシミュレーション専用である。スライド 10 はこれらを「implemented with simple combinational logics」の下に挙げているが、そこがこの講義でスライドが厳密に誤っている唯一の箇所である。

6.3 Bitwise operators6.3 位元運算子6.3 ビット演算子

Nothing could be simpler. &, |, ^, ~, ~&, ~|, ~^ applied to two $n$-bit vectors produce $n$ independent two-input gates with no interaction between bit positions. Area is exactly $n$ gates — about $n$ GE for AND/OR/NAND/NOR, about $2n$ to $2.5n$ for XOR/XNOR — and delay is exactly one level regardless of $n$. These are the only operators in the language whose delay does not grow with word width.沒有比這更簡單的了。&、|、^、~、~&、~|、~^ 作用在兩個 $n$ 位元向量上，產生 $n$ 顆彼此獨立的二輸入閘，位元位置之間沒有任何互動。面積恰好是 $n$ 顆閘 — AND/OR/NAND/NOR 約 $n$ GE，XOR/XNOR 約 $2n$ 到 $2.5n$ — 而延遲恰好是一層，不論 $n$ 多大。這是語言裡唯一一類延遲不隨字寬成長的運算子。これ以上単純なものはない。2 つの $n$ ビットベクタに適用された &、|、^、~、~&、~|、~^ は、ビット位置間に相互作用のない独立した 2 入力ゲートを $n$ 個生む。面積はちょうど $n$ ゲート分 — AND/OR/NAND/NOR で約 $n$ GE、XOR/XNOR で約 $2n$〜$2.5n$ — であり、遅延は $n$ によらずちょうど 1 段である。遅延がワード幅とともに増えない唯一の演算子クラスである。

The one thing to watch is width mismatch. Bitwise operators are context-determined, so a narrow operand is extended to the context width, and the extension is with zeros for an unsigned operand and with the sign for a signed one. wire [7:0] y = a & 1'b1; does not mask to one bit; it extends 1'b1 to 8'b00000001 and gives {7'b0, a[0]}. If you wanted "is a non-zero" you wanted the logical operators of section 6.5.唯一要留意的是位寬不匹配。位元運算子由情境決定位寬，所以較窄的運算元會被擴展到情境位寬，無號運算元補零、有號運算元補符號。wire [7:0] y = a & 1'b1; 並不會遮罩成一位元；它把 1'b1 擴展成 8'b00000001，得到 {7'b0, a[0]}。如果你想問的是「a 是否非零」，你要的是 6.5 節的邏輯運算子。注意すべき点は幅の不一致だけである。ビット演算子は文脈決定なので、狭いオペランドは文脈幅へ拡張される。符号なしならゼロ拡張、符号付きなら符号拡張である。wire [7:0] y = a & 1'b1; は 1 ビットにマスクしない。1'b1 を 8'b00000001 に拡張し、{7'b0, a[0]} を与える。「a が非ゼロか」を問いたかったのなら、必要なのは 6.5 節の論理演算子である。

Also worth noting: XOR and XNOR are the expensive gates in CMOS. A two-input NAND is four transistors; a two-input XOR is eight to twelve depending on the construction. A wide XOR network — a parity tree, a CRC, a scrambler, a Galois-field multiplier — therefore costs two to three times what a gate count alone suggests, and XOR networks do not simplify under Boolean optimisation the way AND/OR networks do, because every input is in the support of the output. This matters enormously in communication IC design, where CRC and LFSR logic is pure XOR.另外值得一提：XOR 與 XNOR 是 CMOS 裡昂貴的閘。二輸入 NAND 是四顆電晶體；二輸入 XOR 視構造而定是八到十二顆。因此一個寬 XOR 網路 — 同位元樹、CRC、擾碼器、Galois 體乘法器 — 的成本是單看閘數所暗示的兩到三倍；而且 XOR 網路不像 AND/OR 網路那樣能在布林最佳化下化簡，因為每個輸入都在輸出的支撐集裡。這在通訊 IC 設計裡極為重要，因為 CRC 與 LFSR 邏輯全都是 XOR。もう一つ注目に値する点がある。CMOS において XOR と XNOR は高価なゲートである。2 入力 NAND はトランジスタ 4 個、2 入力 XOR は構成によって 8〜12 個である。したがって幅広い XOR ネットワーク — パリティツリー、CRC、スクランブラ、ガロア体乗算器 — のコストはゲート数だけから想像される値の 2〜3 倍になる。さらに XOR ネットワークは AND/OR ネットワークのようにブール最適化で簡単化されない。すべての入力が出力のサポートに含まれるからである。CRC と LFSR の論理が純粋な XOR である通信 IC 設計では、この点が決定的に重要になる。

6.4 Reduction operators6.4 歸約運算子6.4 リダクション演算子

A reduction operator takes one vector and produces one bit by applying the operator across all bit positions: &a is the AND of every bit, |a the OR, ^a the XOR (that is, the parity), and ~&, ~|, ~^ their complements. The slide's reduction module exercises all six on a two-bit word and shows the result: six two-input gates, since for $n=2$ a reduction over the whole word is just one gate.歸約運算子接受一個向量，把運算子套用到所有位元位置上，產生一個位元：&a 是所有位元的 AND，|a 是 OR，^a 是 XOR（也就是同位元），而 ~&、~|、~^ 是它們的補數。投影片的 reduction 模組在一個兩位元字上操演了全部六種，結果是六顆二輸入閘 — 因為 $n=2$ 時，對整個字做歸約就只是一顆閘。リダクション演算子はベクタを 1 つ取り、全ビット位置に演算子を適用して 1 ビットを生む。&a は全ビットの AND、|a は OR、^a は XOR（すなわちパリティ）であり、~&、~|、~^ はそれらの補数である。スライドの reduction モジュールは 2 ビットのワードに対して 6 種すべてを試し、結果は 2 入力ゲート 6 個となる。$n=2$ ではワード全体のリダクションがゲート 1 個にすぎないからである。

module reduction (data_word, y_red_and, y_red_or, y_red_nand,
                  y_red_nor, y_red_xor, y_red_xnor);
  input  [1:0] data_word;
  output       y_red_and, y_red_or, y_red_nand, y_red_nor, y_red_xor, y_red_xnor;
  reg          y_red_and, y_red_or, y_red_nand, y_red_nor, y_red_xor, y_red_xnor;

  always @ (data_word) begin
    y_red_and  <=  &data_word;
    y_red_or   <=  |data_word;
    y_red_nand <= ~&data_word;
    y_red_nor  <= ~|data_word;
    y_red_xor  <=  ^data_word;
    y_red_xnor <= ~^data_word;
  end
endmodule

The interesting question is what happens for a wide vector, and the answer is that a reduction over $n$ bits is $n-1$ two-input gates, which the tool may arrange as a linear chain of depth $n-1$ or as a balanced tree of depth $\lceil \log_2 n\rceil$. The area is identical; only the depth differs. Associative and commutative operators — and all six reductions are both — give the optimiser complete freedom to rebalance, so you get the tree automatically whenever timing demands it. This is in sharp contrast to the addition chain of section 6.8, where rebalancing changes the widths of the intermediate results and the tool is more conservative.有趣的問題是寬向量會怎樣，答案是：對 $n$ 位元做歸約需要 $n-1$ 顆二輸入閘，工具可以把它們排成深度 $n-1$ 的線性串，也可以排成深度 $\lceil \log_2 n\rceil$ 的平衡樹。面積完全相同，只有深度不同。可結合且可交換的運算子 — 這六種歸約都是 — 給了最佳化器完全的重新平衡自由，所以只要時序有要求，你就會自動拿到樹狀形式。這和 6.8 節的加法鏈形成強烈對比：在那裡重新平衡會改變中間結果的位寬，工具就保守得多。興味深いのは幅の広いベクタで何が起こるかであり、答えは、$n$ ビットのリダクションは 2 入力ゲート $n-1$ 個であり、ツールはそれを深さ $n-1$ の直鎖にも深さ $\lceil \log_2 n\rceil$ の平衡木にも並べうる、というものである。面積は同一で、違うのは深さだけである。結合的かつ可換な演算子 — 6 種のリダクションはすべてそうである — は最適化器に再平衡の完全な自由を与えるので、タイミングが要求すれば自動的に木の形が得られる。これは 6.8 節の加算の連鎖と鋭い対照をなす。そちらでは再平衡が中間結果の幅を変えるため、ツールはずっと保守的になる。

The cost table, for a vector of $n$ bits:對一個 $n$ 位元向量，成本表如下：$n$ ビットのベクタに対するコスト表は次のとおりである。

Two idioms are worth committing to memory because they replace comparators with reductions. "Is a zero?" is ~|a, about $n$ GE, not a == 0 — though every tool recognises the latter and produces the former. "Is a all ones?" is &a. And the terminal-count signal of a counter is &count, which is why counters that count up to an all-ones value are cheaper than counters that count to an arbitrary modulus.有兩個慣用寫法值得背下來，因為它們用歸約取代了比較器。「a 是零嗎？」是 ~|a，約 $n$ GE，而不是 a == 0 — 雖然每個工具都認得後者並產生前者。「a 全為 1 嗎？」是 &a。而計數器的終值訊號是 &count，這就是為什麼數到全 1 的計數器比數到任意模數的計數器便宜。覚えておく価値のある慣用句が二つある。比較器をリダクションで置き換えるものである。「a はゼロか」は a == 0 ではなく ~|a で、約 $n$ GE である — もっともどのツールも後者を認識して前者を生成する。「a はオール 1 か」は &a である。そしてカウンタのターミナルカウント信号は &count であり、オール 1 まで数えるカウンタが任意の法まで数えるカウンタより安い理由がここにある。

6.5 Logical operators6.5 邏輯運算子6.5 論理演算子

&&, || and ! are not bitwise. They first reduce each operand to a single truth value — zero is false, anything non-zero is true — and then combine those truth values. So a && b with eight-bit operands is (|a) & (|b): two OR-reductions feeding one AND, about $2n + 1$ GE and $\lceil\log_2 n\rceil + 1$ levels. !a is ~|a.&&、|| 與 ! 不是位元運算子。它們先把每個運算元歸約成單一真假值 — 零為假，任何非零為真 — 再把這些真假值組合起來。所以八位元運算元的 a && b 是 (|a) & (|b)：兩個 OR 歸約餵進一顆 AND，約 $2n + 1$ GE、$\lceil\log_2 n\rceil + 1$ 層。!a 就是 ~|a。&&、||、! はビット演算子ではない。まず各オペランドを単一の真偽値に縮約し — ゼロは偽、非ゼロは真 — それらの真偽値を結合する。したがって 8 ビットオペランドの a && b は (|a) & (|b) であり、2 つの OR リダクションが AND 1 個を駆動する形で、約 $2n + 1$ GE、$\lceil\log_2 n\rceil + 1$ 段である。!a は ~|a である。

Confusing & with && is a classic error with a clear hardware signature. if (a & b) on multi-bit operands tests whether any bit position has a 1 in both, which needs an AND per bit plus a reduction; if (a && b) tests whether both are non-zero. They coincide for single-bit operands, which is why the mistake survives simulation of simple cases, and diverge the moment either operand is widened. On a single bit the two cost the same, so there is no efficiency argument either way; use && for conditions and & for data, and the intent reads correctly.把 & 和 && 搞混是經典錯誤，而且有清楚的硬體特徵。對多位元運算元而言，if (a & b) 測試的是是否有任何位元位置兩邊都是 1，這需要每位元一顆 AND 再加一次歸約；if (a && b) 測試的則是兩者是否都非零。對單位元運算元它們一致，這就是為什麼這個錯誤能在簡單情況的模擬中存活下來，而只要任一運算元加寬就會分歧。在單一位元上兩者成本相同，所以沒有效率上的論據偏向哪一邊；條件用 &&、資料用 &，意圖就讀得正確。& と && の取り違えは古典的な誤りで、ハードウェア上の特徴がはっきりしている。多ビットオペランドでは if (a & b) はどこかのビット位置で両方が 1 かを調べ、ビットごとの AND とリダクションを要する。if (a && b) は両方が非ゼロかを調べる。1 ビットのオペランドでは一致するので、この誤りは単純なケースのシミュレーションを生き延び、どちらかのオペランドが広がった瞬間に乖離する。1 ビットでは両者のコストは同じなので効率上の論拠はどちらにもない。条件には &&、データには & を使えば意図が正しく読める。

One Verilog-specific hazard: unlike C, Verilog's && and || do not reliably short-circuit in a way you can depend on for safety, and in synthesis they never do — both sides of the expression exist as hardware simultaneously. Writing if (ptr != 0 && mem[ptr]) gives you a memory read that happens regardless, so the guard protects nothing in silicon.一個 Verilog 特有的風險：與 C 不同，Verilog 的 && 與 || 不會以你能拿來當安全保障的方式可靠地短路，而在合成中它們從來不短路 — 運算式的兩邊同時都以硬體的形式存在。寫 if (ptr != 0 && mem[ptr]) 得到的記憶體讀取無論如何都會發生，所以這個守衛在矽上什麼都沒保護到。Verilog 固有の落とし穴が一つある。C と異なり Verilog の && と || は、安全性の根拠にできるような形で確実に短絡評価されるわけではなく、合成では決して短絡しない。式の両辺が同時にハードウェアとして存在する。if (ptr != 0 && mem[ptr]) と書けばメモリ読み出しは無条件に起こるので、このガードはシリコン上で何も守っていない。

6.6 The conditional operator6.6 條件運算子6.6 条件演算子

Slide 15 says ?: is "synthesized into muxes or gates that implement muxes", and that is exactly right. cond ? a : b on $n$-bit operands is $n$ two-to-one multiplexers sharing one select line, about $2.5n$ GE and one mux level, plus whatever logic computes cond. Whether the mapper uses actual MUX2 cells or covers the function with AOI/OAI gates is a technology-mapping decision invisible from the RTL — the lecture's mux_conditional schematic shows the AOI form, with the tri-state-looking boxes being mux cells and the rest AND-OR-INVERT plus inverters.第 15 張投影片說 ?: 會「synthesized into muxes or gates that implement muxes」，這完全正確。$n$ 位元運算元上的 cond ? a : b 是 $n$ 顆共用一條選擇線的二對一多工器，約 $2.5n$ GE、一層多工器延遲，再加上計算 cond 所需的邏輯。對應器究竟是用真正的 MUX2 元件，還是用 AOI/OAI 閘來覆蓋這個函式，是從 RTL 看不見的製程對應決策 — 這一講的 mux_conditional 電路圖顯示的是 AOI 形式，那些看起來像三態的方塊是多工器元件，其餘是 AND-OR-INVERT 加反相器。スライド 15 は ?: が「synthesized into muxes or gates that implement muxes」だと述べており、これはまったく正しい。$n$ ビットオペランドに対する cond ? a : b は、選択線を共有する 2 対 1 マルチプレクサ $n$ 個で、約 $2.5n$ GE、マルチプレクサ 1 段分の遅延に加え cond を計算する論理が乗る。マッパが実際の MUX2 セルを使うか AOI/OAI ゲートで関数を覆うかは RTL からは見えないテクノロジマッピングの判断である。講義の mux_conditional の回路図は AOI の形を示しており、トライステートのように見える箱がマルチプレクサセル、残りが AND-OR-INVERT とインバータである。

module mux_conditional (data_out, data_a, data_b, data_c, data_d, sel);
  input  [3:0] data_a, data_b, data_c, data_d;
  input  [1:0] sel;
  output [3:0] data_out;

  assign data_out = (sel == 2'b00) ? data_a :
                    (sel == 2'b01) ? data_b :
                    (sel == 2'b10) ? data_c : data_d;
endmodule

The important structural point is what a chain of conditionals becomes. Written as above, the expression is a nested priority structure: test the first condition, else test the second, else test the third. Taken literally that is three mux levels on the data_d path and one on the data_a path — an unbalanced tree. But the three conditions here are mutually exclusive and exhaustive over a two-bit selector, and a good optimiser proves that and collapses the chain into a balanced 4:1 mux of two levels, which is what the slide's schematic shows. When the conditions are not provably exclusive, the chain stays a chain, and a twenty-way priority ?: cascade gives you a twenty-level path.結構上重要的一點是條件運算子串接後會變成什麼。照上面那樣寫，這個運算式是一個巢狀的優先權結構：先測第一個條件，否則測第二個，否則測第三個。照字面看，那是 data_d 路徑上三層多工器、data_a 路徑上一層 — 一棵不平衡的樹。但這裡三個條件在一個兩位元選擇子上是互斥且窮盡的，好的最佳化器會證明這點，把這串塌縮成一顆兩層的平衡 4:1 多工器，這正是投影片電路圖顯示的樣子。當條件不能被證明互斥時，這串就仍然是一串，而一個二十路的優先權 ?: 級聯會給你一條二十層的路徑。構造上重要なのは、条件演算子の連鎖が何になるかである。上記のように書けば、式は入れ子の優先順位構造になる。最初の条件を調べ、だめなら 2 番目、だめなら 3 番目、という具合である。文字どおりに取れば data_d の経路には 3 段、data_a の経路には 1 段のマルチプレクサがある — 不平衡な木である。しかしここでの 3 つの条件は 2 ビットのセレクタに対して互いに排他かつ網羅的であり、よい最適化器はそれを証明して連鎖を 2 段の平衡した 4:1 マルチプレクサに縮退させる。スライドの回路図が示すのがこれである。条件が排他だと証明できない場合、連鎖は連鎖のまま残り、20 分岐の優先順位 ?: カスケードは 20 段の経路を生む。

6.7 Concatenation and replication6.7 串接與重複6.7 連結と繰り返し

Slide 16's two lines — supported in general, equivalent to a logical bus with no functionality of its own — are complete and correct. {a, b} costs nothing; it names a bus formed from existing wires. Replication {4{a}} likewise costs nothing; it fans one signal out to four positions, which has a fanout cost in buffering but no logic cost.第 16 張投影片的兩行 — 一般都支援，等價於一條本身沒有任何功能的邏輯匯流排 — 既完整又正確。{a, b} 不花成本；它只是替由既有線路組成的匯流排取個名字。重複 {4{a}} 同樣不花成本；它把一個訊號扇出到四個位置，在緩衝上有扇出成本，但沒有邏輯成本。スライド 16 の 2 行 — 一般に対応しており、それ自体は機能を持たない論理的なバスに等しい — は完全かつ正しい。{a, b} はコストゼロで、既存の配線から成るバスに名前を付けるだけである。繰り返し {4{a}} も同様にコストゼロで、1 本の信号を 4 箇所へファンアウトする。バッファリングのファンアウトコストはあるが論理コストはない。

The concatenation operator is nonetheless one of the most useful tools in synthesisable RTL, precisely because it is free. Three idioms recur constantly:儘管如此，串接運算子仍是可合成 RTL 中最有用的工具之一，正因為它免費。有三個慣用寫法不斷出現：とはいえ連結演算子は合成可能 RTL でもっとも有用な道具の一つである。まさに無料だからである。三つの慣用句が繰り返し現れる。

// 1. Capture the carry out of an addition without a separate comparator
wire [8:0] sum = {1'b0, a} + {1'b0, b};
wire       carry = sum[8];

// 2. Sign-extend explicitly rather than relying on signedness rules
wire [15:0] sx = {{8{a[7]}}, a};

// 3. Build a shift register with no shift operator at all
always @(posedge clk) sr <= {sr[6:0], serial_in};

The third idiom is the canonical way to write a shift register in modern RTL, and it is worth seeing why it costs nothing beyond the flip-flops: the right-hand side is a concatenation of a part select and a wire, which is pure routing, so the inferred hardware is eight flip-flops with their D pins wired to their neighbours' Q pins. No multiplexers, no gates. Contrast the data_shift module of section 5.5, which needed three muxes per bit because it also had to load, hold and clear.第三個慣用寫法是現代 RTL 裡寫移位暫存器的典範做法，而且值得看看它為什麼除了正反器以外什麼都不花：右手邊是一個部分選取與一條線的串接，純粹是繞線，所以推論出來的硬體就是八顆正反器，D 腳接到鄰居的 Q 腳。沒有多工器，沒有閘。對照 5.5 節的 data_shift 模組，它每位元需要三顆多工器，因為它還得載入、保持與清除。三つ目の慣用句は現代 RTL でシフトレジスタを書く定石であり、フリップフロップ以外に何もコストがかからない理由を見ておく価値がある。右辺は部分選択と配線の連結であり純粋なルーティングなので、推論されるハードウェアはフリップフロップ 8 個の D ピンが隣の Q ピンに接続されたものになる。マルチプレクサもゲートもない。ロード・ホールド・クリアも行わねばならないため 1 ビットあたり 3 個のマルチプレクサを要した 5.5 節の data_shift モジュールと対照的である。

Two traps. First, the self-determined-width rule of section 2.3: operands inside { } keep their own width, so an unsized literal is thirty-two bits. Second, an empty or unsized replication count is illegal, and a replication count must be a constant — {n{a}} with n a signal cannot be elaborated, for the same reason a non-static loop cannot.兩個陷阱。第一是 2.3 節的自決定位寬規則：{ } 內的運算元保有自己的位寬，所以未指定位寬的常數是三十二位元。第二，空的或未指定的重複次數是非法的，而重複次數必須是常數 — {n{a}} 若 n 是訊號就無法展開，理由和非靜態迴圈無法展開相同。罠が二つある。第一は 2.3 節の自己決定幅の規則で、{ } 内のオペランドは自身の幅を保つため、サイズ指定のないリテラルは 32 ビットになる。第二に、空または未指定の繰り返し回数は不正であり、繰り返し回数は定数でなければならない。n が信号である {n{a}} はエラボレートできない。非静的ループが展開できないのと同じ理由である。

6.8 Grouping and the shape of the operator tree6.8 括號分組與運算子樹的形狀6.8 グループ化と演算子ツリーの形

Slide 17 is a single example with no text, and it is one of the most practically useful slides in the lecture.第 17 張投影片只有一個範例、沒有文字，卻是這一講裡實用價值最高的投影片之一。スライド 17 は本文のない例が一つだけだが、この講義でもっとも実用的に有用なスライドの一つである。

module operator_group (sum1, sum2, a, b, c, d);
  input  [3:0] a, b, c, d;
  output [4:0] sum1, sum2;

  assign sum1 = a + b + c + d;
  assign sum2 = (a + b) + (c + d);
endmodule

Verilog's binary operators are left-associative, so a + b + c + d parses as ((a + b) + c) + d. Three additions, arranged in a chain: the result of the first feeds the second, which feeds the third. The parenthesised version is also three additions, but arranged as a balanced tree: the two inner sums are computed in parallel and then combined. The slide's figure shows precisely this — a three-deep ladder for sum1, a two-deep tree for sum2.Verilog 的二元運算子是左結合的，所以 a + b + c + d 解析成 ((a + b) + c) + d。三次加法，排成一串：第一次的結果餵給第二次，第二次餵給第三次。加了括號的版本同樣是三次加法，但排成一棵平衡樹：兩個內層的和平行算出後再合併。投影片的圖顯示的正是這個 — sum1 是三層的梯子，sum2 是兩層的樹。Verilog の二項演算子は左結合なので、a + b + c + d は ((a + b) + c) + d と解析される。加算 3 回が鎖状に並び、1 つ目の結果が 2 つ目へ、2 つ目が 3 つ目へ流れる。括弧を付けた版も加算 3 回だが、平衡木として並ぶ。内側の 2 つの和が並列に計算され、その後で結合される。スライドの図が示すのはまさにこれで、sum1 は 3 段のはしご、sum2 は 2 段の木である。

Two quantitative remarks. First, the widths. Both targets are five bits, so the context width of the whole expression is five, every operand is zero-extended to five bits, and all three adders are five-bit adders — about 30 GE each, 90 GE in total, identical for both versions. Only the depth differs: about fifteen levels for the chain against about ten for the tree if ripple adders are used. Second, the saving generalises. Summing $k$ operands as a chain costs $k-1$ adder delays; as a balanced tree it costs $\lceil\log_2 k\rceil$. For eight operands that is seven against three.兩點量化的說明。第一是位寬。兩個目標都是五位元，所以整個運算式的情境位寬是五，每個運算元都零擴展到五位元，三個加法器都是五位元加法器 — 每個約 30 GE，合計 90 GE，兩個版本完全相同。只有深度不同：若用漣波加法器，串接版約十五層，樹狀版約十層。第二，這個節省可以推廣。把 $k$ 個運算元串成鏈相加要花 $k-1$ 個加法器延遲；排成平衡樹則是 $\lceil\log_2 k\rceil$。八個運算元就是七對三。定量的な指摘が二つある。第一に幅である。どちらの代入先も 5 ビットなので式全体の文脈幅は 5 となり、すべてのオペランドが 5 ビットにゼロ拡張され、3 つの加算器はいずれも 5 ビット加算器になる — 各約 30 GE、合計 90 GE で、両方の版で同一である。異なるのは深さだけで、リップル加算器なら連鎖版が約 15 段、木の版が約 10 段である。第二に、この節約は一般化する。$k$ 個のオペランドを鎖状に加算すると加算器遅延 $k-1$ 段、平衡木なら $\lceil\log_2 k\rceil$ 段で済む。8 オペランドなら 7 対 3 である。

Modern synthesisers contain an arithmetic restructuring engine that will rebalance an addition chain on its own when timing demands it, so the parentheses are not always necessary. They are still worth writing, for three reasons: restructuring is disabled or limited in some flows and for some operator mixes, especially when signed and unsigned operands are combined or when an intermediate result is also used elsewhere; the parenthesised form documents the intended structure for a reader; and restructuring cannot help at all when the intermediate value is itself a named signal that the design uses, because then the tool must preserve it.現代合成器內含一個算術重構引擎，在時序有要求時會自行重新平衡加法鏈，所以括號並非總是必要。但它們仍然值得寫，理由有三：在某些流程與某些運算子組合下重構會被停用或受限，尤其是有號與無號運算元混用時，或中間結果在別處也被使用時；加了括號的寫法把預期的結構記錄給讀者看；而當中間值本身是設計會用到的具名訊號時，重構完全幫不上忙，因為工具必須保留它。現代の合成器は算術再構成エンジンを備えており、タイミングが要求すれば加算の連鎖を自ら再平衡する。したがって括弧は常に必要というわけではない。それでも書く価値が三つある。フローや演算子の組合せによっては再構成が無効化されたり制限されたりする。とくに符号付きと符号なしのオペランドが混ざる場合や、中間結果が他所でも使われる場合である。括弧付きの形は意図した構造を読み手に文書化する。そして中間値自体が設計で使われる名前付き信号である場合、ツールはそれを保持せねばならないので再構成はまったく助けにならない。

For summing many operands there is a better structure still. A chain or tree of carry-propagate adders pays the carry propagation $k-1$ or $\log_2 k$ times. A carry-save tree instead reduces $k$ operands to two using 3:2 compressors (full adders used as counters, with no carry propagation at all), and pays for a single carry-propagate adder at the very end. For eight 16-bit operands this is roughly half the area and a third of the delay of a binary tree of ripple adders. Writing it in RTL means instantiating the compressors or relying on the tool's own multi-operand-addition recognition, which most modern tools have.要把很多個運算元加起來，還有更好的結構。進位傳播加法器的鏈或樹會付出 $k-1$ 次或 $\log_2 k$ 次的進位傳播代價。carry-save 樹則改用 3:2 壓縮器（當成計數器用的全加器，完全不傳播進位）把 $k$ 個運算元縮減成兩個，最後只付一次進位傳播加法器的代價。對八個 16 位元運算元而言，這大約是漣波加法器二元樹的一半面積與三分之一延遲。要在 RTL 裡寫出它，就得實例化那些壓縮器，或仰賴工具自己的多運算元加法辨識 — 多數現代工具都有。多数のオペランドを加算するには、さらに良い構造がある。キャリー伝播加算器の鎖や木はキャリー伝播の代価を $k-1$ 回あるいは $\log_2 k$ 回払う。キャリーセーブ木は代わりに 3:2 圧縮器（カウンタとして使う全加算器で、キャリー伝播はまったくない）で $k$ 個のオペランドを 2 個に縮約し、最後にキャリー伝播加算器 1 個分だけを払う。16 ビットのオペランド 8 個なら、リップル加算器の二分木に比べておよそ半分の面積と 3 分の 1 の遅延になる。RTL で書くには圧縮器をインスタンス化するか、ツール自身の多オペランド加算の認識に頼ることになる。現代のツールの多くはこれを備えている。

6.9 Operator-to-hardware reference6.9 運算子對應硬體速查表6.9 演算子とハードウェアの対応表

The following table collects everything from sections 4 through 6 in one place. $n$ is the operand width in bits. Area figures are rough two-input gate equivalents on a generic standard-cell library and should be read as scaling laws, not as data-sheet values.下表把第 4 到 6 節的內容集中在一處。$n$ 是運算元的位寬。面積數字是泛用標準元件庫上粗略的二輸入等效閘數，應該當成尺度律來讀，而不是規格書上的數值。次の表は第 4 節から第 6 節までの内容を一箇所に集めたものである。$n$ はオペランドのビット幅である。面積の数値は汎用スタンダードセルライブラリにおけるおおまかな 2 入力ゲート等価であり、データシートの値ではなくスケーリング則として読むべきものである。

(a) assign z = ~|d;
(b) assign p = ^d;
(c) assign f = &d[7:0];
(d) assign g = (d == 32'b0);
(e) assign h = |(d & mask);
(f) assign k = ^(d ^ {d[30:0], 1'b0});

assign acc = w0 + w1 + w2 + w3 + w4 + w5 + w6 + w7;

7. Continuous Assignments, case and if7. 連續指定、case 與 if7. 連続代入、case と if

7.1 Continuous assignments7.1 連續指定7.1 連続代入

A continuous assignment drives a net from an expression, permanently. Slide 18 says it is "translated to Boolean equations which are then optimized and synthesized into combinational gates", and the only thing to add is how literally that should be read. The right-hand side is an expression tree; the tool walks it, emits a generic operator node for each operator according to the table in section 6.9, then hands the whole network to the optimiser, which flattens what it can into Boolean equations and covers the result with library cells.連續指定會以一個運算式永久驅動一條 net。第 18 張投影片說它「translated to Boolean equations which are then optimized and synthesized into combinational gates」，唯一要補充的是這句話該讀得多字面。右手邊是一棵運算式樹；工具走過它，依 6.9 節的表為每個運算子產生一個泛用運算子節點，然後把整個網路交給最佳化器，由它把能攤平的攤平成布林方程式，再用庫元件覆蓋結果。連続代入はネットを式によって恒久的に駆動する。スライド 18 は「translated to Boolean equations which are then optimized and synthesized into combinational gates」と述べており、付け加えるべきはこれをどれほど文字どおりに読むべきかということだけである。右辺は式の木であり、ツールはそれをたどって 6.9 節の表に従い演算子ごとにジェネリック演算子ノードを出し、ネットワーク全体を最適化器へ渡す。最適化器は平坦化できるものをブール式に平坦化し、結果をライブラリセルで覆う。

Several consequences follow that students often treat as separate rules:由此推出好幾個結果，而學生常把它們當成各自獨立的規則：ここからいくつかの帰結が導かれるが、学生はしばしばそれらを別々の規則として扱う。

• A continuous assignment can never infer storage. There is no condition under which it can "fail to execute", so there is nothing to hold. This is why a continuous assignment is latch-proof, whereas an always block is not — the entire latch-inference discussion of Lecture 5 simply does not apply here.連續指定永遠不可能推論出儲存元件。沒有任何條件能讓它「沒有執行到」，所以沒有東西需要保持。這就是為什麼連續指定不會產生閂鎖，而 always 區塊會 — 第 5 講整個閂鎖推論的討論在這裡根本不適用。連続代入は記憶素子を推論しえない。「実行されない」状況が存在しないので、保持すべきものがない。連続代入がラッチを生まず always ブロックが生むのはこのためであり、第 5 講のラッチ推論の議論はここにはまったく当てはまらない。
• The order of continuous assignments in the file is irrelevant. They are not statements; they are simultaneous equations. assign y = t; assign t = a & b; behaves identically to the reverse order.連續指定在檔案中的順序無關緊要。它們不是敘述，而是聯立方程式。assign y = t; assign t = a & b; 與相反順序的行為完全相同。連続代入のファイル中での順序は無関係である。それらは文ではなく連立方程式である。assign y = t; assign t = a & b; は逆順に書いたものとまったく同じふるまいをする。
• Only a net can be the target. A reg cannot, because a reg is written procedurally. This is the only remaining practical reason to care about the net/variable distinction in RTL, and SystemVerilog's logic type removes even that by allowing either, provided there is exactly one driver.只有 net 能當目標。reg 不行，因為 reg 是以程序方式寫入的。這是在 RTL 中還需要在意 net／變數區別的唯一實際理由，而 SystemVerilog 的 logic 型態連這個理由都消除了 — 只要恰好只有一個驅動源，兩者皆可。代入先になれるのは net だけである。reg はなれない。reg は手続き的に書き込まれるものだからである。これが RTL で net と変数の区別を気にする唯一の実務的理由であり、SystemVerilog の logic 型は、ドライバがちょうど一つであればどちらでもよいとすることでその理由さえ取り除いた。
• Two continuous assignments to the same net is a multi-driver condition. In simulation the net type resolves it; in synthesis it is an error unless the net is wand/wor (section 2.2) or the drivers are tri-states whose enables are provably exclusive.對同一條 net 做兩次連續指定就是多驅動源狀況。在模擬中由 net 型態來解析；在合成中則是錯誤，除非該 net 是 wand／wor（2.2 節），或那些驅動源是致能可被證明互斥的三態。同じ net への連続代入が 2 つあればマルチドライバ状態である。シミュレーションでは net の型が解決するが、合成ではエラーになる。ただしその net が wand／wor（2.2 節）である場合、またはドライバがイネーブルの排他性を証明できるトライステートである場合を除く。

7.2 No combinational loops7.2 不可有組合迴路7.2 組合せループは禁止

The second bullet on slide 18 — "no structural feedback allowed (no combinational loops)" — deserves more than its one line, because it is the rule that most often turns a design that simulates into a design that cannot be built.第 18 張投影片的第二條 —「no structural feedback allowed (no combinational loops)」— 值得多過一行的篇幅，因為它是最常把「模擬得出來的設計」變成「建不出來的設計」的規則。スライド 18 の二つ目の項目 —「no structural feedback allowed (no combinational loops)」— は 1 行以上の説明に値する。シミュレーションは通る設計を、構築できない設計に変えてしまう規則としてもっとも頻出するからである。

A combinational loop is a cycle in the network of gates with no storage element in it. assign y = y ^ a; is the simplest example. In the real world such a circuit is an oscillator, a latch or a metastable mess depending on the loop's delay and the gate functions, and which of those you get depends on process, voltage, temperature and layout — none of which the RTL expresses. A static timing analyser cannot even analyse it, because there is no path start and no path end; the path goes round forever. So synthesis tools break the loop arbitrarily, warn, and produce something that is probably not what you meant, or they error out.組合迴路是閘的網路中一個不含任何儲存元件的環。assign y = y ^ a; 是最簡單的例子。在真實世界裡，這樣的電路會是一個振盪器、一個閂鎖，或一團亞穩態的混亂，取決於迴路延遲與閘的功能，而究竟是哪一種又取決於製程、電壓、溫度與佈局 — 這些 RTL 都沒有表達。靜態時序分析器甚至無法分析它，因為沒有路徑起點也沒有路徑終點；路徑永遠繞下去。所以合成工具會任意打斷迴路、發出警告，產生出大概不是你想要的東西，或者乾脆報錯。組合せループとは、ゲートのネットワーク中にある記憶素子を含まない閉路のことである。assign y = y ^ a; がもっとも単純な例である。現実にはこうした回路はループ遅延とゲート関数に応じて発振器になったり、ラッチになったり、メタステーブルな混沌になったりする。そのどれになるかはプロセス、電圧、温度、レイアウトに依存し、そのどれも RTL は表現していない。静的タイミング解析器はこれを解析することすらできない。経路の始点も終点もなく、経路が永遠に回り続けるからである。したがって合成ツールはループを任意の場所で断ち切って警告を出し、おそらく意図とは違うものを生成するか、エラーで止まる。

The loops that bite in practice are not the obvious one-liners but the ones that appear through a chain of modules, or inside a case where one branch reads a variable the other branch writes:實務上會咬人的迴路，不是那種顯而易見的一行式，而是經由一串模組出現的迴路，或出現在 case 裡 — 其中一個分支讀取另一個分支所寫的變數：実務で噛みつくループは、分かりやすい 1 行ものではなく、モジュールの連鎖を通って現れるものや、一方の分岐が他方の分岐の書く変数を読む case の内部に現れるものである。

always @* begin
  if (mode)  y = a & b;
  else       y = y | c;      // y on both sides, no edge: combinational loop
end

Note that this particular example is also a latch inference, and the two diagnoses are related: a latch is a deliberately controlled combinational loop (two cross-coupled gates with an enable). When a tool reports "latch inferred" on a line like this, the deeper problem is the feedback, and adding the missing else fixes both.請注意這個特定的例子同時也是一次閂鎖推論，而這兩個診斷是相關的：閂鎖就是一個被刻意控制的組合迴路（兩顆交叉耦合的閘加一個致能）。當工具對這樣的一行回報「latch inferred」時，更深層的問題是回授，而補上缺少的 else 會同時修好兩者。この例が同時にラッチ推論でもある点に注意してほしい。この二つの診断は関係している。ラッチとは意図的に制御された組合せループ（交差結合した 2 つのゲートとイネーブル）だからである。ツールがこのような行に「latch inferred」を報告するとき、より深い問題はフィードバックであり、欠けている else を補えば両方が直る。

There is one legitimate case: an intentional loop through a cell that the tool recognises as storage, such as a hand-instantiated latch, or a clock-gating cell. Those are instantiated, not described, exactly so that the loop lives inside a cell boundary where timing analysis can model it.有一個正當的例外：刻意讓迴路穿過一個工具認得是儲存元件的 cell，例如手動實例化的閂鎖或時脈閘控元件。那些是實例化而非描述出來的，正是為了讓迴路活在一個 cell 邊界之內，使時序分析能夠對它建模。正当なケースが一つある。ツールが記憶素子と認識するセル — 手でインスタンス化したラッチやクロックゲーティングセルなど — を通る意図的なループである。それらは記述ではなくインスタンス化される。まさにループをセル境界の内側に閉じ込め、タイミング解析がモデル化できるようにするためである。

7.3 Priority versus parallel7.3 優先權式與平行式7.3 優先順位型と並列型

Slide 19 shows one example of case and if together, and leaves the most important distinction implicit. An if/else if/else if chain describes a priority structure: conditions are tested in order, and an earlier true condition wins over a later one even if both are true. A case statement describes a selection, and if the items are mutually exclusive — which they are whenever the case expression is a single signal and the items are distinct constants — the structure is a balanced multiplexer. The two cost differently:第 19 張投影片把 case 與 if 放在同一個範例裡，卻把最重要的區別留在暗處。if/else if/else if 鏈描述的是一個優先權結構：條件依序測試，就算兩個條件同時為真，較早的那個也勝出。case 敘述描述的是一個選擇，而如果各個 item 互斥 — 只要 case 運算式是單一訊號而 item 是相異常數，它們就互斥 — 結構就是一個平衡多工器。兩者的成本不同：スライド 19 は case と if を一つの例にまとめ、もっとも重要な区別を暗黙のままにしている。if/else if/else if の連鎖は優先順位構造を記述する。条件は順に評価され、両方が真でも先の条件が後の条件に勝つ。case 文は選択を記述し、アイテムが互いに排他であれば — ケース式が単一の信号でアイテムが相異なる定数であれば常にそうなる — 構造は平衡したマルチプレクサになる。両者のコストは異なる。

The lecture's own identity_if_4bit example sits in an interesting middle position. It is written as an if/else if chain, which would normally imply priority, but every condition is an equality test on the same two-bit signal against a distinct constant, so the conditions are provably mutually exclusive. The optimiser proves it and produces a balanced 4-to-1 multiplexer — the slide labels the schematic "4-to-1 MUX" — and a second tool run produced the same function as plain AND-OR gates with sel[1], sel[0] and their complements. Same function, two mappings, both two levels deep. This is a good illustration of why you should not read a schematic as the answer; it is one covering among many.這一講自己的 identity_if_4bit 範例處在一個有趣的中間位置。它寫成 if/else if 鏈，照理應該隱含優先權，但每個條件都是拿同一個兩位元訊號去與相異常數做相等測試，所以這些條件可被證明互斥。最佳化器證明了這點，產生一個平衡的 4 對 1 多工器 — 投影片把那張電路圖標成「4-to-1 MUX」— 而第二次執行工具則把同一個函式做成單純的 AND-OR 閘，用的是 sel[1]、sel[0] 與它們的補數。同一個函式、兩種對應，都是兩層深。這很好地說明了為什麼你不該把一張電路圖讀成那個答案；它只是眾多覆蓋方式之一。講義自身の identity_if_4bit の例は興味深い中間的な位置にある。if/else if の連鎖として書かれており本来なら優先順位を含意するが、どの条件も同じ 2 ビット信号と相異なる定数との等価判定なので、条件は排他だと証明できる。最適化器はそれを証明して平衡した 4 対 1 マルチプレクサを生成し、スライドは回路図に「4-to-1 MUX」と記している。そして 2 回目のツール実行では、sel[1]、sel[0] とその補数を使った素の AND-OR ゲートとして同じ関数が得られた。同じ関数、二つのマッピング、どちらも深さ 2 段である。回路図を唯一の答えとして読むべきでない理由をよく示している。それは数ある被覆の一つにすぎない。

module identity_if_4bit (data_out, data_a, data_b, data_c, data_d, sel);
  input  [3:0] data_a, data_b, data_c, data_d;
  input  [1:0] sel;
  output [3:0] data_out;
  reg    [3:0] data_out;

  always @ (data_a or data_b or data_c or data_d or sel)
    begin
      if      (sel == 2'b00) data_out = data_a;
      else if (sel == 2'b01) data_out = data_b;
      else if (sel == 2'b10) data_out = data_c;
      else                   data_out = data_d;
    end
endmodule

Two incidental points about this code, both worth noting because they date it. The sensitivity list is written out by hand with or separators; since IEEE 1364-2001 you should write always @* (or always @(*)), which cannot be incomplete and therefore cannot accidentally infer a latch or produce a pre-synthesis/post-synthesis mismatch — the standard hazard covered in Lecture 5. And the final else with no condition is what makes the block complete, so no latch is inferred; had the author written else if (sel == 2'b11) instead, data_out would need to hold its value when sel is x, and a latch would appear.關於這段程式碼還有兩個附帶的點，都值得一提，因為它們透露了它的年代。感度列表是用 or 分隔手寫出來的；自 IEEE 1364-2001 起你應該寫 always @*（或 always @(*)），它不可能不完整，因此不會意外推論出閂鎖，也不會造成合成前後的不匹配 — 那是第 5 講談過的標準風險。另外，最後那個沒有條件的 else 讓整個區塊變得完整，所以不會推論出閂鎖；如果作者寫的是 else if (sel == 2'b11)，那麼當 sel 為 x 時 data_out 就必須保持原值，閂鎖就會出現。このコードについて付随する指摘が二つある。どちらも年代を物語るので触れておく価値がある。センシティビティリストが or 区切りで手書きされている。IEEE 1364-2001 以降は always @*（または always @(*)）と書くべきである。これは不完全になりえないので、うっかりラッチを推論することも、合成前後の不一致を生むこともない — 第 5 講で扱った標準的な落とし穴である。また、条件のない最後の else がブロックを完全にしているのでラッチは推論されない。著者が代わりに else if (sel == 2'b11) と書いていたら、sel が x のとき data_out は値を保持せねばならず、ラッチが現れていたはずである。

7.4 The ALU example and the retained port7.4 ALU 範例與被保留的埠7.4 ALU の例と残されるポート

Slide 19's module brings together four separate threads of this lecture, which is presumably why it was chosen.第 19 張投影片的模組把這一講四條獨立的脈絡匯聚在一起，想必這正是它被挑中的原因。スライド 19 のモジュールは、この講義の四つの別個の筋をまとめて扱っている。おそらくそれが選ばれた理由である。

module alu_reg_with_z1 (alu_out, en, a, b, s0, s1, s2, clk, reset);
  output [1:0] alu_out;
  input  [1:0] a, b;
  input        en, s0, s1, s2, clk, reset;
  reg    [1:0] out_int;

  assign alu_out = (en == 1) ? out_int : 2'bz;

  always @ (posedge clk)
    if (reset) out_int = 2'b0;
    else
      case ({s0, s1, s2})
        3'b111:  out_int = a & b;
        3'b011:  out_int = a | b;
        3'b001:  out_int = a ^ b;
        default: out_int = 2'bx;
      endcase
endmodule

Thread one: the tri-state. The continuous assignment with 2'bz in the else branch gives two tri-state output buffers between the internal register and the port, enabled by en, exactly as section 3.6 described.脈絡一：三態。else 分支為 2'bz 的連續指定，在內部暫存器與埠之間放了兩顆由 en 致能的三態輸出緩衝器，正如 3.6 節所述。筋その一：トライステート。else 分岐が 2'bz の連続代入は、内部レジスタとポートの間に en でイネーブルされるトライステート出力バッファを 2 個置く。3.6 節で述べたとおりである。

Thread two: the synchronous reset. reset is tested inside a block sensitive only to posedge clk, so it is a synchronous reset: the flip-flops are ordinary DFFs and the reset is a term in the combinational logic driving their D pins. Had the event control been @(posedge clk or posedge reset) the tool would have used the flip-flops' asynchronous reset pins instead and saved the datapath logic. Section 9.4 returns to this choice.脈絡二：同步重置。reset 是在一個只對 posedge clk 敏感的區塊內被測試的，所以它是同步重置：正反器是普通的 DFF，而 reset 只是驅動其 D 腳的組合邏輯裡的一項。如果事件控制寫成 @(posedge clk or posedge reset)，工具就會改用正反器的非同步重置腳，省下資料路徑上的邏輯。9.4 節會回到這個選擇。筋その二：同期リセット。reset は posedge clk にのみ反応するブロックの内部で評価されるので、これは同期リセットである。フリップフロップは通常の DFF で、リセットはその D ピンを駆動する組合せ論理の一項にすぎない。イベント制御が @(posedge clk or posedge reset) であれば、ツールはフリップフロップの非同期リセットピンを使い、データパスの論理を節約していただろう。9.4 節でこの選択に立ち返る。

Thread three: the don't care. The three listed items are 111, 011 and 001, and the default is 2'bx. Of the eight possible codes, five are don't cares. Now look at the listed items: all three have s2 = 1 in the concatenation {s0,s1,s2}, meaning the last bit — which is s2 — is 1 in every case that matters. The optimiser is therefore free to choose, for each of the five unlisted codes, whatever output makes the logic smallest, and the smallest choice ignores s2 entirely and decodes on s0 and s1 alone: s0 s1 = 11 gives AND, 01 gives OR, 00 gives XOR, and 10 is free. That is why the slide's schematic shows a two-level AOI network driven by s0 and s1 and by nothing from s2.脈絡三：don't care。列出的三個 item 是 111、011 與 001，而 default 是 2'bx。八個可能的碼中有五個是 don't care。現在看看列出的 item：在串接 {s0,s1,s2} 中三者都是 s2 = 1，也就是說在每一個有意義的 case 裡，最後一個位元 — 也就是 s2 — 都是 1。因此最佳化器可以為那五個未列出的碼各自自由選擇讓邏輯最小的輸出，而最小的選擇是完全忽略 s2，只用 s0 與 s1 解碼：s0 s1 = 11 給 AND、01 給 OR、00 給 XOR，而 10 是自由的。這就是為什麼投影片的電路圖顯示一個由 s0 與 s1 驅動、完全沒有 s2 參與的兩層 AOI 網路。筋その三：ドントケア。列挙されたアイテムは 111、011、001 で、デフォルトは 2'bx である。8 通りのコードのうち 5 つがドントケアになる。列挙されたアイテムを見ると、連結 {s0,s1,s2} において 3 つとも s2 = 1 である。つまり意味のあるすべてのケースで最後のビット — すなわち s2 — は 1 である。したがって最適化器は、列挙されていない 5 つのコードそれぞれについて論理が最小になる出力を自由に選べ、その最小の選択は s2 を完全に無視して s0 と s1 だけでデコードすることである。s0 s1 = 11 なら AND、01 なら OR、00 なら XOR、10 は自由である。スライドの回路図が s0 と s1 に駆動され s2 からは何も受け取らない 2 段の AOI ネットワークを示しているのはこのためである。

Thread four: the retained port. And yet s2 is still there on the left edge of the schematic, as a port with an ESD pad cell attached and no load. This is the rule of section 2.1 in action, and the slide flags it explicitly — "note that unused input s2 is retained". The port is part of the interface; the interface is a contract; the contract survives optimisation.脈絡四：被保留的埠。然而 s2 仍然在電路圖的左緣，是一個接了 ESD pad 元件、卻沒有任何負載的埠。這就是 2.1 節那條規則在運作，而投影片也明確標出了它 —「note that unused input s2 is retained」。埠是介面的一部分；介面是契約；契約在最佳化中存活下來。筋その四：残されるポート。それでも s2 は回路図の左端にあり、ESD パッドセルが付いて負荷のないポートとして存在する。これは 2.1 節の規則が働いている姿であり、スライドも明示的に指摘している —「note that unused input s2 is retained」。ポートはインタフェースの一部であり、インタフェースは契約であり、契約は最適化を生き延びる。

always @* case (s)
  3'b000: y = a + b;
  3'b010: y = a - b;
  3'b100: y = a & b;
  3'b110: y = a | b;
  default: y = ???;
endcase

8. Blocking vs Non-Blocking in Synthesisable Pipelines8. 可合成管線中的阻塞式與非阻塞式指定8. 合成可能なパイプラインにおけるブロッキングとノンブロッキング

Slides 20 to 22 present three modules that look almost identical and synthesise to three different circuits. They are the clearest demonstration in the course of the fact that Verilog's procedural statements describe simulation scheduling, and that the hardware is inferred from the scheduling rather than from the text.第 20 到 22 張投影片呈現三個看起來幾乎一模一樣、卻合成出三種不同電路的模組。它們是本課程中最清楚的示範，說明 Verilog 的程序式敘述描述的是模擬排程，而硬體是從排程而非從文字推論出來的。スライド 20 から 22 は、ほとんど同一に見えて三つの異なる回路に合成される三つのモジュールを提示する。Verilog の手続き文がシミュレーションのスケジューリングを記述しており、ハードウェアはテキストではなくそのスケジューリングから推論されることを、本科目でもっとも明快に示す例である。

8.1 The scheduling rule8.1 排程規則8.1 スケジューリング規則

Strip it to one sentence each.各用一句話剝到見骨。それぞれ一文に削ぎ落とす。

• A blocking assignment x = e evaluates e and updates x immediately, before the next statement in the block runs. Subsequent reads of x in the same block, in the same pass, see the new value.阻塞式指定 x = e 會求值 e 並立刻更新 x，在區塊中下一道敘述執行之前就完成。同一區塊、同一次執行中後續對 x 的讀取會看到新值。ブロッキング代入 x = e は e を評価し、ブロック内の次の文が走る前にただちに x を更新する。同じブロックの同じパス内での以降の x の読み出しは新しい値を見る。
• A non-blocking assignment x <= e evaluates e immediately but schedules the update of x for the end of the current time step. Every read of x anywhere during this time step, including later statements in the same block, sees the old value.非阻塞式指定 x <= e 會立刻求值 e，但把 x 的更新排程到當前時間步的結尾。在這個時間步內任何地方對 x 的讀取 — 包括同一區塊中較後面的敘述 — 看到的都是舊值。ノンブロッキング代入 x <= e は e を直ちに評価するが、x の更新は現在の時間ステップの終わりにスケジュールする。この時間ステップ中のどこで x を読んでも — 同じブロックの後続の文も含めて — 見えるのは古い値である。

Translated into hardware terms: a blocking assignment in a clocked block behaves like a wire inside the clock period — the value flows through combinationally — while a non-blocking assignment behaves like the output of a flip-flop that will not change until the edge completes. That mapping is the whole of the following analysis.翻譯成硬體的說法：時脈區塊裡的阻塞式指定在一個時脈週期之內表現得像一條 wire — 值以組合方式流過去 — 而非阻塞式指定表現得像正反器的輸出，在邊緣完成之前不會改變。接下來的整個分析就建立在這個對應上。ハードウェアの言葉に訳せば、クロックブロック内のブロッキング代入はクロック周期の内側では wire のようにふるまい — 値が組合せ的に流れる — ノンブロッキング代入はエッジが完了するまで変わらないフリップフロップの出力のようにふるまう。以下の分析はすべてこの対応の上に立っている。

There is a second rule, less often stated, that explains the pipe1_alt case: assignments in different always blocks triggered by the same edge have no ordering guarantee at all. If one block writes a variable with = and another reads it at the same edge, the language does not say which happens first. That is a race, and the fact that synthesis resolves it one particular way while simulation may resolve it either way is precisely why the convention exists.還有第二條較少被明說的規則，它解釋了 pipe1_alt 的情況：由同一個邊緣觸發的不同 always 區塊之間，指定的先後完全沒有保證。如果一個區塊用 = 寫入某個變數，而另一個區塊在同一個邊緣讀它，語言並沒有規定誰先誰後。那就是一場競爭，而合成會以某一種特定方式解決它、模擬卻可能以任一種方式解決它 — 這正是那條慣例存在的理由。あまり明言されない第二の規則があり、これが pipe1_alt のケースを説明する。同じエッジで起動される異なる always ブロック間の代入には、順序の保証がまったくない。あるブロックが = で変数を書き、別のブロックが同じエッジでそれを読むとき、どちらが先かを言語は定めていない。それが競合であり、合成が特定の一通りに解決する一方でシミュレーションはどちらにも解決しうる。この慣習が存在する理由はまさにそこにある。

8.2 pipe1 — mixed blocking and non-blocking8.2 pipe1 — 阻塞式與非阻塞式混用8.2 pipe1 — ブロッキングとノンブロッキングの混在

module pipe1 (data, rega, regb, regc, clk, reset);
  input  [1:0] data;
  input        clk, reset;
  output [1:0] rega, regb, regc;
  reg    [1:0] rega, regb, regc;

  always @ (posedge clk or posedge reset)
    if (reset)
      begin
        rega  = 2'b0;
        regb <= 2'b0;
        regc <= 2'b0;
      end
    else
      begin
        rega  = data;          // blocking: rega is now data
        regb <= rega + 1;      // reads the NEW rega = data
        regc <= regb + 1;      // reads the OLD regb
      end
endmodule

Walk the else branch. rega = data updates rega at once. The next line reads rega, and because the previous assignment was blocking it sees data, so the scheduled value of regb is data + 1. The third line reads regb, and because regb was assigned non-blocking its update has not happened yet, so it sees the previous cycle's regb.走一遍 else 分支。rega = data 立刻更新 rega。下一行讀 rega，因為前一次指定是阻塞式的，所以它看到 data，於是 regb 被排程的值是 data + 1。第三行讀 regb，因為 regb 是非阻塞式指定、更新尚未發生，所以它看到的是前一週期的 regb。else 分岐をたどる。rega = data は rega を直ちに更新する。次の行は rega を読むが、直前の代入がブロッキングだったので data を見る。したがって regb にスケジュールされる値は data + 1 である。3 行目は regb を読むが、regb はノンブロッキングで代入され更新がまだ起きていないので、前サイクルの regb を見る。

The inferred hardware, which is what the slide's figure shows: reg_a is a register loaded directly from data; reg_b is a register loaded from an adder whose input is data, not from reg_a's output; reg_c is a register loaded from an adder on reg_b's output. So rega and regb are fed in parallel from data, and only regc is genuinely a pipeline stage behind. The design has three registers but only two pipeline depths.推論出來的硬體，也就是投影片圖上畫的：reg_a 是一個直接從 data 載入的暫存器；reg_b 是一個從加法器載入的暫存器，而那個加法器的輸入是 data，不是 reg_a 的輸出；reg_c 則是從作用在 reg_b 輸出上的加法器載入。所以 rega 與 regb 是並行地由 data 餵進去，只有 regc 真的落後一級。這個設計有三個暫存器，卻只有兩層管線深度。推論されるハードウェア、すなわちスライドの図が示すものはこうである。reg_a は data から直接ロードされるレジスタ。reg_b は加算器からロードされるレジスタだが、その加算器の入力は reg_a の出力ではなく data である。reg_c は reg_b の出力に作用する加算器からロードされる。つまり rega と regb は data から並列に供給され、本当に 1 段遅れているのは regc だけである。この設計はレジスタ 3 個を持つが、パイプライン深さは 2 段しかない。

8.3 pipe1_alt — the same text split into two blocks8.3 pipe1_alt — 同樣的文字拆成兩個區塊8.3 pipe1_alt — 同じ記述を 2 つのブロックに分割

module pipe1_alt (data, rega, regb, regc, clk, reset);
  input  [1:0] data;
  input        clk, reset;
  output [1:0] rega, regb, regc;
  reg    [1:0] rega, regb, regc;

  always @ (posedge clk or posedge reset)
    if (reset) rega = 2'b0; else rega = data;

  always @ (posedge clk or posedge reset)
    if (reset)
      begin
        regb <= 2'b0;
        regc <= 2'b0;
      end
    else
      begin
        regb <= rega + 1;      // rega from the PREVIOUS cycle
        regc <= regb + 1;
      end
endmodule

The statements are textually the same, but rega now lives in a different block. The second block reads rega at the same edge at which the first block writes it. In hardware there is no ambiguity: rega is a flip-flop output, the adder feeding regb is fed from that output, and a flip-flop output at a clock edge is the value stored before the edge. So regb gets the previous cycle's rega plus one, and regc gets the previous cycle's regb plus one. This is a true three-stage pipeline, and the slide's annotation says exactly that: "rega is from the previous cycle, not the current one!"敘述在文字上完全相同，但 rega 現在住在另一個區塊裡。第二個區塊在第一個區塊寫 rega 的同一個邊緣讀它。在硬體上沒有任何歧義：rega 是一個正反器輸出，餵給 regb 的加法器接的是那個輸出，而正反器輸出在時脈邊緣上的值，是邊緣之前所儲存的值。所以 regb 得到的是前一週期的 rega 加一，regc 得到的是前一週期的 regb 加一。這是一條真正的三級管線，而投影片的註記說的正是這件事：「rega is from the previous cycle, not the current one!」文は字面上まったく同じだが、rega はいま別のブロックに属している。2 番目のブロックは、最初のブロックが rega を書くのと同じエッジでそれを読む。ハードウェアには曖昧さがない。rega はフリップフロップの出力であり、regb を駆動する加算器はその出力から供給される。クロックエッジにおけるフリップフロップ出力とは、エッジの前に保持されていた値である。したがって regb は前サイクルの rega に 1 を足した値を、regc は前サイクルの regb に 1 を足した値を得る。これは本物の 3 段パイプラインであり、スライドの注記もまさにそう述べている。「rega is from the previous cycle, not the current one!」

8.4 pipe2 — everything blocking8.4 pipe2 — 全部用阻塞式8.4 pipe2 — すべてブロッキング

module pipe2 (data, rega, regb, regc, clk, reset);
  input  [1:0] data;
  input        clk, reset;
  output [1:0] rega, regb, regc;
  reg    [1:0] rega, regb, regc;

  always @ (posedge clk or posedge reset)
    if (reset)
      begin rega = 2'b0; regb = 2'b0; regc = 2'b0; end
    else
      begin
        rega = data;
        regb = rega + 1;
        regc = regb + 1;
      end
endmodule

Every assignment is blocking, so every read sees the value just written. The slide draws out the reasoning as expression substitution: substituting forward gives rega = data, regb = data + 1, regc = data + 1 + 1, and once the statements are in that form the order no longer matters, so they are equivalent to three non-blocking assignments with those right-hand sides.每個指定都是阻塞式的，所以每次讀取看到的都是剛剛寫入的值。投影片把推理攤開成運算式代換：往前代換得到 rega = data、regb = data + 1、regc = data + 1 + 1，而一旦敘述變成這個形式，順序就不再重要，所以它們等價於三個以這些右手邊為值的非阻塞式指定。どの代入もブロッキングなので、どの読み出しも直前に書かれた値を見る。スライドはその推論を式の代入として展開する。前向きに代入していくと rega = data、regb = data + 1、regc = data + 1 + 1 となり、この形になれば順序はもはや関係しないので、これらはその右辺を持つ 3 つのノンブロッキング代入と等価である。

The hardware is three registers all loaded from data through different amounts of combinational logic: reg_a directly, reg_b through one incrementer, reg_c through two incrementers in series. All three are at pipeline depth one; the circuit is not a pipeline at all. Critically, the two incrementers are now in series within one clock period, so the critical path is twice as long as in pipe1_alt, where each incrementer sat in its own stage. For two-bit arithmetic that is irrelevant; for a thirty-two-bit datapath it would halve the achievable clock frequency.硬體是三個暫存器，全都從 data 經過不同數量的組合邏輯載入：reg_a 是直接接，reg_b 經過一個遞增器，reg_c 經過串聯的兩個遞增器。三者都在管線深度一；這個電路根本不是管線。關鍵在於，兩個遞增器現在是在同一個時脈週期內串聯，所以關鍵路徑是 pipe1_alt 的兩倍長 — 在 pipe1_alt 裡每個遞增器各自待在自己的一級。對兩位元算術來說這無關緊要；對三十二位元資料路徑來說，這會把可達成的時脈頻率砍半。ハードウェアは、いずれも data から異なる量の組合せ論理を経てロードされる 3 つのレジスタである。reg_a は直結、reg_b はインクリメンタ 1 個経由、reg_c は直列のインクリメンタ 2 個経由である。3 つともパイプライン深さ 1 であり、この回路はパイプラインですらない。重要なのは、2 つのインクリメンタがいまや同一クロック周期内で直列になっていることで、各インクリメンタが自分の段にいた pipe1_alt に比べてクリティカルパスは 2 倍になる。2 ビットの算術なら無関係だが、32 ビットのデータパスなら達成可能なクロック周波数が半分になる。

8.5 The three results side by side8.5 三種結果並排比較8.5 三つの結果を並べて比較

Three modules, essentially the same six lines, three different circuits. The lesson that matters more than any individual result is the method: to work out what a clocked block builds, rewrite every blocking assignment by forward substitution until no variable appears on both sides, then read the remaining right-hand sides as the D inputs of flip-flops. Variables that disappear entirely under substitution were wires, not registers; variables that still appear on a right-hand side after substitution are flip-flop outputs read from the previous cycle.三個模組、本質上同樣的六行、三種不同的電路。比任何單一結果都更重要的教訓是那個方法：要算出一個時脈區塊建出什麼，就把每個阻塞式指定以往前代換的方式重寫，直到沒有變數同時出現在兩側，然後把剩下的右手邊讀成正反器的 D 輸入。在代換下完全消失的變數是 wire 而不是暫存器；代換後仍出現在某個右手邊的變數，則是從前一週期讀到的正反器輸出。三つのモジュール、本質的に同じ 6 行、三つの異なる回路。個々の結果以上に重要な教訓はその方法である。クロックブロックが何を作るかを知るには、どの変数も両辺に現れなくなるまで各ブロッキング代入を前向き代入で書き換え、残った右辺をフリップフロップの D 入力として読めばよい。代入の過程で完全に消える変数はレジスタではなく配線であり、代入後もなお右辺に現れる変数は前サイクルから読まれるフリップフロップ出力である。

always @(posedge clk or posedge reset)
  if (reset) begin rega <= 0; regb <= 0; regc <= 0; end
  else       begin rega <= data; regb <= rega + 1; regc <= regb + 1; end

9. Delay Controls, Event Controls and Resets9. 延遲控制、事件控制與重置9. 遅延制御、イベント制御、リセット

9.1 Delay controls9.1 延遲控制9.1 遅延制御

Slide 23 makes three statements about # delays in synthesisable code, and all three point the same way.第 23 張投影片針對可合成程式碼中的 # 延遲講了三句話，三句都指向同一個方向。スライド 23 は合成可能なコードにおける # 遅延について三つのことを述べ、三つとも同じ方向を指している。

They are not advisable. A delay in Verilog is measured in time units set by `timescale, and the synthesiser has no mapping from time units to gate delays — the gate delays do not exist until after technology mapping, and they change with every process corner. So a delay cannot be honoured in any meaningful sense.不建議使用。Verilog 的延遲以 `timescale 設定的時間單位計量，而合成器沒有從時間單位到閘延遲的對應 — 閘延遲要到製程對應之後才存在，而且每個製程角落都不一樣。所以延遲在任何有意義的意義上都無法被遵守。推奨されない。Verilog の遅延は `timescale が定める時間単位で測られるが、合成器は時間単位からゲート遅延への対応を持たない。ゲート遅延はテクノロジマッピング後まで存在せず、プロセスコーナーごとに変わる。したがって遅延を意味ある形で守ることはできない。

Delays shorter than a clock cycle are ignored. This is the usual case and the merciful one. a <= #1 b; or #2 a = b; simply loses the # and becomes a <= b;. The RTL simulation shows a one-unit delay, the gate simulation shows the real cell delay, and the function is the same. The idiom q <= #1 d; is in fact deliberately used in some houses to make waveforms readable by separating the clock edge from the data change, and it is harmless precisely because synthesis ignores it. Lecture 3 covers the simulation semantics of inertial and transport delay in detail.短於一個時脈週期的延遲會被忽略。這是常見而且仁慈的情況。a <= #1 b; 或 #2 a = b; 就只是丟掉 #，變成 a <= b;。RTL 模擬顯示一個單位的延遲，閘級模擬顯示真實的元件延遲，而功能相同。q <= #1 d; 這個慣用寫法事實上在某些公司是刻意使用的，用來把時脈邊緣與資料變化分開以便看波形，而它之所以無害，正是因為合成會忽略它。第 3 講詳細講了慣性延遲與傳輸延遲的模擬語意。クロック周期より短い遅延は無視される。これが通常のケースであり、慈悲深いケースでもある。a <= #1 b; や #2 a = b; は単に # が落ちて a <= b; になる。RTL シミュレーションは 1 単位の遅延を示し、ゲートシミュレーションは実際のセル遅延を示すが、機能は同じである。q <= #1 d; という慣用句は、クロックエッジとデータ変化を分離して波形を読みやすくするために、一部の現場で意図的に使われている。合成がそれを無視するからこそ無害なのである。慣性遅延と伝送遅延のシミュレーション意味論は第 3 講が詳しく扱う。

Delays longer than a clock cycle may be turned into clock cycles. This is the dangerous case, and the slide's "Avoid!!" is earned. Some behavioural-synthesis-capable tools will interpret a long delay as a scheduling instruction and place the assignment in a later clock cycle, inserting state to do so. The result is that the circuit's latency depends on the timescale directive and on a tool option, and that changing `timescale 1ns/1ps to `timescale 1ps/1ps silently changes the hardware. Nothing about that is acceptable in a design you have to maintain.長於一個時脈週期的延遲可能被轉成時脈週期。這是危險的情況，投影片那句「Avoid!!」是實至名歸的。某些具備行為合成能力的工具會把長延遲解讀成排程指令，把該指定放到較晚的時脈週期，並為此插入狀態。結果是電路的延遲取決於 timescale 指令與某個工具選項，而把 `timescale 1ns/1ps 改成 `timescale 1ps/1ps 就會悄悄改變硬體。這在一個你必須維護的設計裡，沒有一點是可以接受的。クロック周期より長い遅延はクロックサイクルに変換されることがある。これが危険なケースで、スライドの「Avoid!!」はもっともである。振る舞い合成が可能な一部のツールは、長い遅延をスケジューリング指示と解釈し、その代入をより後のクロックサイクルに置き、そのために状態を挿入する。結果として回路のレイテンシが timescale 指令とツールのオプションに依存し、`timescale 1ns/1ps を `timescale 1ps/1ps に変えるだけでハードウェアが黙って変わる。保守しなければならない設計において、これはどこをとっても受け入れられない。

The rule is therefore simple: no # anywhere inside a module that will be synthesised. Delays belong in the test bench, where they are the entire mechanism for generating stimulus, and in gate-level library models, where they come from the SDF back-annotation rather than from the source.所以規則很簡單：任何將被合成的模組內部，任何地方都不要有 #。延遲屬於測試平台 — 在那裡它是產生激勵的全部機制 — 以及閘級庫模型，在那裡延遲來自 SDF 反標註而不是來自原始碼。したがって規則は単純である。合成されるモジュールの内部には、どこにも # を書かないこと。遅延はテストベンチに属し — そこでは刺激を生成する仕組みそのものである — またゲートレベルのライブラリモデルに属する。そこでの遅延はソースではなく SDF の逆アノテーションから来る。

9.2 Event control rules9.2 事件控制規則9.2 イベント制御の規則

Slides 24 and 25 give six rules governing the event control expression of a behaviour that is to become sequential logic. They are reproduced here in full because they are the most exam-tested part of the lecture, and then explained in the following subsection.第 24 與 25 張投影片給出六條規則，規範一個要變成循序邏輯的行為其事件控制運算式。這裡完整重現它們，因為這是這一講最常被考的部分，接著在下一小節解釋。スライド 24 と 25 は、順序論理になるべき振る舞いのイベント制御式を規定する 6 つの規則を与える。この講義でもっとも試験に出る部分なのでここに全文を再掲し、続く小節で説明する。

The lecture's own example exercises rules 3 and 4:這一講自己的範例操演了規則 3 與規則 4：講義自身の例は規則 3 と規則 4 を実演している。

always @ (posedge x or posedge y or posedge z)
  begin
    if (x)
      a <= 0;          // x appears in the event control -> asynchronous clear
    else if (y)
      a <= 1;          // y appears in the event control -> asynchronous set
    // z is not mentioned here, and is assumed synchronous
    else a <= b & c;   // the one synchronous branch: z is the clock
  end

Note what has happened: nothing in the code says "z is the clock". The tool deduces it, by elimination, from rule 3. The signal in the event control that is not tested in a branch condition must be the synchronising signal, because every other signal has declared itself asynchronous by appearing in a condition. This is why a signal listed in the sensitivity list but never referenced in the body is normally an error — the tool would have two candidate clocks and no way to choose.注意這裡發生了什麼：程式碼裡沒有任何一句說「z 是時脈」。工具是靠規則 3 以排除法推論出來的。事件控制中那個沒有被任何分支條件測試的訊號，必定是同步訊號，因為其餘每個訊號都因為出現在某個條件裡而宣告了自己是非同步的。這就是為什麼一個出現在感度列表、卻從未在主體中被引用的訊號通常是錯誤 — 工具會有兩個候選時脈，卻無從選擇。ここで何が起きたかに注目してほしい。コードのどこにも「z はクロックである」とは書かれていない。ツールは規則 3 によって消去法で推論する。イベント制御の中で分岐条件に現れない信号こそが同期用の信号に違いない。他のすべての信号は条件に現れることで自らを非同期だと宣言しているからである。センシティビティリストに挙げられていながら本体で一度も参照されない信号が通常エラーになるのはこのためである。ツールはクロックの候補を二つ持ち、選ぶ手立てがなくなる。

9.3 Why the rules exist9.3 這些規則為何存在9.3 規則が存在する理由

Every one of the six rules is a direct consequence of what a standard-cell flip-flop is. A library D flip-flop has a D input, a clock input, optionally an asynchronous set pin, optionally an asynchronous clear pin, and optionally a scan input and enable. That is the entire menu. The rules exist to make sure the Verilog you write can be expressed in that menu.這六條規則每一條都是「標準元件正反器是什麼」的直接結果。庫裡的 D 型正反器有一個 D 輸入、一個時脈輸入，選配一個非同步 set 腳、選配一個非同步 clear 腳，以及選配一個掃描輸入與致能。整張菜單就這些。這些規則的存在，是為了確保你寫的 Verilog 能用這張菜單表達出來。6 つの規則はどれも、スタンダードセルのフリップフロップが何であるかから直接導かれる。ライブラリの D フリップフロップは D 入力、クロック入力、任意で非同期セットピン、任意で非同期クリアピン、任意でスキャン入力とイネーブルを持つ。メニューはそれですべてである。規則は、書いた Verilog がそのメニューで表現できることを保証するために存在する。

Rule 4 is the one students violate most often, usually by writing the enable first:規則 4 是學生最常違反的一條，通常是把致能寫在前面：規則 4 は学生がもっともよく破る規則で、たいていはイネーブルを先に書いてしまうことによる。

always @ (posedge clk or negedge rst_n)
  if (en)        q <= d;
  else if (!rst_n) q <= 0;

always @ (posedge clk or negedge rst_n)
  if (!rst_n)  q <= 0;
  else if (en) q <= d;

Rule 6 has a modern footnote. Dual-edge-triggered flip-flops do exist — they are used in double-data-rate interfaces — but they are instantiated as library primitives or built from two flip-flops and a multiplexer, never inferred from @(posedge clk or negedge clk). If you need DDR behaviour, write two separate always blocks, one on each edge, and combine their outputs with a mux on the clock; or instantiate the vendor's DDR primitive.規則 6 有一個現代的註腳。雙邊緣觸發正反器確實存在 — 它們用在雙倍資料率介面上 — 但它們是以庫原始元件的形式被實例化，或是用兩顆正反器加一顆多工器搭出來，絕不會從 @(posedge clk or negedge clk) 推論出來。如果你需要 DDR 行為，請寫兩個分開的 always 區塊，一邊一個邊緣，再用一顆由時脈控制的多工器把輸出合併；或者實例化廠商的 DDR 原始元件。規則 6 には現代的な脚注が付く。両エッジトリガのフリップフロップは実在し — ダブルデータレートのインタフェースで使われる — だがライブラリのプリミティブとしてインスタンス化されるか、フリップフロップ 2 個とマルチプレクサで組まれるかであって、@(posedge clk or negedge clk) から推論されることは決してない。DDR のふるまいが必要なら、各エッジに一つずつ計 2 つの always ブロックを書き、クロックで選ぶマルチプレクサで出力を合成するか、ベンダの DDR プリミティブをインスタンス化すること。

9.4 Resets9.4 重置9.4 リセット

Slide 26 makes two points. The first — that an asynchronous reset is modelled inside the event control expression that detects the synchronising signal — is really just rule 5 restated: the reset earns its asynchronous status by being in the sensitivity list with an edge qualifier, which is what tells the tool to use the flip-flop's reset pin rather than build logic on D.第 26 張投影片講了兩點。第一點 — 非同步重置是在偵測同步訊號的那個事件控制運算式裡建模的 — 其實只是規則 5 的重述：重置是靠帶著邊緣修飾出現在感度列表裡，才取得它的非同步身分，而那正是告訴工具去用正反器的重置腳、而不是在 D 上建邏輯的依據。スライド 26 は二点を述べる。第一点 — 非同期リセットは同期信号を検出するイベント制御式の内部でモデル化される — は実のところ規則 5 の言い換えである。リセットはエッジ修飾付きでセンシティビティリストに現れることで非同期という身分を得る。それこそが、D 側に論理を作るのではなくフリップフロップのリセットピンを使えとツールに伝えるものである。

The choice between asynchronous and synchronous reset is a real engineering decision and worth laying out, because it is not on the slide and it comes up in every project review.非同步與同步重置之間的選擇是一個真實的工程決策，值得攤開來講，因為投影片上沒有，而它在每一次專案審查中都會出現。非同期リセットと同期リセットの選択は現実の設計判断であり、整理しておく価値がある。スライドには載っておらず、しかもあらゆるプロジェクトレビューで話題になるからである。

The standard compromise, used in most ASIC flows including communication chips, is the asynchronous assert, synchronous de-assert reset synchroniser: the reset is applied asynchronously so that it works with no clock, and released through two flip-flops clocked by the destination clock so that the release edge is synchronous and the recovery/removal checks are trivially met. It costs two flip-flops per clock domain and removes an entire class of start-up failures.大多數 ASIC 流程（包括通訊晶片）採用的標準折衷，是非同步設定、同步解除的重置同步器：重置以非同步方式施加，因此沒有時脈也能作用；而解除則經過兩顆由目的端時脈驅動的正反器，使釋放邊緣是同步的，recovery/removal 檢查也就輕鬆滿足。它每個時脈域只花兩顆正反器，卻消除了一整類的啟動失效。通信チップを含むほとんどの ASIC フローで使われる標準的な妥協は、非同期アサート・同期デアサートのリセットシンクロナイザである。リセットは非同期にかけられるのでクロックがなくても効き、解放は宛先クロックで駆動される 2 個のフリップフロップを通るので解放エッジが同期的になり、リカバリ／リムーバル検査は自明に満たされる。クロックドメインあたりフリップフロップ 2 個のコストで、起動時故障の一群をまるごと取り除ける。

The second point on slide 26 — that unused set/reset pins on the selected library cells are tied to power or ground — is a small but real detail of the mapping pass. If the tool picks a DFFRPQ (D flip-flop with asynchronous reset and preset) because that is the only cell of the right drive strength available, and your code uses only the reset, then the preset pin must be tied inactive. The tie is to a rail through a tie-cell, not directly to the supply, because direct connections to power and ground from a signal pin cause antenna and ESD problems during manufacture. You will see TIEHI/TIELO cells in the netlist for exactly this reason, and they are why the gate count in a report is sometimes slightly higher than you expect.第 26 張投影片的第二點 — 所選庫元件上未使用的 set/reset 腳會被綁到電源或地 — 是對應階段一個小而真實的細節。如果工具因為那是唯一具備合適驅動能力的元件而挑了一顆 DFFRPQ（帶非同步 reset 與 preset 的 D 型正反器），而你的程式碼只用到 reset，那麼 preset 腳就必須被綁成無作用。綁定是透過 tie-cell 接到電源軌，而不是直接接到電源，因為訊號腳直接連到電源與地會在製造時造成天線效應與 ESD 問題。你會在 netlist 裡看到 TIEHI／TIELO 元件，原因正是如此，而它們也是報告中閘數有時比你預期略高的理由。スライド 26 の第二点 — 選ばれたライブラリセルの未使用のセット／リセットピンは電源またはグラウンドに固定される — はマッピングパスの小さいが現実的な細部である。適切な駆動力を持つセルがそれしかないという理由でツールが DFFRPQ（非同期リセットとプリセットを備えた D フリップフロップ）を選び、コードがリセットしか使っていなければ、プリセットピンは非アクティブに固定されねばならない。固定は電源に直結するのではなくタイセルを介して電源レールにつなぐ。信号ピンを電源やグラウンドに直結すると製造時にアンテナ効果と ESD の問題が生じるからである。ネットリストに TIEHI／TIELO セルが見えるのはまさにこの理由であり、レポートのゲート数が予想より少し多くなることがあるのもこのためである。

(a) always @ (posedge clk or negedge rst_n)
      if (!rst_n) q <= 0; else q <= d;

(b) always @ (posedge clk or negedge rst_n)
      if (en) q <= d; else if (!rst_n) q <= 0;

(c) always @ (posedge clk or negedge clk) q <= d;

(d) always @ (posedge clk or posedge set or posedge clr)
      if (clr) q <= 0; else if (set) q <= 1; else q <= d;

(e) always @ (posedge clk or posedge rst) q <= d;

(f) always @ (posedge clk_a or posedge clk_b)
      if (sel) q <= d1; else q <= d2;

(g) always @ (posedge clk or negedge rst_n)
      if (!rst_n) q <= 0;
      else if (load) q <= d;
      else if (shift) q <= {q[6:0], 1'b0};

10. Loops and Loop Unrolling10. 迴圈與迴圈展開10. ループとループ展開

The loop taxonomy on slide 27 is the single most quotable thing in Lecture 7, and the four counting-ones modules that follow it are the best worked example in the course. The taxonomy has two independent axes, which is why there are four types: is the loop static, and does it contain an internal timing control?第 27 張投影片的迴圈分類法是第 7 講裡最值得引用的東西，而緊接其後的四個「數 1 的個數」模組是本課程最好的實作範例。這個分類法有兩個獨立的軸，所以才有四種型別：迴圈是不是靜態的，以及它有沒有內部時序控制？スライド 27 のループ分類は第 7 講でもっとも引用に値するもので、それに続く 4 つの「1 の個数を数える」モジュールは本科目で最良の実例である。この分類には独立な軸が二つあり、だから 4 つの型になる。ループが静的か、そして内部タイミング制御を含むか、である。

10.1 Static versus non-static10.1 靜態與非靜態10.1 静的か非静的か

A loop is static, or data-independent, when the compiler can determine the number of iterations at elaboration time. Operationally: the initial value, the termination condition and the increment must all be computable from constants and parameters, and the loop variable must not be modified anywhere inside the body. for (i = 0; i < 4; i = i + 1) is static. for (i = 0; i < n; i = i + 1) is static if n is a parameter and non-static if n is a signal. while (temp) where the body shifts temp is non-static, because the trip count depends on the data.當編譯器能在展開期判定迭代次數時，這個迴圈就是靜態的，也就是與資料無關。操作上來說：初始值、終止條件與增量都必須能從常數與參數算出來，而且迴圈變數不能在主體內任何地方被修改。for (i = 0; i < 4; i = i + 1) 是靜態的。for (i = 0; i < n; i = i + 1) 在 n 是參數時是靜態的，在 n 是訊號時是非靜態的。主體會移位 temp 的 while (temp) 是非靜態的，因為迭代次數取決於資料。ループが静的、すなわちデータ非依存であるとは、コンパイラがエラボレーション時に反復回数を決定できることをいう。実務的には、初期値、終了条件、増分がすべて定数とパラメータから計算可能で、かつループ変数が本体のどこでも変更されないことである。for (i = 0; i < 4; i = i + 1) は静的である。for (i = 0; i < n; i = i + 1) は n がパラメータなら静的、n が信号なら非静的である。本体が temp をシフトする while (temp) は、反復回数がデータに依存するので非静的である。

The significance of staticness is that only a static loop can be unrolled, and unrolling is the only way a loop can become combinational logic. A circuit has a fixed number of gates; a loop that runs a data-dependent number of times would need a data-dependent number of gates. There is no way around this, and it is not a tool limitation — it is a fact about physical objects.靜態性之所以重要，是因為只有靜態迴圈能被展開，而展開是迴圈變成組合邏輯的唯一途徑。電路的閘數是固定的；一個執行次數取決於資料的迴圈會需要取決於資料的閘數。這沒有任何繞道可走，而且這不是工具的限制 — 這是關於物理物體的事實。静的性が重要なのは、展開できるのは静的ループだけであり、展開こそがループが組合せ論理になる唯一の道だからである。回路のゲート数は固定である。実行回数がデータに依存するループは、データに依存する数のゲートを必要とする。これを回避する方法はなく、ツールの制限でもない — 物理的な物体についての事実である。

An internal timing control is an @(posedge clk), an @(some_signal) or a #delay inside the loop body. Its effect is to break the loop's work across time rather than across space: each iteration happens in a different clock cycle. This is behavioural synthesis — the tool must build an implicit state machine to sequence the iterations — and it is supported by only some tools and configurations, which is why the slide marks types II and IV "not recommended".內部時序控制指的是迴圈主體內部的 @(posedge clk)、@(some_signal) 或 #delay。它的效果是把迴圈的工作攤在時間上而不是空間上：每次迭代發生在不同的時脈週期。這就是行為合成 — 工具必須建一個隱含的狀態機來把迭代排序 — 而只有部分工具與部分設定支援它，這就是投影片把第 II 與第 IV 型標成「not recommended」的原因。内部タイミング制御とは、ループ本体の内部にある @(posedge clk)、@(some_signal)、#delay のことである。その効果はループの仕事を空間ではなく時間に広げることで、各反復が別のクロックサイクルで起こる。これは振る舞い合成であり — ツールは反復を順序付ける暗黙の状態機械を作らねばならない — 一部のツールと設定でしか対応されていない。スライドがタイプ II と IV を「not recommended」と記すのはそのためである。

10.2 Type I — unrolling10.2 第 I 型 — 展開10.2 タイプ I — 展開

Unrolling is textual substitution performed at elaboration. The tool replaces the loop with $N$ copies of the body, substituting the literal value of the loop index into each copy, and then discards the loop variable entirely. After unrolling there is no loop and no index; there is a straight-line sequence of assignments that the rest of the flow treats like any other.展開是在展開期執行的文字替換。工具把迴圈換成 $N$ 份主體複本，把迴圈索引的字面值代入每一份，然後把迴圈變數整個丟掉。展開之後沒有迴圈也沒有索引；剩下的是一串直線式的指定敘述，流程其餘部分就把它當成一般的敘述處理。展開とはエラボレーション時に行われるテキスト置換である。ツールはループを本体の $N$ 個のコピーに置き換え、ループインデックスのリテラル値を各コピーに代入し、ループ変数を完全に捨てる。展開後にはループもインデックスも存在せず、残るのは一直線の代入の並びで、以降のフローはそれを他と同様に扱う。

module for_and_loop_comb (out, a, b);
  input  [3:0] a, b;
  output [3:0] out;
  reg    [2:0] i;
  reg    [3:0] out;

  always @ (a or b)
    begin
      for (i = 0; i < 4; i = i + 1)
        out[i] = a[i] & b[i];
    end
endmodule

Three observations about this unrolling that generalise.關於這次展開有三點觀察，而且可以推廣。この展開について三つの観察があり、いずれも一般化できる。

The loop variable produces no hardware. i is declared reg [2:0], which in any other context would mean three flip-flops. Here it is consumed entirely at elaboration and does not appear in the netlist. That is why the counting-ones example can declare several apparently expensive registers and still synthesise to a handful of gates.迴圈變數不產生任何硬體。i 宣告成 reg [2:0]，在其他任何情境下那都代表三顆正反器。這裡它在展開期就被完全消耗掉，不會出現在 netlist 裡。這就是為什麼數 1 的個數的範例可以宣告好幾個看似昂貴的暫存器，卻仍然合成成寥寥幾個閘。ループ変数はハードウェアを生まない。i は reg [2:0] と宣言されており、他の文脈ならフリップフロップ 3 個を意味する。ここではエラボレーション時に完全に消費され、ネットリストには現れない。1 の個数を数える例が高価そうなレジスタをいくつも宣言しながら数ゲートに合成される理由はここにある。

The index must be wide enough. i is three bits, not two, because the loop terminates by testing i < 4, which requires i to be able to hold 4. With reg [1:0] i the increment from 3 wraps to 0, the condition is always true, and the loop never terminates — in simulation it hangs, and at elaboration the tool either hangs or reports an iteration limit. This is an exam favourite and a real bug; use an integer for loop indices and the question never arises.索引必須夠寬。i 是三位元而不是兩位元，因為迴圈靠測試 i < 4 來終止，這要求 i 能夠保存 4。若用 reg [1:0] i，從 3 遞增會回繞成 0，條件永遠為真，迴圈永不終止 — 在模擬中它會卡住，在展開期工具要嘛卡住、要嘛回報迭代次數上限。這是考試的常客，也是真實的錯誤；迴圈索引用 integer，這個問題就永遠不會出現。インデックスは十分な幅が要る。i が 2 ビットではなく 3 ビットなのは、ループが i < 4 の判定で終了し、i が 4 を保持できる必要があるからである。reg [1:0] i では 3 からのインクリメントが 0 にラップし、条件は常に真となり、ループは終了しない。シミュレーションではハングし、エラボレーションではツールがハングするか反復回数の上限を報告する。試験の定番であり、現実のバグでもある。ループインデックスに integer を使えばこの問題は生じない。

Constant indices are free. After substitution, a[i] has become a[0], a[1], a[2], a[3] — four constant part selects, which are wires. Had the index remained a signal, each a[i] would have been a 4-to-1 multiplexer (see the last row of the table in section 6.9). The difference between a free wire and a mux per access is the main reason unrolling matters so much for area.常數索引是免費的。代換之後，a[i] 變成了 a[0]、a[1]、a[2]、a[3] — 四個常數部分選取，也就是線。如果索引仍然是訊號，每一個 a[i] 就會是一顆 4 對 1 多工器（見 6.9 節表格的最後一列）。免費的線與每次存取一顆多工器之間的差距，正是展開對面積如此重要的主因。定数インデックスは無料である。代入後、a[i] は a[0]、a[1]、a[2]、a[3] になる。4 つの定数部分選択、すなわち配線である。インデックスが信号のままなら、各 a[i] は 4 対 1 マルチプレクサになっていた（6.9 節の表の最終行を参照）。無料の配線とアクセスごとのマルチプレクサの差こそ、展開が面積にとってこれほど重要である主な理由である。

The slide's final note — that replacing @(a or b) with @(posedge clk) yields for_and_loop_reg — shows that unrolling is orthogonal to storage inference. Unrolling produces four AND gates either way; the event control then decides whether those gates drive outputs directly or drive four flip-flops. The slide's synthesis result shows exactly that: four AND gates in part (a), and the same four ANDs feeding four scan-enabled flip-flops in part (b).投影片最後那個註記 — 把 @(a or b) 換成 @(posedge clk) 就得到 for_and_loop_reg — 顯示展開與儲存推論是正交的。不論哪一種，展開都產生四顆 AND 閘；接著由事件控制決定那些閘是直接驅動輸出，還是驅動四顆正反器。投影片的合成結果正好顯示這點：(a) 部分是四顆 AND 閘，(b) 部分是同樣四顆 AND 餵進四顆帶掃描致能的正反器。スライドの最後の注記 — @(a or b) を @(posedge clk) に替えると for_and_loop_reg になる — は、展開が記憶の推論と直交することを示している。どちらにせよ展開は AND ゲートを 4 個生み、そのゲートが出力を直接駆動するかフリップフロップ 4 個を駆動するかはイベント制御が決める。スライドの合成結果はまさにそれを示す。(a) では AND ゲート 4 個、(b) では同じ AND 4 個がスキャンイネーブル付きフリップフロップ 4 個を駆動している。

10.3 Counting ones, unrolled10.3 數 1 的個數，展開版10.3 1 の個数を数える、展開版

The counting-ones example is where unrolling becomes genuinely interesting, because the body is not independent per iteration — each iteration reads what the previous one wrote.數 1 的個數這個範例是展開真正變得有趣的地方，因為它的主體不是每次迭代各自獨立 — 每次迭代都讀取前一次寫下的東西。1 の個数を数える例は展開が本当に面白くなる場面である。本体が反復ごとに独立ではなく、各反復が直前の反復の書いたものを読むからである。

module count_ones_a (bit_count, data, clk, reset);
  parameter data_width  = 4;
  parameter count_width = 3;
  output [count_width-1:0] bit_count;
  input  [data_width-1:0]  data;
  input                    clk, reset;
  reg    [count_width-1:0] count, bit_count, index;
  reg    [data_width-1:0]  temp;

  always @ (posedge clk)
    if (reset) begin count = 0; bit_count = 0; end
    else begin
      count = 0;
      bit_count = 0;
      temp = data;
      for (index = 0; index < data_width; index = index + 1) begin
        count = count + temp[0];
        temp  = temp >> 1;
      end
      bit_count = count;
    end
endmodule

Unroll it by hand. Substituting index = 0, 1, 2, 3 and then forward-substituting every blocking assignment:動手把它展開。代入 index = 0、1、2、3，再把每個阻塞式指定往前代換：手で展開してみよう。index = 0、1、2、3 を代入し、各ブロッキング代入を前向きに代入していく。

// after unrolling
count = 0;      temp = data;
count = count + temp[0];   temp = temp >> 1;   // iteration 0
count = count + temp[0];   temp = temp >> 1;   // iteration 1
count = count + temp[0];   temp = temp >> 1;   // iteration 2
count = count + temp[0];   temp = temp >> 1;   // iteration 3
bit_count = count;

// after forward substitution: every temp[0] resolves to a constant bit of data
bit_count = data[0] + data[1] + data[2] + data[3];

The shifts vanish, because each one is a shift by a literal and the temp[0] that follows it is therefore a constant bit index into data. The intermediate count values vanish too, because each is written before it is read in the same pass. What is left is the sum of four one-bit numbers into a three-bit result — a population count, or in adder-tree language a (4,3) counter.移位消失了，因為每一次都是對字面常數的移位，於是其後的 temp[0] 就是對 data 的一個常數位元索引。中間的 count 值也消失了，因為每一個都在同一次執行中先寫後讀。剩下來的是把四個一位元數字加總成一個三位元結果 — 一個population count，用加法樹的語言說就是一個 (4,3) 計數器。シフトは消える。どれもリテラルによるシフトなので、続く temp[0] は data への定数ビットインデックスになるからである。途中の count の値も消える。どれも同じパス内で読まれる前に書かれているからである。残るのは 1 ビットの数 4 個を 3 ビットの結果に加算するもの — ポピュレーションカウント、加算器ツリーの言葉で言えば (4,3) カウンタである。

The cheapest construction is one full adder and two half adders. Let $\text{FA}(d_0,d_1,d_2)$ give sum $s$ and carry $c$; then add $d_3$ to $s$ with a half adder giving sum $u$ and carry $v$; the result is $\text{bit\_count} = \{c\wedge v,\ c\oplus v,\ u\}$, which needs one more half adder. Total: 1 FA + 2 HA $\approx$ 6 + 2×2 = 10 GE and three levels of logic. The slide's synthesis schematic shows precisely this shape — a handful of XOR, NAND and NOR gates — feeding three flip-flops.最便宜的構造是一顆全加器加兩顆半加器。令 $\text{FA}(d_0,d_1,d_2)$ 給出和 $s$ 與進位 $c$；接著用半加器把 $d_3$ 加到 $s$，得到和 $u$ 與進位 $v$；結果是 $\text{bit\_count} = \{c\wedge v,\ c\oplus v,\ u\}$，這還需要再一顆半加器。總計：1 顆 FA + 2 顆 HA $\approx$ 6 + 2×2 = 10 GE，三層邏輯。投影片的合成電路圖顯示的正是這個形狀 — 幾顆 XOR、NAND 與 NOR 閘 — 餵進三顆正反器。もっとも安い構成は全加算器 1 個と半加算器 2 個である。$\text{FA}(d_0,d_1,d_2)$ が和 $s$ と桁上げ $c$ を与えるとし、半加算器で $d_3$ を $s$ に加えて和 $u$ と桁上げ $v$ を得る。結果は $\text{bit\_count} = \{c\wedge v,\ c\oplus v,\ u\}$ で、これにもう 1 個半加算器が要る。合計で FA 1 個 + HA 2 個 $\approx$ 6 + 2×2 = 10 GE、論理 3 段である。スライドの合成回路図はまさにこの形 — XOR、NAND、NOR がいくつか — がフリップフロップ 3 個を駆動する姿を示している。

Scaling matters here. For a general $n$-bit population count the best-known construction is a Wallace-style tree of full adders, costing roughly $n - \nu(n)$ full adders where $\nu(n)$ counts the ones in the binary representation of $n$, with depth $O(\log n)$. For $n=8$ that is about seven full adders, 45 GE, four levels; for $n=32$, about 31 full adders, 190 GE, five levels. So population count scales as $O(n)$ in area and $O(\log n)$ in delay — cheap. Writing it as the unrolled loop above gets you that automatically, provided the tool's arithmetic restructuring is enabled; a naive left-to-right chain of additions would instead give $O(n)$ depth, which is why the balanced-tree discussion of section 6.8 applies here too.這裡的尺度很重要。對一般 $n$ 位元的 population count，目前已知最好的構造是 Wallace 式的全加器樹，約花 $n - \nu(n)$ 顆全加器，其中 $\nu(n)$ 是 $n$ 的二進位表示中 1 的個數，深度為 $O(\log n)$。$n=8$ 時約七顆全加器、45 GE、四層；$n=32$ 時約 31 顆全加器、190 GE、五層。所以 population count 在面積上是 $O(n)$、延遲上是 $O(\log n)$ — 很便宜。寫成上面那個展開迴圈就會自動得到這個結果，前提是工具的算術重構有開啟；一條天真的由左到右加法鏈反而會給出 $O(n)$ 深度，這就是為什麼 6.8 節關於平衡樹的討論在這裡同樣適用。ここではスケーリングが重要である。一般の $n$ ビットのポピュレーションカウントで知られる最良の構成は Wallace 風の全加算器ツリーで、$n$ の 2 進表現中の 1 の個数を $\nu(n)$ とすると、およそ $n - \nu(n)$ 個の全加算器を要し、深さは $O(\log n)$ である。$n=8$ なら全加算器約 7 個、45 GE、4 段。$n=32$ なら約 31 個、190 GE、5 段である。つまりポピュレーションカウントは面積が $O(n)$、遅延が $O(\log n)$ — 安い。上記の展開ループとして書けばこれが自動的に得られる。ただしツールの算術再構成が有効であることが条件で、素朴な左から右への加算の連鎖では深さが $O(n)$ になる。6.8 節の平衡木の議論がここでも当てはまる理由である。

10.4 Type II — static loop with internal timing controls10.4 第 II 型 — 帶內部時序控制的靜態迴圈10.4 タイプ II — 内部タイミング制御を持つ静的ループ

Put an @(posedge clk) inside a static loop and the meaning changes completely: the iterations are no longer replicated in space, they are sequenced in time.在靜態迴圈裡放一個 @(posedge clk)，意義就完全改變了：迭代不再被複製到空間中，而是被排序到時間中。静的ループの中に @(posedge clk) を置くと意味はまったく変わる。反復はもはや空間に複製されず、時間の中に順序付けられる。

module count_ones_b (bit_count, data, clk, reset);
  parameter data_width  = 4;
  parameter count_width = 3;
  output [count_width-1:0] bit_count;
  input  [data_width-1:0]  data;
  input                    clk, reset;
  reg    [count_width-1:0] count, bit_count, index;
  reg    [data_width-1:0]  temp;

  always @ (posedge clk)
    if (reset) begin count = 0; bit_count = 0; end
    else begin
      count = 0;
      temp  = data;
      for (index = 0; index < data_width; index = index + 1)
        @ (posedge clk)
          begin
            if (temp[0]) count = count + 1;
            temp = temp >> 1;
          end
      @ (posedge clk)
        bit_count = count;
    end
endmodule

Now the behaviour is: on the triggering edge, clear count and load temp; then on each of the next four edges, add the low bit of temp to count and shift temp; then on a fifth further edge, publish count into bit_count. The total latency is five clocks after the starting edge, fixed, independent of the data.現在的行為是：在觸發邊緣上清除 count 並載入 temp；接著在之後四個邊緣的每一個上，把 temp 的最低位加到 count 並把 temp 移位；然後在再下一個第五個邊緣上，把 count 發布到 bit_count。總延遲是起始邊緣之後五個時脈，固定不變，與資料無關。ふるまいはこうなる。起動エッジで count をクリアし temp をロードする。続く 4 つのエッジそれぞれで temp の最下位ビットを count に加え temp をシフトする。さらに 5 つ目のエッジで count を bit_count に出す。総レイテンシは起動エッジから 5 クロックで固定、データには依存しない。

The hardware is a small sequential machine: a three-bit counter for count with an incrementer and an enable, a four-bit shift register for temp, a three-bit output register, and an implicit state machine with six states that sequences them. That state machine is not written anywhere in the source; the tool must synthesise it from the control flow. This is behavioural synthesis rather than RTL synthesis, and it is why the slide says "not recommended": many RTL synthesisers reject the construct outright, those that accept it differ in how they encode the implicit states, and the resulting latency is invisible in the source text.硬體是一台小型循序機器：count 用一個帶遞增器與致能的三位元計數器，temp 用一個四位元移位暫存器，一個三位元輸出暫存器，再加一台有六個狀態、負責把它們排序的隱含狀態機。那台狀態機在原始碼裡任何地方都沒有被寫出來；工具必須從控制流推論出來。這是行為合成而不是 RTL 合成，也是投影片說「not recommended」的原因：許多 RTL 合成器會直接拒絕這個構件，而接受它的工具在隱含狀態如何編碼上各不相同，產生的延遲在原始碼中也看不出來。ハードウェアは小さな順序機械である。count のためのインクリメンタとイネーブル付き 3 ビットカウンタ、temp のための 4 ビットシフトレジスタ、3 ビットの出力レジスタ、そしてそれらを順序付ける 6 状態の暗黙の状態機械である。その状態機械はソースのどこにも書かれていない。ツールが制御フローから合成せねばならない。これは RTL 合成ではなく振る舞い合成であり、スライドが「not recommended」と言う理由でもある。多くの RTL 合成器はこの構文を端から拒否し、受け付けるツールも暗黙の状態の符号化が異なり、生じるレイテンシはソーステキストから見えない。

Compare the two implementations honestly. Type I: 10 GE of combinational logic plus three flip-flops, one clock of latency, one result per clock. Type II: an incrementer, a shift register, a state machine — perhaps 60 GE — five clocks of latency, one result every six clocks. For four bits, Type I wins on every axis. The trade only begins to favour the sequential form at large widths, where the unrolled adder tree becomes genuinely big, and even then you would write the state machine explicitly rather than hope the tool infers the one you wanted.誠實地比較這兩種實作。第 I 型：10 GE 的組合邏輯加三顆正反器，延遲一個時脈，每個時脈出一個結果。第 II 型：一個遞增器、一個移位暫存器、一台狀態機 — 大概 60 GE — 延遲五個時脈，每六個時脈出一個結果。對四位元來說，第 I 型在每一個面向上都贏。只有在位寬很大、展開後的加法樹真的變大時，這個取捨才開始偏向循序形式，而即使那時，你也會自己明確寫出狀態機，而不是期待工具推論出你想要的那一台。二つの実装を正直に比べよう。タイプ I は組合せ論理 10 GE とフリップフロップ 3 個、レイテンシ 1 クロック、毎クロック 1 結果。タイプ II はインクリメンタ、シフトレジスタ、状態機械 — おそらく 60 GE — レイテンシ 5 クロック、6 クロックごとに 1 結果である。4 ビットではあらゆる軸でタイプ I が勝つ。このトレードオフが順序形式に傾き始めるのは、展開した加算器ツリーが本当に大きくなる広い幅のときだけで、しかもそのときでさえ、ツールが望みどおりの状態機械を推論してくれることを期待するより、自分で明示的に書くことになる。

10.5 Type III — non-static without timing controls10.5 第 III 型 — 非靜態且無時序控制10.5 タイプ III — 非静的かつタイミング制御なし

module count_ones_c (bit_count, data, clk, reset);
  parameter data_width  = 4;
  parameter count_width = 3;
  output [count_width-1:0] bit_count;
  input  [data_width-1:0]  data;
  input                    clk, reset;
  reg    [count_width-1:0] count, bit_count, index;
  reg    [data_width-1:0]  temp;

  always @ (posedge clk)
    if (reset) begin count = 0; bit_count = 0; end
    else begin
      count = 0;
      temp  = data;
      for (index = 0; | temp; index = index + 1) begin   // stops when temp == 0
        if (temp[0]) count = count + 1;
        temp = temp >> 1;
      end
      bit_count = count;
    end
endmodule

One character has changed in substance: the termination condition is now |temp, the OR-reduction of a variable that the body modifies. The loop exits as soon as temp becomes zero, so it runs between zero and four times depending on the position of the highest set bit in data. This is a genuine optimisation in software — it skips the leading zeros — and it is completely unsynthesisable.實質上只改了一個字元：終止條件現在是 |temp，也就是對一個主體會修改的變數做 OR 歸約。迴圈一旦 temp 變成零就離開，所以它會依 data 中最高位 1 的位置執行零到四次。這在軟體裡是真正的最佳化 — 它跳過前導零 — 而且它完全不可合成。実質的に変わったのは 1 文字である。終了条件がいまや |temp、すなわち本体が書き換える変数の OR リダクションになった。temp がゼロになり次第ループを抜けるので、data の最上位の 1 の位置に応じて 0〜4 回実行される。ソフトウェアではこれは本物の最適化であり — 先頭のゼロを飛ばす — そしてまったく合成できない。

The slide's phrasing is exact and worth memorising: it is "essentially an iterative combinational circuit of data-dependent size". There is no clock in the loop, so all the iterations must happen within one clock period, which means they must all exist simultaneously as gates. But the number of iterations depends on data, which is a run-time value. A circuit cannot grow and shrink at run time. There is nothing to build.投影片的措辭很精確，值得背下來：它是「essentially an iterative combinational circuit of data-dependent size」。迴圈裡沒有時脈，所以所有迭代都必須發生在一個時脈週期之內，也就是說它們全都必須同時以閘的形式存在。但迭代次數取決於 data，那是個執行期的值。電路無法在執行時長大縮小。根本沒有東西可以建。スライドの言い回しは正確で、暗記する価値がある。それは「essentially an iterative combinational circuit of data-dependent size」である。ループ内にクロックがないので、すべての反復は 1 クロック周期内で起こらねばならず、つまりすべてが同時にゲートとして存在せねばならない。しかし反復回数は実行時の値である data に依存する。回路は実行時に伸び縮みできない。作るべきものが存在しないのである。

Note carefully what the tool can and cannot do here. It cannot unroll, because the trip count is unknown. It cannot build a state machine, because there is no timing control to give it clock boundaries. It cannot conservatively unroll four times and mask, because in general the bound is not known either — here temp is four bits so four is an upper bound, but the compiler is not required to perform that reasoning and standard RTL synthesis does not. So it reports an error, usually along the lines of "loop iteration limit exceeded" or "non-constant loop condition". The module simulates perfectly, which is what makes this trap worth remembering: a testbench will not catch it.請仔細看工具在這裡能做與不能做什麼。它不能展開，因為迭代次數未知。它不能建狀態機，因為沒有時序控制給它時脈邊界。它也不能保守地展開四次再加遮罩，因為一般而言上界同樣未知 — 這裡 temp 是四位元所以四是一個上界，但編譯器沒有義務做這種推理，標準 RTL 合成也不做。所以它會報錯，通常是「loop iteration limit exceeded」或「non-constant loop condition」之類。這個模組模擬得完美無缺，這正是這個陷阱值得記住的原因：測試平台抓不到它。ここでツールにできること・できないことをよく見てほしい。反復回数が不明なので展開できない。クロック境界を与えるタイミング制御がないので状態機械も作れない。保守的に 4 回展開してマスクすることもできない。一般には上限も不明だからである — ここでは temp が 4 ビットなので 4 が上限だが、コンパイラにその推論を行う義務はなく、標準的な RTL 合成はそれをしない。したがってエラーを出す。たいていは「loop iteration limit exceeded」や「non-constant loop condition」といった類である。このモジュールは完璧にシミュレーションされる。だからこそこの罠は覚えておく価値がある。テストベンチでは捕まらないのである。

10.6 Type IV — non-static with internal timing controls10.6 第 IV 型 — 非靜態且帶內部時序控制10.6 タイプ IV — 非静的かつ内部タイミング制御あり

module count_ones_d (bit_count, data, clk, reset);
  parameter data_width  = 4;
  parameter count_width = 3;
  output [count_width-1:0] bit_count;
  input  [data_width-1:0]  data;
  input                    clk, reset;
  reg    [count_width-1:0] count, bit_count;
  reg    [data_width-1:0]  temp;

  always @ (posedge clk)
    if (reset) begin count = 0; bit_count = 0; end
    else begin: bit_counter
      count = 0;
      temp  = data;
      while (temp)
        @ (posedge clk)
          if (reset) begin
            count = 2'b0;
            disable bit_counter;
          end
          else begin
            count = count + temp[0];   // notice: no if needed
            temp  = temp >> 1;
          end
      @ (posedge clk)
        if (reset) begin
          count = 0;
          disable bit_counter;
        end
        else bit_count = count;
    end
endmodule

Adding the timing control rescues the non-static loop from impossibility, because the iterations are now sequenced in time and a state machine can run a data-dependent number of cycles. The circuit is finite; only its schedule varies. So Type IV is synthesisable in principle, by the same behavioural-synthesis machinery as Type II.加上時序控制，就把非靜態迴圈從「不可能」裡救了出來，因為迭代現在是在時間中排序，而狀態機可以執行與資料相關的週期數。電路是有限的；變動的只是它的排程。所以第 IV 型原則上可以合成，用的是和第 II 型相同的行為合成機制。タイミング制御を加えると非静的ループは不可能から救われる。反復が時間の中で順序付けられ、状態機械がデータ依存の回数だけサイクルを回せるからである。回路は有限で、変わるのはそのスケジュールだけである。したがってタイプ IV は原理的に合成可能であり、タイプ II と同じ振る舞い合成の機構によるものである。

Several details of this module repay study. The begin: bit_counter gives the block a name so that disable can target it; disable terminates the named block and, in this context, restarts the behaviour from the top at the next trigger. The reset test is repeated at every internal @(posedge clk), because once the behaviour has entered the loop, the outer if (reset) is no longer being evaluated — control is suspended inside the loop, waiting for an edge. Without those inner tests the module would ignore reset for up to five cycles. And the body uses count = count + temp[0] rather than if (temp[0]) count = count + 1, which the slide flags with "notice missing if" — the two are equivalent, and the arithmetic form is one gate cheaper since adding a bit is the same as conditionally adding one.這個模組有好幾個細節值得研究。begin: bit_counter 給這個區塊一個名字，好讓 disable 能指向它；disable 會終止這個具名區塊，在這個脈絡下則是在下一次觸發時讓行為從頭重新開始。重置測試在每一個內部 @(posedge clk) 處都重複出現，因為行為一旦進入迴圈，外層的 if (reset) 就不再被求值了 — 控制權懸停在迴圈內部，等待邊緣。沒有那些內層測試，這個模組最多會有五個週期忽略重置。另外主體寫的是 count = count + temp[0] 而不是 if (temp[0]) count = count + 1，投影片以「notice missing if」標出這點 — 兩者等價，而算術形式少一顆閘，因為加上一個位元就等於有條件地加一。このモジュールにはじっくり見る価値のある細部がいくつもある。begin: bit_counter はブロックに名前を与え、disable がそれを対象にできるようにする。disable は名前付きブロックを終了させ、この文脈では次の起動で振る舞いを先頭から再開させる。リセットの判定はすべての内部 @(posedge clk) で繰り返される。振る舞いがいったんループに入ると、外側の if (reset) はもはや評価されないからである — 制御はループ内部で停止し、エッジを待っている。これら内側の判定がなければ、モジュールは最大 5 サイクルのあいだリセットを無視する。また本体は if (temp[0]) count = count + 1 ではなく count = count + temp[0] と書かれており、スライドは「notice missing if」と注記している — 両者は等価で、ビットを足すことは条件付きで 1 を足すことと同じなので、算術形式のほうがゲート 1 個分安い。

The reason this is "not recommended" is the same as for Type II, plus one more: the latency is now data-dependent, so the block needs a handshake. Any consumer must be told when the result is valid, which means a done output and a protocol, none of which the implicit state machine provides. In practice you would write the FSM explicitly, with a busy and a valid, and then everything is visible and verifiable.這個型別「not recommended」的理由和第 II 型相同，再加一個：延遲現在取決於資料，所以這個區塊需要一套交握。任何消費端都必須被告知結果何時有效，也就是需要一個 done 輸出與一套協定，而隱含狀態機一個都沒提供。實務上你會把 FSM 明確寫出來，附上 busy 與 valid，這樣一切就都看得見、也驗得了。これが「not recommended」である理由はタイプ II と同じで、さらに一つ加わる。レイテンシがデータ依存になったので、このブロックにはハンドシェイクが必要である。消費側は結果がいつ有効かを知らされねばならず、つまり done 出力とプロトコルが要るが、暗黙の状態機械はそのどちらも提供しない。実務では FSM を busy と valid とともに明示的に書く。そうすればすべてが見え、検証もできる。

(a) for (k = 0; k < 8; k = k + 1) y[k] = x[7-k];
(b) while (q != 0) begin q = q - 1; n = n + 1; end
(c) repeat (4) @(posedge clk) acc = acc + in;
(d) while (busy) @(posedge clk) busy = check(status);
(e) for (k = 0; k < WIDTH; k = k + 1) p = p ^ d[k];      // WIDTH is a parameter
(f) for (k = 0; k < n; k = k + 1) s = s + d[k];          // n is an input port
(g) forever @(posedge clk) q <= d;

integer i;
reg [3:0] t, y;
always @(posedge clk) begin
  t = d;
  for (i = 0; i < 4; i = i + 1)
    t[i] = t[i] ^ (i == 0 ? 1'b0 : t[i-1]);
  y <= t;
end

t = d;
t[0] = t[0] ^ 1'b0;    // = d[0]
t[1] = t[1] ^ t[0];    // = d[1] ^ d[0]
t[2] = t[2] ^ t[1];    // t[1] is ALREADY the new value: = d[2] ^ d[1] ^ d[0]
t[3] = t[3] ^ t[2];    // = d[3] ^ d[2] ^ d[1] ^ d[0]
y <= t;

11. Tasks and Functions11. task 與 function11. タスクと関数

Tasks and functions are Verilog's two subprogram forms, and slides 36 to 40 give their synthesis rules in six bullets. Underneath all six is one fact: both are expanded inline at elaboration, and nothing survives of the subprogram abstraction into the netlist.task 與 function 是 Verilog 的兩種副程式形式，第 36 到 40 張投影片以六條要點給出它們的合成規則。六條底下都是同一個事實：兩者都在展開期被內聯展開，副程式這層抽象沒有任何東西留進 netlist。タスクと関数は Verilog の二つのサブプログラム形式で、スライド 36〜40 がその合成規則を 6 項目で与える。6 つすべての底にあるのは一つの事実である。どちらもエラボレーション時にインライン展開され、サブプログラムという抽象はネットリストに何も残さない。

11.1 Tasks are expanded inline11.1 task 會被內聯展開11.1 タスクはインライン展開される

A task may have input, output and inout arguments, may contain timing controls, and may contain any number of statements. For synthesis the rules narrow that considerably:task 可以有 input、output 與 inout 引數，可以含時序控制，也可以含任意多道敘述。對合成而言，規則把這些收窄了不少：タスクは input、output、inout の引数を持て、タイミング制御を含んでよく、任意個数の文を含んでよい。合成に関しては規則がこれをかなり狭める。

• Expanded inline. Each call site gets its own copy of the body, with the actual arguments substituted for the formals.被內聯展開。每個呼叫點都拿到自己的一份主體複本，實際引數代入形式引數。インライン展開される。各呼び出し箇所が本体のコピーを一つずつ得て、仮引数に実引数が代入される。
• No inout arguments. An inout would require bidirectional dataflow through what, after inlining, is just a set of assignments. There is no way to express "this wire is both read and written by the same construct" without inferring either storage or a tri-state, and the tool will not guess which.不可有 inout 引數。inout 會要求資料在一個內聯後只是一組指定敘述的東西裡雙向流動。要表達「這條線被同一個構件同時讀又寫」，不推論出儲存元件就得推論出三態，而工具不會去猜是哪一種。inout 引数は不可。inout は、インライン展開後には単なる代入の集まりでしかないものの中に双方向のデータフローを要求する。「この配線は同じ構文によって読まれかつ書かれる」を表現するには記憶かトライステートのどちらかを推論するしかなく、ツールはどちらかを推測しない。
• No timing controls means combinational. A task whose body contains no @ and no # completes within the invoking process's time step, so it contributes only combinational logic. A task with timing controls carries the same implicit-state-machine problem as a Type II loop and the same "not recommended" status.沒有時序控制就代表是組合的。主體不含 @ 也不含 # 的 task 會在呼叫它的程序的同一個時間步內完成，所以它只貢獻組合邏輯。含有時序控制的 task 則帶著和第 II 型迴圈一樣的隱含狀態機問題，以及一樣的「not recommended」地位。タイミング制御がなければ組合せ回路になる。本体に @ も # も含まないタスクは、呼び出し元プロセスの同じ時間ステップ内で完了するので、組合せ論理しか生まない。タイミング制御を含むタスクはタイプ II ループと同じ暗黙の状態機械の問題を抱え、同じく「not recommended」の立場になる。

The lecture's example wraps an addition in a task:這一講的範例把一次加法包進一個 task 裡：講義の例は加算をタスクに包んでいる。

module adder_task (c_out, sum, clk, reset, c_in, data_a, data_b);
  input  [3:0] data_a, data_b;
  input        clk, reset, c_in;
  output [3:0] sum;
  output       c_out;
  reg    [3:0] sum;
  reg          c_out;

  always @ (posedge clk or posedge reset)
    if (reset) {c_out, sum} = 0;
    else       add_values (sum, c_out, data_a, data_b, c_in);

  task add_values;
    output [3:0] sum;
    output       c_out;
    input  [3:0] data_a, data_b;
    input        c_in;
    reg    [3:0] sum;
    reg          c_out;
    begin
      {c_out, sum} = data_a + (data_b + c_in);
    end
  endtask
endmodule

After inlining, the always block contains {c_out, sum} = data_a + (data_b + c_in); and nothing else. The parenthesisation is significant and is the grouping lesson of section 6.8 in miniature: data_b + c_in is computed first, then added to data_a, giving two adders in series. A smarter formulation would feed c_in into the carry-in of a single adder, which is free, instead of spending a whole second adder on it — and indeed the slide's synthesis result shows two five-bit adder symbols in series, exactly as written. Five flip-flops with asynchronous reset follow. So the module costs about 60 GE of adder where 30 would do.內聯之後，always 區塊裡就只有 {c_out, sum} = data_a + (data_b + c_in);，沒有別的。那個括號很重要，是 6.8 節分組教訓的縮影：data_b + c_in 先算，再加到 data_a，於是是兩個加法器串聯。更聰明的寫法會把 c_in 餵進單一個加法器的進位輸入，那是免費的，而不是為它花掉一整個第二個加法器 — 而投影片的合成結果確實顯示兩個串聯的五位元加法器符號，就照著寫的樣子。後面接著五顆帶非同步重置的正反器。所以這個模組在加法器上花了約 60 GE，而 30 GE 就夠了。インライン展開後、always ブロックに残るのは {c_out, sum} = data_a + (data_b + c_in); だけである。この括弧は重要で、6.8 節のグループ化の教訓の縮図になっている。data_b + c_in が先に計算され、それが data_a に加えられるので、加算器が 2 個直列になる。より賢い定式化は、2 つ目の加算器をまるごと費やす代わりに c_in を単一の加算器のキャリー入力へ入れることで、それは無料である。実際スライドの合成結果は書かれたとおり 5 ビット加算器のシンボルを 2 個直列に示している。その後に非同期リセット付きフリップフロップが 5 個続く。したがってこのモジュールは 30 GE で済むところに約 60 GE の加算器を費やしている。

Note also the asynchronous reset here — @(posedge clk or posedge reset) with reset tested first — which satisfies all six event-control rules of section 9.2, and which uses the flip-flops' clear pins rather than datapath logic.另外請注意這裡的非同步重置 — @(posedge clk or posedge reset) 且 reset 最先被測試 — 它滿足 9.2 節全部六條事件控制規則，而且使用的是正反器的 clear 腳而不是資料路徑邏輯。ここでの非同期リセットにも注目してほしい。@(posedge clk or posedge reset) で reset が最初に検査されており、9.2 節の 6 つのイベント制御規則をすべて満たし、データパス論理ではなくフリップフロップのクリアピンを使っている。

11.2 Functions11.2 function11.2 関数

A function is more restricted than a task and correspondingly better behaved for synthesis. It has exactly one return value, returned by assigning to the function's own name; it may have only input arguments; it may not contain timing controls at all; and it must execute in zero simulation time. Those restrictions mean a function is necessarily combinational — there is no way to write one that is not.function 比 task 受限，也因此對合成而言表現得更好。它恰好有一個回傳值，透過指定給 function 自己的名字來回傳；它只能有 input 引數；它完全不能含時序控制；而且必須在零模擬時間內執行完畢。這些限制意味著 function 必然是組合的 — 根本沒有辦法寫出一個不是組合的 function。関数はタスクより制約が強く、その分だけ合成に対して行儀がよい。戻り値はちょうど一つで、関数自身の名前への代入によって返す。引数は input のみ。タイミング制御は一切含められない。そしてシミュレーション時間ゼロで実行を終えねばならない。これらの制約により関数は必然的に組合せ回路になる。そうでない関数を書く方法は存在しない。

The two synthesis rules on slide 38 follow:第 38 張投影片的兩條合成規則隨之而來：スライド 38 の二つの合成規則はここから導かれる。

• Expanded at the site of the call, exactly as for a task.在呼叫點展開，與 task 完全相同。呼び出し箇所で展開される。タスクとまったく同じである。
• Incompletely specified case and if statements are not allowed. This is the latch rule from Lecture 5, applied with no escape hatch. In an ordinary combinational always block, an incomplete conditional infers a latch; in a function, a latch is impossible by definition, so the incompleteness is simply an error. The practical requirement is that the function name must be assigned on every path through the body.不允許不完整指定的 case 與 if 敘述。這是第 5 講的閂鎖規則，而且沒有任何逃生口。在一般的組合 always 區塊裡，不完整的條件式會推論出閂鎖；在 function 裡，閂鎖依定義不可能存在，所以不完整就只是個錯誤。實務上的要求是：function 的名字必須在主體的每一條路徑上都被指定。不完全に指定された case と if は許されない。これは第 5 講のラッチ規則を逃げ道なしで適用したものである。通常の組合せ always ブロックでは不完全な条件がラッチを推論するが、関数では定義上ラッチが不可能なので、不完全さは単なるエラーになる。実務上の要件は、関数名が本体のすべてのパスで代入されていることである。

module arithmetic_unit (operand_1, operand_2, result_1, result_2);
  input  [3:0] operand_1, operand_2;
  output [4:0] result_1;
  output [3:0] result_2;

  assign result_1 = sum_of_operands (operand_1, operand_2);
  assign result_2 = largest_operand (operand_1, operand_2);

  function [4:0] sum_of_operands;
    input [3:0] operand_1, operand_2;
    sum_of_operands = operand_1 + operand_2;
  endfunction

  function [3:0] largest_operand;
    input [3:0] operand_1, operand_2;
    largest_operand = (operand_1 >= operand_2) ? operand_1 : operand_2;
  endfunction
endmodule

Both functions assign their name unconditionally, so both are complete. sum_of_operands inlines to a five-bit addition — note that the function's own declared width, [4:0], sets the context width, so the carry is kept, which is why result_1 can be five bits. largest_operand inlines to a comparator driving four two-to-one multiplexers. The slide's synthesis result shows exactly that: a block of comparison gates on the left feeding four mux_2a cells for result_2, and a separate adder symbol for result_1. Total cost roughly 30 GE for the adder, 10 GE for the comparator and 10 GE for the muxes.兩個 function 都無條件地指定自己的名字，所以兩者都是完整的。sum_of_operands 內聯成一次五位元加法 — 注意 function 自己宣告的位寬 [4:0] 設定了情境位寬，所以進位被保留下來，這就是 result_1 可以是五位元的原因。largest_operand 內聯成一個比較器驅動四顆二對一多工器。投影片的合成結果正是如此：左邊一團比較閘餵進四顆 mux_2a 元件給 result_2，另外一個獨立的加法器符號給 result_1。總成本大約是加法器 30 GE、比較器 10 GE、多工器 10 GE。どちらの関数も自分の名前を無条件に代入しているので、どちらも完全である。sum_of_operands は 5 ビットの加算にインライン展開される — 関数自身の宣言幅 [4:0] が文脈幅を決めるのでキャリーが保たれ、result_1 が 5 ビットでありうる理由になっている。largest_operand は比較器が 2 対 1 マルチプレクサ 4 個を駆動する形に展開される。スライドの合成結果はまさにそれで、左側の比較ゲートの塊が result_2 用の mux_2a セル 4 個を駆動し、result_1 用には別の加算器シンボルがある。総コストは加算器が約 30 GE、比較器が約 10 GE、マルチプレクサが約 10 GE である。

A safe habit for completeness is to assign a default at the top of the function and then override:確保完整性的一個安全習慣，是在 function 開頭先指定一個預設值，之後再覆寫：完全性を確保する安全な習慣は、関数の先頭でデフォルトを代入し、その後で上書きすることである。

function [1:0] enc;
  input [3:0] r;
  case (r)
    4'b0001: enc = 2'd0;
    4'b0010: enc = 2'd1;
    4'b0100: enc = 2'd2;
  endcase          // no default!
endfunction

function [1:0] enc;
  input [3:0] r;
  begin
    enc = 2'd0;    // default first
    case (r)
      4'b0010: enc = 2'd1;
      4'b0100: enc = 2'd2;
      4'b1000: enc = 2'd3;
    endcase
  end
endfunction

11.3 One copy per call site11.3 每個呼叫點一份複本11.3 呼び出し箇所ごとに一つのコピー

The consequence of inlining that catches people out is that subprograms do not share hardware. A software function called eight times executes eight times on one piece of silicon; a Verilog function called eight times produces eight copies of its logic.內聯造成的、最容易讓人栽跟頭的後果是：副程式不會共用硬體。一個被呼叫八次的軟體函式，是在同一塊矽上執行八次；一個被呼叫八次的 Verilog function，則產生八份它的邏輯。インライン展開の帰結で人がもっとも足をすくわれるのは、サブプログラムがハードウェアを共有しないことである。8 回呼ばれるソフトウェアの関数は 1 枚のシリコン上で 8 回実行されるが、8 回呼ばれる Verilog の関数はその論理のコピーを 8 個生む。

assign y0 = big_multiply(a0, b0);
assign y1 = big_multiply(a1, b1);
assign y2 = big_multiply(a2, b2);
assign y3 = big_multiply(a3, b3);
// FOUR multipliers, not one.

If the four multiplications can happen in parallel, four multipliers is what you want and the function is simply a clean way to describe them. If they are meant to be sequential uses of one shared unit, a function is exactly the wrong construct: you need a single instance, a multiplexer on its inputs, a register on its output and a controller to sequence the four operations. That is resource sharing, and it is a structural decision you must make yourself — synthesis will share small operators automatically when they are in mutually exclusive branches of a conditional, but it will not invent a controller.如果那四次乘法可以同時發生，四個乘法器就正是你要的，而 function 只是描述它們的一種乾淨寫法。如果它們本來是要循序使用同一個共用單元，那 function 就是完全錯誤的構件：你需要單一個實例、輸入上的一顆多工器、輸出上的一個暫存器，以及一個把四次運算排序的控制器。那叫資源共享，而它是你必須自己做的結構決策 — 當運算位於某個條件式的互斥分支中時，合成會自動共用小型運算子，但它不會憑空發明控制器。4 回の乗算が並列に起こってよいなら、乗算器 4 個こそ望むものであり、関数はそれを簡潔に記述する手段にすぎない。だが一つの共有ユニットを順に使うつもりだったのなら、関数はまったく誤った構文である。必要なのは単一のインスタンス、その入力のマルチプレクサ、出力のレジスタ、そして 4 つの演算を順序付けるコントローラである。それがリソース共有であり、自分で下さねばならない構造上の判断である — 条件文の排他的な分岐にある小さな演算子なら合成が自動で共有するが、コントローラを発明することはない。

12. specify Blocks and Compiler Directives12. specify 區塊與編譯指令12. specify ブロックとコンパイラ指令

12.1 specify blocks are ignored12.1 specify 區塊會被忽略12.1 specify ブロックは無視される

A specify ... endspecify block declares module path delays and timing checks: (a => y) = 1.2; says that a change on a reaches y after 1.2 time units, and $setup, $hold, $recovery and friends declare the timing constraints that the module's inputs must satisfy. This is the mechanism by which a vendor's gate-level library model carries its timing, and it is how SDF back-annotation attaches real post-layout numbers to a netlist.specify ... endspecify 區塊宣告模組的路徑延遲與時序檢查：(a => y) = 1.2; 表示 a 的變化在 1.2 個時間單位後到達 y，而 $setup、$hold、$recovery 等則宣告模組輸入必須滿足的時序限制。這是廠商的閘級庫模型攜帶其時序資訊的機制，也是 SDF 反標註把真實佈局後數值附加到 netlist 上的方式。specify ... endspecify ブロックはモジュールのパス遅延とタイミングチェックを宣言する。(a => y) = 1.2; は a の変化が 1.2 時間単位後に y へ届くことを表し、$setup、$hold、$recovery などはモジュール入力が満たすべきタイミング制約を宣言する。これはベンダのゲートレベルライブラリモデルがタイミング情報を運ぶ仕組みであり、SDF 逆アノテーションが実際のレイアウト後の数値をネットリストに付与する方法でもある。

Slide 41 says it is ignored by synthesis, and the reason is simply that the information flows the other way. Delay in a synthesised design is a result, computed by the static timing analyser from the cell library's characterised data and the extracted parasitics. A delay written in the RTL would be at best a guess and at worst a contradiction of what the implementation actually achieves. So the synthesiser parses the block for syntax and discards it.第 41 張投影片說它被合成忽略，理由很簡單：資訊的流向是相反的。合成後設計的延遲是一個結果，由靜態時序分析器根據元件庫的特徵化資料與萃取出的寄生參數算出來。寫在 RTL 裡的延遲，最好的情況是猜測，最糟的情況是與實作實際達成的結果互相矛盾。所以合成器只檢查這個區塊的語法，然後把它丟掉。スライド 41 はこれが合成で無視されると述べる。理由は単純で、情報の流れが逆だからである。合成後の設計における遅延は結果であり、静的タイミング解析器がセルライブラリの特性データと抽出された寄生成分から計算する。RTL に書かれた遅延はよくて推測、悪ければ実装が実際に達成する値との矛盾である。したがって合成器はこのブロックを構文として解析したうえで捨てる。

The practical consequence is that you cannot use a specify block to tell the synthesiser what timing you want. The mechanism for that is the constraint file: create_clock, set_input_delay, set_output_delay, set_max_delay, set_false_path, set_multicycle_path. Those are SDC commands, not Verilog, and they are what the tool actually optimises against — including, as section 4.2 described, the choice of adder architecture.實務上的後果是：你不能用 specify 區塊去告訴合成器你想要什麼樣的時序。做這件事的機制是限制檔：create_clock、set_input_delay、set_output_delay、set_max_delay、set_false_path、set_multicycle_path。那些是 SDC 指令而不是 Verilog，而它們才是工具真正拿來做最佳化的依據 — 包括 4.2 節講過的加法器架構選擇。実務上の帰結として、specify ブロックで合成器に望むタイミングを伝えることはできない。そのための仕組みは制約ファイルである。create_clock、set_input_delay、set_output_delay、set_max_delay、set_false_path、set_multicycle_path。これらは Verilog ではなく SDC コマンドであり、ツールが実際に最適化の対象とするのはこちらである。4.2 節で述べた加算器アーキテクチャの選択もそこに含まれる。

12.2 Compiler directives are honoured12.2 編譯指令會被遵守12.2 コンパイラ指令は守られる

Compiler directives — the back-tick ones — are processed by the Verilog preprocessor before any analysis happens, so they are not really part of the language at all; they transform the source text. Slide 41's statement that they are "synthesized" means that they take effect normally, because by the time the synthesiser sees the design they have already done their work.編譯指令 — 就是那些反引號開頭的 — 是在任何分析開始之前由 Verilog 前處理器處理的，所以它們其實根本不算語言的一部分；它們只是轉換原始碼文字。第 41 張投影片說它們「被合成」，意思是它們正常生效，因為等合成器看到這個設計時，它們早就把工作做完了。コンパイラ指令 — バッククォートで始まるもの — は、いかなる解析よりも前に Verilog のプリプロセッサが処理する。したがって実際には言語の一部ですらなく、ソーステキストを変換するだけである。スライド 41 がこれらを「合成される」と言うのは、通常どおり効果を持つという意味である。合成器が設計を見る時点で、それらはすでに仕事を終えているからである。

Of these, `default_nettype none deserves its recommendation. Verilog's implicit net declaration means that asign data_valied = ... — a typo in the target name — creates a brand-new one-bit wire called data_valied and leaves data_valid undriven, which simulates as x and synthesises as a constant. With `default_nettype none at the top of the file, the same typo is an error at compile time.這些之中，`default_nettype none 當得起它那句建議。Verilog 的隱含 net 宣告意味著 asign data_valied = ... — 目標名稱打錯字 — 會建出一條全新的、叫做 data_valied 的一位元 wire，而讓 data_valid 沒有驅動源，模擬起來是 x、合成起來是常數。在檔案開頭加上 `default_nettype none，同樣的錯字在編譯期就是錯誤。このうち `default_nettype none はその推奨に値する。Verilog の暗黙 net 宣言のせいで、asign data_valied = ... — 代入先の名前のタイプミス — は data_valied という新しい 1 ビット wire を作り、data_valid を未駆動のまま残す。シミュレーションでは x、合成では定数になる。ファイル先頭に `default_nettype none を置けば、同じタイプミスはコンパイル時のエラーになる。

12.3 Synthesis pragmas are comments12.3 合成 pragma 其實是註解12.3 合成プラグマはコメントである

Not on the slide, but the third category you will meet, and easy to confuse with compiler directives: synthesis pragmas. These are comments of the form // synopsys full_case parallel_case, /* synthesis keep */ or the newer (* full_case *) attribute syntax. They are invisible to the simulator — they are comments — and meaningful only to the synthesiser.投影片上沒有，但這是你會遇到的第三個類別，而且很容易和編譯指令搞混：合成 pragma。它們是形如 // synopsys full_case parallel_case、/* synthesis keep */ 的註解，或較新的 (* full_case *) 屬性語法。它們對模擬器是隱形的 — 它們是註解 — 只對合成器有意義。スライドにはないが、遭遇する第三のカテゴリであり、コンパイラ指令と混同しやすい。合成プラグマである。// synopsys full_case parallel_case、/* synthesis keep */ のようなコメント、あるいは新しい (* full_case *) という属性構文である。シミュレータからは見えず — コメントだからである — 合成器にだけ意味を持つ。

That asymmetry is the whole danger. A pragma that changes what the tool builds, while leaving the simulation unchanged, is a mechanism for creating RTL-to-gate mismatches on purpose. The two notorious ones:那個不對稱就是全部的危險所在。一個會改變工具所建硬體、卻讓模擬維持不變的 pragma，就是一套刻意製造 RTL 與閘級不匹配的機制。兩個惡名昭彰的例子：この非対称性こそが危険のすべてである。ツールが作るものを変えながらシミュレーションを変えないプラグマは、RTL とゲートの不一致を意図的に作り出す仕掛けである。悪名高い二つを挙げる。

• full_case promises that every unlisted case item is a don't care. If the promise is false, the gates will do something the RTL simulation never showed — and you have deliberately disabled the tool's ability to tell you. Writing an explicit default achieves the same optimisation honestly, and the simulation then agrees.full_case 承諾每一個未列出的 case item 都是 don't care。如果這個承諾是假的，閘會做出 RTL 模擬從未顯示過的事 — 而你還刻意關掉了工具告訴你的能力。寫一個明確的 default 可以誠實地達成同樣的最佳化，而且模擬也會一致。full_case は列挙されていないケースアイテムがすべてドントケアだと約束する。その約束が偽なら、ゲートは RTL シミュレーションが一度も見せなかったふるまいをする — しかもあなたは、それを知らせるツールの能力をわざわざ無効にしている。明示的な default を書けば同じ最適化が正直に達成され、シミュレーションも一致する。
• parallel_case promises that no two case items can match at once, so the tool may build a balanced mux rather than a priority chain. If the promise is false — which is exactly when it is tempting, in a casez with overlapping items — RTL simulation gives the first match while the gates give an arbitrary one or a wired-OR of several.parallel_case 承諾沒有兩個 case item 會同時相符，所以工具可以建平衡多工器而不是優先權鏈。如果這個承諾是假的 — 而那恰好正是它最誘人的時候，也就是在 item 重疊的 casez 裡 — RTL 模擬會給第一個相符者，而閘會給出任意一個，或給出好幾個的 wired-OR。parallel_case は 2 つのケースアイテムが同時に一致することはないと約束し、ツールが優先順位の連鎖ではなく平衡したマルチプレクサを作れるようにする。その約束が偽のとき — それはまさにこれを使いたくなるとき、つまりアイテムが重なる casez のとき — RTL シミュレーションは最初の一致を返すが、ゲートは任意の一つ、あるいは複数のワイヤード OR を返す。

13. Summary and Exam Checklist13. 總結與考前檢查表13. まとめと試験チェックリスト

13.1 The thirteen things to know13.1 必須知道的十三件事13.1 知っておくべき 13 項目

13.2 Ten traps, with the one-line fix13.2 十個陷阱與一行修法13.2 十の罠と一行の修正