Introduction — Explained緒論 — 詳解序論 — 詳解

1. The Digital IC Design Flow and Where You Stand In It1. 數位 IC 設計流程，以及你站在哪裡1. デジタル IC 設計フローと自分の位置

Before any of the Verilog in this lecture makes sense, you need a map of the territory. A modern digital chip is not designed the way a breadboard circuit is designed. Nobody draws twenty million transistors. Instead there is a long, highly automated pipeline that starts with a paragraph of English and ends with a set of photomasks, and at every stage of that pipeline a different tool reads a different file in a different language and hands its output to the next tool. Verilog is the file format that the first half of the pipeline consumes, and almost everything you will learn in this course is about writing Verilog that the rest of the pipeline can actually use.在這一講的 Verilog 能說得通之前，你需要一張地形圖。現代數位晶片的設計方式和麵包板電路完全不同，沒有人會去畫兩千萬顆電晶體。取而代之的，是一條冗長而高度自動化的管線：它從一段英文敘述開始，最後產出一組光罩；在這條管線的每一個階段，都有不同的工具讀取不同語言寫成的不同檔案，再把輸出交給下一個工具。Verilog 正是這條管線前半段所消耗的檔案格式，而你在這門課裡學到的幾乎所有東西，都是為了寫出管線後續真的用得上的 Verilog。この講義の Verilog が意味を持つには、まず地形図が必要である。現代のデジタルチップは、ブレッドボード回路のようには設計されない。二千万個のトランジスタを誰も描かない。代わりにあるのは、英語の一段落から始まり一組のフォトマスクで終わる、長く高度に自動化されたパイプラインである。その各段階で、異なるツールが異なる言語で書かれた異なるファイルを読み、出力を次のツールへ渡す。Verilog はそのパイプラインの前半が消費するファイル形式であり、この科目で学ぶことのほとんどは、パイプラインの残りが実際に使える Verilog を書くためのものである。

The slides split the pipeline into a front end and a back end. The division is not arbitrary. Everything in the front end is a description of function: what the chip computes, and roughly how fast. Everything in the back end is a description of geometry: where each transistor physically sits, how wide each wire is, how much capacitance that wire adds. The hand-off point between the two is the gate-level netlist — a file that says "instance U17 is a NAND2X1 cell from the library; its A pin connects to net n43" and nothing about position. The front end produces it; the back end places it on silicon.投影片把這條管線分成前段（front end）與後段（back end）。這個分界並不隨意。前段的一切都是在描述功能：晶片算什麼，大致多快。後段的一切則是在描述幾何：每顆電晶體實際擺在哪裡、每條線有多寬、那條線又增加了多少電容。兩者之間的交接點是閘級網表（gate-level netlist） — 一個只說「instance U17 是函式庫裡的 NAND2X1 cell；它的 A 腳接到 net n43」而完全不提位置的檔案。前段產生它，後段把它擺到矽晶片上。スライドはこのパイプラインをフロントエンドとバックエンドに分ける。この区切りは恣意的ではない。フロントエンドにあるものはすべて機能の記述である。チップが何を計算し、おおよそどれだけ速いか。バックエンドにあるものはすべて幾何形状の記述である。各トランジスタが物理的にどこに座り、各配線がどれだけ太く、その配線がどれだけ容量を加えるか。両者の引き渡し点がゲートレベル・ネットリストである。「インスタンス U17 はライブラリの NAND2X1 セルであり、その A ピンはネット n43 につながる」とだけ述べ、位置については何も言わないファイルだ。フロントエンドがこれを生み、バックエンドがシリコン上に配置する。

1.1 The front end, step by step1.1 前段流程，逐步拆解1.1 フロントエンドを一段ずつ

Design specification. This is a document, not a file a tool reads. It states what the block does, its interface, its throughput, its area and power budget, and — crucially — its timing contract: which signals are synchronous to which clock, what the clock period is, how many cycles of latency the outside world may expect. Everything downstream is measured against this document. A specification that says "decodes a convolutional code" without saying "at 100 Msymbol/s with a traceback depth of 35" cannot be verified, because there is no statement that could be false.設計規格。這是一份文件，不是工具讀的檔案。它陳述這個區塊做什麼、它的介面、吞吐率、面積與功耗預算，而且關鍵的是它的時序契約：哪些訊號同步於哪個時脈、時脈週期是多少、外界可以預期多少個週期的延遲。下游的一切都以這份文件為量尺。一份只說「解碼一個迴旋碼」而沒說「在 100 Msymbol/s 下、回溯深度 35」的規格無法被驗證，因為裡面沒有任何一句話有可能是錯的。設計仕様。これは文書であって、ツールが読むファイルではない。そのブロックが何をするか、インタフェース、スループット、面積と電力のバジェット、そして決定的に重要なタイミング契約——どの信号がどのクロックに同期するか、クロック周期はいくつか、外界が何サイクルのレイテンシを見込んでよいか——を述べる。下流のすべてはこの文書を基準に測られる。「畳み込み符号を復号する」とだけ書き、「100 Msymbol/s でトレースバック長 35」と書かない仕様は検証できない。偽になりうる主張が一つも存在しないからである。

Design partition. You cut the system into modules that one person can write and one simulation can exercise. Partitioning is the single most consequential decision in the front end and the one that EDA tools help with the least. The rule of thumb that matters for synthesis is: register the outputs of every block, and put a whole combinational path inside one module. If a combinational path starts in block A, runs through block B and ends in a flip-flop in block C, the synthesiser must optimise it in three separate passes with artificial budgets at each boundary, and it will almost always produce a worse result than if the path had lived inside one module. Lectures 5 and 6 come back to this when they discuss synthesis constraints.設計切割。你把系統切成一個人寫得完、一次模擬跑得動的模組。切割是前段最具決定性的一步，卻也是 EDA 工具幫忙最少的一步。對合成而言最要緊的經驗法則是：每個區塊的輸出都要先過暫存器，而且把一整條組合路徑放在同一個模組裡。如果一條組合路徑起於區塊 A、穿過區塊 B、終於區塊 C 的正反器，合成器就必須分三趟最佳化它，而且每個邊界都只能給一個人造的預算；結果幾乎必然比整條路徑都住在同一個模組裡來得差。第 5、6 講談合成限制時會再回到這一點。設計分割。システムを、一人が書き切れて一回のシミュレーションで動かせるモジュールへ切り分ける。分割はフロントエンドで最も影響の大きい決定であり、同時に EDA ツールが最も助けてくれない決定でもある。合成にとって重要な経験則はこうだ。すべてのブロックの出力をレジスタで受け、組合せパス全体を一つのモジュール内に収めよ。組合せパスがブロック A で始まり B を通って C のフリップフロップで終わるなら、合成器は三回に分けて、しかも各境界に人為的なバジェットを置いて最適化せざるをえず、同一モジュール内に収めた場合よりほぼ確実に悪い結果になる。第 5 講と第 6 講で合成制約を論じる際にこの話へ戻る。

Design entry in Verilog. This is where you are. You write modules that describe behaviour at the register-transfer level: what combinational function feeds each register, and when each register loads. You are not drawing gates, and you are also not writing a program — you are writing a specification of hardware that happens to look like a program, and the difference will bite you in Section 2.以 Verilog 進行設計輸入。這就是你所在的位置。你寫的模組描述的是暫存器轉移層級的行為：哪個組合函數餵進哪個暫存器、每個暫存器何時載入。你不是在畫閘，但也不是在寫程式 — 你是在寫一份碰巧長得像程式的硬體規格，而這個差別會在第 2 節咬你一口。Verilog による設計入力。ここが君のいる場所である。レジスタ転送レベルでの振る舞い——どの組合せ関数が各レジスタを駆動し、各レジスタがいつロードするか——を記述するモジュールを書く。ゲートを描いているのではないが、プログラムを書いているのでもない。たまたまプログラムに見えるハードウェアの仕様を書いているのであり、その違いは第 2 節で君に噛みつく。

Simulation and functional verification. A simulator reads your Verilog plus a testbench, builds an event queue, and tells you what the outputs do. This is pure function: no gate has a delay yet, no wire has capacitance. If the design is wrong here it is wrong everywhere, and the bug is a thousand times cheaper to find here than after tape-out. Lecture 2 is entirely about this step.模擬與功能驗證。模擬器讀入你的 Verilog 加上一份測試平台（testbench），建立事件佇列，然後告訴你輸出會怎麼動。這一步是純功能：還沒有任何閘有延遲，也還沒有任何線有電容。設計若在這裡是錯的，它在任何地方都是錯的；而在這裡找出臭蟲，比下線（tape-out）之後才找出要便宜一千倍。第 2 講整講都在談這一步。シミュレーションと機能検証。シミュレータは君の Verilog とテストベンチを読み、イベントキューを構築し、出力がどう動くかを教える。これは純粋に機能のレベルであり、まだどのゲートにも遅延はなく、どの配線にも容量はない。ここで設計が誤っていればどこでも誤っており、しかもバグをここで見つけるほうがテープアウト後に見つけるより千倍安い。第 2 講はまるごとこの段階の話である。

Design integration and verification. Modules written by different people are wired together and the whole block is re-verified. Interface mismatches — a bus declared [7:0] on one side and [0:7] on the other, a handshake with the ready and valid signals swapped — surface here, and they surface as silently wrong data rather than as a compile error, because Verilog's positional port binding is happy to connect anything to anything of the right width.設計整合與驗證。不同人寫的模組被接在一起，整個區塊重新驗證一次。介面不一致 — 一側宣告成 [7:0] 另一側卻是 [0:7] 的匯流排、ready 和 valid 接反的交握訊號 — 都在這裡浮現，而且是以「資料安靜地錯掉」而不是以編譯錯誤的形式浮現，因為 Verilog 的位置式埠連接很樂意把任何東西接到任何等寬的東西上。設計統合と検証。別々の人が書いたモジュールを結線し、ブロック全体を再検証する。インタフェースの食い違い——片側で [7:0]、もう片側で [0:7] と宣言されたバス、ready と valid が入れ替わったハンドシェイク——はここで表面化する。しかもコンパイルエラーとしてではなく、静かに誤ったデータとして表面化する。Verilog の位置指定ポート接続は、幅さえ合えば何でも何にでもつないでしまうからだ。

Pre-synthesis sign-off. A gate: the RTL is frozen, lint-clean, and passes its functional regression. Only then does it go to synthesis. Teams that synthesise unfinished RTL spend their lives chasing timing on logic that is about to be rewritten.合成前簽核。一道關卡：RTL 凍結、lint 乾淨、功能回歸測試全過，只有這時才送去合成。拿未完成的 RTL 去合成的團隊，一輩子都在追一堆即將被重寫的邏輯的時序。合成前サインオフ。一つのゲートである。RTL を凍結し、lint をクリアし、機能回帰テストを通す。そこで初めて合成へ回す。未完成の RTL を合成に回すチームは、まもなく書き直される論理のタイミングを一生追いかけることになる。

Synthesis and mapping. A synthesiser — Synopsys Design Compiler / Design Vision, or Cadence Genus (the slides name its ancestor, Encounter RTL Compiler) — reads the RTL and a standard-cell library and produces a gate-level netlist. Internally this is two phases. First elaboration and generic optimisation: your always blocks and assign statements become a technology-independent network of generic operators (adders, multiplexers, Boolean nodes, registers). Then mapping: each generic node is replaced by real cells from the library, chosen to meet the timing constraints you supplied in an SDC file. The same RTL mapped against a 40 nm library and a 180 nm library yields completely different netlists.合成與映射。合成器 — Synopsys Design Compiler／Design Vision，或 Cadence Genus（投影片提到的是它的前身 Encounter RTL Compiler）— 讀入 RTL 與一套標準元件庫（standard-cell library），產出閘級網表。這件事內部分兩個階段。先是展開與一般化最佳化（elaboration and generic optimisation）：你的 always 區塊和 assign 敘述變成一張與製程無關的通用運算元網路（加法器、多工器、布林節點、暫存器）。接著是映射（mapping）：每個通用節點被換成函式庫裡的實體 cell，選哪一顆則取決於你在 SDC 檔裡給的時序限制。同一份 RTL 對 40 nm 與 180 nm 函式庫映射，會得到完全不同的網表。合成とマッピング。合成器——Synopsys Design Compiler / Design Vision、あるいは Cadence Genus（スライドはその前身 Encounter RTL Compiler を挙げている）——は RTL とスタンダードセル・ライブラリを読み、ゲートレベル・ネットリストを出力する。内部は二段階だ。まずエラボレーションと汎用最適化：君の always ブロックや assign 文が、プロセス非依存な汎用演算子（加算器、マルチプレクサ、ブール節点、レジスタ）のネットワークになる。次にマッピング：各汎用節点が、SDC ファイルで与えたタイミング制約を満たすように選ばれた実在のライブラリセルに置き換わる。同じ RTL でも 40 nm ライブラリと 180 nm ライブラリにマップすれば、まったく別のネットリストになる。

Post-synthesis validation and timing verification. The netlist is simulated again — now with real cell delays — and run through static timing analysis (STA). STA does not simulate; it enumerates every path from a register output to a register input, adds up the cell and wire delays, and compares the total against the clock period. It is exhaustive where simulation is only as good as your vectors, which is why timing is signed off by STA and function is signed off by simulation.合成後驗證與時序驗證。網表再被模擬一次 — 這次帶著真實的 cell 延遲 — 並送進靜態時序分析（STA）。STA 不做模擬；它窮舉每一條從暫存器輸出到暫存器輸入的路徑，把 cell 與線路的延遲加總，再和時脈週期比較。它是窮盡的，而模擬的好壞只取決於你的測試向量 — 這正是為什麼時序由 STA 簽核、功能由模擬簽核。合成後検証とタイミング検証。ネットリストを——今度は実際のセル遅延つきで——もう一度シミュレーションし、静的タイミング解析（STA）にかける。STA はシミュレートしない。レジスタ出力からレジスタ入力までのすべてのパスを列挙し、セルと配線の遅延を足し上げ、合計をクロック周期と比べる。シミュレーションがテストベクタの質までしか良くならないのに対し、STA は網羅的である。だからこそタイミングは STA で、機能はシミュレーションでサインオフされる。

Test generation and fault simulation. Design for testability (DFT) stitches the flip-flops into a shift register (a scan chain) so that a tester can load any state into the chip and read any state out. Automatic test pattern generation (ATPG, e.g. Synopsys TetraMAX) then computes a set of input vectors that will detect manufacturing defects, modelled as nets stuck at 0 or stuck at 1. Fault simulation reports the coverage. A chip that works perfectly but cannot be tested is worthless, because you cannot tell a good die from a bad one.測試樣本產生與故障模擬。可測試性設計（DFT）把正反器串成一條移位暫存器（掃描鏈，scan chain），讓測試機台能把任意狀態載入晶片、也能把任意狀態讀出來。自動測試樣本產生（ATPG，例如 Synopsys TetraMAX）接著算出一組輸入向量，用來偵測製造缺陷 — 缺陷被模型化成某條 net 固定在 0 或固定在 1。故障模擬則回報涵蓋率。一顆功能完美但無法測試的晶片毫無價值，因為你分不出哪顆是好的晶粒。テストパターン生成と故障シミュレーション。テスト容易化設計（DFT）はフリップフロップをシフトレジスタ（スキャンチェーン）に縫い合わせ、テスタが任意の状態をチップに書き込み、任意の状態を読み出せるようにする。次に自動テストパターン生成（ATPG、たとえば Synopsys TetraMAX）が、ネットが 0 固定または 1 固定になるとモデル化した製造欠陥を検出する入力ベクタ集合を計算する。故障シミュレーションがカバレッジを報告する。完璧に動くがテストできないチップは無価値である。良品ダイと不良ダイを区別できないからだ。

1.2 The back end1.2 後段流程1.2 バックエンド

Automatic place and route (APR) takes the netlist and the physical library (the actual rectangles of each cell) and does four things that matter to you as a front-end designer. It places each cell on the standard-cell rows. It inserts the clock tree, a balanced buffer network that delivers the clock to every flip-flop with as little skew as possible — this is why you must never write combinational logic on a clock in RTL, because the tool needs the clock to be a clean, single-source signal it can buffer. It routes the signal nets in metal. Then the physical and electrical design rules are checked (DRC/ERC), the parasitic resistance and capacitance of every routed wire are extracted into an SPEF file, and timing is verified one last time with real wire delays instead of the statistical estimates synthesis used. If post-layout timing fails, the netlist comes back to the front end and you may have to restructure RTL you thought was finished.自動佈局繞線（APR）拿到網表與實體函式庫（每顆 cell 真正的矩形圖形），做四件對前段設計者有意義的事。它把每顆 cell 擺放到標準元件列上。它插入時脈樹，一棵平衡的緩衝器網路，盡可能以最小的偏斜（skew）把時脈送到每顆正反器 — 這正是為什麼你在 RTL 裡絕不可以對時脈寫組合邏輯，因為工具需要時脈是一個乾淨的、單一來源的訊號才能去加緩衝。它用金屬層繞線各條訊號 net。接著檢查實體與電性設計規則（DRC／ERC），把每條繞好的線的寄生電阻與電容萃取成 SPEF 檔，最後再用真實的線路延遲（而不是合成時用的統計估計）驗證一次時序。如果佈局後時序沒過，網表就被退回前段，而你可能得重構你以為早已完工的 RTL。自動配置配線（APR）は、ネットリストと物理ライブラリ（各セルの実際の矩形群）を受け取り、フロントエンド設計者にとって意味のある四つのことを行う。各セルをスタンダードセル行の上に配置する。クロックツリーを挿入する。これはクロックをできるだけ小さいスキューで全フリップフロップへ届ける平衡バッファ網であり、RTL でクロックに組合せ論理を書いてはならない理由でもある。ツールはバッファリングできる清浄な単一ソースのクロックを必要とするからだ。信号ネットを金属層で配線する。その後、物理・電気的デザインルールを検査し（DRC/ERC）、配線済み各ネットの寄生抵抗と容量を SPEF ファイルへ抽出し、合成が用いた統計的推定ではなく実際の配線遅延でタイミングを最終確認する。レイアウト後タイミングが落ちれば、ネットリストはフロントエンドへ戻され、完成したと思っていた RTL を作り直す羽目になる。

After design sign-off, the layout becomes GDSII, the GDSII becomes masks, and the project is taped out. The name is a fossil: layouts used to be cut from coloured tape on mylar. Months later packaged parts come back and are measured on the bench with a pattern generator driving the inputs and a logic analyser capturing the outputs — which is exactly the same stimulus-and-response structure as the testbench you wrote at the start, implemented in hardware instead of in the simulator.設計簽核之後，佈局變成 GDSII，GDSII 變成光罩，專案就下線（taped out）了。這個名字是化石：早年的佈局是用彩色膠帶黏在聚酯膜上剪出來的。幾個月後封裝好的晶片送回來，在實驗桌上量測 — 用圖樣產生器驅動輸入、用邏輯分析儀擷取輸出 — 這和你一開始寫的測試平台是完全相同的「刺激與回應」結構，只是用硬體而不是用模擬器實現。設計サインオフの後、レイアウトは GDSII になり、GDSII はマスクになり、プロジェクトはテープアウトされる。この名は化石である。昔のレイアウトはマイラー上の色テープから切り出されていた。数か月後、パッケージされた部品が戻り、パターンジェネレータで入力を駆動しロジックアナライザで出力を取り込んでベンチ上で測定される。これは最初に書いたテストベンチとまったく同じ刺激と応答の構造を、シミュレータではなくハードウェアで実装したものにほかならない。

1.3 What "cell-based" actually means1.3 「cell-based」的真正含意1.3「セルベース」の本当の意味

This single fact explains most of the style rules you will meet in Lectures 5 to 7. Why must you write always @(posedge clk) in a particular shape? Because the library contains a D flip-flop cell and the synthesiser has to recognise your code as "this is that cell". Why can't you write an arbitrary analogue behaviour? Because there is no cell for it. Why do tri-state buffers need care? Because z only has meaning on a net driven by an actual tri-state cell. The library is the vocabulary and synthesis is the translator; RTL that does not translate into library vocabulary is not a design, it is a simulation.這一個事實就解釋了你在第 5 到第 7 講會遇到的大多數風格規則。為什麼 always @(posedge clk) 一定要寫成某種特定形狀？因為函式庫裡有一顆 D 型正反器 cell，而合成器必須把你的程式碼認成「這就是那顆 cell」。為什麼你不能寫任意的類比行為？因為根本沒有那種 cell。為什麼三態緩衝器需要小心？因為 z 只有在由真正的三態 cell 驅動的 net 上才有意義。函式庫是詞彙，合成是翻譯者；翻不進函式庫詞彙的 RTL 不是設計，只是一段模擬。この一つの事実が、第 5 講から第 7 講で出会うスタイル規則のほとんどを説明する。なぜ always @(posedge clk) を特定の形で書かねばならないのか。ライブラリに D フリップフロップのセルがあり、合成器が君のコードを「これはそのセルだ」と認識しなければならないからだ。なぜ任意のアナログ的振る舞いを書けないのか。そのためのセルが存在しないからだ。なぜトライステートバッファには注意が要るのか。z は実際のトライステートセルが駆動するネットの上でしか意味を持たないからだ。ライブラリが語彙であり、合成が翻訳者である。ライブラリの語彙に翻訳できない RTL は設計ではなく、単なるシミュレーションである。

The slides also sketch the research flow a graduate student actually follows: pick a direction, find a topic, model the algorithm in C/C++ or MATLAB/Simulink until the fixed-point performance is acceptable, write the Verilog, verify it with the CAD tools (Design Compiler, DFT Compiler, TetraMAX, power analysis), lay it out, fabricate through a shuttle service, solder the part onto a board, measure it, and compare against reference ICs. Verilog sits in the middle of that chain. Every stage before it is a model; every stage after it is a consequence. If the Verilog is a faithful implementation of the MATLAB model and a synthesisable description of hardware, the project works. If it is only one of the two, it does not.投影片也勾勒了一位研究生實際會走的研究流程：選定方向、找題目、用 C/C++ 或 MATLAB/Simulink 把演算法模型化到定點效能可以接受為止、寫 Verilog、用 CAD 工具驗證（Design Compiler、DFT Compiler、TetraMAX、功耗分析）、佈局、經由多專案晶圓服務下線、把晶片焊上電路板、量測，再和參考 IC 比較。Verilog 坐在這條鏈的正中央。它之前的每一階段都是模型；它之後的每一階段都是後果。如果這份 Verilog 既忠實實現了 MATLAB 模型又是可合成的硬體描述，專案就成立；如果它只做到其中一件，就不成立。スライドは、大学院生が実際にたどる研究フローも素描している。方向を選び、テーマを見つけ、固定小数点性能が許容できるまで C/C++ や MATLAB/Simulink でアルゴリズムをモデル化し、Verilog を書き、CAD ツール（Design Compiler、DFT Compiler、TetraMAX、電力解析）で検証し、レイアウトし、シャトルサービスで試作し、部品を基板に実装し、測定し、参照 IC と比較する。Verilog はこの鎖の中央に座る。その前の各段階はモデルであり、その後の各段階は帰結である。Verilog が MATLAB モデルの忠実な実装でありかつ合成可能なハードウェア記述であれば、プロジェクトは成立する。どちらか一方でしかなければ成立しない。

1.4 The abstraction hierarchy1.4 抽象層次階層1.4 抽象化の階層

The slides draw a pyramid: system concept at the apex, then algorithm, architecture, register-transfer level, gate level, transistor level at the base. Climbing the pyramid increases behavioural abstraction; descending it increases detail and complexity. The pyramid shape is not decorative — it is a statement about information content. A system-level description of an OFDM receiver fits on one page. Its RTL is twenty thousand lines. Its gate netlist is two million lines. Its transistor netlist is ten million devices. Each level down multiplies the volume of data by roughly an order of magnitude, which is exactly why each step down is automated and each step must be verified against the level above rather than re-derived by hand.投影片畫了一座金字塔：頂端是系統概念，往下依序是演算法、架構、暫存器轉移層級、閘級，底部是電晶體級。往上爬，行為抽象度提高；往下走，細節與複雜度增加。金字塔的形狀不是裝飾 — 它是在陳述資訊量。一個 OFDM 接收機的系統級描述只有一頁；它的 RTL 是兩萬行；它的閘級網表是兩百萬行；它的電晶體網表是一千萬顆元件。每往下一層，資料量大約乘上一個數量級，這正是為什麼每一次往下都要自動化，而且每一層都必須對照上一層驗證，而不是用手重新推導一遍。スライドはピラミッドを描く。頂点にシステム構想、続いてアルゴリズム、アーキテクチャ、レジスタ転送レベル、ゲートレベル、底にトランジスタレベル。登れば動作の抽象度が上がり、降りれば詳細と複雑さが増す。ピラミッド形は飾りではなく、情報量についての主張である。OFDM 受信機のシステムレベル記述は一ページに収まる。その RTL は二万行。そのゲートネットリストは二百万行。そのトランジスタネットリストは一千万素子。一段下るごとにデータ量はおよそ一桁増える。だからこそ下りの各段は自動化され、各段は手で導き直すのではなく一つ上の層と突き合わせて検証されねばならない。

The slide's System Specification page is worth dwelling on because it shows the three artifacts of a real spec side by side: a function block diagram (a videoconferencing terminal: H.263 video codec, G.723.1 audio codec, H.225 mux/demux, V.34 modem), a pin table giving each port's direction, meaning and drive strength or output load, and a timing diagram showing when start, in, ready and out are valid relative to the clock. Those three together are what you must have before you type module. The pin table is the module header. The timing diagram is the testbench. The block diagram is the partition.投影片那頁「System Specification」值得多看一會兒，因為它把一份真實規格的三樣產出並排放在一起：一張功能方塊圖（一台視訊會議終端：H.263 視訊編解碼器、G.723.1 音訊編解碼器、H.225 多工／解多工、V.34 數據機）、一張接腳表標出每個埠的方向、意義與驅動強度或輸出負載，以及一張時序圖說明 start、in、ready、out 相對於時脈何時有效。這三樣加起來，就是你在打出 module 之前必須先有的東西。接腳表就是模組標頭；時序圖就是測試平台；方塊圖就是切割方式。スライドの System Specification のページは、実際の仕様がもつ三つの成果物を並べて見せている点で、立ち止まる価値がある。機能ブロック図（テレビ会議端末：H.263 映像コーデック、G.723.1 音声コーデック、H.225 多重／分離、V.34 モデム）、各ポートの方向・意味・ドライブ強度または出力負荷を与えるピン表、そして start、in、ready、out がクロックに対していつ有効かを示すタイミング図である。この三つが揃って初めて module とタイプできる。ピン表はモジュールヘッダであり、タイミング図はテストベンチであり、ブロック図は分割である。

The Algorithm Mapping slide makes the same point one level down, using the DFT. At system level you have the equation「Algorithm Mapping」那頁在低一層做同樣的事，用的是 DFT。在系統層級你拿到的是方程式Algorithm Mapping のスライドは、一段下のレベルで同じことを DFT を使って示す。システムレベルで手元にあるのは次の式である。

and its decimation-in-time decomposition以及它的時域抽取（decimation-in-time）分解そしてその時間間引き（decimation-in-time）分解

Nothing in those two lines says anything about hardware. The architecture step is what turns them into an input buffer, a serial-to-parallel converter, a bank of shift registers, an r-point DFT engine using distributed arithmetic, a coefficient ROM, a parallel-to-serial converter and a RAM. Two different architectures implementing the identical equation can differ by a factor of fifty in area. That choice is yours, not the tool's, and it is made before a line of Verilog is written. This is the content of Lecture 8.這兩行裡沒有一個字談到硬體。架構這一步才是把它們變成一個輸入緩衝器、一個串列轉並列轉換器、一組移位暫存器、一個用分散式算術實作的 r 點 DFT 引擎、一個係數 ROM、一個並列轉串列轉換器，以及一塊 RAM。兩種實作同一條方程式的不同架構，面積可以差到五十倍。那個選擇是你的，不是工具的，而且是在寫下第一行 Verilog 之前就做了。這是第 8 講的內容。この二行はハードウェアについて何も語っていない。それらを入力バッファ、直列並列変換器、シフトレジスタ群、分散算術による r 点 DFT エンジン、係数 ROM、並列直列変換器、そして RAM へ変えるのがアーキテクチャの段階である。同一の式を実装する二つの異なるアーキテクチャが、面積で五十倍違うこともある。その選択はツールではなく君のものであり、Verilog を一行も書かないうちに下される。これが第 8 講の内容である。

1.5 Design model domains and the Y-chart1.5 設計模型的三個領域與 Y 圖1.5 設計モデルのドメインと Y チャート

The slides present a table whose rows are abstraction levels (system, algorithm, RTL, gate, transistor) and whose columns are three model domains: abstract (what the thing does), structural (what it is made of), and physical (where the pieces are). Overlapping boxes labelled Architecture Design, Structural Design, Logic Design and Layout Design march diagonally down the table, with arrows labelled synthesis pointing right-and-down and arrows labelled verification pointing left-and-up.投影片上有一張表，列是抽象層次（系統、演算法、RTL、閘級、電晶體級），行是三個模型領域：抽象（這東西做什麼）、結構（它由什麼組成）、實體（各部件放在哪裡）。標著 Architecture Design、Structural Design、Logic Design、Layout Design 的方框彼此重疊，沿著表格對角線往下排列；標著合成的箭頭指向右下，標著驗證的箭頭指向左上。スライドには、行が抽象化レベル（システム、アルゴリズム、RTL、ゲート、トランジスタ）、列が三つのモデルドメイン——抽象（それが何をするか）、構造（何でできているか）、物理（部品がどこにあるか）——からなる表が示されている。Architecture Design、Structural Design、Logic Design、Layout Design と記された重なり合う箱が表を対角線状に下り、合成と記された矢印が右下を、検証と記された矢印が左上を指している。

That table is a flattened rendering of the Gajski–Kuhn Y-chart, the standard way this idea is drawn in the literature. The Y-chart puts the same three domains on three axes radiating from a common origin, with concentric rings for the abstraction levels. Reading it is mechanical: pick a ring, and the three points where it crosses the axes are three equivalent descriptions of the same design. Moving along an axis toward the centre is refinement within a domain; moving between axes at the same ring is a domain translation, and that translation is what the word "synthesis" means.那張表其實是 Gajski–Kuhn Y 圖攤平後的畫法，而 Y 圖才是文獻裡表達這個想法的標準方式。Y 圖把同樣的三個領域放在從同一原點輻射出去的三根軸上，再用同心圓環代表抽象層次。讀法是機械式的：挑一個圓環，它與三根軸相交的三個點，就是同一個設計的三種等價描述。沿著一根軸往圓心移動，是同一領域內的細化；在同一個圓環上跨越軸，則是領域之間的翻譯，而那個翻譯正是「合成」這個詞的意思。あの表は、文献でこの考えを描く標準的な図である Gajski–Kuhn の Y チャートを平らに引き伸ばしたものである。Y チャートは同じ三つのドメインを共通の原点から放射する三本の軸に置き、抽象化レベルを同心円で表す。読み方は機械的だ。一つの円を選べば、その円が三本の軸と交わる三点が、同じ設計の三つの等価な記述である。軸に沿って中心へ動くのはドメイン内の詳細化であり、同じ円の上で軸をまたぐのはドメイン間の翻訳であって、その翻訳こそが「合成」という語の意味である。

The practical value of the chart is that it tells you what a tool is and is not allowed to change. Synthesis moves you from the behavioural axis to the structural axis at a fixed or finer ring; it may not invent a better algorithm. If your RTL says "ripple-carry adder", Design Compiler may rebuild it as a carry-look-ahead adder because both implement the same Boolean function at the same ring — but if your RTL says "compute the DFT with 1024 sequential multiplications", no synthesiser in the world will give you an FFT, because that is a move along the behavioural axis and tools do not make it. Architectural improvement is human work. This is the single most important thing the Y-chart has to teach you.這張圖的實用價值，在於它告訴你一個工具被允許改動什麼、不被允許改動什麼。合成把你從行為軸搬到結構軸，而且是在同一個或更細的圓環上；它不會替你發明更好的演算法。如果你的 RTL 寫的是「漣波進位加法器」，Design Compiler 可以把它重建成超前進位加法器，因為兩者在同一個圓環上實現同一個布林函數 — 但如果你的 RTL 寫的是「用 1024 次連續乘法算 DFT」，世界上沒有任何合成器會還你一個 FFT，因為那是沿著行為軸的移動，而工具不做這種移動。架構上的改良是人的工作。這是 Y 圖要教你的最重要一件事。このチャートの実用的な価値は、ツールが何を変えてよく何を変えてはならないかを教える点にある。合成は君を動作軸から構造軸へ移すが、それは同じ円か、より内側の円の上でである。より良いアルゴリズムを発明したりはしない。RTL が「リップルキャリー加算器」と言っているなら、Design Compiler はそれをキャリー先見加算器に組み替えてよい。どちらも同じ円の上で同じブール関数を実装するからだ。しかし RTL が「1024 回の逐次乗算で DFT を計算する」と言っているなら、世界中のどの合成器も FFT を返してはくれない。それは動作軸に沿った移動であり、ツールはその移動をしないからだ。アーキテクチャの改良は人間の仕事である。これが Y チャートが教えるもっとも重要な一点である。

2. Why a Hardware Description Language Exists2. 為什麼需要硬體描述語言2. なぜハードウェア記述言語が存在するのか

The slides give a list of reasons for using an HDL — hardware is hard to design directly, an HDL is cheaper for exploring options, it reduces time and cost, it supports concurrency — and the list is correct but it reads like marketing. It is worth understanding what each item really means, because the single feature that separates an HDL from a programming language, concurrency, is also the feature that produces the most confusing bugs for a student arriving from C.投影片列了一串使用 HDL 的理由 — 硬體難以直接設計、用 HDL 探索各種方案比較便宜、它縮短時間與成本、它支援並行性 — 這串理由都對，但讀起來像廣告詞。值得弄清楚每一條真正的意思，因為把 HDL 和程式語言分開來的那個唯一特徵：並行性，同時也是對一個從 C 語言過來的學生製造最多困惑臭蟲的特徵。スライドは HDL を使う理由を並べる——ハードウェアは直接設計しにくい、HDL のほうが選択肢を安く探索できる、時間とコストを削減する、並行性を扱える——。いずれも正しいが、宣伝文句のように読める。各項目が実際に何を意味するかを理解する価値はある。HDL をプログラミング言語から分かつ唯一の特徴である並行性こそ、C から来た学生に最も紛らわしいバグを生む特徴でもあるからだ。

2.1 Hardware is concurrent; software is not2.1 硬體是並行的，軟體不是2.1 ハードウェアは並行、ソフトウェアはそうでない

Consider these two fragments, one in C and one in Verilog, which look nearly identical.看看下面兩段幾乎長得一模一樣的程式碼，一段是 C，一段是 Verilog。ほとんど見分けのつかない次の二つの断片を見よ。一方は C、他方は Verilog である。

int a = 1, b = 0, c;
c = a & b;        // c = 0
b = 1;            // c is still 0
printf("%d", c);  // prints 0

reg  a = 1, b = 0;
wire c;
assign c = a & b;   // a permanent connection
initial begin
  #10 b = 1;        // at t=10, c becomes 1
  #0  $display(c);  // prints 1
end

In C, c = a & b; is an event: it happens once, at the moment control reaches that line, and afterwards c is a dead value that remembers the past. In Verilog, assign c = a & b; is a structure: it describes an AND gate that exists for the whole simulation, re-evaluating every time a or b changes. The slide's phrase for this is "continuous assignment: static binding between LHS and RHS; no mechanism to eliminate or alter the binding". The gate is soldered in. You cannot un-solder it from inside the language.在 C 裡，c = a & b; 是一個事件：它只發生一次，就在控制流抵達那一行的瞬間，之後 c 變成一個記著過去的死值。在 Verilog 裡，assign c = a & b; 是一個結構：它描述一顆在整個模擬期間都存在的 AND 閘，每當 a 或 b 變動就重新求值。投影片對此的說法是「連續指定：LHS 與 RHS 之間的靜態繫結；語言中沒有任何機制可以消除或改變這個繫結」。這顆閘是焊上去的，你無法在語言內部把它拆焊。C では c = a & b; はイベントである。制御がその行に達した瞬間に一度だけ起こり、以後 c は過去を覚えているだけの死んだ値になる。Verilog では assign c = a & b; は構造である。シミュレーション中ずっと存在し、a か b が変わるたびに再評価される AND ゲートを記述している。スライドの言い方では「連続代入：左辺と右辺の静的な束縛。その束縛を取り除いたり変えたりする機構は存在しない」。ゲートははんだ付けされている。言語の内側からはんだを外すことはできない。

Every assign, every gate primitive, and every always block in every module in your design is a separate concurrent process. The order in which you write them in the file has no effect whatsoever on behaviour. A student who writes你設計裡每個模組中的每一條 assign、每一顆閘基元、每一個 always 區塊，都是一個各自獨立的並行行程。你在檔案裡把它們寫成什麼順序，對行為毫無影響。一個學生寫下設計中のあらゆるモジュールにある assign の一つ一つ、ゲートプリミティブの一つ一つ、always ブロックの一つ一つが、それぞれ独立した並行プロセスである。ファイル内でどの順に書いたかは振る舞いにまったく影響しない。次のように書いて

assign y = t & d;      // uses t
assign t = a | b;      // defines t — order does NOT matter

and worries that t is "used before it is defined" has not yet made the mental switch. There is no "before". Both statements are wires and gates that coexist. The simulator discovers the dependency itself through its event queue: when a changes it schedules an update of t; when t changes it schedules an update of y. That mechanism is the subject of Lecture 2.然後擔心 t「在定義之前就被使用」，這表示他還沒完成腦中的切換。這裡沒有「之前」。兩條敘述都是同時存在的線與閘。模擬器會自己透過事件佇列發現相依關係：a 變動時它排程一次 t 的更新；t 變動時它排程一次 y 的更新。那套機制正是第 2 講的主題。t が「定義より先に使われている」と心配する学生は、まだ頭の切り替えができていない。「先」など存在しない。どちらの文も同時に存在する配線とゲートである。シミュレータは依存関係をイベントキューによって自ら見つける。a が変われば t の更新をスケジュールし、t が変われば y の更新をスケジュールする。その仕組みが第 2 講の主題である。

2.2 What an HDL actually buys you2.2 HDL 真正帶來什麼2.2 HDL が実際にもたらすもの

Beyond concurrency, the slides list several features. Each is worth one sentence of translation into practice.除了並行性之外，投影片還列了好幾項特性。每一項都值得用一句話翻譯成實務上的意義。並行性のほかにも、スライドはいくつかの特徴を挙げる。どれも実務の言葉へ一文で翻訳しておく価値がある。

• High-level programming constructs. You can write if, case, for and arithmetic operators and let the synthesiser build the multiplexers, priority encoders and adders. Writing a 32-bit comparator as a gate netlist takes an afternoon and contains at least one typo; writing assign gt = (a > b); takes four seconds and contains none.高階程式構造。你可以寫 if、case、for 和算術運算子，讓合成器去搭出多工器、優先編碼器與加法器。把一個 32 位元比較器寫成閘級網表要花一個下午，而且至少會有一個筆誤；寫 assign gt = (a > b); 只要四秒，而且一個筆誤也沒有。高級なプログラミング構文。if、case、for や算術演算子を書けば、マルチプレクサ、プライオリティエンコーダ、加算器は合成器が組み立てる。32 ビット比較器をゲートレベル・ネットリストとして書けば午後一杯かかり、誤記が少なくとも一つ混じる。assign gt = (a > b); と書けば四秒で済み、誤記は一つもない。
• Description of connectivity. The same language that expresses behaviour also expresses structure, so a gate-level netlist produced by synthesis is itself legal Verilog that you can simulate with the same testbench. This is why post-synthesis validation is even possible.連接關係的描述。表達行為的那同一套語言也能表達結構，所以合成產生的閘級網表本身就是合法的 Verilog，你可以用同一份測試平台去模擬它。這正是合成後驗證之所以可能的原因。接続関係の記述。振る舞いを表すのと同じ言語が構造も表すので、合成が生んだゲートレベル・ネットリスト自体が正当な Verilog であり、同じテストベンチでシミュレーションできる。合成後検証が成り立つのはこのためである。
• Free mixing of abstraction levels. You can simulate a chip in which the block under design is RTL, its neighbour is a gate netlist, and the memory is a behavioural model with $readmemh. Without this you could never verify anything incrementally.抽象層次可以自由混用。你可以模擬一顆晶片，其中正在設計的區塊是 RTL、它的鄰居是閘級網表、記憶體則是用 $readmemh 的行為模型。沒有這一點，你永遠無法逐步驗證任何東西。抽象化レベルの自由な混在。設計中のブロックは RTL、その隣はゲートネットリスト、メモリは $readmemh を使う動作モデル——そんなチップをまとめてシミュレーションできる。これなしには、何一つ段階的に検証できない。
• One language for design, test and verification. The testbench is written in the same language, which means there is no translation layer in which a misunderstanding can hide.設計、測試與驗證共用一種語言。測試平台也用同一種語言撰寫，這表示中間沒有任何可以藏住誤解的翻譯層。設計・テスト・検証に一つの言語。テストベンチも同じ言語で書かれる。つまり、誤解が潜みうる翻訳層が存在しない。
• Functionality and timing. Verilog can carry delay annotations (#5, and from SDF back-annotation after layout), so the very same netlist can be simulated as pure logic before synthesis and with real cell delays afterwards. Lecture 3 covers the delay model in detail.功能與時序兼備。Verilog 可以攜帶延遲標註（#5，以及佈局後由 SDF 反標註而來的延遲），所以同一份網表既能在合成前當成純邏輯模擬，也能在合成後帶著真實 cell 延遲模擬。第 3 講會詳細講延遲模型。機能とタイミングの両方。Verilog は遅延注釈（#5、およびレイアウト後の SDF バックアノテーション）を担えるので、まったく同じネットリストを合成前は純論理として、合成後は実セル遅延つきでシミュレーションできる。遅延モデルは第 3 講で詳しく扱う。
• Portability and IP reuse. RTL is technology independent. The same source compiles against a 180 nm library, a 28 nm library or an FPGA. This is the whole economic basis of the IP industry.可移植性與 IP 再利用。RTL 與製程無關。同一份原始碼可以對 180 nm 函式庫、28 nm 函式庫或 FPGA 編譯。這就是整個 IP 產業的經濟基礎。移植性と IP の再利用。RTL はプロセス非依存である。同じソースが 180 nm ライブラリにも 28 nm ライブラリにも FPGA にもコンパイルされる。これが IP 産業全体の経済的基盤である。

2.3 Verilog versus VHDL2.3 Verilog 與 VHDL2.3 Verilog と VHDL

The honest summary is the slide's: they are equally effective and the choice is preference or employer policy. For a Verilog beginner, though, one asymmetry matters. VHDL's strong typing rejects at compile time a large class of mistakes — connecting a 4-bit signal to an 8-bit port, assigning an integer to a bit vector — that Verilog accepts silently, zero-extends or truncates, and turns into a functional bug you find three days later in a waveform. Verilog's low ceremony is a real productivity advantage and a real hazard, and the lint tools in the front-end flow exist largely to recover the checking that the language declined to do.最誠實的總結就是投影片講的：兩者同樣有效，選哪個是偏好或雇主政策的問題。不過對 Verilog 初學者而言，有一個不對稱很要緊。VHDL 的強型別在編譯期就擋下一大類錯誤 — 把 4 位元訊號接到 8 位元的埠、把整數指定給位元向量 — 而 Verilog 會安靜地接受、自動零延伸或截斷，然後變成一個三天後才在波形上發現的功能臭蟲。Verilog 的「少儀式」既是真正的生產力優勢，也是真正的危險；前段流程裡的 lint 工具之所以存在，很大程度上就是為了把語言不肯做的檢查補回來。正直なまとめはスライドの通りである。両者は同程度に有効で、選択は好みか雇用主の方針による。ただし Verilog の初学者には一つの非対称が重要だ。VHDL の強い型付けは、4 ビット信号を 8 ビットのポートにつなぐ、整数をビットベクタに代入する、といった広い範囲の誤りをコンパイル時に拒否する。Verilog はそれを黙って受け入れ、ゼロ拡張または切り詰め、三日後に波形の中で見つかる機能バグに変える。Verilog の儀式の少なさは本物の生産性であると同時に本物の危険であり、フロントエンドの lint ツールは、言語がやらないことにした検査を取り戻すために存在していると言ってよい。

2.4 Three jobs for one language2.4 一種語言，三項任務2.4 一つの言語に三つの役割

The conclusion slide calls Verilog "a platform", and that is the right word, because the same file format plays three quite different roles.總結那頁投影片把 Verilog 稱為「一個平台」，這個詞用得對，因為同一種檔案格式扮演三種相當不同的角色。まとめのスライドは Verilog を「プラットフォーム」と呼ぶ。同じファイル形式がかなり異なる三つの役割を演じるのだから、これは適切な語である。

Confusing these roles is the commonest novice error in the course. Code that works beautifully in simulation but contains #5 or initial will either be ignored by the synthesiser (producing a netlist whose behaviour differs from your simulation) or rejected outright. Code written with synthesis in mind but used in a testbench is merely tedious. The badge not synthesisable appears throughout these guides on constructs that belong strictly to the testbench column.把這三種角色搞混，是本課程最常見的新手錯誤。在模擬裡跑得漂漂亮亮、卻含有 #5 或 initial 的程式碼，要不是被合成器忽略（產出一份行為與你的模擬不同的網表），就是被直接拒收。反過來說，抱著合成心態寫出來卻用在測試平台裡的程式碼，頂多只是囉嗦。本系列指南中凡是嚴格屬於測試平台那一欄的語法，都會掛上 不可合成 的標記。この三つの役割を混同するのが、本科目で最も多い初学者の誤りである。シミュレーションでは見事に動くが #5 や initial を含むコードは、合成器に無視される（君のシミュレーションとは振る舞いの違うネットリストが出る）か、そのまま拒否される。逆に合成を意識して書いたコードをテストベンチで使うのは、単に冗長なだけだ。本ガイドでは、テストベンチの列にだけ属する構文に 合成不可 のバッジを付けている。

2.5 The synthesisable subset, and why it is a subset2.5 可合成子集，以及它為何只是一個子集2.5 合成可能サブセットと、それがなぜサブセットなのか

IEEE 1364 defines what a simulator must do with every construct. It says nothing about what a synthesiser must do, because a synthesiser is not obliged to exist. The synthesisable subset is defined separately (IEEE 1364.1) and, in practice, by what Design Compiler accepts. The boundary is not arbitrary: a construct is synthesisable if and only if its meaning can be realised by a fixed network of library cells whose behaviour does not depend on wall-clock time.IEEE 1364 定義的是模擬器對每一種語法必須做什麼。它完全沒說合成器必須做什麼，因為合成器沒有存在的義務。可合成子集是另外定義的（IEEE 1364.1），而實務上是由 Design Compiler 接受什麼來定義的。這條界線並不隨意：一個語法可合成，若且唯若它的意義能用一張固定的函式庫 cell 網路實現，而那張網路的行為不依賴真實世界的時鐘。IEEE 1364 が定めるのは、各構文に対してシミュレータが何をすべきかである。合成器が何をすべきかは何も述べていない。合成器には存在する義務がないからだ。合成可能サブセットは別に（IEEE 1364.1 として）定義され、実務上は Design Compiler が受理するものによって定義される。この境界は恣意的ではない。ある構文が合成可能であるのは、その意味が、実時間に依存しない振る舞いを持つライブラリセルの固定したネットワークで実現できるとき、かつそのときに限る。

assign y = sel ? a : b;

always @(posedge clk)
  q <= d;

always @(*)
  case (op)
    2'b00: r = a + b;
    2'b01: r = a - b;
    default: r = a;
  endcase

for (k = 0; k < 8; k = k + 1)
  s[k] = a[k] ^ b[k];   // unrolled

#5 y = a;              // delay control

initial q = 0;         // power-on value

wait (ready == 1);     // level-sensitive wait

forever #10 clk = ~clk;

real gain;             // floating point

$display("q = %b", q); // system task

while (x != 0)         // bound unknown at
  x = x - 1;           // elaboration time

Look at the right-hand column and ask, for each line, "what cell would this be?". There is no cell that waits five nanoseconds and then copies a value; delay in real hardware is a consequence of the gates you chose, not something you request. There is no cell that sets itself to 0 at power-on unless it is a flip-flop with a reset pin — which is why reset is a port, written explicitly, rather than an initial block. There is no cell that loops an unknown number of times; a for loop is synthesisable only when the tool can unroll it at elaboration time into a fixed amount of hardware, which requires constant bounds.看著右邊那一欄，對每一行問自己：「這會是哪一顆 cell？」沒有哪顆 cell 會等五奈秒再複製一個值；真實硬體裡的延遲是你所選的閘造成的後果，不是你可以點菜的東西。也沒有哪顆 cell 會在上電時把自己設成 0，除非它是一顆帶 reset 腳的正反器 — 這正是為什麼 reset 是一個明確寫出來的埠，而不是一個 initial 區塊。更沒有哪顆 cell 會迴圈不確定的次數；for 迴圈只有在工具能於展開期把它攤成固定數量的硬體時才可合成，而那需要常數的上下界。右の列を見て、各行について「これはどのセルになるのか」と自問せよ。五ナノ秒待ってから値を写すセルなど存在しない。実在のハードウェアにおける遅延は、選んだゲートの帰結であって、注文できるものではない。電源投入時に自分を 0 にするセルも存在しない——リセットピンを持つフリップフロップでない限りは。だからこそリセットは initial ブロックではなく、明示的に書かれたポートなのである。不定回数ループするセルも存在しない。for ループが合成可能なのは、ツールがエラボレーション時にそれを固定量のハードウェアへ展開できるときだけであり、そのためには境界が定数である必要がある。

module bad_order (y, a, b, d);
  input  a, b, d;
  output y;
  reg    t, y;

  always @(a or b) t = a | b;
  always @(t or d) y = t & d;
endmodule

3. Modules, Ports, Nets and Registers3. 模組、埠、net 與暫存器型別3. モジュール・ポート・ネット・レジスタ

3.1 The module is the only design entity3.1 模組是唯一的設計單位3.1 モジュールが唯一の設計単位

Verilog has exactly one unit of design: the module, delimited by the keywords module and endmodule. Everything else — gates, assignments, procedural blocks, instances of other modules — is a module item that lives inside one. Three rules follow, and the slides state all three.Verilog 只有一種設計單位：模組（module），由關鍵字 module 與 endmodule 界定。其他一切 — 閘、指定、程序區塊、其他模組的實例 — 都是住在某個模組裡的模組項目（module item）。由此推出三條規則，投影片三條都講了。Verilog の設計単位はただ一つ、キーワード module と endmodule で区切られるモジュールである。それ以外のすべて——ゲート、代入、手続きブロック、他モジュールのインスタンス——は、そのいずれかの内側に住むモジュール項目である。ここから三つの規則が導かれ、スライドはその三つすべてを述べている。

• A module is created by declaration. Writing module Add_half (…); … endmodule defines a type, much like a class definition. It does not by itself put any hardware in your chip.模組靠宣告而誕生。寫下 module Add_half (…); … endmodule 定義的是一個型別，很像類別定義。它本身並不會在你的晶片裡放進任何硬體。モジュールは宣言によって生まれる。module Add_half (…); … endmodule と書くことは、クラス定義によく似た型の定義である。それだけではチップに何のハードウェアも置かれない。
• Modules cannot be nested. You may not write a module declaration inside another module. Hierarchy is built by instantiating one module inside another, which is a different act — it is the difference between defining a type and allocating an object of that type. This is Section 7.模組不能巢狀。你不可以在一個 module 裡面再寫一個 module 宣告。階層是靠在一個模組裡實例化另一個模組建立起來的，那是另一回事 — 就像定義一個型別和配置一個該型別的物件之間的差別。這是第 7 節的內容。モジュールは入れ子にできない。module 宣言を別の module の内側に書くことはできない。階層は、あるモジュールの中で別のモジュールをインスタンス化することで作られる。これは別の行為であり、型を定義することと、その型のオブジェクトを確保することの違いに当たる。第 7 節の話である。
• All modules run concurrently. There is no main, no entry point, no call order. Every instance in the design is live for the whole simulation.所有模組同時運行。沒有 main，沒有進入點，沒有呼叫順序。設計中的每一個實例在整個模擬期間都是活的。すべてのモジュールは同時に動く。main も、エントリポイントも、呼び出し順序もない。設計中のあらゆるインスタンスがシミュレーション中ずっと生きている。

The last rule has a corollary worth stating explicitly: the top module of a design is simply the module that nothing else instantiates. The simulator finds it by elaboration, not by a keyword. If you accidentally leave two modules un-instantiated you get two top modules and two independent circuits, both simulating, usually with one of them producing nothing but x.最後這條規則有一個值得明講的推論：一個設計的頂層模組，不過就是沒有被任何其他模組實例化的那個模組。模擬器是靠展開（elaboration）找到它的，不是靠某個關鍵字。如果你不小心讓兩個模組都沒被實例化，你就會得到兩個頂層模組、兩個互不相干的電路同時在模擬，而且通常其中一個只會吐出 x。最後の規則には明言しておく価値のある系がある。設計のトップモジュールとは、他のどこからもインスタンス化されていないモジュールにすぎない。シミュレータはそれをキーワードではなくエラボレーションによって見つける。うっかり二つのモジュールをインスタンス化し忘れれば、トップモジュールが二つ、互いに独立な回路が二つ同時にシミュレーションされ、たいていは片方が x しか出さない。

3.2 Ports and port modes3.2 埠與埠的方向3.2 ポートとポートモード

A module's ports are listed in parentheses after its name and their direction is declared inside the body with input, output or inout. This is the Verilog-1995 style used throughout these slides:一個模組的埠列在名稱後面的括號裡，方向則在本體內以 input、output 或 inout 宣告。這是本系列投影片通篇採用的 Verilog-1995 風格：モジュールのポートは名前の後の括弧に並べ、方向は本体の中で input、output、inout によって宣言する。これはスライド全体で用いられる Verilog-1995 のスタイルである。

module Add_half (sum, c_out, a, b);   // port list: names only
  input  a, b;                        // port modes declared separately
  output sum, c_out;
  wire   c_out_bar;                   // internal signal
  // ... body ...
endmodule

Verilog-2001 added the ANSI-style header, in which direction, type and width are all written once in the port list: module Add_half (output sum, output c_out, input a, input b);. It is shorter and removes a whole class of typo. This course's slides use the 1995 style, and you should be fluent in reading it because every legacy IP core and every synthesised netlist you ever open is written that way. Write new code in whichever style your group has standardised on, but never mix the two within one module — that is a syntax error.Verilog-2001 加入了 ANSI 風格的標頭，方向、型別與位寬全部在埠列裡寫一次：module Add_half (output sum, output c_out, input a, input b);。它比較短，也消滅了一整類筆誤。這門課的投影片用的是 1995 風格，而你應該要能流利地閱讀它，因為你將來打開的每一個舊 IP 核、每一份合成出來的網表，都是那樣寫的。新程式碼用你們團隊標準化的那種風格即可，但千萬別在同一個模組裡混用兩種 — 那是語法錯誤。Verilog-2001 は ANSI 形式のヘッダを追加した。方向・型・幅をすべてポートリストに一度だけ書く形式である。module Add_half (output sum, output c_out, input a, input b);。短く、まるごと一種類の誤記を消し去る。本科目のスライドは 1995 形式を使っており、君はそれを読みこなせる必要がある。これから開くレガシー IP コアも合成済みネットリストも、すべてその形式で書かれているからだ。新しいコードは所属グループが標準としている形式で書けばよいが、一つのモジュール内で両者を混ぜてはならない。それは構文エラーである。

3.3 Nets3.3 Net3.3 ネット

A net models a physical connection. The defining property, in the slides' words, is that a net "doesn't store value, just a connection". It has no memory. At every instant its value is whatever its driver or drivers are forcing onto it, and if nothing drives it, it is z — floating — not 0 and not its last value.net 模擬的是一條實體連接。用投影片的話說，它的定義性質是 net「不儲存值，只是一條連接」。它沒有記憶。在任何一瞬間，它的值就是它的驅動器（可能不只一個）正在逼它成為的值；如果沒有任何東西驅動它，它就是 z — 浮接 — 既不是 0，也不是它上一刻的值。ネットは物理的な接続をモデル化する。スライドの言葉を借りれば、定義的な性質はネットが「値を保持せず、接続にすぎない」ことである。記憶を持たない。任意の瞬間におけるその値は、ドライバ（複数のこともある）が押し付けている値そのものであり、何も駆動していなければ値は z——フローティング——であって、0 でもなければ直前の値でもない。

The net types are wire, wand, wor, tri, triand, trior, tri0, tri1, trireg, supply0 and supply1. Ninety-nine per cent of synthesisable RTL uses only wire. The others exist to describe what happens when a net has more than one driver:net 的型別有 wire、wand、wor、tri、triand、trior、tri0、tri1、trireg、supply0 與 supply1。可合成 RTL 有百分之九十九只用 wire。其餘那些的存在，是為了描述當一條 net 有多於一個驅動器時會發生什麼事：ネット型には wire、wand、wor、tri、triand、trior、tri0、tri1、trireg、supply0、supply1 がある。合成可能な RTL の九十九パーセントは wire しか使わない。残りは、ネットに複数のドライバがあるとき何が起こるかを記述するために存在する。

The slides' three operational rules for nets are:投影片給 net 的三條操作規則是：スライドが挙げるネットの運用規則は三つである。

1. Driven with assign. A net's value comes from a continuous assignment, from a gate primitive output, or from a module instance output port.用 assign 驅動。net 的值來自連續指定、來自閘基元的輸出，或來自模組實例的輸出埠。assign で駆動する。ネットの値は連続代入、ゲートプリミティブの出力、またはモジュールインスタンスの出力ポートから来る。
2. Ports default to wire. If you declare input a; and nothing else, a is a 1-bit wire. You rarely need to write wire a; as well — the slide's Add_rca_16 example does redeclare its ports as wires, which is legal but redundant.埠預設就是 wire。如果你只宣告 input a; 而沒寫別的，a 就是一條 1 位元的 wire。你很少需要再寫一次 wire a; — 投影片的 Add_rca_16 範例確實把埠又宣告成 wire 一次，那是合法的，但多餘。ポートの既定は wire。input a; とだけ宣言すれば、a は 1 ビットの wire である。重ねて wire a; と書く必要はまずない。スライドの Add_rca_16 の例はポートを wire として再宣言しているが、これは合法でありながら冗長である。
3. A net can never be the target of an assignment inside an always block. This is the rule students hit first and understand last. See §3.5.net 永遠不能成為 always 區塊裡指定敘述的目標。這是學生最早撞到、卻最晚真正理解的一條規則。見 §3.5。ネットは always ブロック内の代入の左辺には決してなれない。学生が最初にぶつかり、最後まで腑に落ちない規則である。§3.5 を参照。

3.4 Registers3.4 暫存器型別3.4 レジスタ型

A variable — Verilog-1995 calls it a register, and the keyword is reg — does store a value. It holds whatever was last procedurally assigned to it, until something assigns again. The register data types are reg, integer, time and real.變數 — Verilog-1995 稱它為 register，關鍵字是 reg — 是真的會儲存值的。它保有最後一次被程序指定的內容，直到下一次有東西再指定它為止。暫存器類資料型別有 reg、integer、time 與 real。変数——Verilog-1995 はこれをレジスタと呼び、キーワードは reg である——は実際に値を保持する。最後に手続き的に代入されたものを、次の代入まで保ち続ける。レジスタ系のデータ型は reg、integer、time、real である。

The slide's side-by-side comparison is exactly the right picture to memorise:投影片那張並排比較，正是最該背起來的一幅圖：スライドの並列比較は、まさに記憶に焼き付けるべき図である。

module test (a, b, c, d);
  input  a, b;
  output c, d;
  wire   c, d;

  assign c = a | b;
  assign d = a & b;
endmodule

module test (a, b, c, d);
  input  a, b;
  output c, d;
  reg    c, d;

  always @ (a or b) begin   // sensitivity list
    c = a | b;
    d = a & b;
  end
endmodule

These two modules produce identical hardware: one OR gate and one AND gate. Not similar hardware — identical. Run both through Design Compiler and the netlists are the same. The difference is purely in how you asked for it: the left-hand module declares a structural binding, the right-hand module describes a procedure that recomputes the outputs whenever an input changes. The synthesiser reduces both to the same truth table.這兩個模組產生完全相同的硬體：一顆 OR 閘和一顆 AND 閘。不是相似的硬體，是相同的。把兩者都丟進 Design Compiler，網表一模一樣。差別純粹在於你是怎麼要求的：左邊的模組宣告了一組結構性繫結，右邊的模組描述了一段每當輸入改變就重算輸出的程序。合成器把兩者都化簡成同一張真值表。この二つのモジュールはまったく同一のハードウェアを生む。OR ゲート一つと AND ゲート一つ。似たハードウェアではなく、同一である。両方を Design Compiler に通せばネットリストは一致する。違いはひとえに要求の仕方にある。左のモジュールは構造的な束縛を宣言し、右のモジュールは入力が変わるたびに出力を再計算する手続きを記述している。合成器はどちらも同じ真理値表へ還元する。

3.5 A reg is not a register3.5 reg 並不是正反器3.5 reg はレジスタではない

The slide's own wording — "use of reg data type is not exactly synthesized to a really register" — says this, somewhat telegraphically. Here is the rule stated the way synthesis actually applies it.投影片自己的說法 — use of reg data type is not exactly synthesized to a really register — 講的就是這件事，只是講得有點像電報。底下是這條規則按合成實際適用的方式重新陳述一次。スライド自身の文言——use of reg data type is not exactly synthesized to a really register——はこのことを、やや電文調に述べている。以下は、この規則を合成が実際に適用する形で言い直したものである。

Why does the language insist on the distinction at all, then? Because of how the simulator is built. A continuous assignment and a gate are drivers: the simulator keeps, for each net, a list of drivers and a resolution function, and recomputes the net whenever any driver changes. A procedural assignment is a store: it writes a value into a variable's storage location and that value sits there. These are two different data structures inside the simulator, and a signal has to be one or the other. Hence: nets are driven by assign and by instance outputs; variables are written by procedural statements inside always, initial, tasks and functions. Mixing them is not a style preference, it is a type error.那麼語言為何還堅持要有這個區分？因為模擬器是這樣造出來的。連續指定和閘都是驅動器：模擬器為每一條 net 保存一份驅動器清單與一個裁決函數，只要任一驅動器改變就重算這條 net。程序指定則是一次儲存：它把一個值寫進變數的儲存位置，那個值就待在那裡。這是模擬器內部兩種不同的資料結構，而一個訊號只能是其中之一。因此：net 由 assign 和實例輸出驅動；變數由 always、initial、task 和 function 裡的程序敘述寫入。把兩者混用不是風格偏好，是型別錯誤。では、なぜ言語はこの区別に固執するのか。シミュレータの作りがそうなっているからである。連続代入とゲートはドライバである。シミュレータは各ネットについてドライバのリストと解決関数を保持し、いずれかのドライバが変わるたびにネットを再計算する。手続き的代入は記憶である。変数の記憶場所へ値を書き込み、その値はそこに居座る。これはシミュレータ内部の二つの異なるデータ構造であり、信号はどちらか一方でしかありえない。ゆえに、ネットは assign とインスタンス出力が駆動し、変数は always、initial、タスク、ファンクション内の手続き文が書き込む。両者を混ぜるのはスタイルの好みではなく、型エラーである。

module m (y, a, b);
  input  a, b;
  output y;
  wire y;

  always @(a or b)
    y = a & b;   // ERROR: illegal
                 // left-hand side
endmodule

module m (y, a, b);
  input  a, b;
  output y;
  reg y;

  assign y = a & b;  // ERROR: cannot
                      // continuously assign
                      // to a variable
endmodule

Both of these are compile-time errors, which is the good case. The bad case is subtler: a signal that you meant to drive but forgot to, which stays at z and then makes everything downstream x. Section 4.3 traces how that looks in a waveform.這兩種都是編譯期錯誤，而那是好的情況。糟糕的情況更隱微：一條你打算驅動卻忘了驅動的訊號，它停在 z，然後把下游一切變成 x。4.3 節會追蹤那在波形上長什麼樣子。どちらもコンパイル時エラーであり、それは良いほうの事例である。悪いほうはもっと微妙だ。駆動するつもりだったのに忘れた信号は z のまま留まり、下流のすべてを x にする。それが波形でどう見えるかは 4.3 節で追う。

  // case (a)
  wire y;
  assign y = 1'b1;
  assign y = 1'b0;

  // case (b)
  wire y;
  assign y = 1'b1;
  assign y = 1'bz;

  // case (c)
  wand y;
  assign y = 1'b1;
  assign y = 1'b0;

  // case (d)
  reg y;
  always @(a) y = 1'b1;
  always @(b) y = 1'b0;

4. Four-Value Logic and Number Literals4. 四值邏輯與數值常數4. 四値論理と数値リテラル

4.1 Why four values and not two4.1 為何是四個值而不是兩個4.1 なぜ二値ではなく四値なのか

Boolean algebra has two values. Verilog has four: 0, 1, x (or X — the case of the value letter does not matter) and z (or Z). The two extra values are not a mathematical extension of Boolean logic; they are engineering admissions about what a simulator can honestly claim.布林代數有兩個值。Verilog 有四個：0、1、x（或 X — 值字母的大小寫無關）與 z（或 Z）。多出來的那兩個值不是布林邏輯的數學延伸；它們是工程上對模擬器究竟能誠實宣稱什麼所做的坦白。ブール代数は二値である。Verilog は四値を持つ。0、1、x（または X——値を表す文字の大小は問わない）、z（または Z）である。追加の二値はブール論理の数学的拡張ではない。シミュレータが正直に主張できることは何かについての、工学的な告白である。

• x means the simulator does not know. It is not a third logic level in silicon. The physical node is at some voltage, and that voltage will be read as a 0 or a 1 by whatever gate is downstream. x says "the model cannot tell you which, and if your design depends on it you have a bug". It arises from uninitialised storage, from conflicting drivers, from reading a memory location never written, and from timing-check violations in gate-level simulation.x 的意思是模擬器不知道。它不是矽上的第三個邏輯位準。那個實體節點一定處在某個電壓，而下游的閘一定會把那個電壓讀成 0 或 1。x 說的是「模型無法告訴你是哪一個，而如果你的設計依賴它，那你就有臭蟲」。它來自未初始化的儲存、來自互相衝突的驅動器、來自讀取從未寫過的記憶體位置，以及來自閘級模擬中的時序檢查違規。x はシミュレータが知らないという意味である。シリコン上の第三の論理レベルではない。物理ノードは何らかの電圧にあり、その電圧は下流のゲートによって 0 か 1 として読まれる。x は「モデルはどちらかを言えない。設計がそれに依存しているなら、それはバグだ」と述べている。未初期化の記憶、衝突するドライバ、一度も書かれていないメモリ位置の読み出し、そしてゲートレベル・シミュレーションにおけるタイミングチェック違反から生じる。
• z means no driver — the node is floating, high impedance. Unlike x, z is a genuine physical state and a useful design element: it is how a tri-state buffer gets off a shared bus.z 的意思是沒有驅動器 — 該節點浮接，呈高阻抗。和 x 不同，z 是一個貨真價實的實體狀態，也是有用的設計元素：三態緩衝器正是靠它從共用匯流排上退下來的。z はドライバがないという意味である。ノードはフローティングで高インピーダンスだ。x と違い z は本物の物理状態であり、有用な設計要素でもある。トライステートバッファが共有バスから降りるのは z によってである。

The reason this matters more than it looks: four-value logic is the mechanism by which a Verilog simulation tells you about a class of bug that no amount of testbench cleverness would otherwise find. If reset is missing from a flip-flop, the flop starts at x, the x propagates through the datapath, and within a few cycles the output is a solid red band in the waveform viewer. Two-valued simulation (which is what most FPGA tools and all formal engines use internally) would have randomised the flop to 0 or 1 and you might never have noticed. X-propagation is a feature. Students who "fix" an x by writing initial q = 0; have hidden the bug rather than fixed it, because the silicon has no initial block.這件事比看起來更重要的理由是：四值邏輯正是 Verilog 模擬告訴你一類再怎麼聰明的測試平台也找不到的臭蟲的機制。如果某顆正反器少了 reset，它從 x 開始，x 沿著資料路徑傳播，幾個週期之內輸出就在波形檢視器裡變成一整片紅帶。二值模擬（大多數 FPGA 工具與所有形式驗證引擎內部用的就是它）會把那顆正反器隨機設成 0 或 1，而你可能永遠不會注意到。X 傳播是一項功能。用 initial q = 0; 來「修好」一個 x 的學生，是把臭蟲藏起來而不是修掉，因為矽上沒有 initial 區塊。これが見かけ以上に重要な理由はこうだ。四値論理こそ、Verilog のシミュレーションがどれほど巧妙なテストベンチでも見つけられない種類のバグを教えてくれる仕組みなのである。あるフリップフロップにリセットが欠けていれば、それは x から始まり、x がデータパスを伝播し、数サイクルのうちに出力は波形ビューアで一面の赤い帯になる。二値シミュレーション（多くの FPGA ツールとすべての形式検証エンジンが内部で使う）なら、そのフリップフロップを 0 か 1 にランダム初期化してしまい、君は何にも気づかなかったかもしれない。X 伝播は機能である。initial q = 0; と書いて x を「直した」学生は、直したのではなく隠したのだ。シリコンに initial ブロックは存在しない。

4.2 The operator tables4.2 運算子真值表4.2 演算子の真理値表

Every bitwise and gate-level operator is defined over all four values. The tables are not arbitrary; each entry is the answer to "given this much knowledge about the inputs, how much can I claim about the output?"每一個位元運算子與閘級運算子都在全部四個值上有定義。這些表並不隨意；每一格都是在回答「已知輸入的資訊只有這麼多，我對輸出能宣稱到什麼程度？」ビット演算子とゲートレベル演算子はすべて四つの値すべてに対して定義されている。表は恣意的ではない。各欄は「入力についてこれだけの知識しかないとき、出力について何をどこまで主張できるか」への答えである。

Read the AND table along its first row and first column: a 0 on either input forces the output to 0 whatever the other input is — including x and z. This is the controlling value of the AND gate, and it is physically true: with one NMOS in the stack turned off, the pull-down path is broken regardless of the other. Symmetrically, 1 is the controlling value of OR. Everywhere else, an x or z input produces x.沿著 AND 表的第一列與第一行讀：任一輸入上的 0 都會把輸出壓成 0，不論另一個輸入是什麼 — 包括 x 與 z。這就是 AND 閘的控制值（controlling value），而且它在物理上為真：堆疊中只要有一顆 NMOS 關閉，下拉路徑就斷了，和另一顆無關。對稱地，1 是 OR 的控制值。除此之外的每一格，只要有 x 或 z 輸入，輸出就是 x。AND 表を第一行と第一列に沿って読め。どちらかの入力の 0 は、もう一方が何であろうと——x でも z でも——出力を 0 に固定する。これが AND ゲートの支配値であり、物理的にも正しい。スタック中の NMOS が一つでもオフなら、もう一方に関係なくプルダウン経路は切れている。対称的に、OR の支配値は 1 である。それ以外の欄では、x または z の入力は出力を x にする。

Notice what the tables do not contain: the value z. A logic gate never outputs z. Its output stage is always driving. z appears on a net only when that net has no driver at all, or when its driver is a tri-state primitive (bufif0, bufif1, notif0, notif1) whose enable is deasserted. Gate inputs treat an incoming z as "I cannot tell", i.e. as x — which is exactly what the last row and column of each table encode.注意這些表裡沒有什麼：值 z。邏輯閘永遠不會輸出 z，它的輸出級一直在驅動。z 只有在一條 net 根本沒有驅動器時，或它的驅動器是一顆 enable 被解除的三態基元（bufif0、bufif1、notif0、notif1）時，才會出現在 net 上。閘的輸入把進來的 z 當成「我分辨不出」，也就是當成 x — 那正是每張表最後一列與最後一行所編碼的內容。表にないものに注意せよ。値 z である。論理ゲートが z を出力することはない。その出力段は常に駆動している。z がネット上に現れるのは、そのネットにドライバがまったくないか、ドライバがイネーブルを落としたトライステート・プリミティブ（bufif0、bufif1、notif0、notif1）であるときだけだ。ゲートの入力は入ってきた z を「判別できない」、すなわち x として扱う。各表の最終行・最終列はまさにそれを符号化している。

XOR is harsher still: it has no controlling value, so a single unknown input makes the output unknown unconditionally.XOR 更嚴苛：它沒有控制值，所以只要有一個未知輸入，輸出就無條件未知。XOR はさらに厳しい。支配値を持たないので、不定の入力が一つあれば出力は無条件に不定になる。

4.3 How x propagates, and what it looks like4.3 x 如何傳播，以及它長什麼樣子4.3 x はどう伝播し、どう見えるか

Work through a concrete trace. Take the full adder $S = A \oplus B \oplus C_I$, $C_O = AB + AC_I + BC_I$ and feed it $A=1$, $B=0$, $C_I=x$.我們來做一次具體的推演。取全加器 $S = A \oplus B \oplus C_I$、$C_O = AB + AC_I + BC_I$，餵給它 $A=1$、$B=0$、$C_I=x$。具体的に追ってみよう。全加算器 $S = A \oplus B \oplus C_I$、$C_O = AB + AC_I + BC_I$ に、$A=1$、$B=0$、$C_I=x$ を与える。

In a waveform viewer, x is conventionally drawn as a red band at mid-level and z as a grey or blue band on the centre line. The debugging procedure is always the same and always works: find the earliest time at which the red appears, then trace backwards through the drivers to the first signal that is red at that time. One of four things will be true at the source.在波形檢視器裡，x 慣例上畫成中間高度的紅色帶狀，z 則畫成中線上的灰色或藍色帶狀。除錯程序永遠一樣，而且永遠有效：找出紅色最早出現的時刻，然後沿著驅動器往回追，追到在那個時刻第一個變紅的訊號。在那個源頭，下列四件事之一會成立。波形ビューアでは、慣例として x は中央の高さに赤い帯で、z は中心線上に灰色または青の帯で描かれる。デバッグ手順はいつも同じで、いつも有効である。赤が現れる最も早い時刻を見つけ、ドライバをさかのぼって、その時刻に赤くなっている最初の信号まで追う。その源では、次の四つのうちどれかが成り立っている。

4.4 z, tri-state and why you will rarely use it4.4 z、三態，以及為何你很少會用到它4.4 z、トライステート、そしてそれをめったに使わない理由

A high-impedance output is produced by a tri-state driver. The four Verilog primitives are bufif1, bufif0, notif1 and notif0; in RTL you write it with a conditional whose false branch is z:高阻抗輸出由三態驅動器產生。Verilog 的四個基元是 bufif1、bufif0、notif1 與 notif0；在 RTL 裡你是用一個「假分支為 z」的條件運算式寫出來的：高インピーダンス出力はトライステート・ドライバが生む。Verilog のプリミティブは bufif1、bufif0、notif1、notif0 の四つである。RTL では偽側の枝を z にした条件式で書く。

module bus_driver (bus, data, oe);
  input  [7:0] data;
  input        oe;
  output [7:0] bus;

  assign bus = oe ? data : 8'bz;   // tri-state: releases the bus when oe = 0
endmodule

Several such modules can drive one wire, and as long as at most one has oe = 1 at a time the resolution works out: the single non-z driver wins. If two assert simultaneously you get x on the bus in simulation and a short circuit in silicon.數個這樣的模組可以驅動同一條 wire，只要在任何時刻至多只有一個的 oe = 1，裁決就會成立：唯一那個非 z 的驅動器勝出。如果有兩個同時拉起，模擬裡匯流排上就是 x，矽上則是一條短路。こうしたモジュールを複数同じ wire につないでも、どの時点でも oe = 1 が高々一つであれば解決は成立する。z でない唯一のドライバが勝つ。二つが同時にアサートすれば、シミュレーションではバス上に x が、シリコン上には短絡が生じる。

In modern on-chip design this is almost always the wrong structure. Internal tri-state buses are hard to test (a floating node has no defined value for ATPG to observe), they are prone to crowbar currents during the overlap when one driver turns off and another turns on, and the library cells for them are large. Nearly every design replaces them with a multiplexer, which costs more gates and is enormously better behaved. Tri-state survives at the chip boundary — bidirectional I/O pads for an SRAM interface, an I²C line — and that is where inout ports belong. Expect to see this again in Lecture 7 when the synthesisable subset is discussed in detail.在現代晶片內部設計中，這幾乎總是錯誤的結構。晶片內部的三態匯流排很難測試（浮接節點沒有確定值可供 ATPG 觀測），在一個驅動器關閉與另一個開啟的重疊期間容易產生貫穿電流，而且對應的函式庫 cell 很大。幾乎每個設計都會改用多工器取代它：多花一些閘，但行為好太多了。三態只在晶片邊界存活下來 — SRAM 介面的雙向 I/O pad、一條 I²C 線 — 而那正是 inout 埠該出現的地方。第 7 講詳細討論可合成子集時，你會再遇到這個主題。現代のオンチップ設計では、これはほぼ常に誤った構造である。内部のトライステートバスはテストしにくく（浮いたノードには ATPG が観測できる確定値がない）、一方のドライバが切れ他方が入る重なりの間に貫通電流を生みやすく、対応するライブラリセルも大きい。ほとんどの設計はこれをマルチプレクサで置き換える。ゲート数は増えるが、振る舞いははるかに素直である。トライステートが生き残るのはチップ境界——SRAM インタフェースの双方向 I/O パッド、I²C の信号線——であり、そこが inout ポートの居場所である。合成可能サブセットを詳しく扱う第 7 講で再会することになる。

4.5 Number literal syntax4.5 數值常數的語法4.5 数値リテラルの構文

The size is counted in bits, and that is the single most common misreading. One octal digit is three bits; one hex digit is four. So 5'O36 is five bits wide although octal 36 nominally needs six — and the answer is 11110, the low five bits of 011110, with the leading 0 dropped by truncation. And 16'H3AB is sixteen bits although only three hex digits were written — the value is zero-extended to 0000_0011_1010_1011.位寬是用位元計算的，而這正是最常被讀錯的一點。一個八進位數字是三個位元；一個十六進位數字是四個位元。所以 5'O36 寬五個位元，儘管八進位的 36 名目上需要六個位元 — 答案是 11110，也就是 011110 的低五位，最前面那個 0 被截斷掉了。而 16'H3AB 是十六個位元，儘管只寫了三個十六進位數字 — 值被零延伸成 0000_0011_1010_1011。サイズはビットで数える。ここが最もよく読み違えられる。8 進の 1 桁は 3 ビット、16 進の 1 桁は 4 ビットである。したがって 5'O36 は 5 ビット幅であり、8 進の 36 は名目上 6 ビットを要するにもかかわらずそうなる。答えは 011110 の下位 5 ビット、すなわち 11110 で、先頭の 0 は切り捨てられる。また 16'H3AB は 16 進数字を 3 桁しか書いていないが 16 ビットであり、値はゼロ拡張されて 0000_0011_1010_1011 になる。

4.6 The sizing and extension rules, derived4.6 位寬與延伸規則的推導4.6 サイズ決定と拡張の規則を導く

Three rules cover everything, and the slides' example table is a direct application of all three.三條規則就涵蓋了一切，而投影片的範例表正是這三條規則的直接應用。三つの規則ですべてが尽くされ、スライドの例の表はその三つの直接の適用である。

1. If the literal is narrower than the declared size, extend on the left. Extend with 0 if the leftmost written digit is 0 or 1; extend with x if the leftmost digit is x; extend with z if it is z. (In Verilog-2001, a signed literal sign-extends instead.)如果常數比宣告的位寬窄，就在左側延伸。若最左邊寫出來的數字是 0 或 1，就用 0 延伸；若最左邊是 x，就用 x 延伸；若是 z，就用 z 延伸。（在 Verilog-2001 中，有號常數改為符號延伸。）リテラルが宣言された幅より狭ければ、左側へ拡張する。書かれた最左の桁が 0 か 1 なら 0 で、x なら x で、z なら z で拡張する。（Verilog-2001 では符号付きリテラルは符号拡張になる。）
2. If the literal is wider than the declared size, truncate from the left, discarding the most significant bits. Simulators warn; synthesisers warn; the value silently changes.如果常數比宣告的位寬寬，就從左側截斷，丟掉最高位的那些位元。模擬器會警告、合成器會警告；而值就這樣安靜地變了。リテラルが宣言された幅より広ければ、左から切り詰め、上位ビットを捨てる。シミュレータも合成器も警告を出すが、値は黙って変わる。
3. Every digit must be legal in the stated base. 3'b5 is a syntax error because 5 is not a binary digit — this is one of the few places Verilog actually refuses to guess.每一個數字都必須在所宣告的基底下合法。3'b5 是語法錯誤，因為 5 不是二進位數字 — 這是 Verilog 少數真的拒絕猜測的地方之一。どの桁も、指定した基数で合法でなければならない。3'b5 は構文エラーである。5 は 2 進の数字ではないからだ。Verilog が推測を拒む数少ない場所の一つである。

5. The Three Descriptive Styles5. 三種描述風格5. 三つの記述スタイル

Verilog offers three ways to say the same thing, and the lecture insists on all three because each one teaches something the others hide. Structural description teaches you that a design is a graph of connected objects. RTL description teaches you to think in terms of functions between registers. Behavioral description teaches you that the tool, not you, is responsible for building the gates. In production RTL you will mostly write the middle one, with behavioral always blocks for sequential logic and structural instantiation only for hierarchy — but you must be able to read all three, because synthesis output is pure structure and legacy IP is full of all of them.Verilog 提供三種說同一件事的方式，而這一講堅持三種都要講，因為每一種都教了另外兩種藏起來的東西。結構化描述教你：一個設計是一張由物件連接而成的圖。RTL 描述教你用「暫存器之間的函數」來思考。行為描述教你：負責把閘搭出來的是工具，不是你。在實務 RTL 裡你大多會寫中間那一種，順序邏輯用行為式 always 區塊，結構化實例化則只用在階層上 — 但三種你都必須讀得懂，因為合成的輸出是純結構，而舊 IP 裡三種都滿滿都是。Verilog は同じことを言う方法を三つ用意しており、この講義は三つすべてを扱うことにこだわる。どれもが、他の二つが隠してしまうことを教えるからだ。構造記述は、設計とは接続された対象のグラフであることを教える。RTL 記述は、レジスタ間の関数として考えることを教える。動作記述は、ゲートを組み立てる責任が君ではなくツールにあることを教える。実務の RTL ではたいてい真ん中を書き、順序論理には動作記述の always ブロックを、構造的インスタンス化は階層にだけ使う——が、三つとも読めなければならない。合成の出力は純粋な構造であり、レガシー IP には三つとも溢れているからだ。

5.1 Structural description5.1 結構化描述5.1 構造記述

A structural description is a netlist written by hand. The built-in primitives relevant to this lecture are the multi-input combinational gates: and, nand, or, nor, xor, xnor, plus the single-input buf and not. Their instantiation syntax has one quirk you must internalise:結構化描述就是一份用手寫出來的網表。與本講相關的內建基元是多輸入組合閘：and、nand、or、nor、xor、xnor，再加上單輸入的 buf 與 not。它們的實例化語法有一個你必須內化的怪癖：構造記述とは、手で書いたネットリストである。この講義に関係する組み込みプリミティブは多入力の組合せゲート——and、nand、or、nor、xor、xnor——と、単入力の buf、not である。そのインスタンス化構文には、身体で覚えるべき癖が一つある。

The output is always the first terminal. This is the opposite of the C convention y = f(a,b) you might expect to see mirrored, and it is the opposite of how assign reads. The and, or, xor, nand, nor and xnor primitives accept any number of inputs ≥ 2, so or (y, a, b, c, d); is a four-input OR. buf and not are the mirror image: they take one input, which is last, and may have several outputs before it — not (y1, y2, a); is two inverters both driven by a.輸出永遠是第一個端子。這和你可能期待被沿用的 C 慣例 y = f(a,b) 相反，也和 assign 的讀法相反。and、or、xor、nand、nor、xnor 這些基元接受任意 ≥ 2 個輸入，所以 or (y, a, b, c, d); 是一顆四輸入 OR。buf 與 not 則是鏡像：它們只有一個輸入，而且放在最後，前面可以有好幾個輸出 — not (y1, y2, a); 是兩顆都由 a 驅動的反相器。出力は常に最初の端子である。これは、そのまま引き継がれていそうな C の慣習 y = f(a,b) とは逆であり、assign の読み方とも逆である。and、or、xor、nand、nor、xnor は 2 個以上いくつでも入力を取るので、or (y, a, b, c, d); は 4 入力 OR である。buf と not は鏡像で、入力は一つだけ、しかも最後に置かれ、その前に複数の出力を並べられる。not (y1, y2, a); は、ともに a で駆動される二つのインバータである。

The instance name is optional for primitives and mandatory for module instances. That asymmetry is in the slides' Language Conventions page ("instance of a module must be named") and it appears in the full-adder example, where Add_half M1 (…) is named and or (c_out, w2, w3); is not.實例名稱對基元是選用的，對模組實例則是必要的。這個不對稱寫在投影片的 Language Conventions 那頁（「instance of a module must be named」），而且就出現在全加器範例裡：Add_half M1 (…) 有名字，or (c_out, w2, w3); 沒有。インスタンス名はプリミティブでは省略可、モジュールインスタンスでは必須である。この非対称はスライドの Language Conventions のページ（「instance of a module must be named」）にあり、全加算器の例にそのまま現れる。Add_half M1 (…) には名があり、or (c_out, w2, w3); にはない。

5.2 Continuous assignment, in detail5.2 連續指定的細部5.2 連続代入を詳しく

The RTL style rests on one construct, and the slides' two forms of it are worth separating carefully.RTL 風格建立在一個語法構造上，而投影片給的兩種寫法值得仔細區分開來。RTL スタイルは一つの構文の上に立つ。スライドが示すその二形式は、丁寧に区別しておく価値がある。

module nand2_1 (y, x1, x2);
  input  x1, x2;
  output y;

  assign y = ~(x1 & x2);
endmodule

module nand2_2 (y, x1, x2);
  input  x1, x2;
  output y;
  wire   y = ~(x1 & x2);
endmodule

The second form combines the declaration of the net and its continuous assignment into one statement. It is legal, it means exactly the same thing, and it may appear only once per net (you cannot declare a net twice). It is slightly terse for a complicated expression but very convenient for a one-line intermediate signal.第二種寫法把 net 的宣告和它的連續指定併成一條敘述。它合法，意思完全相同，而且每條 net 只能出現一次（你不能把同一條 net 宣告兩次）。對複雜運算式來說它稍嫌擁擠，但對一行搞定的中間訊號非常方便。二つ目の形式は、ネットの宣言とその連続代入を一文にまとめる。合法であり、意味もまったく同じで、ネット一本につき一度しか書けない（同じネットを二度宣言はできない）。複雑な式にはやや窮屈だが、一行で済む中間信号にはとても便利である。

Four semantic properties of continuous assignment, each with a consequence:連續指定有四個語意性質，每一個都帶出一個後果：連続代入には四つの意味的性質があり、それぞれに帰結がある。

1. The target must be a net. Never a reg. (§3.5.)目標必須是 net。絕不可以是 reg。（§3.5。）代入先はネットでなければならない。reg は不可。（§3.5。）
2. It is a static binding. In the slides' words, "no mechanism to eliminate or alter the binding". There is no construct that disables an assign. Compare this with a procedural assignment, which only takes effect when its block runs.它是靜態繫結。用投影片的話說：「沒有任何機制可以消除或改變這個繫結」。沒有任何語法構造能停用一條 assign。把它和程序指定對照：程序指定只有在它所屬的區塊執行時才生效。それは静的な束縛である。スライドの言葉では「その束縛を取り除いたり変えたりする機構は存在しない」。assign を無効化する構文はない。手続き的代入と対比せよ。あちらは所属ブロックが走るときにだけ効く。
3. It is evaluated whenever any operand on the right changes, and also once at time 0 so the net starts out defined. This is why the fix in Practice 3 works.只要右側任何運算元改變它就被求值，而且在時間 0 也會被求值一次，所以這條 net 一開始就是有定義的。這正是練習 3 那個修法奏效的原因。右辺のどのオペランドが変化しても評価され、さらに時刻 0 でも一度評価される。だからネットは最初から定義されている。練習 3 の直し方が効くのはこのためである。
4. The right-hand side may contain anything that is not procedural — operators, function calls, bit selects, part selects, concatenations, replications, and the conditional operator. It may not contain if, case, or a delay other than an inertial delay specification.右側可以放任何非程序性的東西 — 運算子、函式呼叫、位元選取、部分選取、串接、重複，以及條件運算子。它不能含有 if、case，也不能有慣性延遲規格以外的延遲。右辺には手続き的でないものなら何でも置ける。演算子、関数呼び出し、ビット選択、部分選択、連結、繰り返し、条件演算子。if や case は置けず、慣性遅延指定以外の遅延も置けない。

The conditional operator deserves special note, because it is the workhorse of RTL:條件運算子值得特別提一下，因為它是 RTL 的主力：条件演算子は特筆に値する。RTL の主力だからである。

assign y    = sel ? a : b;                // a 2:1 multiplexer
assign bus  = oe ? data : 8'bz;           // a tri-state driver
assign y4   = s[1] ? (s[0] ? d3 : d2)
                   : (s[0] ? d1 : d0);    // a 4:1 mux as a tree

With four-value operands the conditional operator does something clever: if sel is x or z, the result is computed bit by bit — each bit position where a and b agree keeps that value, and each position where they differ becomes x. So 1'bx ? 4'b1100 : 4'b1010 gives 4'b1xx0, not 4'bxxxx. This is a small piece of X-accuracy that the if statement does not have.面對四值運算元，條件運算子會做一件聰明的事：如果 sel 是 x 或 z，結果是逐位元算出來的 — a 與 b 相同的每個位元位置保留那個值，兩者不同的每個位置則變成 x。所以 1'bx ? 4'b1100 : 4'b1010 得到 4'b1xx0，而不是 4'bxxxx。這是一小塊 if 敘述所沒有的 X 精確度。四値オペランドに対して、条件演算子は気の利いたことをする。sel が x や z のとき、結果はビットごとに計算される。a と b が一致するビット位置はその値を保ち、食い違う位置は x になる。したがって 1'bx ? 4'b1100 : 4'b1010 は 4'bxxxx ではなく 4'b1xx0 になる。if 文が持たないささやかな X 精度である。

5.3 Behavioral description5.3 行為描述5.3 動作記述

A behavioral description puts procedural statements inside an always block. The slides summarise its key features as procedural constructs for conditional, if-else, case and looping operations; arithmetic, logical, bitwise and reduction operators in expressions; and timing control.行為描述把程序敘述放進 always 區塊裡。投影片把它的主要特色歸納為：用於條件、if-else、case 與迴圈操作的程序性語法構造；運算式中的算術、邏輯、位元與縮減運算子；以及時序控制。動作記述は always ブロックの中に手続き文を置く。スライドはその主な特徴を、条件・if-else・case・ループのための手続き構文、式の中の算術／論理／ビット／リダクション演算子、そしてタイミング制御、とまとめている。

The always block has a sensitivity list (the slide calls it the "sensitive list"), which is the set of events that cause the block to run. Three forms matter:always 區塊有一份敏感清單（sensitivity list）（投影片稱為 sensitive list），也就是會讓這個區塊執行的事件集合。有三種形式值得注意：always ブロックは感度リスト（スライドは sensitive list と呼ぶ）を持つ。ブロックを走らせるイベントの集合である。重要な形式は三つある。

always @ (a or b)      // sel is MISSING
  if (sel) y = a;
  else     y = b;

Two further details from the slides. First, always @ (A or B) and always @ (A, B) are identical — the comma form was added in Verilog-2001 and the or keyword here has nothing to do with the OR operator. Second, the slides' algorithmic AND example uses a named block and disable:投影片還有兩個細節。第一，always @ (A or B) 與 always @ (A, B) 完全相同 — 逗號形式是 Verilog-2001 加入的，而這裡的 or 關鍵字和 OR 運算子毫無關係。第二，投影片那個演算法式 AND 的範例用到了具名區塊與 disable：スライドからもう二点。第一に、always @ (A or B) と always @ (A, B) は同一である。カンマ形式は Verilog-2001 で加わったもので、ここの or キーワードは OR 演算子とは何の関係もない。第二に、スライドのアルゴリズム的 AND の例は名前付きブロックと disable を使っている。

always @ (x_in)
  begin: and_loop            // a named block
    y_out = 1;
    for (k = 0; k <= 3; k = k + 1)
      if (x_in[k] == 0)
        begin
          y_out = 0;
          disable and_loop;    // early exit, like C's "break"
        end
  end

disable <block_name> terminates that named block immediately. It is Verilog's break, and it requires the block to be named, which is the only reason and_loop has a label. Many synthesis tools accept disable when it exits a loop with constant bounds, but some do not; it is on the edge of the subset and is best avoided in RTL you intend to ship.disable <block_name> 會立刻終止那個具名區塊。它是 Verilog 的 break，而且要求區塊必須有名字 — 這就是 and_loop 之所以有標籤的唯一理由。許多合成工具在 disable 用來跳出一個有常數邊界的迴圈時會接受它，但有些不接受；它位在可合成子集的邊緣，在你打算交付的 RTL 中最好避開。disable <block_name> はその名前付きブロックを直ちに終了させる。Verilog の break であり、ブロックに名前があることを要求する。and_loop にラベルがある唯一の理由がそれだ。定数境界のループを抜ける用途なら disable を受理する合成ツールは多いが、受理しないものもある。サブセットの縁にある構文であり、出荷する RTL では避けるのが賢い。

5.4 One full adder, three ways5.4 全加器的三種寫法5.4 全加算器を三通りで

module fa_bhv (S, CO, A, B, CI);
  output S, CO;
  input  A, B, CI;
  reg    S, CO;     // required to hold values
                       between events

  always @ (A or B or CI)
    begin
      S  = A ^ B ^ CI;                   // procedural
      CO = A & B | A & CI | B & CI;      // procedural
    end
endmodule

module fa_rtl (S, CO, A, B, CI);
  output S, CO;
  input  A, B, CI;

  assign S  = A ^ B ^ CI;                // continuous
  assign CO = A & B | A & CI | B & CI;   // continuous
endmodule

module full_add (S, CO, A, B, CI);
  output S, CO;
  input  A, B, CI;
  wire   N1, N2, N3;

  or       P1  (CO, N3, N2);
  half_add HA1 (N1, N2, A, B),   // one statement,
           HA2 (S, N3, N1, CI);  // two instances
endmodule

module half_add (S, C, X, Y);
  output S, C;
  input  X, Y;

  xor (S, X, Y);
  and (C, X, Y);
endmodule

Three things to extract from this comparison.從這個比較可以萃取出三件事。この比較から取り出すべきことが三つある。

The comma form. half_add HA1 (…), HA2 (…); is a single instantiation statement that creates two instances. The module name is written once; each instance gets its own name and its own port list, separated by commas, with one semicolon at the end. Students frequently mis-copy this as two statements and then wonder why the second one errors on a missing module name.逗號形式。half_add HA1 (…), HA2 (…); 是一條實例化敘述，卻建立了兩個實例。模組名稱只寫一次；每個實例有自己的名字與自己的埠列，以逗號分隔，最後只有一個分號。學生常常把它誤抄成兩條敘述，然後納悶第二條為什麼會報缺少模組名稱的錯。カンマ形式。half_add HA1 (…), HA2 (…); は一つのインスタンス化文でありながら二つのインスタンスを作る。モジュール名は一度だけ書き、各インスタンスは自分の名前と自分のポートリストを持ち、カンマで区切られ、末尾のセミコロンは一つである。学生はこれを二つの文に書き写し、二つ目がモジュール名なしでエラーになる理由をよく不思議がる。

Declaration order does not matter. In full_add the or primitive that computes CO from N3 and N2 is written before the half adders that produce N2 and N3. This is perfectly fine — concurrency again. The simulator sorts the dependencies out itself.宣告順序無關緊要。在 full_add 裡，那顆由 N3 與 N2 算出 CO 的 or 基元，寫在產生 N2 與 N3 的半加器之前。這完全沒問題 — 又是並行性。模擬器會自己把相依關係理清楚。宣言順序はどうでもよい。full_add では、N3 と N2 から CO を計算する or プリミティブが、N2 と N3 を生む半加算器より前に書かれている。まったく問題ない——再び並行性である。シミュレータが依存関係を自分で整理する。

Why the carry needs an OR and not an XOR. In a full adder built from two half adders, $C_O = (A\oplus B)\,C_I + AB$. The two terms are mutually exclusive — if $AB=1$ then $A \oplus B = 0$ — so they can never both be 1, which means OR and XOR would both work here. The lecture uses OR because it is the cheaper cell and because the Boolean identity $C_O = AB + AC_I + BC_I$ is the one in the textbook. Knowing that the terms are disjoint is what lets you prove the two-half-adder construction equals the three-term majority function; it is a standard exam question.為什麼進位需要 OR 而不是 XOR。在由兩個半加器搭成的全加器中，$C_O = (A\oplus B)\,C_I + AB$。這兩項是互斥的 — 若 $AB=1$ 則 $A \oplus B = 0$ — 所以它們不可能同時為 1，這表示這裡用 OR 或 XOR 都行。本講用 OR，是因為它是比較便宜的 cell，也因為教科書上的布林恆等式寫的是 $C_O = AB + AC_I + BC_I$。正因為知道這兩項互斥，你才能證明兩個半加器的構造等於三項的多數函數；這是標準考題。なぜキャリーには XOR ではなく OR が要るのか。半加算器二つで組んだ全加算器では $C_O = (A\oplus B)\,C_I + AB$ である。二つの項は互いに排反で、$AB=1$ なら $A \oplus B = 0$ だから、両方が 1 になることはない。つまりここでは OR でも XOR でも動く。講義が OR を使うのは、そちらが安いセルであり、教科書のブール恒等式が $C_O = AB + AC_I + BC_I$ だからである。二項が排反だと知っていることが、半加算器二つの構成が三項の多数決関数に等しいことの証明を可能にする。定番の試験問題だ。

5.5 The half adder in detail5.5 半加器細部解析5.5 半加算器を詳しく

The lecture's half adder is a small enough circuit to look at every level simultaneously. The schematic: a and b feed an XOR producing sum, and a NAND producing an intermediate c_out_bar, which an inverter turns into c_out.本講的半加器小到可以同時從每一個層次來看。電路圖是：a 與 b 餵進一顆 XOR 產生 sum，同時餵進一顆 NAND 產生中間訊號 c_out_bar，再由一顆反相器把它變成 c_out。この講義の半加算器は、すべての階層を同時に眺められるほど小さい。回路図はこうだ。a と b が XOR に入って sum を生み、同時に NAND に入って中間信号 c_out_bar を生み、それをインバータが c_out に変える。

module Add_half (sum, c_out, a, b);   // name, ports
  input  a, b;                        // port modes
  output sum, c_out;
  wire   c_out_bar;                   // internal signal

  xor  (sum, a, b);                   // primitives
  nand (c_out_bar, a, b);
  not  (c_out, c_out_bar);
endmodule

module Add_half (sum, c_out, a, b);
  input  a, b;
  output sum, c_out;
  reg    sum, c_out;

  always @ (a or b)
    begin
      sum   = a ^ b;     // exclusive or
      c_out = a & b;     // and
    end
endmodule

module add_half (sum, c_out, a, b);
  input  a, b;
  output sum, c_out;

  assign {c_out, sum} = a + b;   // concatenation as an assignment target
endmodule

This last one repays study. a and b are 1-bit, so a + b is an addition whose natural result range is 0 to 2 — two bits. The left-hand side {c_out, sum} is a concatenation of two 1-bit nets, forming a 2-bit target with c_out as the more significant bit. Verilog's expression-width rule then sizes the addition to 2 bits, so the carry lands in c_out instead of vanishing. Change the left side to just sum and the addition is done in 1 bit, 1 + 1 gives 0, and the carry is silently lost. The width of the target determines the width of the arithmetic. Internalise this now; it is the root cause of more silent functional bugs than any other feature of the language.最後這一種值得細讀。a 與 b 都是 1 位元，所以 a + b 的自然結果範圍是 0 到 2 — 兩個位元。左側的 {c_out, sum} 是兩條 1 位元 net 的串接，構成一個 2 位元的目標，其中 c_out 是較高位。於是 Verilog 的運算式位寬規則把這個加法定成 2 位元，進位就落進 c_out 而不會消失。把左側改成只有 sum，加法就以 1 位元進行，1 + 1 得到 0，進位安靜地不見了。目標的位寬決定算術的位寬。現在就把這句話內化；它是這個語言中造成最多安靜功能臭蟲的根源，沒有之一。最後のものは精読に値する。a と b は 1 ビットなので、a + b の自然な結果の範囲は 0 から 2——2 ビットである。左辺の {c_out, sum} は 1 ビットのネット二本の連結で、c_out を上位とする 2 ビットの代入先を作る。すると Verilog の式幅規則が加算を 2 ビットに決めるので、キャリーは消えずに c_out へ落ちる。左辺を sum だけにすれば加算は 1 ビットで行われ、1 + 1 は 0 になり、キャリーは黙って失われる。代入先の幅が算術の幅を決める。いま身体に入れておけ。この言語のどの機能より多くの、静かな機能バグの根源である。

The same idiom scales. For $n$-bit operands:同樣的慣用寫法可以放大。對 $n$ 位元運算元：同じ書き方はそのまま拡張できる。$n$ ビットのオペランドに対しては：

module adder_n #(parameter N = 16) (sum, c_out, a, b, c_in);
  input  [N-1:0] a, b;
  input          c_in;
  output [N-1:0] sum;
  output         c_out;

  assign {c_out, sum} = a + b + c_in;   // N+1 bit target → N+1 bit addition
endmodule

This is the adder you should write in practice: one line, no carry chain to get wrong, and the synthesiser is free to choose a ripple-carry, carry-select, carry-look-ahead or parallel-prefix implementation according to the timing constraint you gave it. Section 7 builds the same function structurally from 16 full adders, which is instructive and also strictly worse hardware — writing out the ripple-carry structure by hand forbids the tool from choosing anything faster.這才是你實務上該寫的加法器：一行、沒有會寫錯的進位鏈，而且合成器可以依你給的時序限制自由選擇漣波進位、進位選擇、超前進位或並行前綴的實作。第 7 節會用 16 顆全加器把同一個功能結構化地搭出來，那很有教學意義，但也是嚴格意義上更差的硬體 — 把漣波進位結構親手寫出來，等於禁止工具挑選任何更快的做法。実務で書くべき加算器はこれである。一行で済み、間違えるキャリーチェーンもなく、与えたタイミング制約に応じて合成器がリップルキャリー、キャリーセレクト、キャリー先見、並列プレフィックスのどれでも自由に選べる。第 7 節は同じ機能を全加算器 16 個で構造的に組み立てる。教育的ではあるが、厳密に劣るハードウェアでもある。リップルキャリー構造を手書きすることは、より速い実装を選ぶことをツールに禁じることだからだ。

5.6 Reduction, bitwise, and the loop5.6 縮減、位元運算與迴圈5.6 リダクション・ビット演算・ループ

The slides show a 4-input AND three ways, which is the cleanest demonstration of the style spectrum in the whole lecture.投影片用三種寫法呈現一顆四輸入 AND，這是整講中對風格光譜最乾淨的一次示範。スライドは 4 入力 AND を三通りで示す。講義全体を通じて、スタイルのスペクトルを最も明快に見せる場面である。

module and4_rtl (y_out, x_in);
  input  [3:0] x_in;
  output       y_out;

  assign y_out = & x_in;      // reduction AND
  // alternative, bitwise:
  // assign y_out = x_in[3] & x_in[2]
  //              & x_in[1] & x_in[0];
endmodule

module and4_alg (y_out, x_in);
  input  [3:0] x_in;
  output       y_out;
  reg          y_out;
  integer      k;

  always @ (x_in)
    begin: and_loop
      y_out = 1;
      for (k = 0; k <= 3; k = k + 1)
        if (x_in[k] == 0)
          begin
            y_out = 0;
            disable and_loop;
          end
    end
endmodule

The crucial distinction is between the unary reduction operator and the binary bitwise operator, which are spelled with the same character.關鍵的區分在於單元縮減運算子與二元位元運算子，兩者用同一個字元書寫。決定的な区別は単項リダクション演算子と二項ビット演算子の間にあり、両者は同じ文字で書かれる。

The parser distinguishes the first two by counting operands. The third, &&, is a different token entirely and a different operation: 4'b0010 & 4'b0001 is 4'b0000, while 4'b0010 && 4'b0001 is 1'b1, because both operands are non-zero. Mixing these up gives code that is correct for 1-bit signals and wrong the moment someone widens a bus — a classic maintenance bug. The complete reduction family is & (AND), ~& (NAND), | (OR), ~| (NOR), ^ (XOR, i.e. odd parity), ~^ or ^~ (XNOR, even parity). Reduction XOR is the idiomatic way to compute a parity bit: assign parity = ^ data;.剖析器靠數運算元個數來區分前兩者。第三個 && 完全是另一個記號、另一種運算：4'b0010 & 4'b0001 是 4'b0000，而 4'b0010 && 4'b0001 是 1'b1，因為兩個運算元都非零。把它們搞混，寫出來的程式碼對 1 位元訊號是對的，而在有人把匯流排加寬的那一刻就錯了 — 經典的維護期臭蟲。完整的縮減家族是 &（AND）、~&（NAND）、|（OR）、~|（NOR）、^（XOR，也就是奇同位）、~^ 或 ^~（XNOR，偶同位）。縮減 XOR 是算同位位元的慣用寫法：assign parity = ^ data;。パーサは最初の二つをオペランド数で区別する。三つ目の && はまったく別のトークンであり別の演算である。4'b0010 & 4'b0001 は 4'b0000 だが、4'b0010 && 4'b0001 は両辺とも非ゼロなので 1'b1 になる。これを取り違えたコードは 1 ビット信号では正しく、誰かがバスを広げた瞬間に誤る——典型的な保守バグだ。リダクションの一族は &（AND）、~&（NAND）、|（OR）、~|（NOR）、^（XOR、奇パリティ）、~^ または ^~（XNOR、偶パリティ）である。パリティビットの計算にはリダクション XOR が慣用である。assign parity = ^ data;。

All three descriptions of and4 synthesise to the same thing: a 4-input AND, probably realised as a NAND4 plus an inverter, or as two NAND2s and a NOR2, depending on the library. But they are not equally good source code. The reduction form is one token and obviously correct. The bitwise form is explicit and easy to mistype (x_in[1] written twice is a bug the compiler cannot see). The loop form is twelve lines, uses a construct on the edge of the synthesisable subset, and would still be twelve lines if the vector were 64 bits wide — which is its only genuine advantage, and one that a parameterised reduction does not need.and4 的三種描述合成出來是同一個東西：一顆四輸入 AND，大概會實現成一顆 NAND4 加一顆反相器，或兩顆 NAND2 加一顆 NOR2，視函式庫而定。但它們作為原始碼並不一樣好。縮減形式只有一個記號，而且明擺著是對的。位元形式很明確，也很容易打錯（把 x_in[1] 寫兩次，是編譯器看不出來的臭蟲）。迴圈形式有十二行，用到位於可合成子集邊緣的語法，而且就算向量寬 64 位元它還是十二行 — 那是它唯一真正的優勢，而這個優勢在參數化的縮減寫法面前根本不需要。and4 の三つの記述は同じものに合成される。4 入力 AND であり、ライブラリ次第で NAND4 とインバータ、あるいは NAND2 二つと NOR2 として実現されるだろう。しかしソースコードとしての出来は同じではない。リダクション形式はトークン一つで、見るからに正しい。ビット形式は明示的だが打ち間違えやすい（x_in[1] を二度書く誤りはコンパイラに見えない）。ループ形式は十二行あり、合成可能サブセットの縁にある構文を使い、ベクタが 64 ビットでもやはり十二行である——それが唯一の本当の利点だが、パラメータ化したリダクションにはその利点すら要らない。

assign y = ((a ^ b) & c) | (~a & ~b);

module f_str (y, a, b, c);
  input  a, b, c;
  output y;
  wire   t1, t2, t3;

  xor G1 (t1, a, b);       // a ^ b
  and G2 (t2, t1, c);      // (a^b) & c
  nor G3 (t3, a, b);       // ~a & ~b
  or  G4 (y, t2, t3);
endmodule

reg y;
always @ (*)               // or @(a or b or c)
  y = ((a ^ b) & c) | (~a & ~b);

6. Case Study: The 2-Bit Comparator6. 案例研究：二位元比較器6. ケーススタディ：2 ビット比較器

The comparator is the lecture's set-piece, and it earns its place because it is the smallest circuit for which the three styles produce visibly different source code and identical hardware. Work through it slowly; almost every exam question about Lecture 1 is a variation on it.比較器是本講的重頭戲，而它之所以配得上這個位置，是因為它是三種風格會產生明顯不同的原始碼、卻產生相同硬體的最小電路。請慢慢讀過去；幾乎每一道關於第 1 講的考題都是它的變形。比較器はこの講義の目玉であり、その地位にふさわしい。三つのスタイルが目に見えて異なるソースを生みながら同一のハードウェアを生む、最小の回路だからである。ゆっくり読み通すこと。第 1 講に関する試験問題のほとんどはこれの変形である。

6.1 Specification6.1 規格6.1 仕様

Compare two 2-bit unsigned numbers $A = \{A_1, A_0\}$ and $B = \{B_1, B_0\}$ and produce three outputs: A_lt_B ($A < B$), A_gt_B ($A > B$) and A_eq_B ($A = B$). The block has four inputs and three outputs, so the truth table has 16 rows and the three outputs are mutually exclusive and jointly exhaustive — exactly one of them is 1 in every row. That property is not an accident of the specification; it is a theorem about a total order, and it is what makes the structural implementation in §6.3 possible.比較兩個 2 位元無號數 $A = \{A_1, A_0\}$ 與 $B = \{B_1, B_0\}$，產生三個輸出：A_lt_B（$A < B$）、A_gt_B（$A > B$）與 A_eq_B（$A = B$）。這個區塊有四個輸入、三個輸出，所以真值表有 16 列，而三個輸出彼此互斥且聯合窮盡 — 每一列中恰好有一個是 1。那個性質不是規格上的偶然；它是關於全序的一條定理，也正是 §6.3 的結構化實作之所以可行的原因。2 ビットの符号なし数 $A = \{A_1, A_0\}$ と $B = \{B_1, B_0\}$ を比較し、三つの出力 A_lt_B（$A < B$）、A_gt_B（$A > B$）、A_eq_B（$A = B$）を出す。入力四つ、出力三つなので真理値表は 16 行であり、三つの出力は互いに排反かつ全体を尽くす——どの行でもちょうど一つだけが 1 になる。この性質は仕様の偶然ではない。全順序についての定理であり、§6.3 の構造的実装を可能にしているものである。

6.2 Deriving the equations6.2 推導邏輯式6.2 論理式の導出

You can read the equations off a K-map, but the structural derivation is more memorable and generalises to any width.你可以從卡諾圖上把式子讀出來，但結構式的推導更好記，而且能推廣到任意位寬。カルノー図から式を読み取ってもよいが、構造的に導くほうが記憶に残り、任意の幅へ一般化できる。

Note the symmetry: A_gt_B is A_lt_B with $A$ and $B$ swapped, exactly as you would expect from $A > B \iff B < A$. And A_eq_B is the sum of the four minterms where $A$ and $B$ match, which factors beautifully:注意這個對稱性：A_gt_B 就是把 A_lt_B 裡的 $A$ 與 $B$ 對調，正如你從 $A > B \iff B < A$ 所預期的。而 A_eq_B 是 $A$ 與 $B$ 相符的那四個最小項之和，它可以漂亮地因式分解：対称性に注意せよ。A_gt_B は A_lt_B の $A$ と $B$ を入れ替えたものであり、$A > B \iff B < A$ から予想されるとおりである。そして A_eq_B は $A$ と $B$ が一致する四つの最小項の和であり、見事に因数分解できる。

That is the form the structural implementation uses — two XNOR gates and an AND — and it is linear in the word width, whereas the four-minterm sum is exponential. For a 32-bit comparator the minterm form has $2^{32}$ terms and the XNOR form has 32 gates. Finding a factorisation like this is exactly what a synthesis tool does automatically, and seeing by hand how much it buys you is the point of the exercise.那正是結構化實作所採用的形式 — 兩顆 XNOR 加一顆 AND — 而且它對字長是線性的，而四個最小項的和則是指數的。對一個 32 位元比較器，最小項形式有 $2^{32}$ 項，XNOR 形式則只有 32 顆閘。找到這樣一個因式分解，正是合成工具自動在做的事；親手看一次它省下多少，就是這個練習的意義。それが構造的実装の採る形——XNOR 二つと AND 一つ——であり、語長に対して線形である。一方、四つの最小項の和は指数的だ。32 ビット比較器なら最小項形は $2^{32}$ 項、XNOR 形は 32 ゲートである。こうした因数分解を見つけるのはまさに合成ツールが自動で行うことであり、それがどれだけ得かを手で確かめることがこの演習の眼目である。

6.3 Type 1 — structural description6.3 型式 1 — 結構化描述6.3 タイプ 1 — 構造記述

module compare_2_str (A_lt_B, A_gt_B, A_eq_B, A0, A1, B0, B1);
  input  A0, A1, B0, B1;
  output A_lt_B, A_gt_B, A_eq_B;
  wire   w1, w2, w3, w4, w5, w6, w7;

  or   (A_lt_B, w1, w2, w3);          // sum of the three lt terms
  nor  (A_gt_B, A_lt_B, A_eq_B);      // neither less nor equal
  and  (A_eq_B, w4, w5);              // (A1 == B1) AND (A0 == B0)
  and  (w1, w6, B1);                  // ~A1 · B1
  and  (w2, w6, w7, B0);              // ~A1 · ~A0 · B0
  and  (w3, w7, B0, B1);              // ~A0 · B1 · B0
  not  (w6, A1);                      // w6 = ~A1
  not  (w7, A0);                      // w7 = ~A0
  xnor (w4, A1, B1);                  // A1 == B1
  xnor (w5, A0, B0);                  // A0 == B0
endmodule

Three observations that students regularly miss.三個學生經常漏看的觀察。学生が決まって見落とす三点。

The output-first rule again. In and (w2, w6, w7, B0); the first terminal w2 is the output and the remaining three are inputs. Read any of these lines right-to-left and you get the wrong circuit.又是輸出在前的規則。在 and (w2, w6, w7, B0); 裡，第一個端子 w2 是輸出，其餘三個是輸入。把這幾行裡的任何一行由右往左讀，你得到的就是錯的電路。またしても出力優先の規則。and (w2, w6, w7, B0); では最初の端子 w2 が出力で、残りの三つが入力である。この手の行を右から左に読めば、別の回路ができあがる。

A_gt_B costs one gate, not three. Instead of building the three-term sum-of-products for greater-than, the design exploits mutual exclusivity: exactly one of the three outputs is 1, so $gt = \overline{lt + eq}$, which is a single NOR. This is a genuine optimisation — it replaces one NOT, three ANDs and one OR with one NOR — and it is the kind of thing a human notices from the specification and a synthesiser notices from the truth table. They arrive at the same place by different routes.A_gt_B 只花一顆閘，不是三顆。這個設計沒有替「大於」搭出三項的積之和，而是利用互斥性：三個輸出中恰好有一個是 1，所以 $gt = \overline{lt + eq}$，就是單單一顆 NOR。這是一個貨真價實的最佳化 — 它用一顆 NOR 取代了一顆 NOT、三顆 AND 和一顆 OR — 而且是人從規格看出來、合成器從真值表看出來的那種東西。兩者由不同路徑抵達同一個地方。A_gt_B はゲート三つではなく一つで済む。この設計は「より大きい」に三項の積和を組むのではなく、排反性を利用する。三つの出力のうちちょうど一つが 1 なので $gt = \overline{lt + eq}$、すなわち NOR 一つである。これは本物の最適化であり——NOT 一つ、AND 三つ、OR 一つを NOR 一つで置き換える——人間が仕様から気づき、合成器が真理値表から気づく類のものだ。両者は別の道で同じ場所に着く。

The module's ports are declared in the order A0, A1, B0, B1, while the RTL version in §6.4 declares them A1, A0, B1, B0. If you instantiate both with the same positional port list, one of them will compare the wrong bits and you will see a comparator that is right for 00 and 11 and wrong for 01 and 10. Nothing in the language warns you. This is the single strongest argument for named port binding (§7.2).這個模組的埠是以 A0, A1, B0, B1 的順序宣告的，而 §6.4 的 RTL 版本宣告的順序是 A1, A0, B1, B0。如果你用同一份位置式埠列去實例化兩者，其中一個就會比較到錯的位元，而你會看到一個對 00 與 11 正確、對 01 與 10 錯誤的比較器。語言裡沒有任何東西會警告你。這是支持具名埠連接（§7.2）最強的一個論證。このモジュールのポートは A0, A1, B0, B1 の順に宣言されているのに対し、§6.4 の RTL 版は A1, A0, B1, B0 の順で宣言する。同じ位置指定ポートリストで両方をインスタンス化すれば、片方は誤ったビットを比較し、00 と 11 では正しく 01 と 10 では誤る比較器ができあがる。言語は何も警告しない。これが名前指定ポート接続（§7.2）を支持する最強の論拠である。

6.4 Type 2 — RTL description6.4 型式 2 — RTL 描述6.4 タイプ 2 — RTL 記述

module compare_2a (A_lt_B, A_gt_B, A_eq_B, A1, A0, B1, B0);
  input  A1, A0, B1, B0;
  output A_lt_B, A_gt_B, A_eq_B;

  assign A_lt_B = (~A1) & B1 | (~A1) & (~A0) & B0 | (~A0) & B1 & B0;

  assign A_gt_B = A1 & (~B1) | A0 & (~B1) & (~B0) | A1 & A0 & (~B0);

  assign A_eq_B = (~A1) & (~A0) & (~B1) & (~B0) | (~A1) & A0 & (~B1) & B0
                | A1 & A0 & B1 & B0 | A1 & (~A0) & B1 & (~B0);
endmodule

This is a direct transcription of the three equations, and it relies on Verilog's operator precedence: & binds tighter than |, so a & b | c & d parses as (a & b) | (c & d), the sum-of-products reading you want. The parenthesised (~A1) is not necessary — ~ binds tighter than everything — but it is good practice, because Verilog's precedence table has 15 levels and nobody remembers all of them. The one you genuinely must know is that the comparison and equality operators bind more loosely than the bitwise operators, which is why if (a & b == c) means if (a & (b == c)) and almost never what the author intended.這是三條方程式的直接轉寫，而它依賴 Verilog 的運算子優先順序：& 比 | 結合得更緊，所以 a & b | c & d 會剖析成 (a & b) | (c & d)，也就是你要的積之和讀法。加括號的 (~A1) 其實不必要 — ~ 比任何東西都結合得緊 — 但這是好習慣，因為 Verilog 的優先順序表有 15 層，沒有人記得住全部。你真正必須記住的那一條是：比較與等值運算子比位元運算子結合得更鬆，這就是為什麼 if (a & b == c) 的意思是 if (a & (b == c))，而那幾乎從來不是作者想要的。これは三つの式をそのまま書き写したもので、Verilog の演算子優先順位に依存している。& は | より強く結合するので、a & b | c & d は (a & b) | (c & d) と解析され、望みどおりの積和の読みになる。括弧付きの (~A1) は不要だが——~ は何よりも強く結合する——良い習慣である。Verilog の優先順位表は 15 段あり、全部を覚えている者はいない。本当に覚えるべき一点は、比較演算子と等価演算子はビット演算子より弱く結合することだ。だから if (a & b == c) は if (a & (b == c)) を意味し、それは書き手の意図とまず一致しない。

6.5 Type 3 — behavioral description6.5 型式 3 — 行為描述6.5 タイプ 3 — 動作記述

module compare_2b (A_lt_B, A_gt_B, A_eq_B,
                   A1, A0, B1, B0);
  input  A1, A0, B1, B0;
  output A_lt_B, A_gt_B, A_eq_B;

  assign A_lt_B = ({A1, A0} <  {B1, B0});
  assign A_gt_B = ({A1, A0} >  {B1, B0});
  assign A_eq_B = ({A1, A0} == {B1, B0});
endmodule

module compare_2ca (A_lt_B, A_gt_B, A_eq_B, A, B);
  input  [1:0] A, B;
  output       A_lt_B, A_gt_B, A_eq_B;

  assign A_lt_B = (A <  B);
  assign A_gt_B = (A >  B);
  assign A_eq_B = (A == B);
endmodule

These are where the abstraction finally pays. Approach 1 keeps the scalar interface of the slides' earlier versions but builds a 2-bit vector on the fly with the concatenation operator { } and hands it to the relational operators. Approach 2 declares the ports as vectors in the first place, which is what you would actually do.抽象到這裡終於開始回本。做法 1 保留了投影片先前版本的純量介面，但用串接運算子 { } 當場組出一個 2 位元向量，交給關係運算子處理。做法 2 則一開始就把埠宣告成向量，那才是你實務上真正會做的。抽象がようやく元を取るのがここである。方法 1 はスライドの旧版と同じスカラなインタフェースを保ちつつ、連結演算子 { } でその場で 2 ビットのベクタを組み、関係演算子に渡す。方法 2 は最初からポートをベクタとして宣言する。実務で実際にそうするのはこちらだ。

Both are four-line modules that are completely width-independent in spirit. To make compare_2ca an 8-bit comparator you change exactly one character set: input [7:0] A, B;. Nothing else moves. Compare that with the structural version, where going to 8 bits means re-deriving the Boolean equations, drawing a new schematic, and writing about forty gate instantiations, every one of which is an opportunity for a typo. This is the entire argument for RTL as a design methodology, compressed into one example.兩者都是精神上完全與位寬無關的四行模組。要把 compare_2ca 變成 8 位元比較器，你只需要改動一組字元：input [7:0] A, B;。其他什麼都不必動。拿它和結構化版本比較：要做成 8 位元，意味著重新推導布林方程式、畫一張新的電路圖、寫大約四十個閘實例化，而每一個都是一次打錯字的機會。這就是「以 RTL 作為設計方法論」的全部論證，壓縮成一個例子。どちらも精神において完全に幅非依存な四行のモジュールである。compare_2ca を 8 ビット比較器にするには、変えるのは一組の文字だけだ。input [7:0] A, B;。ほかは何も動かない。構造記述版と比べよ。8 ビットにするとは、ブール式を導き直し、新しい回路図を描き、四十ほどのゲートをインスタンス化することであり、その一つ一つが誤記の機会である。設計方法論としての RTL を支持する論証のすべてが、この一例に凝縮されている。

Also note that A and B are declared with input [1:0], i.e. unsigned. The relational operators on unsigned operands do an unsigned comparison, so 2'b11 > 2'b01 is true (3 > 1). If you wanted two's-complement comparison you would need input signed [1:0] (Verilog-2001) and then 2'b11 is $-1$ and the same comparison is false. Signedness is a declaration property, not a property of the operator, and getting it wrong in a DSP datapath produces a filter that works for small signals and explodes for large ones.另外注意 A 與 B 是用 input [1:0] 宣告的，也就是無號。關係運算子對無號運算元做的是無號比較，所以 2'b11 > 2'b01 為真（3 > 1）。如果你要的是二補數比較，就必須寫 input signed [1:0]（Verilog-2001），那時 2'b11 是 $-1$，同樣的比較就為假。有號性是宣告的屬性，不是運算子的屬性；在 DSP 資料路徑裡把它弄錯，會做出一個小訊號正常、大訊號爆掉的濾波器。また A と B が input [1:0]、すなわち符号なしで宣言されている点にも注意。関係演算子は符号なしオペランドには符号なし比較を行うので、2'b11 > 2'b01 は真である（3 > 1）。二の補数の比較が欲しければ input signed [1:0]（Verilog-2001）が必要で、そのとき 2'b11 は $-1$ となり同じ比較は偽になる。符号の有無は宣言の属性であって演算子の属性ではない。DSP のデータパスでこれを誤ると、小信号では動き大信号で破綻するフィルタができる。

6.6 Behavioral with an algorithmic description6.6 以演算法式行為描述改寫6.6 アルゴリズム的な動作記述

module compare_2_algo (A_lt_B, A_gt_B, A_eq_B, A, B);

  input  [1:0] A, B;
  output       A_lt_B, A_gt_B, A_eq_B;
  reg          A_lt_B, A_gt_B, A_eq_B;

  always @ (A or B)         // behavior and event expression
    begin
      A_lt_B = 0;           // default assignments —
      A_gt_B = 0;           // these are what prevent latches
      A_eq_B = 0;
      if      (A == B) A_eq_B = 1;
      else if (A >  B) A_gt_B = 1;
      else             A_lt_B = 1;
    end
endmodule

This is the version that teaches the most, because of those three leading zeros.這個版本教的最多，原因就在開頭那三個 0 的指定。最も多くを教えてくれるのがこの版である。理由は冒頭の三つのゼロ代入にある。

Why are latches a failure mode rather than just an inefficiency? Three reasons, all of which matter in a cell-based flow. A latch is transparent while its enable is high, so a combinational path can propagate through it, which breaks the clean register-to-register timing model that STA assumes and forces you into time-borrowing analysis that is far harder to close. A latch inferred by accident has an enable derived from your if conditions, which is combinational logic acting as a clock — exactly what clock-tree synthesis cannot handle. And a latch is not in the scan chain the way a flip-flop is, so DFT coverage drops. Lecture 6 revisits all of this; for now, the rule is simply: if the synthesis log says "inferred latch", you have a bug.為什麼閂鎖是一種失效模式，而不只是效率差一點？三個理由，在 cell-based 流程裡都很要緊。閂鎖在 enable 為高時是透通的，所以一條組合路徑可以穿過它，這破壞了 STA 所假設的乾淨「暫存器到暫存器」時序模型，逼你走進難收斂許多的 time-borrowing 分析。意外推斷出來的閂鎖，其 enable 是從你的 if 條件推導出來的，也就是一塊當成時脈用的組合邏輯 — 那正是時脈樹合成處理不了的東西。而且閂鎖不像正反器那樣能進掃描鏈，所以 DFT 涵蓋率會掉。第 6 講會再回頭談這一切；現在的規則很單純：如果合成記錄檔說「inferred latch」，你就有臭蟲。なぜラッチは単なる非効率ではなく失敗モードなのか。理由は三つあり、いずれもセルベース・フローで重要である。ラッチはイネーブルが高の間は透過なので、組合せパスがその中を通り抜けられる。これは STA が前提とする清潔なレジスタ間タイミングモデルを壊し、収束がはるかに難しいタイムボローイング解析へ追い込む。事故で推論されたラッチのイネーブルは if の条件から導かれる、すなわちクロックとして働く組合せ論理であり、クロックツリー合成が最も扱えないものだ。さらにラッチはフリップフロップのようにスキャンチェーンに入らないので、DFT カバレッジが落ちる。第 6 講でこれらすべてを再訪する。いまのところ規則は単純だ。合成ログに「inferred latch」と出たら、それはバグである。

Note also the operator > inside the else if. Because A == B was already tested and was false, the else if (A > B) arm and the final else arm together partition the remaining cases. The chain is a priority structure — the synthesiser builds it as cascaded multiplexers, with the first condition closest to the output. Had the three conditions been mutually exclusive and written as a case, the tool would have built a flatter, faster parallel structure. For three conditions the difference is negligible; for a 32-way priority chain it is the difference between meeting timing and not. Lecture 5 covers case versus if-else in detail.另外注意 else if 裡的運算子 >。因為 A == B 已經先被測試過而且為假，else if (A > B) 這一支與最後的 else 這一支合起來就分割了剩下的所有情況。這個鏈是一個優先權結構 — 合成器會把它搭成串接的多工器，第一個條件離輸出最近。如果這三個條件彼此互斥而且寫成 case，工具就會搭出一個比較扁平、比較快的並行結構。三個條件時，差別微不足道；三十二路的優先鏈時，那就是時序過與不過的差別。第 5 講會詳細談 case 與 if-else 的取捨。else if の中の演算子 > にも注意せよ。A == B は既に検査されて偽だったので、else if (A > B) の腕と最後の else の腕が残りの場合を分割する。この連鎖は優先順位構造であり、合成器はこれを縦続したマルチプレクサとして組み、最初の条件を出力にいちばん近く置く。三つの条件が互いに排反でかつ case として書かれていれば、ツールはもっと平たく速い並列構造を組んだだろう。条件が三つなら差は無視できるが、32 方向の優先連鎖ではタイミングが入るか入らないかの差になる。case と if-else の比較は第 5 講で詳しく扱う。

6.7 What synthesis actually produces6.7 合成實際產生什麼6.7 合成が実際に生むもの

The slides show the Design Vision schematic for the comparator: roughly a dozen cells — a handful of inverters, two XNOR-ish gates, several NANDs and NORs, an AOI or two, and output buffers. It looks nothing like any of the four source descriptions. Here is what the tool did, step by step, and it is worth knowing because it explains why "optimising" your RTL by hand is usually wasted effort.投影片展示了這個比較器在 Design Vision 裡的電路圖：大約十來顆 cell — 幾顆反相器、兩顆類 XNOR 的閘、數顆 NAND 與 NOR、一兩顆 AOI，還有輸出緩衝器。它和那四種原始碼描述裡的任何一種都不像。以下是工具一步一步做了什麼，值得知道，因為它解釋了為什麼親手「最佳化」你的 RTL 通常是白費力氣。スライドは比較器の Design Vision 回路図を示す。セルはおよそ十数個——インバータが数個、XNOR 系のゲートが二つ、NAND と NOR がいくつか、AOI が一つ二つ、そして出力バッファ。四つのソース記述のどれにも似ていない。以下はツールが段階ごとに何をしたかであり、知っておく価値がある。RTL を手で「最適化」するのがたいてい徒労である理由を説明してくれるからだ。

1. Elaborate. Read the RTL, resolve parameters, build a technology-independent network. The relational operators <, >, == become generic comparator cells (DesignWare components, in Synopsys terms).展開（elaborate）。讀入 RTL、解析參數、建出一張與製程無關的網路。關係運算子 <、>、== 會變成通用比較器元件（在 Synopsys 的術語裡就是 DesignWare 元件）。エラボレーション。RTL を読み、パラメータを解決し、プロセス非依存のネットワークを構築する。関係演算子 <、>、== は汎用比較器セル（Synopsys の用語では DesignWare コンポーネント）になる。
2. Extract the function. For a block this small, the tool computes the complete truth table over the four inputs — 16 rows, three outputs — and discards your structure entirely. For larger blocks it works on bounded cones of logic rather than the whole thing, but the principle is the same.萃取函數。對這麼小的區塊，工具會算出四個輸入上的完整真值表 — 16 列、三個輸出 — 然後把你的結構整個丟掉。對較大的區塊它會改成處理有界的邏輯錐而不是整塊，但原理一樣。関数の抽出。これほど小さいブロックなら、ツールは四入力に対する完全な真理値表——16 行、出力三つ——を計算し、君の構造をまるごと捨てる。大きなブロックでは全体ではなく有界の論理コーンを対象にするが、原理は同じである。
3. Factor and share. It notices that A_eq_B and A_lt_B share the subexpression $A_1 \odot B_1$ and builds it once. It notices that A_gt_B is the NOR of the other two outputs — whether or not you wrote it that way, because that identity is visible in the truth table.因式分解與共用。它注意到 A_eq_B 與 A_lt_B 共用子運算式 $A_1 \odot B_1$，於是只建一次。它也注意到 A_gt_B 是另外兩個輸出的 NOR — 不管你有沒有那樣寫，因為那個恆等式在真值表上看得見。因数分解と共有。ツールは A_eq_B と A_lt_B が部分式 $A_1 \odot B_1$ を共有していることに気づき、一度だけ作る。また A_gt_B が他の二出力の NOR であることにも気づく——君がそう書いたかどうかに関係なくである。その同一性は真理値表に見えているからだ。
4. Map to cells. Each node is covered by library cells. The tool tries many coverings and keeps the cheapest that meets timing. If the library has an AOI21 cell (AND-OR-INVERT, 2-input AND feeding a 2-input NOR), covering $\overline{ab + c}$ with one cell beats three.映射到 cell。每個節點都被函式庫 cell 覆蓋。工具會嘗試許多種覆蓋方式，留下能滿足時序的最便宜的那一種。如果函式庫裡有 AOI21 cell（AND-OR-INVERT，一顆 2 輸入 AND 餵進一顆 2 輸入 NOR），用一顆 cell 覆蓋 $\overline{ab + c}$ 就勝過用三顆。セルへのマッピング。各節点をライブラリセルで覆う。ツールは多くの覆い方を試し、タイミングを満たす中で最も安いものを残す。ライブラリに AOI21 セル（AND-OR-INVERT、2 入力 AND が 2 入力 NOR を駆動する）があれば、$\overline{ab + c}$ をセル一つで覆うほうが三つより優る。
5. Size and buffer. Cells on the critical path are upsized; cells driving many loads get buffers inserted. The output buffers visible in the slide's schematic are there because the tool assumed an external load.調整尺寸與加緩衝。關鍵路徑上的 cell 會被換成更大的；驅動許多負載的 cell 會被插入緩衝器。投影片電路圖上看得到的那些輸出緩衝器，就是因為工具假設了外部負載才出現的。サイジングとバッファ挿入。クリティカルパス上のセルは大きいものへ置き換えられ、多くの負荷を駆動するセルにはバッファが挿入される。スライドの回路図に見える出力バッファは、ツールが外部負荷を仮定したために置かれたものである。

always @ (*)
  begin
    A_eq_B = (A == B);
    A_gt_B = (A >  B);
    A_lt_B = (A <  B);
  end

7. Module Instantiation and Hierarchy7. 模組實例化與階層7. モジュールのインスタンス化と階層

7.1 The rules of instantiation7.1 實例化的規則7.1 インスタンス化の規則

Hierarchy in Verilog is built by instantiation: writing a child module's name as an item inside a parent module, giving the instance a name, and listing the parent's signals that connect to the child's ports. The slides state four rules; each deserves a sentence of unpacking.Verilog 的階層是靠實例化建立的：把子模組的名稱當成一個項目寫在父模組裡面，給這個實例一個名字，再列出父模組中要連到子模組各埠的訊號。投影片列了四條規則；每一條都值得用一句話展開。Verilog の階層はインスタンス化で築かれる。子モジュールの名前を親モジュールの中の項目として書き、インスタンスに名前を与え、子のポートへつなぐ親側の信号を並べる。スライドは四つの規則を挙げる。どれも一文ずつほどく価値がある。

• Instantiation creates the hierarchy. A module declaration defines a type; an instantiation allocates one copy of that type. Instantiating Add_half four times creates four physically distinct sets of gates on the die. They do not share anything.實例化創造階層。模組宣告定義一個型別；實例化配置該型別的一份複本。把 Add_half 實例化四次，就在晶粒上造出四組物理上各自獨立的閘。它們之間什麼都不共用。インスタンス化が階層を作る。モジュール宣言は型を定義し、インスタンス化はその型のコピーを一つ確保する。Add_half を四回インスタンス化すれば、ダイ上に物理的に別個のゲート群が四組できる。互いに何も共有しない。
• It is accomplished by entering the module name as a module item, with signal identifiers at the ports. Syntax: <module_name> <instance_name> ( <port connections> );做法是把模組名稱當成一個模組項目寫進去，並在埠的位置放上訊號識別字。語法：<module_name> <instance_name> ( <埠連接> );やり方は、モジュール名をモジュール項目として書き、ポートの位置に信号の識別子を置くことである。構文：<module_name> <instance_name> ( <ポート接続> );
• Module instantiation needs a module identifier — that is, the instance must be named. Unlike a gate primitive, you may not write Add_half (w1, w2, a, b);.模組實例化需要一個模組識別字 — 也就是說，實例必須命名。和閘基元不同，你不可以寫 Add_half (w1, w2, a, b);。モジュールのインスタンス化には識別子が要る——つまりインスタンスには名前が必要である。ゲートプリミティブと違い、Add_half (w1, w2, a, b); とは書けない。
• A module is never declared within another module. Declarations are all at file scope.模組絕不會宣告在另一個模組裡面。宣告一律在檔案層級。モジュールが別のモジュールの中で宣言されることはない。宣言はすべてファイルスコープにある。

The rule about naming is more than bookkeeping. Every instance name becomes part of a hierarchical path — tb.dut.M1.HA2.sum — and those paths are how you probe a signal from a testbench, how a waveform viewer labels its tree, how a synthesis constraint targets one block, how a timing report identifies a path, and how an SDF file back-annotates delays after layout. An unnamed instance would have no address in any of those tools. A gate primitive can get away with it because the tool invents a name; a module instance, which may contain thousands of signals, cannot.命名這條規則不只是帳務工作。每個實例名稱都會成為一條階層路徑的一部分 — tb.dut.M1.HA2.sum — 而那些路徑正是你從測試平台探測某條訊號的方式、波形檢視器替它的樹狀圖標名的方式、合成限制鎖定某個區塊的方式、時序報告指認一條路徑的方式，以及 SDF 檔在佈局後反標註延遲的方式。沒有名字的實例，在上述任何一個工具裡都沒有地址。閘基元可以僥倖過關，因為工具會替它發明一個名字；而一個可能含有上千條訊號的模組實例，不行。命名の規則は事務処理以上のものである。各インスタンス名は階層パスの一部になる——tb.dut.M1.HA2.sum——そしてそのパスこそ、テストベンチから信号を覗く方法であり、波形ビューアがツリーにラベルを付ける方法であり、合成制約が特定ブロックを狙う方法であり、タイミング報告がパスを同定する方法であり、SDF ファイルがレイアウト後に遅延をバックアノテートする方法である。名前のないインスタンスは、そのどのツールにおいても住所を持たない。ゲートプリミティブが見逃されるのはツールが名前を発明するからだ。数千本の信号を含みうるモジュールインスタンスでは、そうはいかない。

7.2 Positional versus named binding7.2 位置對應與名稱對應7.2 位置指定と名前指定

module child (a, b, c);
  ...
endmodule

module parent;
  wire u, v, w;

  child m1 (u, v, w);                // by position
  child m2 (.c(w), .a(u), .b(v));    // by name
  child m3 (u, , w);                 // empty port: b unconnected
endmodule

All three instances connect a–u, b–v, c–w (except that m3 leaves b unconnected).三個實例全都把 a–u、b–v、c–w 連在一起（只有 m3 讓 b 懸空未接）。三つのインスタンスはいずれも a–u、b–v、c–w を接続する（ただし m3 は b を未接続にしている）。

Empty ports. Leaving a port unconnected is legal and sometimes correct, but the two directions behave very differently:空埠。把一個埠留著不接是合法的，有時也正確，但兩個方向的行為差很多：未接続のポート。ポートをつながずに残すのは合法で、正しいこともあるが、方向によって振る舞いが大きく違う。

• An unconnected output is harmless. The logic driving it still exists in simulation; in synthesis, the cone of logic that feeds only that output has no observable effect and is removed entirely. If you instantiate a 32-bit multiplier and connect only the low 16 bits of the product, you get a 16-bit-output multiplier's worth of gates and a warning about unconnected output pins. This is usually what you want.未接的輸出無害。驅動它的邏輯在模擬中依然存在；在合成中，只餵給那個輸出的那一塊邏輯錐沒有任何可觀察的效果，於是被整個移除。如果你實例化一顆 32 位元乘法器，卻只接了乘積的低 16 位元，你得到的是相當於一顆 16 位元輸出乘法器的閘數，外加一條輸出腳未接的警告。這通常正是你要的。未接続の出力は無害である。それを駆動する論理はシミュレーションでは依然存在するが、合成ではその出力だけを養う論理コーンは観測可能な効果を持たないのでまるごと削除される。32 ビット乗算器をインスタンス化して積の下位 16 ビットだけをつなげば、16 ビット出力の乗算器相当のゲートと、出力ピン未接続の警告が得られる。たいていはそれが望みどおりである。
• An unconnected input floats at z. Every gate it feeds then produces x unless a controlling value saves it. In synthesis you get a warning and the tool typically ties it to a constant, but which constant is tool-dependent. Never leave an input unconnected by accident; tie it explicitly: .enable(1'b1).未接的輸入浮在 z。它餵給的每一顆閘接著都會產生 x，除非有控制值救了它。在合成中你會得到一條警告，工具通常會把它綁到一個常數，但是哪一個常數則因工具而異。絕對不要不小心讓某個輸入懸空；明確把它綁起來：.enable(1'b1)。未接続の入力は z で浮く。支配値に救われない限り、それが養うゲートはすべて x を出す。合成では警告が出て、ツールはたいてい定数に固定するが、どちらの定数かはツール依存である。入力をうっかり未接続のまま残してはならない。明示的に固定せよ。.enable(1'b1)。

7.3 The full adder from two half adders7.3 用兩個半加器組成全加器7.3 半加算器二つから全加算器を組む

module Add_full (sum, c_out, a, b, c_in);   // parent module
  input  a, b, c_in;
  output c_out, sum;
  wire   w1, w2, w3;

  Add_half M1 (w1, w2, a, b);                 // child module
  Add_half M2 (sum, w3, w1, c_in);            // child module
  or          (c_out, w2, w3);                // primitive instantiation
endmodule

The resulting hierarchy is three levels deep: Add_full contains M1 and M2 (each an Add_half) plus an or; each Add_half contains an xor, a nand and a not. The slide's tree diagram makes the point that nested module instantiation is the mechanism for hierarchical decomposition of a design, and the count is worth noting: one Add_full costs 2 × 3 + 1 = 7 primitive gates.由此得到的階層有三層深：Add_full 含有 M1 與 M2（各是一個 Add_half）加上一顆 or；每個 Add_half 含有一顆 xor、一顆 nand 與一顆 not。投影片的樹狀圖要講的是：巢狀的模組實例化就是設計階層分解的機制，而數量也值得注意：一個 Add_full 要花 2 × 3 + 1 = 7 顆基元閘。こうしてできる階層は三段である。Add_full は M1 と M2（いずれも Add_half）に or を一つ加えたもので、各 Add_half は xor、nand、not を一つずつ含む。スライドのツリー図が言いたいのは、入れ子のモジュール・インスタンス化こそ設計を階層的に分解する機構であるということだ。個数も記しておく価値がある。Add_full 一つは 2 × 3 + 1 = 7 個のプリミティブゲートである。

7.4 The 16-bit ripple-carry adder7.4 16 位元漣波進位加法器7.4 16 ビット・リップルキャリー加算器

The lecture scales the same idea twice. Four Add_full instances make a 4-bit ripple-carry adder; four of those make a 16-bit one.本講把同一個想法放大了兩次。四個 Add_full 實例組成一個 4 位元漣波進位加法器；四個那樣的區塊再組成一個 16 位元的。講義は同じ考えを二度スケールさせる。Add_full 四つで 4 ビットのリップルキャリー加算器を作り、それを四つ並べて 16 ビットにする。

module Add_rca_16 (sum, c_out, a, b, c_in);
  output [15:0] sum;
  output        c_out;
  input  [15:0] a, b;
  input         c_in;
  wire          c_in4, c_in8, c_in12;

  Add_rca_4 M1 (sum[3:0],   c_in4,
                a[3:0],   b[3:0],   c_in);
  Add_rca_4 M2 (sum[7:4],   c_in8,
                a[7:4],   b[7:4],   c_in4);
  Add_rca_4 M3 (sum[11:8],  c_in12,
                a[11:8],  b[11:8],  c_in8);
  Add_rca_4 M4 (sum[15:12], c_out,
                a[15:12], b[15:12], c_in12);
endmodule

module Add_rca_4 (sum, c_out, a, b, c_in);
  output [3:0] sum;
  output       c_out;
  input  [3:0] a, b;
  input        c_in;
  wire         c_in2, c_in3, c_in4;

  Add_full G1 (sum[0], c_in2, a[0], b[0], c_in);
  Add_full G2 (sum[1], c_in3, a[1], b[1], c_in2);
  Add_full G3 (sum[2], c_in4, a[2], b[2], c_in3);
  Add_full G4 (sum[3], c_out, a[3], b[3], c_in4);
endmodule

Two things to notice in the source. Part selects as port connections: a[7:4] is a 4-bit slice of a 16-bit net, and connecting it to a 4-bit port is perfectly legal — port connections are made by width, not by identity. The naming of the carry nets follows the bit index of the stage they feed, so c_in4 is the carry into bit 4. That is a good convention; the alternative, c1, c2, c3, gives you no clue which stage a timing report is talking about.原始碼裡有兩件事要注意。把部分選取當作埠連接：a[7:4] 是一條 16 位元 net 的 4 位元切片，把它接到一個 4 位元的埠完全合法 — 埠連接是按位寬配對的，不是按身分。進位 net 的命名跟著它所餵入的那一級的位元索引走，所以 c_in4 是進入位元 4 的進位。那是好慣例；另一種寫法 c1, c2, c3 完全無法讓你從時序報告看出它在講哪一級。ソースで注意すべき点が二つある。部分選択をポート接続に使うこと：a[7:4] は 16 ビットのネットの 4 ビットの切片であり、それを 4 ビットのポートにつなぐのは完全に合法である。ポート接続は同一性ではなく幅で行われる。キャリー・ネットの命名は、それが入る段のビット番号に従う。だから c_in4 はビット 4 へ入るキャリーである。良い慣習だ。もう一方の c1, c2, c3 では、タイミング報告がどの段の話をしているのか手がかりがない。

7.5 Where the delay comes from7.5 延遲是從哪裡來的7.5 遅延はどこから来るのか

The ripple-carry adder is the lecture's vehicle for its first real timing argument, and it is worth doing with actual numbers rather than hand-waving.漣波進位加法器是本講第一個真正的時序論證所用的載具，而它值得用實際數字來做，而不是揮揮手帶過。リップルキャリー加算器は、この講義で初めて本格的なタイミング議論を行うための題材である。手振りで済ませず、実際の数字でやる価値がある。

Assume each primitive gate has a unit delay $t_g$. Inside one Add_half, the path from an input to sum is one XOR, i.e. $t_g$; the path from an input to c_out is a NAND then a NOT, i.e. $2t_g$. Now trace the carry path through one Add_full, which is the path that matters, because it is the one that chains:假設每顆基元閘有單位延遲 $t_g$。在一個 Add_half 內部，從輸入到 sum 的路徑只有一顆 XOR，也就是 $t_g$；從輸入到 c_out 的路徑是一顆 NAND 接一顆 NOT，也就是 $2t_g$。現在追蹤穿過一個 Add_full 的進位路徑，那才是要緊的路徑，因為它是會串起來的那一條：各プリミティブゲートの遅延を単位 $t_g$ とする。Add_half 一つの中で、入力から sum までの経路は XOR 一つ、すなわち $t_g$。入力から c_out までは NAND と NOT、すなわち $2t_g$ である。では Add_full 一つを貫くキャリー経路を追おう。連鎖するのはこの経路なので、重要なのはこちらである。

The structure of that equation is the thing to remember. Ripple-carry delay is $O(n)$: double the word width, double the delay. At 16 bits and a 50 ps gate that is about 2.4 ns, so the adder alone eats a 400 MHz clock period. At 64 bits it is 9.6 ns and nothing works. This linear growth is why carry-select, carry-skip, carry-look-ahead and parallel-prefix (Kogge–Stone, Brent–Kung) adders exist, all of which trade area for an $O(\log n)$ delay. It is also why the one-line assign {c_out, sum} = a + b; of §5.5 is better engineering than the structural version: it lets the synthesiser pick the architecture that meets your constraint, instead of freezing the slowest one into the source.該記住的是那條方程式的結構。漣波進位延遲是 $O(n)$：字長加倍，延遲就加倍。在 16 位元、每顆閘 50 ps 的條件下大約是 2.4 ns，光一顆加法器就吃掉一個 400 MHz 的時脈週期。到 64 位元就是 9.6 ns，什麼都動不了。這種線性成長正是進位選擇、進位跳躍、超前進位，以及並行前綴（Kogge–Stone、Brent–Kung）加法器存在的理由，它們全都以面積換取 $O(\log n)$ 的延遲。這也是為什麼 §5.5 那一行 assign {c_out, sum} = a + b; 比結構化版本更好的工程：它讓合成器去挑一個滿足你限制的架構，而不是把最慢的那一個凍結進原始碼裡。覚えるべきはこの式の構造である。リップルキャリー遅延は $O(n)$。語長を倍にすれば遅延も倍になる。16 ビットでゲート 50 ps なら約 2.4 ns であり、加算器だけで 400 MHz のクロック周期を食い尽くす。64 ビットなら 9.6 ns で、何も動かない。この線形増加こそ、キャリーセレクト、キャリースキップ、キャリー先見、並列プレフィックス（Kogge–Stone、Brent–Kung）加算器が存在する理由であり、いずれも面積と引き換えに $O(\log n)$ の遅延を得る。§5.5 の一行 assign {c_out, sum} = a + b; が構造記述版より良い工学である理由でもある。制約を満たすアーキテクチャを合成器に選ばせるのであって、最も遅いものをソースに凍結するのではない。

One further consequence worth internalising: during that 48-gate-delay window, the sum outputs glitch. Bit 15's XOR sees its carry input change several times as the ripple works its way up, so sum[15] may toggle multiple times before settling. In a purely synchronous design that is harmless — nothing samples it until the clock edge, long after settling — but it burns dynamic power, and it is fatal if you ever feed a ripple-carry output into something edge-sensitive. Never clock on a data signal.還有一個值得內化的後果：在那 48 個閘延遲的窗口裡，和的輸出會發生毛刺。第 15 位元的 XOR 會隨著漣波一路往上爬而看到它的進位輸入變動好幾次，所以 sum[15] 可能在穩定之前翻轉好幾次。在純同步設計裡這無害 — 在時脈邊緣之前沒有東西會去取樣它，而那早在穩定之後 — 但它會燒掉動態功耗，而且如果你哪天把漣波進位的輸出餵進任何對邊緣敏感的東西，那就是致命的。永遠不要拿資料訊號當時脈。もう一つ身体に入れておくべき帰結がある。その 48 ゲート遅延の窓の間、和の出力はグリッチする。ビット 15 の XOR は、リップルが上がっていくにつれてキャリー入力が何度も変わるのを見るので、sum[15] は落ち着くまでに何度もトグルしうる。純粋な同期設計では無害だ——クロックエッジまで誰もサンプルせず、それは確定のはるか後である——が、動的電力を燃やすし、リップルキャリーの出力をエッジ感応な何かに食わせれば致命的になる。データ信号をクロックにしてはならない。

7.6 Arrays of instances7.6 實例陣列7.6 インスタンス配列

Writing G1 through G4 by hand is fine for four stages and intolerable for thirty-two. Verilog's array of instances creates a range of identical instances in one statement and distributes vector connections across them bit by bit.手寫 G1 到 G4 在四級時還行，三十二級就令人無法忍受。Verilog 的實例陣列用一條敘述建立一整個範圍的相同實例，並把向量連接逐位元分配給它們。G1 から G4 までを手書きするのは四段なら問題ないが、三十二段では耐えがたい。Verilog のインスタンス配列は、一つの文で同一インスタンスの範囲を作り、ベクタ接続をビットごとに分配する。

module array_of_nor (y, a, b);
  input  [0:7] a, b;
  output [0:7] y;

  nor array [0:7] (y, a, b);   // 8 NOR gates
endmodule

module array_of_adders (sum, c_out, a, b, c_in);
  input  [3:0] a, b;
  input        c_in;
  output [3:0] sum;
  output       c_out;
  wire   [3:1] carry;

  Add_full M [3:0] (sum, {c_out, carry[3:1]},
                    a, b, {carry[3:1], c_in});
endmodule

The distribution rule is mechanical: for each port, if the connected expression is exactly as wide as the port, every instance gets the whole thing; if it is $N$ times as wide (where $N$ is the number of instances), it is split into $N$ consecutive slices, with the lowest-numbered instance taking the least significant slice.分配規則是機械式的：對每個埠而言，如果所接的運算式和埠一樣寬，每一個實例都拿到整份；如果它是埠的 $N$ 倍寬（$N$ 是實例個數），就被切成 $N$ 個連續切片，編號最小的實例拿到最低位的切片。分配の規則は機械的である。各ポートについて、接続された式がポートと同じ幅ならすべてのインスタンスが全体を受け取る。幅が $N$ 倍（$N$ はインスタンス数）なら、$N$ 個の連続した切片に分けられ、番号の最も小さいインスタンスが最下位の切片を取る。

Example 2 is the one to study, because the clever part is the two concatenations. Expand it instance by instance:值得細讀的是範例 2，因為巧妙之處在那兩個串接。把它逐一實例展開：精読すべきは例 2 である。巧妙なのは二つの連結だからだ。インスタンスごとに展開してみよう。

// Add_full M [3:0] (sum, {c_out, carry[3:1]}, a, b, {carry[3:1], c_in});
// is exactly equivalent to:
Add_full M[0] (sum[0], carry[1], a[0], b[0], c_in);
Add_full M[1] (sum[1], carry[2], a[1], b[1], carry[1]);
Add_full M[2] (sum[2], carry[3], a[2], b[2], carry[2]);
Add_full M[3] (sum[3], c_out,    a[3], b[3], carry[3]);

8. Sequential Circuits: Flip-Flops and Pipelines8. 順序電路：正反器與管線8. 順序回路：フリップフロップとパイプライン

8.1 What makes a circuit sequential8.1 什麼讓電路成為順序電路8.1 回路を順序回路にするもの

The slides' definition is compact: a sequential circuit "models the storage elements with a clock". More precisely, a circuit is sequential if its output depends not only on the present inputs but on the history of inputs — which requires state, which requires an element that remembers. In a synchronous design that element is the edge-triggered D flip-flop, and the clock is the signal that decides when it remembers.投影片的定義很精簡：順序電路「用一個時脈來建模儲存元件」。更精確地說，如果一個電路的輸出不只取決於當下的輸入，還取決於輸入的歷史，它就是順序的 — 而那需要狀態，狀態需要一個會記憶的元件。在同步設計中，那個元件就是邊緣觸發 D 型正反器，而時脈就是決定它何時記憶的那條訊號。スライドの定義は簡潔だ。順序回路は「記憶素子をクロックとともにモデル化する」。より正確には、回路の出力が現在の入力だけでなく入力の履歴にも依存するとき、その回路は順序的である。それには状態が要り、状態には記憶する素子が要る。同期設計におけるその素子がエッジトリガ D フリップフロップであり、いつ記憶するかを決める信号がクロックである。

Everything in this course is synchronous. That is a design-methodology decision, not a law of physics, and it is worth knowing what it buys: a synchronous circuit's behaviour is fully described by "what combinational function computes each flip-flop's next state", and its timing is fully described by "does every combinational path fit inside one clock period". Both are mechanically checkable — the first by simulation, the second by static timing analysis — and both become intractable the moment you introduce asynchronous feedback or gated clocks. The entire cell-based flow, from synthesis through APR to sign-off, assumes synchrony.這門課裡的一切都是同步的。那是一項設計方法論的決定，不是物理定律，而且值得知道它換來什麼：一個同步電路的行為，完全可以用「哪個組合函數算出每顆正反器的下一個狀態」來描述；它的時序，完全可以用「每條組合路徑是否塞得進一個時脈週期」來描述。兩者都可以機械化檢查 — 前者靠模擬，後者靠靜態時序分析 — 而一旦你引入非同步回授或閘控時脈，兩者都會變得難以處理。整條 cell-based 流程，從合成到 APR 再到簽核，都假設了同步性。この科目のすべては同期式である。それは物理法則ではなく設計方法論の決定であり、見返りを知っておく価値がある。同期回路の振る舞いは「どの組合せ関数が各フリップフロップの次状態を計算するか」で完全に記述でき、そのタイミングは「すべての組合せパスが 1 クロック周期に収まるか」で完全に記述できる。前者はシミュレーションで、後者は静的タイミング解析で、どちらも機械的に検証できる。そして非同期帰還やゲーテッドクロックを持ち込んだ瞬間、どちらも手に負えなくなる。合成から APR、サインオフに至るセルベース・フロー全体が同期性を前提にしている。

8.2 The D flip-flop8.2 D 型正反器8.2 D フリップフロップ

module Flip_flop (q, data_in, clk, rst);
  input  data_in, clk, rst;
  output q;
  reg    q;

  always @ (posedge clk)     // declaration of synchronous behavior
    begin
      if (rst == 1) q = 0;     // rst is active high
      else          q = data_in;
    end
endmodule

Dissect the three ingredients that make this a flip-flop and not a wire.拆解讓這東西成為正反器、而不是一條線的三項要素。これを配線ではなくフリップフロップにしている三つの要素を解剖しよう。

• posedge clk in the sensitivity list. This is the single decisive feature. An always block triggered by an edge can only execute at discrete instants, so whatever it assigns must hold between those instants — and the only cell that does that is a flip-flop. Synthesis recognises the pattern and emits one DFFRX1 (or whatever the library calls it) per bit of q.敏感清單裡的 posedge clk。這是唯一具決定性的特徵。由邊緣觸發的 always 區塊只能在離散的瞬間執行，所以它所指定的任何東西都必須在那些瞬間之間保持住 — 而唯一會做這件事的 cell 就是正反器。合成認得這個樣式，並為 q 的每一個位元產生一顆 DFFRX1（或你的函式庫怎麼稱呼它）。感度リストの posedge clk。これが唯一の決定的特徴である。エッジで起動される always ブロックは離散的な瞬間にしか実行できないので、そこで代入されるものはその間ずっと保持されねばならない。それを行う唯一のセルがフリップフロップである。合成はこのパターンを認識し、q のビットごとに DFFRX1（ライブラリがどう呼ぶにせよ）を一つ出す。
• q declared reg. Necessary because q is assigned procedurally, but — as §3.5 laboured — not sufficient and not the reason it becomes a flop.q 宣告成 reg。這是必要的，因為 q 是以程序敘述指定的；但正如 §3.5 費力說明的，它並不充分，也不是它變成正反器的原因。q を reg と宣言すること。q が手続き的に代入される以上これは必要だが、§3.5 が力説したとおり十分ではなく、フリップフロップになる理由でもない。
• rst tested inside the edge-triggered block and absent from the sensitivity list. This makes the reset synchronous: it has no effect whatsoever except at a rising clock edge. Hold rst high for a picosecond between edges and nothing happens. Compare the asynchronous form, which appears in Lecture 4 and Lecture 6:rst 在邊緣觸發區塊內部被測試，而且不在敏感清單裡。這讓這個重置成為同步的：除了在時脈上升邊緣之外，它完全不起作用。在兩次邊緣之間把 rst 拉高一皮秒，什麼事也不會發生。對照非同步形式，那會出現在第 4 講與第 6 講：rst がエッジトリガ・ブロックの内側で検査され、感度リストにはないこと。これがリセットを同期式にする。クロックの立ち上がりエッジ以外では一切効かない。エッジの合間に rst を 1 ピコ秒高くしても何も起きない。第 4 講と第 6 講に現れる非同期形式と比べよ。

always @ (posedge clk)
  if (rst) q <= 1'b0;
  else     q <= data_in;

always @ (posedge clk or posedge rst)
  if (rst) q <= 1'b0;
  else     q <= data_in;

8.3 Set, reset, and priority8.3 設定、重置與優先權8.3 セット・リセットと優先順位

module Flip_flop (q, data_in, clk, set, rst);
  input  data_in, clk, set, rst;
  output q;
  reg    q;

  always @ (posedge clk)
    begin
      if (rst == 0) q = 0;       // rst active LOW
      else
        if (set == 0) q = 1;     // set active LOW
        else          q = data_in;
    end
endmodule

Note that in this second slide both controls are active low — they act when the signal is 0 — whereas the first slide's single reset was active high. The lecture is deliberately showing both polarities. Active-low controls are the industry norm for reset (the usual name is rst_n or resetb), partly historical and partly because a floating or un-driven control line tends to pull toward the supply on a CMOS input, which with active-low polarity means "inactive".注意第二張投影片裡兩個控制訊號都是低準位有效 — 它們在訊號為 0 時作用 — 而第一張投影片的那個單一重置是高準位有效。這一講是刻意把兩種極性都呈現出來。低準位有效的控制是業界對重置的常態（常見名稱是 rst_n 或 resetb），一部分是歷史因素，一部分是因為一條浮接或無人驅動的控制線在 CMOS 輸入上傾向被拉向電源，而在低準位有效的極性下，那意味著「未作用」。二枚目のスライドでは両方の制御が負論理——信号が 0 のときに効く——であるのに対し、一枚目の単一のリセットは正論理であった点に注意。講義は意図的に両方の極性を見せている。リセットの制御を負論理にするのは業界の標準であり（名前はたいてい rst_n か resetb）、半分は歴史的な理由、半分は、浮いたり駆動されていない制御線が CMOS 入力では電源側へ引かれがちで、負論理ならそれが「非アクティブ」を意味するからである。

The nested if/else establishes a priority: reset is tested first, so if rst and set are both asserted, q goes to 0. There is no ambiguity and no race; the priority is whatever the code says it is, and the synthesiser builds exactly that. If the library's flip-flop cell has both a set and a clear pin, their simultaneous assertion may be undefined in the cell's datasheet, so a synthesiser often implements set/reset priority in the D-side logic rather than on the cell pins. Either way the function is what you wrote.巢狀的 if/else 建立了一個優先權：重置先被測試，所以如果 rst 與 set 同時成立，q 會變成 0。這裡沒有歧義也沒有競爭；優先權就是程式碼說的那樣，而合成器就照那樣搭出來。如果函式庫的正反器 cell 同時有 set 與 clear 腳，兩者同時成立時的行為在那顆 cell 的資料表裡可能是未定義的，所以合成器常常改在 D 側邏輯裡實現 set／reset 的優先權，而不是用 cell 的腳。不論哪一種，功能都是你寫的那樣。入れ子の if/else が優先順位を定める。リセットが先に検査されるので、rst と set が同時にアサートされれば q は 0 になる。曖昧さも競合もない。優先順位はコードが言うとおりであり、合成器はそのとおりに作る。ライブラリのフリップフロップ・セルがセットピンとクリアピンの両方を持つ場合、同時アサート時の挙動はセルのデータシートで未定義かもしれない。そこで合成器はセットとリセットの優先順位を、セルのピンではなく D 側の論理で実現することが多い。いずれにせよ機能は君が書いたとおりになる。

8.4 Blocking versus non-blocking: a preview you need now8.4 阻隔式與非阻隔式：你現在就需要的預告8.4 ブロッキングとノンブロッキング：いま必要な予告

The slides' flip-flops use the blocking assignment = inside always @(posedge clk). In the examples shown this is harmless, because each block assigns exactly one variable and no other block reads it in the same time step. But it is a habit that fails the moment you write two flip-flops that feed each other, and since the pipeline in §8.6 is exactly that, you need the rule now even though Lecture 4 is where it is taught properly.投影片的正反器在 always @(posedge clk) 裡用的是阻隔式指定 =。在所示的範例中這是無害的，因為每個區塊只指定一個變數，而且在同一個時間步裡沒有別的區塊會讀它。但那是一個習慣，而這個習慣在你寫出兩顆互相餵食的正反器的那一刻就失效了；既然 §8.6 的管線正是那樣，你現在就需要這條規則，即使第 4 講才是正式教它的地方。スライドのフリップフロップは always @(posedge clk) の中でブロッキング代入 = を使っている。示されている例では無害だ。各ブロックが変数を一つだけ代入し、同じ時間ステップで他のブロックがそれを読まないからである。しかしそれは習慣であり、互いを養う二つのフリップフロップを書いた瞬間に破綻する。§8.6 のパイプラインがまさにそれなので、正式に教えるのは第 4 講でも、規則はいま必要になる。

always @(posedge clk) begin
  b = a;      // b takes a NOW
  c = b;      // c takes the NEW b
end
// Result: c = a after ONE edge.
// One flip-flop's worth of shifting,
// from two flip-flops' worth of code.
// And if the two statements were in
// two separate always blocks, the answer
// would depend on which the simulator
// happened to run first — a race.

always @(posedge clk) begin
  b <= a;     // schedule b := old a
  c <= b;     // schedule c := old b
end
// Result: a 2-stage shift register.
// Both right-hand sides are sampled
// before any left-hand side is updated,
// which is exactly what real flip-flops
// do at a clock edge, and the answer
// does not depend on statement order.

The reason is the simulator's event scheduler. At each time step it processes an active region, where blocking assignments take effect immediately, and then a non-blocking update region, where all the right-hand sides sampled earlier are written to their targets. Because every clocked block samples before any writes, the collective effect is "all flip-flops load simultaneously from the previous state" — which is physically what happens. Blocking assignments in clocked blocks make the result depend on the order in which the simulator chose to run the blocks, which the standard explicitly leaves undefined. Synthesis, which has no event queue, infers the shift register either way; so blocking assignments in clocked logic are the purest form of simulation/synthesis mismatch, and the one that costs the most debugging time in this course.理由在於模擬器的事件排程器。在每個時間步，它先處理一個active 區域，阻隔式指定在那裡立即生效；接著處理一個非阻隔式更新區域，先前取樣下來的所有右側值在那裡被寫入各自的目標。因為每個時脈區塊都在任何寫入之前先取樣，集體效果就是「所有正反器同時從先前的狀態載入」 — 而那正是物理上真正發生的事。在時脈區塊裡用阻隔式指定，會讓結果取決於模擬器選擇執行這些區塊的順序，而標準明確把那個順序留作未定義。合成沒有事件佇列，兩種寫法它都推斷出同一個移位暫存器；所以時脈邏輯裡的阻隔式指定是最純粹的模擬／合成不一致，也是這門課裡最耗除錯時間的一種。理由はシミュレータのイベントスケジューラにある。各時間ステップで、まずアクティブ領域が処理され、そこではブロッキング代入が即座に効く。続いてノンブロッキング更新領域が処理され、先にサンプルされた右辺の値がそれぞれの左辺へ書き込まれる。どのクロック同期ブロックも書き込みより前にサンプルするので、全体としての効果は「すべてのフリップフロップが前の状態から同時にロードする」となり、それが物理的に起きていることである。クロック同期ブロックでブロッキング代入を使うと、結果はシミュレータがブロックを走らせた順序に依存し、標準はその順序を明示的に未定義としている。合成にはイベントキューがないのでどちらでも同じシフトレジスタを推論する。したがってクロック同期論理のブロッキング代入は最も純粋なシミュレーション／合成ミスマッチであり、この科目で最もデバッグ時間を食うものでもある。

8.5 Setup, hold, and where the clock period goes8.5 setup、hold，以及時脈週期花到哪去了8.5 セットアップ、ホールド、そしてクロック周期の行き先

A flip-flop is not instantaneous. Three numbers from its datasheet govern everything:正反器不是瞬時的。它資料表上的三個數字主宰了一切：フリップフロップは瞬時ではない。データシートの三つの数値がすべてを支配する。

For a path from flop A through combinational logic to flop B, both clocked by the same clock of period $T$:對一條從正反器 A 經組合邏輯到正反器 B 的路徑，兩者由同一個週期為 $T$ 的時脈驅動：フリップフロップ A から組合せ論理を経てフリップフロップ B へ至る経路について、両者が周期 $T$ の同じクロックで駆動されるとき：

Two very different kinds of failure live in those two lines.那兩行式子裡住著兩種非常不同的失效。この二つの式には、まったく異なる二種類の失敗が住んでいる。

A setup violation is a speed problem. The logic is too slow for the clock; the data arrives after the capturing edge has already sampled. The fix is to make the path faster or the clock slower, and you can always test for it by running the chip at a lower frequency — if it works at 200 MHz and fails at 400 MHz, you have a setup problem. Note that $T$ appears on the right: setup is the constraint that the clock period is for, and it is why the 48-gate ripple-carry delay of §7.5 translated directly into a maximum frequency.setup 違規是速度問題。邏輯對這個時脈來說太慢了；資料在擷取邊緣已經取樣之後才抵達。修法是把路徑弄快或把時脈放慢，而你永遠可以用降頻來測它 — 如果它在 200 MHz 可以跑、400 MHz 掛掉，那就是 setup 問題。注意 $T$ 出現在右邊：時脈週期就是為了 setup 這條限制而存在的，這也是為什麼 §7.5 那 48 個閘延遲的漣波進位會直接換算成一個最高頻率。セットアップ違反は速度の問題である。論理がクロックに対して遅すぎ、データが捕捉エッジのサンプル後に到着する。直し方は経路を速くするかクロックを遅くすることであり、周波数を下げれば必ず切り分けられる。200 MHz で動き 400 MHz で落ちるなら、それはセットアップの問題だ。右辺に $T$ がある点に注意せよ。クロック周期はセットアップ制約のためにあるのであり、§7.5 の 48 ゲート遅延のリップルキャリーがそのまま最高周波数に翻訳された理由でもある。

A hold violation is a race problem and it is fatal. There is no $T$ in the hold equation. A chip with a hold violation fails at every frequency, including DC, and cannot be rescued by slowing the clock. Hold violations come from paths that are too fast — typically a flop driving another flop directly with almost no logic between them, where $t_{cq}$ of the launching flop is less than $t_h$ plus the clock skew of the capturing one. They are fixed by inserting buffers to add delay, which is why APR tools spend a whole optimisation pass inserting what looks like pointless buffering. This is also why clock-tree synthesis works so hard to minimise skew: skew eats margin on both constraints, but it does so asymmetrically, helping setup on one path and hurting hold on the same path.hold 違規是競爭問題，而且是致命的。hold 的式子裡沒有 $T$。一顆有 hold 違規的晶片在任何頻率下都會失敗，包括直流，而且無法靠放慢時脈來挽救。hold 違規來自太快的路徑 — 典型是一顆正反器幾乎不經任何邏輯就直接驅動另一顆，此時發射端的 $t_{cq}$ 小於擷取端的 $t_h$ 加上時脈偏斜。修法是插入緩衝器來增加延遲，這正是為什麼 APR 工具會花一整趟最佳化去插入那些看起來毫無意義的緩衝。這也是為什麼時脈樹合成如此拚命地把偏斜壓小：偏斜會吃掉兩條限制的裕度，但吃的方式是不對稱的 — 它對同一條路徑的 setup 有幫助，卻對 hold 有害。ホールド違反は競合の問題であり、致命的である。ホールドの式に $T$ はない。ホールド違反を抱えたチップは直流を含むあらゆる周波数で失敗し、クロックを遅くしても救えない。ホールド違反は速すぎる経路から生じる。典型的には、論理をほとんど挟まずフリップフロップが別のフリップフロップを直接駆動し、送出側の $t_{cq}$ が捕捉側の $t_h$ とクロックスキューの和より小さい場合である。直し方はバッファを挿入して遅延を足すことであり、APR ツールが一見無意味なバッファ挿入に最適化の一周を費やす理由がこれだ。クロックツリー合成がスキューの最小化に力を注ぐ理由でもある。スキューは両方の制約の余裕を削るが、その削り方は非対称で、同じ経路のセットアップを助けつつホールドを害する。

8.6 The 4-stage pipeline8.6 四級管線8.6 4 段パイプライン

The lecture's final example chains four 8-bit registers, using arrays of instances twice.本講最後一個範例把四個 8 位元暫存器串起來，而且用了兩次實例陣列。講義の最後の例は 8 ビットのレジスタ四つを連ね、インスタンス配列を二度使う。

module array_of_flops (q, data_in, clk, set, rst);
  input  [7:0] data_in;
  input        clk, set, rst;
  output [7:0] q;

  Flip_flop M [7:0] (q, data_in, clk, set, rst);
endmodule

module array_pipeline (q, data_in, clk, set, rst);
  input  [7:0]  data_in;
  input         clk, set, rst;
  output [7:0]  q;
  wire   [23:0] pipe;

  array_of_flops M [3:0] ({q, pipe},
                          {pipe, data_in},
                          clk, set, rst);
endmodule

Work the widths. array_of_flops has an 8-bit q, an 8-bit data_in, and three scalar controls. Four instances are requested, so:把位寬算一遍。array_of_flops 有一個 8 位元的 q、一個 8 位元的 data_in，以及三個純量控制。這裡要求四個實例，所以：幅を計算しよう。array_of_flops は 8 ビットの q、8 ビットの data_in、そして三つのスカラ制御を持つ。ここでは四インスタンスを要求しているので：

• {q, pipe} is 8 + 24 = 32 bits, split into four 8-bit slices. M[0] gets the least significant slice, pipe[7:0]; M[1] gets pipe[15:8]; M[2] gets pipe[23:16]; M[3] gets the most significant slice, q[7:0].{q, pipe} 是 8 + 24 = 32 位元，切成四個 8 位元切片。M[0] 拿到最低位的切片 pipe[7:0]；M[1] 拿到 pipe[15:8]；M[2] 拿到 pipe[23:16]；M[3] 拿到最高位的切片 q[7:0]。{q, pipe} は 8 + 24 = 32 ビットで、8 ビットの切片四つに分けられる。M[0] は最下位の切片 pipe[7:0]、M[1] は pipe[15:8]、M[2] は pipe[23:16]、M[3] は最上位の切片 q[7:0] を受け取る。
• {pipe, data_in} is also 32 bits. M[0] gets data_in; M[1] gets pipe[7:0]; M[2] gets pipe[15:8]; M[3] gets pipe[23:16].{pipe, data_in} 同樣是 32 位元。M[0] 拿到 data_in；M[1] 拿到 pipe[7:0]；M[2] 拿到 pipe[15:8]；M[3] 拿到 pipe[23:16]。{pipe, data_in} もまた 32 ビットである。M[0] は data_in、M[1] は pipe[7:0]、M[2] は pipe[15:8]、M[3] は pipe[23:16] を受け取る。
• clk, set and rst are 1 bit and the port is 1 bit, so every instance gets the same signal. That is the "equal width means broadcast" half of the distribution rule, and it is what makes a shared clock possible.clk、set 與 rst 是 1 位元，而埠也是 1 位元，所以每一個實例都拿到同一條訊號。那就是分配規則中「等寬即廣播」的那一半，也正是共用時脈之所以可能的原因。clk、set、rst は 1 ビットで、ポートも 1 ビットなので、すべてのインスタンスが同じ信号を受け取る。これが分配規則の「幅が等しければブロードキャスト」の半分であり、クロックの共有を可能にしているものである。

The same one-bit shift between the two concatenations that chained the carries in §7.6 chains the pipeline stages here. Stage i's output is stage i+1's input, by construction.在 §7.6 把進位串起來的那同一個「兩個串接之間錯開一位元」的手法，在這裡把管線各級串了起來。第 i 級的輸出就是第 i+1 級的輸入，由構造保證。§7.6 でキャリーを連鎖させたのと同じ「二つの連結を 1 ビットずらす」手法が、ここではパイプラインの段を連鎖させている。段 i の出力が段 i+1 の入力になることが、構成そのものから保証される。