Design Examples, Explained設計範例，逐一詳解設計例を読み解く

1. Reading a Design Example1. 如何讀一個設計範例1. 設計例の読み方

1.1 What a capstone lecture is for1.1 總結性的一講要做什麼1.1 総まとめの講義の役割

The first seven lectures of this course each taught one thing. Lecture 1 introduced modules, nets and registers. Lecture 2 taught you how to build a testbench and watch a simulation. Lecture 3 covered syntax, user-defined primitives and the delay model. Lecture 4 moved from gates to behaviour. Lectures 5, 6 and 7 then narrowed the language down to the subset a logic synthesiser will accept, and told you which coding templates produce combinational logic, which produce flip-flops, and which produce the latches you did not want.本課程前七講每一講都只教一件事。第 1 講介紹模組、net 與 register。第 2 講教你怎麼寫測試平台、怎麼看一次模擬。第 3 講講語法、使用者自訂原件（UDP）與延遲模型。第 4 講從閘級走向行為級。第 5、6、7 講則把語言收斂到邏輯合成器願意接受的子集，並告訴你哪些寫法會產生組合邏輯、哪些會產生正反器、哪些會產生你根本不想要的閂鎖。本講義の最初の 7 回は、それぞれ一つのことだけを教えてきた。第 1 講はモジュール・ネット・レジスタを導入した。第 2 講はテストベンチの書き方とシミュレーションの見方を教えた。第 3 講は構文・ユーザ定義プリミティブ（UDP）・遅延モデルを扱った。第 4 講はゲートレベルから振る舞いレベルへ移った。第 5・6・7 講では言語を論理合成器が受け付ける部分集合まで絞り込み、どの記述テンプレートが組合せ論理を生み、どれがフリップフロップを生み、どれが望んでもいないラッチを生むのかを示した。

Lecture 8 does not introduce a single new construct. Every line of Verilog in it is something you have already seen. What it introduces is the thing no individual lecture can teach: judgement. A design example is a record of the decisions somebody made while turning a one-sentence specification into a netlist, and the only way to learn those decisions is to watch them being made and to argue with them afterwards. Two systems are put on the table.第 8 講沒有引進任何新的語法結構。裡面的每一行 Verilog 你都已經見過。它要引進的，是任何單獨一講都教不了的東西：判斷力。一個設計範例，其實是某個人把一句話的規格變成 netlist 時所做的一連串決定的紀錄；要學會這些決定，唯一的辦法就是看著它們被做出來，然後回過頭來質疑它們。這裡擺上桌的有兩套系統。第 8 講は新しい構文を一つも導入しない。そこに出てくる Verilog の行は、すべてすでに見たものばかりである。導入されるのは、個々の講義では教えられないもの、すなわち判断力である。設計例とは、1 文の仕様を netlist に変えるときに誰かが下した決定の記録であり、その決定を学ぶ唯一の方法は、決定が下される場に立ち会い、あとでそれに異を唱えてみることである。ここでは二つのシステムを机に載せる。

• Design Example I is a two-channel temperature monitor. Two sensors produce 12-bit Celsius readings. Each reading is latched, converted to Fahrenheit, smoothed by a four-sample moving average, and pushed into an eight-word FIFO. A controller lets a host read whichever FIFO it asks for, or read a status word instead. The system is small enough to hold in your head and rich enough to raise every arithmetic question that matters in a datapath: how do you multiply by a non-power-of-two constant without a multiplier, how do you divide without a divider, and how much accuracy do you give away when you do.設計範例一是一套雙通道溫度監測系統。兩個感測器各自產生 12 位元的攝氏讀數。每筆讀數先被暫存，轉換成華氏，再經四筆樣本的移動平均平滑化，最後推進一個八字深的 FIFO。一個控制器讓主機讀取它指定的那個 FIFO，或是改讀一個狀態字。這套系統小到可以整個放在腦子裡，卻又豐富到足以帶出資料路徑中每一個重要的算術問題：沒有乘法器時要怎麼乘上一個非 2 冪次的常數、沒有除法器時要怎麼做除法，以及這麼做會犧牲多少精度。設計例 I は 2 チャネルの温度モニタである。センサ 2 個がそれぞれ 12 ビットの摂氏値を出力する。各サンプルはレジスタに取り込まれ、華氏へ変換され、4 サンプルの移動平均で平滑化され、8 ワードの FIFO へ押し込まれる。コントローラにより、ホストは指定した側の FIFO を読むか、代わりにステータスワードを読むことができる。このシステムは頭の中に収まるほど小さく、しかもデータパスで問題になる算術上の論点をすべて引き出せるほど豊かである。乗算器なしで 2 のべき乗でない定数を掛けるにはどうするか、除算器なしで割るにはどうするか、そしてそのとき精度をどれだけ手放すことになるのか。
• Design Example II is a Verilog model of the AMD Am2901, a 4-bit bit-slice microcontroller from 1975. It has a 16-word register file, a Q register, an operand selector, an ALU and an output selector, all steered by a 9-bit microinstruction split into three 3-bit fields. It is the smallest complete processor datapath that is still recognisably a processor datapath, and it is the standard worked example for the question "how do I describe a controlled datapath in Verilog?"設計範例二是 AMD Am2901 的 Verilog 模型 —— 一顆 1975 年的 4 位元 bit-slice 微控制器。它有一個 16 字的暫存器檔、一個 Q 暫存器、一個運算元選擇器、一個 ALU 與一個輸出選擇器，全部由一個切成三個 3 位元欄位的 9 位元微指令操控。它是「還看得出來是處理器資料路徑」的最小完整處理器資料路徑，也是「我要怎麼用 Verilog 描述一條受控的資料路徑？」這個問題的標準範例。設計例 II は AMD Am2901 の Verilog モデルである。1975 年の 4 ビット・ビットスライス・マイクロコントローラで、16 ワードのレジスタファイル、Q レジスタ、オペランドセレクタ、ALU、出力セレクタを持ち、そのすべてが 3 ビット 3 フィールドに分かれた 9 ビットのマイクロ命令で制御される。プロセッサのデータパスとまだ認識できる範囲で最小の、完全なプロセッサデータパスであり、「制御されたデータパスを Verilog でどう記述するか」という問いに対する定番の題材でもある。

Both examples are presented in the slides as screenshots of code with almost no commentary. That is the gap this page fills. For every block you will get the specification, the architectural choice behind it, the Verilog, a reading of the lines that are not obvious, the timing behaviour, a sketch of the testbench you would write, and a description of what the synthesiser actually produces. Where the slide code is wrong — and in several places it is — the correct behaviour is explained and the discrepancy is flagged rather than repeated.這兩個範例在投影片裡都只是程式碼截圖，幾乎沒有任何說明。本頁要補的就是這段空白。每一個區塊你都會看到：規格、它背後的架構選擇、Verilog 程式碼、那些不是一眼就看得懂的行的解讀、時序行為、你會寫出什麼樣的測試平台，以及合成器實際上會產生什麼。投影片程式碼有錯的地方 —— 而且好幾處確實有錯 —— 本頁會說明正確的行為，並把差異標示出來，而不是照抄一遍。どちらの例もスライドではコードのスクリーンショットとして示されるだけで、解説はほとんどない。このページが埋めるのはその空白である。各ブロックについて、仕様、その背後にあるアーキテクチャ上の選択、Verilog コード、一読では分からない行の読み方、タイミング動作、書くことになるテストベンチの概略、そして合成器が実際に生成するものを示す。スライドのコードが誤っている箇所については——実際に数か所ある——正しい動作を説明し、相違点を指摘する。そのまま書き写すことはしない。

1.2 Three questions for every block1.2 每個區塊都要問的三個問題1.2 どのブロックにも問う三つの問い

Get into the habit of asking the same three questions of every module you meet, in this order. They will carry you through both design examples and through the exam.養成習慣：遇到任何一個模組，都依序問自己同樣的三個問題。這三個問題會帶你走完兩個設計範例，也會帶你走完考試。どのモジュールに出会っても、同じ三つの問いをこの順で自分に投げかける習慣をつけたい。この三つが、二つの設計例と試験の両方を通して支えになる。

1.3 Rules carried over from Lectures 5–71.3 從第 5–7 講帶過來的規則1.3 第 5–7 講から引き継ぐ規則

The design examples are an exercise in applying rules you already have. It is worth laying them out in one table so that when a rule bites later you can see which lecture it came from. Each row is a rule we will invoke by name in the rest of this page.設計範例是把你已經擁有的規則拿來應用的練習。值得把它們列成一張表，這樣後面某條規則咬你一口時，你可以看出它是從哪一講來的。表中每一列都是本頁後面會直接點名引用的規則。設計例は、すでに手にしている規則を適用する演習である。一覧表にしておけば、後で規則に足をすくわれたとき、それがどの講から来たものかを確かめられる。各行は、このページの残りで名指しで参照する規則である。

1.4 The two systems at a glance1.4 兩個系統的全貌1.4 二つのシステムの全体像

Before the detail, fix the shape of both designs in your mind. The temperature monitor is a streaming datapath: data flows left to right through a fixed pipeline, every stage does the same thing on every clock, and the only control is at the very end where a host decides which buffer to drain. The AMD2901 is a controlled datapath: data circulates through a loop of register file → operand selector → ALU → back to register file, and a microinstruction word decides, every cycle, what each multiplexer in that loop does. Almost every digital system you will ever build is one of these two shapes or a composition of them.進入細節之前，先把兩個設計的形狀記在腦中。溫度監測系統是一條串流式資料路徑：資料由左往右流過一條固定的管線，每一級每個時脈都做同一件事，唯一的控制在最末端 —— 由主機決定要把哪一個緩衝區抽空。AMD2901 則是一條受控資料路徑：資料在「暫存器檔 → 運算元選擇器 → ALU → 回到暫存器檔」的迴路中循環，而一個微指令字每個週期決定這個迴路裡每一個多工器要做什麼。你這輩子會建的數位系統，幾乎都是這兩種形狀之一，或是兩者的組合。細部に入る前に、二つの設計の形を頭に入れておきたい。温度モニタはストリーミング型データパスである。データは固定されたパイプラインを左から右へ流れ、各段は毎クロック同じ処理を行い、制御は最後尾だけ——どちらのバッファを吸い出すかをホストが決める部分だけにある。AMD2901 は制御されたデータパスである。データはレジスタファイル → オペランドセレクタ → ALU → レジスタファイル、というループを巡り、マイクロ命令語がそのループ内の各マルチプレクサの動作を毎サイクル決める。これから作るディジタルシステムのほとんどは、この二つの形のどちらか、あるいはその組み合わせである。

One more framing remark. Both examples were written in an era when Verilog-1995 was the language and a gate-array or standard-cell library was the target. That shows: outputs are re-declared as reg on a separate line rather than written output reg, three-state nets are used freely inside the chip, and blocking assignments appear in clocked blocks. None of that is fatal, but all of it would be flagged by a modern linter. Part of reading a design example critically is being able to say "this is historically normal and functionally fine" about one line and "this is a genuine race" about the next. We will do exactly that.最後再講一點背景。這兩個範例都寫在 Verilog-1995 還是主流語言、目標是閘陣列或標準元件庫的年代。這一點看得出來：輸出是另起一行重新宣告成 reg，而不是寫成 output reg；三態 net 在晶片內部被自由使用；時脈區塊裡出現阻塞指定。這些都不致命，但現代的 linter 每一項都會標出來。批判性地讀一個設計範例，有一部分就是要能對某一行說「這在當年很正常，功能上也沒問題」，而對下一行說「這是真正的競爭」。我們接下來就要這樣做。もう一点、背景を補っておく。どちらの例も、Verilog-1995 が標準でありゲートアレイや標準セルライブラリが実装対象だった時代に書かれている。それは記述にも表れている。出力は output reg とは書かず、別行で reg として再宣言される。チップ内部でトライステートのネットが自由に使われる。クロック同期ブロックにブロッキング代入が現れる。どれも致命的ではないが、現代の linter ならすべて指摘するだろう。設計例を批判的に読むとは、ある行については「これは当時として普通で機能上も問題ない」と言い、次の行については「これは本物のレースである」と言えることでもある。これから実際にそれをやる。

2. The FIFO: Specification and Architecture2. FIFO：規格與架構2. FIFO：仕様とアーキテクチャ

2.1 Why a FIFO exists2.1 FIFO 為什麼存在2.1 FIFO が存在する理由

A first-in first-out buffer exists to decouple a producer from a consumer. The producer in our system is the filter, which emits one averaged sample every clock, forever, whether anybody is listening or not. The consumer is a host processor that reads whenever it feels like it. Without a buffer between them, every sample produced while the host is busy is simply lost, and the host must poll at the producer's rate or not at all. With a buffer of depth $N$, the host may be absent for up to $N$ sample periods and still miss nothing.先進先出緩衝器的存在，是為了讓生產者與消費者解耦。在我們這套系統裡，生產者是濾波器：它每個時脈都吐出一筆平均後的樣本，不管有沒有人在聽。消費者是一顆主處理器，它高興的時候才來讀。中間若沒有緩衝區，主機忙碌期間產生的每一筆樣本就直接遺失，而主機只能以生產者的速率輪詢，否則就什麼也拿不到。有了深度 $N$ 的緩衝區，主機最多可以離開 $N$ 個樣本週期而仍不漏掉任何東西。先入れ先出しバッファは、生産者と消費者を切り離すために存在する。本システムの生産者はフィルタであり、誰かが聞いていようがいまいが、毎クロック平均済みのサンプルを 1 つ出し続ける。消費者はホストプロセッサで、気が向いたときに読む。両者の間にバッファがなければ、ホストが取り込めない間に作られたサンプルはすべて失われ、ホストは生産者と同じレートでポーリングするしかなくなる。深さ $N$ のバッファがあれば、ホストは最大 $N$ サンプル周期のあいだ離れていても何も取りこぼさない。

That is the whole value proposition, and it comes with the whole set of problems. A buffer of finite depth can be full, at which point the producer must be told to stop or its data will be dropped. It can be empty, at which point the consumer must be told to wait or it will read rubbish. Those two flags are not decoration; they are the flow-control protocol, and getting them right is the entire intellectual content of a FIFO design. Everything else — the memory, the pointers, the output register — is bookkeeping.這就是 FIFO 的全部價值，而它也帶來全部的問題。有限深度的緩衝區會滿，這時必須通知生產者停下來，否則資料就被丟掉。它也會空，這時必須通知消費者等一下，否則它會讀到垃圾。那兩個旗標不是裝飾品，它們就是流量控制協定，而把它們做對，正是整個 FIFO 設計的全部智力內容。其餘的東西 —— 記憶體、指標、輸出暫存器 —— 都只是記帳。これが FIFO の価値のすべてであり、同時に問題のすべても連れてくる。有限の深さを持つバッファは満杯になりうる。そのときは生産者に止まるよう伝えなければ、データは捨てられる。空にもなりうる。そのときは消費者に待つよう伝えなければ、ゴミを読むことになる。この二つのフラグは飾りではなくフロー制御のプロトコルそのものであり、これを正しく作ることが FIFO 設計の知的内容のすべてである。残り——メモリ、ポインタ、出力レジスタ——はすべて帳簿付けにすぎない。

2.2 The port list as a contract2.2 埠列表就是合約2.2 契約としてのポートリスト

The slide draws the FIFO twice: once as a black box with eight connections, and once with its internals showing. Read the black box first, because the port list is the specification.投影片把 FIFO 畫了兩次：一次是有八條連線的黑盒子，一次是把內部攤開來。先讀黑盒子，因為埠列表就是規格。スライドは FIFO を 2 回描いている。1 回は 8 本の接続を持つブラックボックスとして、もう 1 回は内部を見せた形で。まずブラックボックスを読むとよい。ポートリストこそが仕様だからである。

Three things in that table are design decisions rather than facts of nature, and you should notice them as decisions. First, the flags are combinational functions of registered state, which means they are stable for a whole cycle and describe the FIFO as it stands before the next edge; this is the easy and safe choice, and it costs one gate delay plus a comparator on the flag path. Second, Data_out is registered, which means a read request and its data are one cycle apart; the alternative, a combinational read, is discussed in §3.7. Third, the memory is not reset, which is exactly right for hardware — resetting 96 flip-flops costs area and a reset tree, and the empty flag already prevents anyone from reading uninitialised content.那張表裡有三件事是設計決定，而不是自然法則，你應該要能看出它們是決定。第一，旗標是暫存狀態的組合函數，因此整個週期都穩定，描述的是下一個邊緣之前的 FIFO 狀態；這是簡單又安全的選擇，代價是旗標路徑上多一級閘延遲加一個比較器。第二，Data_out 是已暫存的，所以讀取請求與它的資料相差一個週期；另一種做法是組合式讀取，見 §3.7。第三，記憶體不重置，對硬體而言這完全正確 —— 重置 96 個正反器要付出面積與一棵重置樹，而空旗標本來就擋住了任何人去讀未初始化的內容。この表の中の三つは自然の法則ではなく設計上の決定であり、決定として意識すべきものである。第一に、フラグはレジスタ値の組合せ関数である。したがって 1 サイクルのあいだ安定で、次のエッジより前の FIFO の状態を表す。これは単純で安全な選択で、代償はフラグ経路上のゲート遅延 1 段と比較器 1 個である。第二に、Data_out はレジスタ出力であり、読み出し要求とそのデータは 1 サイクル離れる。もう一方の選択肢である組合せ読み出しは §3.7 で扱う。第三に、メモリはリセットしない。これはハードウェアとしてまったく正しい。96 個のフリップフロップをリセットすれば面積とリセットツリーを食うし、空フラグがそもそも未初期化の内容を読ませないからである。

The three parameters make the module reusable: stack_width sets the data path, stack_height sets the depth, and stack_ptr_width sets the pointer size. The last one is redundant information — it must equal $\log_2(\textit{stack\_height})$ — and that redundancy is a trap. Override the height to 16 and forget to override the pointer width, and you get a FIFO with 16 words of memory of which only 8 are ever addressed, with flags that insist it is full at 16. A modern design would compute the pointer width with $clog2 instead of asking the user.三個參數讓這個模組可以重複使用：stack_width 決定資料路徑寬度，stack_height 決定深度，stack_ptr_width 決定指標大小。最後一個是冗餘資訊 —— 它必須等於 $\log_2(\textit{stack\_height})$ —— 而這個冗餘就是陷阱。把 height 覆寫成 16 卻忘了覆寫指標寬度，你就得到一個有 16 字記憶體但永遠只定址到其中 8 字的 FIFO，而且旗標堅持它在 16 字時才滿。現代的寫法會用 $clog2 自己算出指標寬度，而不是要使用者提供。三つのパラメータがこのモジュールを再利用可能にしている。stack_width がデータパス幅を、stack_height が深さを、stack_ptr_width がポインタのサイズを決める。最後のものは冗長な情報であり——$\log_2(\textit{stack\_height})$ に等しくなければならない——その冗長さが落とし穴になる。height を 16 に上書きしてポインタ幅の上書きを忘れると、16 ワードのメモリを持ちながら 8 ワードしかアドレスされず、しかも 16 で満杯だと言い張るフラグを持つ FIFO ができあがる。現代的な設計なら、利用者に聞かずに $clog2 でポインタ幅を計算する。

2.3 Circular buffer and two pointers2.3 環狀緩衝區與兩個指標2.3 リングバッファと二つのポインタ

The internal organisation is the classic circular buffer. A block of memory stack[0]…stack[stack_height-1] is addressed by two pointers. write_ptr holds the address of the next free slot; read_ptr holds the address of the oldest word still in the buffer. A write stores Data_in at stack[write_ptr] and advances write_ptr. A read fetches stack[read_ptr] and advances read_ptr. Neither pointer ever moves backwards and neither is ever reset in normal operation; they simply count up and wrap.內部組織就是經典的環狀緩衝區。一塊記憶體 stack[0]…stack[stack_height-1] 由兩個指標定址。write_ptr 存放下一個空位的位址；read_ptr 存放仍在緩衝區裡最舊那個字的位址。一次寫入把 Data_in 存到 stack[write_ptr] 並讓 write_ptr 前進。一次讀取取出 stack[read_ptr] 並讓 read_ptr 前進。兩個指標都不會倒退，正常運作時也都不會被重置；它們只是一直往上數，然後繞回去。内部構成は古典的なリングバッファである。メモリ領域 stack[0]…stack[stack_height-1] を二つのポインタでアドレスする。write_ptr は次の空きスロットのアドレスを、read_ptr はバッファ内に残る最も古いワードのアドレスを保持する。書き込みは Data_in を stack[write_ptr] に格納し、write_ptr を進める。読み出しは stack[read_ptr] を取り出し、read_ptr を進める。どちらのポインタも後戻りせず、通常動作ではリセットもされない。ただ数え上がり、折り返すだけである。

The wrap is free, and this is the first small piece of hardware thinking in the design. read_ptr and write_ptr are three bits wide and the depth is eight. Incrementing 3'b111 gives 3'b000 with the carry discarded, which is precisely modulo-8 arithmetic. There is no comparison against the depth, no conditional reset of the pointer to zero, no adder wider than it needs to be. A power-of-two depth buys you the modulo for nothing. If you ever specify a FIFO of depth 10, you pay for it: the pointer needs four bits, it can reach 15, and every increment now needs ptr == 9 ? 0 : ptr + 1, which is an extra comparator and an extra multiplexer in the critical path. Choose powers of two unless the specification forbids it.繞回是免費的，而這是這個設計裡第一處小小的硬體思維。read_ptr 與 write_ptr 都是三位元寬，深度是八。把 3'b111 加一得到 3'b000，進位被丟掉，這正好就是模 8 運算。不需要跟深度比較，不需要有條件地把指標清零，也不需要比必要寬度更寬的加法器。深度取 2 的冪次，模運算就白送你。如果哪天你規定 FIFO 深度是 10，你就得付代價：指標要四位元、會數到 15，而每次加一都變成 ptr == 9 ? 0 : ptr + 1，關鍵路徑上就多了一個比較器和一個多工器。除非規格不允許，否則請選 2 的冪次。折り返しはタダであり、これがこの設計における最初の小さなハードウェア的思考である。read_ptr と write_ptr は 3 ビット幅で、深さは 8 である。3'b111 に 1 を足すとキャリーが捨てられて 3'b000 になり、これがちょうど 8 を法とする演算になる。深さとの比較も、ポインタを条件付きでゼロに戻す処理も、必要以上に広い加算器も要らない。2 のべき乗の深さは、剰余演算をタダで与えてくれる。深さ 10 の FIFO を仕様に書けば、その代償を払うことになる。ポインタは 4 ビット必要で 15 まで届き、インクリメントは毎回 ptr == 9 ? 0 : ptr + 1 となって、クリティカルパスに比較器 1 個とマルチプレクサ 1 個が増える。仕様が禁じない限り 2 のべき乗を選ぶべきである。

2.4 The coincidence ambiguity2.4 指標重合的歧義2.4 ポインタ一致のあいまいさ

Here is the one genuinely subtle thing about FIFOs, and it is worth slowing down for because it is asked in examinations constantly.接下來是 FIFO 唯一真正微妙的地方，值得放慢速度看，因為考試考個不停。ここからが FIFO で唯一本当に微妙な点である。試験で繰り返し問われるので、速度を落として読む価値がある。

Suppose you have only the two pointers and nothing else. Start from reset with both pointers at zero; the buffer is empty and write_ptr == read_ptr. Now write eight words. Each write advances write_ptr: 0, 1, 2, …, 7, and after the eighth write it wraps back to 0. The buffer is now full, and write_ptr == read_ptr again. The two pointers hold exactly the same pair of values in both situations, and the state of the memory is the only thing that differs — which the pointers cannot see.假設你只有那兩個指標，別的什麼都沒有。從重置開始，兩個指標都是零；緩衝區是空的，而且 write_ptr == read_ptr。現在寫入八個字。每次寫入讓 write_ptr 前進：0、1、2、…、7，第八次寫完之後它繞回 0。緩衝區現在是滿的，而 write_ptr == read_ptr 又成立了。兩種情況下兩個指標的值完全相同，唯一不同的是記憶體的狀態 —— 而指標看不到記憶體。ポインタ 2 本のほかに何も無いとしよう。リセット直後、両方のポインタはゼロである。バッファは空で、write_ptr == read_ptr が成り立つ。ここで 8 ワード書き込む。書き込みごとに write_ptr は 0、1、2、…、7 と進み、8 回目のあとで 0 へ折り返す。バッファは今や満杯だが、再び write_ptr == read_ptr である。二つの状況でポインタの値の組はまったく同じで、違うのはメモリの状態だけ——そしてポインタはメモリを見ることができない。

That counting argument tells you immediately that there are exactly three families of solution: add a bit of state that counts, add a bit of state to each pointer, or throw away one of the occupancies. All three are used in practice and you should be able to write and cost each of them.這個計數論證立刻告訴你：解法正好有三族 —— 加一個會計數的狀態位元、給每個指標各加一個狀態位元，或是丟掉其中一種佔用量。這三種在實務上都有人用，而你應該都能寫出來並估出成本。この数え上げの議論から、解法はちょうど三つの系統しかないことがただちに分かる。数えるための状態を 1 ビット足すか、各ポインタに状態を 1 ビットずつ足すか、占有数を一つ捨てるかである。三つとも実務で使われており、どれも書けて、コストを見積もれるようになりたい。

2.5 Cure 1 — an occupancy counter2.5 解法一 —— 佔用量計數器2.5 解法 1 — 占有数カウンタ

This is the cure the lecture's FIFO uses. Carry a separate register ptr_diff that holds the number of words currently stored. It is incremented on a successful write, decremented on a successful read, and left alone otherwise. Because the occupancy ranges from 0 to $N$ inclusive, it needs $\log_2 N + 1$ bits: in our case four bits for a depth of eight. The declaration reg [stack_ptr_width:0] ptr_diff; says exactly that — note the missing -1, which is the whole point of the line and which students routinely copy as [stack_ptr_width-1:0] and then spend an afternoon debugging.這就是本講的 FIFO 所採用的解法。另外帶一個暫存器 ptr_diff，存放目前已存的字數。寫入成功時加一，讀取成功時減一，其餘情況不動。因為佔用量的範圍是 0 到 $N$（含兩端），它需要 $\log_2 N + 1$ 個位元：在我們這裡，深度八就要四位元。宣告 reg [stack_ptr_width:0] ptr_diff; 說的正是這件事 —— 注意那個不見了的 -1，這才是這一行的重點，而學生常常照抄成 [stack_ptr_width-1:0]，然後花一個下午除錯。これが本講の FIFO が採る解法である。現在格納されているワード数を保持する別レジスタ ptr_diff を持つ。書き込みが成立すれば増やし、読み出しが成立すれば減らし、それ以外では変えない。占有数は 0 から $N$ まで（両端を含む）なので $\log_2 N + 1$ ビット必要であり、深さ 8 の本件では 4 ビットになる。宣言 reg [stack_ptr_width:0] ptr_diff; はまさにそれを言っている。消えている -1 に注意したい。そこがこの行の肝であり、学生はしばしば [stack_ptr_width-1:0] と書き写して半日デバッグに費やす。

With $N = 8$, the full test is a comparison against 4'b1000, which is just ptr_diff[3] — a single wire, since the counter never exceeds 8. The empty test is a four-input NOR. Both flags are therefore essentially free. The cost of the cure is the counter itself: four flip-flops and an incrementer/decrementer, or about 30 to 40 gate equivalents in a standard-cell library.當 $N = 8$ 時，滿的判斷是跟 4'b1000 比較，也就是只看 ptr_diff[3] —— 一條線而已，因為計數值永遠不會超過 8。空的判斷是一個四輸入 NOR。所以兩個旗標基本上都是免費的。這個解法的代價是計數器本身：四個正反器加一個加一／減一電路，在標準元件庫裡大約是 30 到 40 個等效閘。$N = 8$ のとき、満杯の判定は 4'b1000 との比較、すなわち ptr_diff[3] を見るだけで済む。カウンタが 8 を超えないので配線 1 本である。空の判定は 4 入力 NOR である。したがってフラグは実質タダである。この解法のコストはカウンタ自体であり、フリップフロップ 4 個とインクリメンタ／デクリメンタ、標準セルライブラリでおよそ 30〜40 ゲート相当になる。

2.6 Cure 2 — an extra wrap bit2.6 解法二 —— 多一個繞回位元2.6 解法 2 — ラップビットを 1 本追加

Make each pointer one bit wider than the address it supplies. For a depth of eight, use four-bit pointers whose low three bits address the memory and whose top bit is a "lap counter" that toggles every time the pointer wraps. Now the pointer pair carries enough information on its own.讓每個指標都比它要提供的位址多一個位元。深度為八時，就用四位元的指標：低三位元去定址記憶體，最高位元是一個「圈數計數器」，指標每繞回一次就翻轉一次。這樣指標對本身就帶有足夠的資訊了。各ポインタを、供給するアドレスより 1 ビット広く取る。深さ 8 なら 4 ビットのポインタとし、下位 3 ビットでメモリをアドレスし、最上位ビットはポインタが折り返すたびに反転する「周回カウンタ」とする。これでポインタの組だけで十分な情報を持つようになる。

In words: the FIFO is empty when the pointers agree completely, including the lap bit — the writer has written exactly as many words as the reader has read. It is full when the addresses agree but the lap bits differ — the writer is exactly one whole lap ahead of the reader. Read it once more and convince yourself that these two conditions are mutually exclusive and cover the two coincident cases.用白話說：當兩個指標連圈數位元都完全相同時，FIFO 是空的 —— 寫入者寫進去的字數正好等於讀取者讀走的字數。當位址相同但圈數位元不同時，FIFO 是滿的 —— 寫入者正好領先讀取者整整一圈。請再讀一次，說服自己這兩個條件互斥，而且涵蓋了兩種重合的情況。言葉にすれば、周回ビットまで含めてポインタが完全に一致するとき FIFO は空である——書き手が書いたワード数と読み手が読んだワード数がちょうど等しい。アドレスは一致するが周回ビットが異なるとき FIFO は満杯である——書き手が読み手のちょうど 1 周先にいる。もう一度読み返して、この二つの条件が互いに排他的で、かつ一致する二つの場合を覆い尽くしていることを自分で納得してほしい。

  // Cure 2: four-bit pointers for an eight-deep FIFO
  reg [3:0] wp, rp;
  wire do_wr = write_to_stack && !stack_full;
  wire do_rd = read_from_stack && !stack_empty;

  always @(posedge clk or posedge rst)
    if (rst) begin wp <= 4'd0; rp <= 4'd0; end
    else begin
      if (do_wr) wp <= wp + 4'd1;
      if (do_rd) rp <= rp + 4'd1;
    end

  assign stack_empty = (wp == rp);
  assign stack_full  = (wp[3] != rp[3]) && (wp[2:0] == rp[2:0]);
  // memory is addressed with the LOW three bits only
  // stack[wp[2:0]] <= Data_in;   Data_out <= stack[rp[2:0]];

Two bonuses come with this style. First, the occupancy is available for free as wp - rp (a four-bit subtraction interpreted modulo 16, which gives the correct 0…8 answer), so you can expose an "almost full" threshold without a separate counter. Second, and much more important, each pointer is now written by exactly one clock domain, which is what makes it safe to Gray-code the pointers and synchronise them across a clock boundary with two flip-flops. That is how every asynchronous FIFO in every modern SoC works, and recognising the wrap-bit trick here is the bridge from this lecture to that topic.這種寫法還附帶兩個好處。第一，佔用量免費可得，就是 wp - rp（四位元減法，以模 16 解讀，會給出正確的 0…8 答案），所以你不必另設計數器就能提供一個「快滿了」的門檻。第二，而且重要得多：現在每個指標都只被一個時脈域寫入，這正是「把指標改成格雷碼、再用兩級正反器同步過時脈邊界」之所以安全的原因。現代 SoC 裡每一個非同步 FIFO 都是這樣做的，而在這裡認出繞回位元這個技巧，就是從本講通往那個主題的橋。この流儀には二つのおまけがつく。第一に、占有数が wp - rp としてタダで得られる（4 ビットの減算を 16 を法として解釈すれば、正しく 0…8 が出る）。したがって別途カウンタを置かずに「もうすぐ満杯」のしきい値を外に出せる。第二に、そしてこちらがはるかに重要だが、各ポインタがちょうど一つのクロックドメインからのみ書かれるようになる。これこそ、ポインタをグレイコード化してフリップフロップ 2 段でクロック境界を越えて同期させても安全な理由である。現代の SoC の非同期 FIFO はすべてこの方式であり、ここでラップビットの技法を見抜けることが、本講からその話題への橋渡しになる。

2.7 Cure 3 — sacrifice one slot2.7 解法三 —— 犧牲一個位置2.7 解法 3 — 1 スロットを犠牲にする

The cheapest cure in logic: declare that the FIFO is full when there is exactly one free slot left, so the pointers never actually coincide in the full state.邏輯上最便宜的解法：規定「還剩剛好一個空位時就算滿」，這樣在滿的狀態下兩個指標永遠不會真正重合。論理としては最も安価な解法である。空きスロットがちょうど 1 つ残った時点で満杯と宣言してしまえば、満杯状態でポインタが実際に一致することはなくなる。

No extra register at all; just an incrementer and a comparator on the write pointer, and the incremented value is usually available anyway because you need it for the next write. The price is one word of storage out of $N$. For an eight-deep, twelve-bit FIFO that is 12 flip-flops thrown away to save a 4-bit counter — a bad trade. For a 4096-deep FIFO built from a RAM macro, one word is negligible and the cure is excellent. The arithmetic is simple: the cure is good when a word of storage is cheaper than $\log_2 N + 1$ flip-flops plus an up/down counter, which is true as soon as the memory is a compiled RAM rather than a pile of flops.完全不需要額外的暫存器；只要在寫指標上加一個加一電路與一個比較器，而且加一後的值通常本來就有，因為下一次寫入要用它。代價是 $N$ 個字裡損失一個。對一個八字深、十二位元寬的 FIFO 來說，這等於丟掉 12 個正反器來省下一個 4 位元計數器 —— 很划不來。但對一個用 RAM 巨集做的 4096 字深 FIFO 來說，一個字微不足道，這個解法就非常好。算式很簡單：當一個字的儲存比 $\log_2 N + 1$ 個正反器加一個上／下數計數器還便宜時，這個解法就划算；而只要記憶體是編譯出來的 RAM 而不是一堆正反器，這就成立了。追加のレジスタは一切要らない。書き込みポインタにインクリメンタと比較器を置くだけで、しかもインクリメント結果は次の書き込みに必要なので大抵すでに手元にある。代償は $N$ ワードのうち 1 ワードを失うことである。深さ 8・幅 12 ビットの FIFO なら、4 ビットのカウンタ 1 個を節約するためにフリップフロップ 12 個を捨てることになり、割に合わない。RAM マクロで作る深さ 4096 の FIFO なら 1 ワードは無視でき、この解法は非常に優れている。算数は単純で、1 ワードの記憶が $\log_2 N + 1$ 個のフリップフロップと上下カウンタより安いときにこの解法はよい。メモリがフリップフロップの山ではなくコンパイルされた RAM になった時点で、それは成り立つ。

2.8 Choosing a cure2.8 該選哪一種解法2.8 解法の選び方

The lecture's choice of the occupancy counter is the right one for its context: a single clock, a small depth, a flop-based memory, and a desire for the clearest possible code. You should still be able to rewrite it in either of the other two styles on demand, because the question "your FIFO must now cross from a 100 MHz domain to a 156.25 MHz domain, what changes?" is a standard interview and examination question, and the answer begins "the occupancy counter has to go".本講選擇佔用量計數器，以它的情境而言是對的：單一時脈、深度很小、用正反器做記憶體，而且希望程式碼盡可能清楚。但你仍然應該能隨時把它改寫成另外兩種寫法，因為「你的 FIFO 現在要從 100 MHz 域跨到 156.25 MHz 域，哪裡要改？」是標準的面試與考試題目，而答案的第一句就是「佔用量計數器必須拿掉」。本講が占有数カウンタを選んだのは、その文脈では正しい。単一クロック、浅い深さ、フリップフロップによるメモリ、そしてできる限り分かりやすいコードという条件に合っている。それでも、求めに応じて他の二つの流儀に書き換えられるようにしておきたい。「この FIFO を 100 MHz ドメインから 156.25 MHz ドメインへ渡すことになった。何が変わるか」は面接でも試験でも定番の問いであり、答えは「占有数カウンタは捨てることになる」から始まるからである。

3. The FIFO in Verilog, Line by Line3. 逐行解讀 FIFO 的 Verilog3. FIFO の Verilog を 1 行ずつ

Here is the complete module as the slides give it, cleaned up only in layout — the content is unchanged, including the defects, which are dissected in §3.6. Read it once for shape, then we will take it apart.以下是投影片給的完整模組，只在排版上整理過 —— 內容完全沒動，連缺陷也保留，那些缺陷會在 §3.6 解剖。先讀一遍抓形狀，然後我們再把它拆開。以下はスライドにあるモジュールの全体で、整えたのはレイアウトだけである。内容は欠陥も含めてそのままで、欠陥は §3.6 で解剖する。まず全体の形をつかむために一度通して読み、そのあとで分解していく。

module FIFO (Data_out, Data_in, stack_empty, stack_full,
             clk, rst, write_to_stack, read_from_stack);

  parameter stack_width     = 12;   // width of stack and data paths
  parameter stack_height    = 8;    // height of stack, in words
  parameter stack_ptr_width = 3;    // width of pointer that addresses the stack

  output [stack_width-1:0]     Data_out;
  output                       stack_empty, stack_full;
  input  [stack_width-1:0]     Data_in;
  input                        clk, rst;
  input                        write_to_stack, read_from_stack;

  reg    [stack_ptr_width-1:0] read_ptr, write_ptr;   // addresses for reading and writing
  reg    [stack_ptr_width:0]   ptr_diff;              // gap between the pointers: 0..8 needs 4 bits
  reg    [stack_width-1:0]     Data_out;
  reg    [stack_width-1:0]     stack [stack_height-1:0];   // the memory array

  assign stack_empty = (ptr_diff == 0)            ? 1'b1 : 1'b0;
  assign stack_full  = (ptr_diff == stack_height) ? 1'b1 : 1'b0;

  always @ (posedge clk or posedge rst) begin: data_transfer
    if (rst) Data_out = 0;
    else if ((read_from_stack) && (!write_to_stack) && (!stack_empty))
      Data_out <= stack[read_ptr];
    else if ((write_to_stack) && (!read_from_stack) && (!stack_full))
      stack[write_ptr] <= Data_in;
  end  // data_transfer

  always @ (posedge clk or posedge rst) begin: update_stack_ptrs
    if (rst) begin
      read_ptr  <= 0;
      write_ptr <= 0;
      ptr_diff  <= 0;
    end
    else
      if ((write_to_stack) && (!stack_full) && (!read_from_stack)) begin
        write_ptr <= write_ptr + 1;   // address for the next clock edge
        ptr_diff  <= ptr_diff  + 1;
      end
      else if ((!write_to_stack) && (!stack_empty) && (read_from_stack)) begin
        read_ptr <= read_ptr + 1;
        ptr_diff <= ptr_diff - 1;
      end
  end  // update_stack_ptrs
endmodule

3.1 Declarations3.1 宣告3.1 宣言部

The port declarations follow the Verilog-1995 convention the whole course uses: the module header lists bare names, and the directions and widths come afterwards in the body. Data_out appears twice, once as output [stack_width-1:0] and once as reg [stack_width-1:0]. That is not a redefinition; it is the only legal way in 1995 syntax to say that a port is driven from a procedural block. Verilog-2001 lets you collapse it to output reg [11:0] Data_out, and Lecture 1 showed both. The other outputs, stack_empty and stack_full, are not re-declared because they are driven by continuous assignments, which must drive nets.埠宣告遵循整門課一路使用的 Verilog-1995 慣例：模組標頭只列出名字，方向與寬度在本體後面才給。Data_out 出現兩次，一次是 output [stack_width-1:0]，一次是 reg [stack_width-1:0]。那不是重複定義；在 1995 語法裡，這是唯一合法的方式來表達「這個埠由程序區塊驅動」。Verilog-2001 允許你把它縮寫成 output reg [11:0] Data_out，第 1 講兩種都示範過。另外兩個輸出 stack_empty 與 stack_full 沒有重新宣告，因為它們由連續指定驅動，而連續指定必須驅動 net。ポート宣言は本講義が一貫して使う Verilog-1995 の流儀に従う。モジュールヘッダには名前だけを並べ、方向と幅は本体側で後から与える。Data_out は 2 回現れ、1 回は output [stack_width-1:0]、もう 1 回は reg [stack_width-1:0] である。これは再定義ではなく、「このポートは手続き型ブロックから駆動される」と言うための 1995 構文における唯一の合法な書き方である。Verilog-2001 なら output reg [11:0] Data_out とまとめられ、第 1 講では両方を示した。他の出力 stack_empty と stack_full が再宣言されていないのは、それらが連続代入で駆動され、連続代入はネットを駆動しなければならないからである。

The memory is declared reg [stack_width-1:0] stack [stack_height-1:0]. Read the two ranges in the right order: the first range is the width of each element, the second is the number of elements. stack[3] is a 12-bit word; stack[3][7] is one bit of it in Verilog-2001 but is illegal in 1995, where you must copy the word to a temporary first. A memory may not appear as a whole in an expression, may not be a port, and may not be assigned by a continuous assignment; it is read and written one word at a time inside procedural code, which is exactly what the two always blocks do.記憶體宣告成 reg [stack_width-1:0] stack [stack_height-1:0]。兩個範圍要照正確順序讀：第一個範圍是每個元素的寬度，第二個是元素的個數。stack[3] 是一個 12 位元的字；stack[3][7] 在 Verilog-2001 裡是它的其中一個位元，但在 1995 裡不合法，那時你得先把整個字複製到暫時變數。記憶體不可以整個出現在運算式裡、不可以當埠、也不可以被連續指定賦值；它只能在程序性程式碼裡一次讀寫一個字，而這正是那兩個 always 區塊在做的事。メモリは reg [stack_width-1:0] stack [stack_height-1:0] と宣言される。二つの範囲は正しい順で読む必要がある。前の範囲が各要素の幅、後ろが要素数である。stack[3] は 12 ビットのワードであり、stack[3][7] は Verilog-2001 ではそのうちの 1 ビットを指すが、1995 では不正で、まずワードを一時変数へ写す必要がある。メモリは式の中に全体として現れることも、ポートになることも、連続代入で駆動されることもできない。手続き型コードの中で 1 ワードずつ読み書きするものであり、二つの always ブロックがまさにそれを行っている。

The highlighted line is the one to remember. reg [stack_ptr_width:0] ptr_diff gives four bits, not three, because the occupancy of an eight-word FIFO has nine possible values. Change it to [stack_ptr_width-1:0] and ptr_diff becomes a mod-8 counter: after eight writes it reads zero, stack_empty goes high while the FIFO is physically full, stack_full can never assert because ptr_diff == 8 is unreachable, and the FIFO will happily overwrite itself for ever. The symptom in simulation is maddening — data comes out in the right order for the first few words and then silently scrambles — which is why this one-character difference is worth memorising.標示出來的那一行才是要記住的。reg [stack_ptr_width:0] ptr_diff 給的是四位元而不是三位元，因為八字 FIFO 的佔用量有九種可能值。把它改成 [stack_ptr_width-1:0]，ptr_diff 就變成一個模 8 計數器：寫滿八次之後它讀回零，stack_empty 在 FIFO 實體上已滿時被拉高，stack_full 永遠不可能成立（因為 ptr_diff == 8 到不了），於是 FIFO 會開開心心地永遠覆寫自己。模擬時的症狀讓人抓狂 —— 前幾個字順序還對，之後就悄悄亂掉 —— 所以這一個字元的差別值得背起來。強調された行こそ覚えておくべきものである。reg [stack_ptr_width:0] ptr_diff は 3 ビットではなく 4 ビットを与える。8 ワードの FIFO の占有数は 9 通りあるからである。これを [stack_ptr_width-1:0] に変えると ptr_diff は 8 を法とするカウンタになる。8 回書き込んだ時点で値はゼロに戻り、物理的には満杯なのに stack_empty が立ち、ptr_diff == 8 には到達できないので stack_full は決して立たず、FIFO は平然と自分自身を上書きし続ける。シミュレーション上の症状は実に厄介で、最初の数ワードは正しい順で出てきて、その後に黙って乱れる。この 1 文字の違いを覚えておく価値はそこにある。

3.2 Flag generation3.2 旗標的產生3.2 フラグの生成

Both flags are continuous assignments with a conditional operator. The conditional is redundant: (ptr_diff == 0) is already a one-bit value, so assign stack_empty = (ptr_diff == 0); is identical and shorter. The explicit ? 1'b1 : 1'b0 is a stylistic habit from a time when people worried about the width of comparison results; it costs nothing and synthesises to the same comparator.兩個旗標都是帶條件運算子的連續指定。那個條件運算子是多餘的：(ptr_diff == 0) 本來就是一個一位元的值，所以 assign stack_empty = (ptr_diff == 0); 完全等價而且更短。明寫 ? 1'b1 : 1'b0 是舊時代的風格習慣，當年大家會擔心比較結果的位元寬度；它不花成本，合成出來也是同一個比較器。どちらのフラグも条件演算子つきの連続代入である。この条件演算子は冗長で、(ptr_diff == 0) はもともと 1 ビットの値なので、assign stack_empty = (ptr_diff == 0); と書けば同じ意味で短い。? 1'b1 : 1'b0 を明示するのは、比較結果の幅を気にしていた時代のスタイル上の習慣である。コストはかからず、合成結果も同じ比較器になる。

What matters is when these flags are valid. They are pure combinational functions of ptr_diff, which is a register. Therefore, during any given clock cycle, the flags describe the FIFO's occupancy as it was established by the previous rising edge. They are stable for the whole cycle, they change shortly after the edge, and the producer and consumer can sample them with ordinary setup and hold margins. This is the behaviour you want and it is why both flags can be fed straight back into the two always blocks without creating a loop: the blocks only look at the flags at an edge, and at that instant the flags still describe the pre-edge state.真正重要的是這些旗標什麼時候有效。它們是 ptr_diff 的純組合函數，而 ptr_diff 是暫存器。因此在任何一個時脈週期內，旗標描述的都是上一個上升邊緣所確立的佔用量。它們整個週期都穩定，在邊緣後不久才改變，生產者與消費者可以用一般的 setup/hold 餘裕去取樣它們。這正是你要的行為，也是為什麼兩個旗標可以直接餵回那兩個 always 區塊而不會造成迴路：區塊只在邊緣看旗標，而在那一瞬間旗標描述的仍然是邊緣之前的狀態。本当に重要なのは、このフラグがいつ有効かである。フラグは ptr_diff の純粋な組合せ関数であり、ptr_diff はレジスタである。したがって任意のクロックサイクル中、フラグは直前の立ち上がりエッジで確定した占有数を表す。1 サイクルのあいだ安定しており、エッジの直後に変化するので、生産者も消費者も通常のセットアップ／ホールドの余裕でサンプルできる。これが望ましい動作であり、両方のフラグをそのまま二つの always ブロックへ戻してもループにならない理由でもある。ブロックはエッジでしかフラグを見ず、その瞬間のフラグはまだエッジ前の状態を表しているからである。

3.3 The data-transfer block3.3 資料搬移區塊3.3 データ転送ブロック

The first always block, named data_transfer by the begin: data_transfer label, moves data in and out of the memory. The named block is not decoration: it gives the block an identifier you can use in hierarchical references from a testbench, and it is required if you want to declare local variables inside it.第一個 always 區塊靠 begin: data_transfer 這個標籤被命名為 data_transfer，它負責把資料搬進與搬出記憶體。命名區塊不是裝飾：它給了這個區塊一個識別字，讓測試平台可以用階層式參照指到它，而且如果你想在區塊內宣告區域變數，命名是必要的。最初の always ブロックは begin: data_transfer というラベルで data_transfer と命名されており、メモリへのデータの出し入れを担当する。ブロックへの命名は飾りではない。テストベンチから階層参照で指せる識別子を与えるものであり、ブロック内でローカル変数を宣言したい場合には必須でもある。

Three mutually exclusive branches follow the reset. The read branch fires when a read is requested, a write is not, and the FIFO is not empty; it copies stack[read_ptr] into the output register. The write branch fires when a write is requested, a read is not, and the FIFO is not full; it copies Data_in into stack[write_ptr]. When neither branch fires nothing happens and both the memory and the output register hold — which is the correct behaviour for an edge-triggered block and costs nothing, because flip-flops hold by default.重置之後跟著三個互斥的分支。讀取分支在「有讀取請求、沒有寫入請求、且 FIFO 不空」時啟動，它把 stack[read_ptr] 複製到輸出暫存器。寫入分支在「有寫入請求、沒有讀取請求、且 FIFO 未滿」時啟動，它把 Data_in 複製到 stack[write_ptr]。兩個分支都沒啟動時什麼事都不發生，記憶體與輸出暫存器都保持原值 —— 這正是邊緣觸發區塊該有的行為，而且不花任何成本，因為正反器本來就預設保持。リセットの後に、互いに排他的な三つの分岐が続く。読み出し分岐は、読み出し要求があり、書き込み要求がなく、FIFO が空でないときに発火し、stack[read_ptr] を出力レジスタへ写す。書き込み分岐は、書き込み要求があり、読み出し要求がなく、FIFO が満杯でないときに発火し、Data_in を stack[write_ptr] へ写す。どちらも発火しなければ何も起こらず、メモリも出力レジスタも値を保持する。これはエッジ記述ブロックとして正しい動作であり、フリップフロップは既定で保持するのでコストもかからない。

Notice the asymmetry the branches create. Because the conditions include !write_to_stack and !read_from_stack respectively, a cycle in which both requests are high does nothing at all: no word is stored and no word is fetched. The write is lost and the read returns stale data. For a FIFO that is sitting between an unstoppable producer and an intermittent consumer, this is a serious functional limitation, and §3.6 shows the fix.注意這些分支造成的不對稱。因為條件裡分別含有 !write_to_stack 與 !read_from_stack，所以兩個請求同時為高的那一個週期什麼都不做：沒有字被存進去，也沒有字被取出來。寫入遺失，讀取傳回舊資料。對一個夾在停不下來的生產者與斷斷續續的消費者之間的 FIFO 來說，這是嚴重的功能限制，而 §3.6 會給出修法。この分岐が生む非対称性に注意したい。条件にそれぞれ !write_to_stack と !read_from_stack が入っているため、両方の要求が High になるサイクルでは何も起こらない。ワードは格納されず、取り出されもしない。書き込みは失われ、読み出しは古いデータを返す。止まらない生産者と断続的な消費者のあいだに挟まる FIFO としては深刻な機能上の制約であり、§3.6 で修正を示す。

Notice also what the read branch does not do: it does not clear the memory word it has just read. The word stays in stack[read_ptr] until it is overwritten several laps later. That is right — clearing it would cost a second write port — and it means that if you dump the memory contents in a waveform viewer you will see old data lying around behind the read pointer. That is normal and is not a bug.也注意讀取分支沒做什麼：它不會清掉剛讀出的那個記憶體字。那個字會一直留在 stack[read_ptr]，直到好幾圈之後被覆寫。這是對的 —— 清掉它要多一個寫入埠 —— 而這也表示如果你在波形檢視器裡把記憶體內容倒出來，會看到讀指標後面還躺著舊資料。那是正常的，不是 bug。読み出し分岐がしないことにも注意したい。読み出したメモリのワードをクリアしないのである。そのワードは数周あとに上書きされるまで stack[read_ptr] に残り続ける。これは正しい。クリアするには書き込みポートがもう一つ要るからである。そのため波形ビューアでメモリの中身を覗くと、読み出しポインタの後ろに古いデータが残って見える。これは正常であり、バグではない。

3.4 The pointer block3.4 指標區塊3.4 ポインタブロック

The second block maintains read_ptr, write_ptr and ptr_diff. Its branch conditions are written to mirror the data block exactly, which is the essential discipline here: the pointer must move if and only if the data moved. If the two blocks ever disagree — if a word is written but the pointer is not advanced, or the pointer advances with no word written — the FIFO is corrupt and the corruption is invisible until data comes out in the wrong order.第二個區塊維護 read_ptr、write_ptr 與 ptr_diff。它的分支條件寫得與資料區塊完全對應，而這正是這裡最關鍵的紀律：資料動了，指標才可以動；指標動了，資料也一定動過。只要這兩個區塊有一次不一致 —— 存了字卻沒推進指標，或指標推進了卻沒存字 —— FIFO 就壞了，而且這種壞法要等到資料以錯誤順序出來才看得見。二つ目のブロックは read_ptr、write_ptr、ptr_diff を保守する。その分岐条件はデータ側のブロックと正確に対応するよう書かれており、これがここでの要となる規律である。データが動いたとき、かつそのときに限り、ポインタも動かなければならない。両ブロックが一度でも食い違えば——ワードを書いたのにポインタを進めない、あるいはワードを書かずにポインタだけ進める——FIFO は壊れ、その壊れ方はデータが誤った順で出てくるまで見えない。

That duplication of the conditions is also the weakness of this coding style. The condition appears twice, in two different always blocks, and a maintainer who changes one and not the other introduces exactly the bug just described. A more robust style computes the conditions once:條件被重複寫兩次，也正是這種寫法的弱點。同一個條件出現在兩個不同的 always 區塊裡，而一個維護者只改了其中一個，就會製造出剛才講的那個 bug。比較穩固的寫法會把條件只算一次：条件が二度書かれることは、この流儀の弱点でもある。同じ条件が二つの別々の always ブロックに現れるため、片方だけを直した保守者は、いま述べたバグをそのまま作り込むことになる。より堅牢な流儀では条件を一度だけ計算する。

  wire do_write = write_to_stack && !stack_full;
  wire do_read  = read_from_stack && !stack_empty;

  always @(posedge clk or posedge rst)
    if (rst) Data_out <= 0;
    else if (do_read) Data_out <= stack[read_ptr];

  always @(posedge clk)
    if (do_write) stack[write_ptr] <= Data_in;   // memory: no reset

  always @(posedge clk or posedge rst)
    if (rst) begin write_ptr <= 0; read_ptr <= 0; ptr_diff <= 0; end
    else begin
      if (do_write) write_ptr <= write_ptr + 1'b1;
      if (do_read)  read_ptr  <= read_ptr  + 1'b1;
      case ({do_write, do_read})
        2'b10:   ptr_diff <= ptr_diff + 1'b1;
        2'b01:   ptr_diff <= ptr_diff - 1'b1;
        default: ptr_diff <= ptr_diff;      // 00 and 11 both leave the count alone
      endcase
    end

This version is shorter, states the intent once, and — because do_write and do_read no longer exclude each other — supports simultaneous read and write, with the occupancy correctly unchanged when both happen. It also separates the memory into its own always @(posedge clk) block with no reset, which is what you want if the memory is ever to be mapped onto a RAM macro: a RAM has no reset pin, and a reset in the inference template will prevent the tool from recognising it.這個版本更短，意圖只敘述一次，而且 —— 因為 do_write 與 do_read 不再互相排斥 —— 支援同時讀寫，並在兩者同時發生時正確地讓佔用量維持不變。它也把記憶體分到自己的 always @(posedge clk) 區塊、不帶重置，這正是你希望記憶體有朝一日能映射到 RAM 巨集時該做的事：RAM 沒有重置腳位，推論樣板裡有重置會讓工具認不出它。この版はより短く、意図を一度だけ述べており、しかも do_write と do_read が互いを排除しなくなったため、同時の読み書きに対応し、両方が起きたときは占有数が正しく変わらないままになる。さらにメモリをリセットなしの always @(posedge clk) ブロックへ分けている。これはメモリをいずれ RAM マクロへ割り当てたい場合に望ましい形である。RAM にはリセットピンがなく、推論テンプレートにリセットがあるとツールが RAM と認識できなくなるからである。

3.5 Why nonblocking matters here3.5 這裡為什麼一定要用非阻塞指定3.5 ここでノンブロッキングが効く理由

This design is an unusually clean illustration of the nonblocking rule from Lecture 6, because the two always blocks genuinely read each other's outputs.這個設計是第 6 講非阻塞規則異常乾淨的範例，因為那兩個 always 區塊真的在讀彼此的輸出。この設計は、第 6 講のノンブロッキング規則を際立ってきれいに示す例である。二つの always ブロックが本当に互いの出力を読んでいるからである。

At a rising clock edge, both blocks are triggered in an order the language does not define. The pointer block evaluates !stack_full, which is a function of ptr_diff, and the data block evaluates stack[read_ptr], which is a function of read_ptr. Both ptr_diff and read_ptr are updated by the pointer block at this very edge. If those updates were made with blocking assignments, the new values would be visible immediately, and whether the data block saw the old or the new read_ptr would depend on which block the simulator happened to execute first — a race, and the two orders produce different, both plausible-looking, waveforms.在時脈上升邊緣，兩個區塊都被觸發，而語言並不規定它們的執行順序。指標區塊會求值 !stack_full，那是 ptr_diff 的函數；資料區塊會求值 stack[read_ptr]，那是 read_ptr 的函數。而 ptr_diff 與 read_ptr 都正好在這個邊緣被指標區塊更新。如果那些更新用的是阻塞指定，新值會立刻可見，於是資料區塊看到的是舊的還是新的 read_ptr，就取決於模擬器剛好先執行哪個區塊 —— 這就是競爭，而且兩種順序會產生不同、卻都看起來合理的波形。クロックの立ち上がりエッジで両方のブロックが起動するが、その順序を言語は定めていない。ポインタブロックは ptr_diff の関数である !stack_full を評価し、データブロックは read_ptr の関数である stack[read_ptr] を評価する。そして ptr_diff も read_ptr も、まさにこのエッジでポインタブロックが更新する。もしその更新がブロッキング代入なら新しい値がただちに見えてしまい、データブロックが古い read_ptr を見るか新しい方を見るかは、シミュレータがどちらのブロックを先に実行したかで決まる。これがレースであり、二つの順序はそれぞれ異なる、しかしどちらももっともらしい波形を生む。

With nonblocking assignments the race disappears. Every right-hand side in the time step is evaluated using the pre-edge values; all the left-hand sides are updated afterwards, in the nonblocking update region. The data block is therefore guaranteed to index the memory with the old read_ptr — the address of the word that is actually the oldest — and to test the old stack_full — the occupancy before this edge's write. Both are what the hardware does, because in the hardware the flip-flop outputs feeding the address multiplexer and the comparator do not change until after the edge has propagated.用非阻塞指定，競爭就消失了。該時間步內的每一個右手邊都用邊緣前的值求值；所有左手邊則在之後的非阻塞更新區間才更新。因此資料區塊保證會用舊的 read_ptr 去索引記憶體 —— 也就是真正最舊那個字的位址 —— 並且測試舊的 stack_full，也就是這個邊緣的寫入之前的佔用量。這兩件事都正是硬體的行為，因為在硬體裡，餵給位址多工器與比較器的那些正反器輸出，要等到邊緣傳播完才會改變。ノンブロッキング代入を使えばレースは消える。その時間ステップのすべての右辺はエッジ前の値で評価され、左辺はその後のノンブロッキング更新領域でまとめて更新される。したがってデータブロックは必ず古い read_ptr でメモリを引き——それが実際に最も古いワードのアドレスである——古い stack_full、すなわちこのエッジの書き込み以前の占有数を判定する。どちらもハードウェアの振る舞いそのものである。ハードウェアでは、アドレスのマルチプレクサと比較器へ入るフリップフロップ出力は、エッジが伝わり終わるまで変化しないからである。

3.6 Three defects in the slide listing3.6 投影片程式碼的三個缺陷3.6 スライドのコードにある三つの欠陥

The listing on slide 5 contains three problems. One is a typographical accident, one is a style violation that happens to be harmless here, and one is a genuine design limitation. Being able to tell them apart is the skill this section is really teaching.投影片第 5 頁的程式碼有三個問題。一個是排版上的意外，一個是風格違規但在這裡剛好無害，還有一個是真正的設計限制。能把它們分辨開來，才是這一節真正要教的本事。スライド 5 ページ目のコードには三つの問題がある。一つは組版上の事故、一つはスタイル違反だがここではたまたま無害なもの、そしてもう一つは本物の設計上の制約である。この三つを見分けられることこそ、この節が本当に教えている技能である。

Defect 1 — a stray semicolon缺陷一 —— 多出來的分號欠陥 1 — 余分なセミコロン

As printed, the second branch of the data block reads印出來的樣子是，資料區塊的第二個分支寫成印刷されたままでは、データブロックの二つ目の分岐はこう書かれている。

    else if ((write_to_stack) && (!read_from_stack) && (!stack_full));
      stack [write_ptr] <= Data_in;

with a semicolon immediately after the closing parenthesis (and an unbalanced extra parenthesis besides). In Verilog, as in C, a lone semicolon is a null statement and is a perfectly legal body for an if. The condition is therefore evaluated, nothing is done either way, and the following line — stack[write_ptr] <= Data_in; — is not part of the if at all. It becomes the next statement in the block, executed unconditionally on every clock edge that is not a reset.在右括號後面緊接一個分號（而且還多了一個不成對的括號）。在 Verilog 裡跟在 C 裡一樣，孤零零的分號是一個空敘述，而且完全合法地可以當作 if 的本體。於是條件照樣被求值，但不論真假都不做任何事，而下一行 —— stack[write_ptr] <= Data_in; —— 根本就不屬於那個 if。它變成區塊裡的下一個敘述，在每一個不是重置的時脈邊緣都無條件執行。閉じ括弧の直後にセミコロンが付いている（しかも対応の取れない括弧も 1 個余分にある）。Verilog でも C と同じく、単独のセミコロンは空文であり、if の本体としてまったく合法である。したがって条件は評価されるが、真でも偽でも何も行われず、次の行 stack[write_ptr] <= Data_in; は if の一部ではなくなる。それはブロック内の次の文となり、リセットでないすべてのクロックエッジで無条件に実行される。

The consequence is that every rising edge writes Data_in into stack[write_ptr], whether a write was requested or not, whether the FIFO is full or not, and even on cycles when a read is in progress. The pointers, however, still advance only on a legal write, so the slot under write_ptr is simply rewritten with whatever happens to be on Data_in until a real write moves the pointer on. A FIFO built this way appears to work for simple test patterns — the last value written before the pointer advances is the one that survives — and corrupts data as soon as Data_in changes between the request and the edge. Treat it as a transcription error in the slide, not as intended behaviour, and let it teach you how much a semicolon can cost.結果是每一個上升邊緣都會把 Data_in 寫進 stack[write_ptr]：不管有沒有提出寫入請求、不管 FIFO 滿不滿，甚至在讀取進行中的週期也照寫。但指標仍然只在合法寫入時才前進，所以 write_ptr 指到的那個位置就被 Data_in 當下的值一再重寫，直到一次真正的寫入把指標推走為止。這樣建出來的 FIFO 在簡單的測試樣式下看起來會正常 —— 指標前進之前最後寫進去的那個值會活下來 —— 但只要 Data_in 在請求與邊緣之間變動，資料就毀了。把它當成投影片的謄寫錯誤，而不是有意的行為，並讓它教你一個分號可以多貴。結果として、すべての立ち上がりエッジで Data_in が stack[write_ptr] に書き込まれる。書き込み要求の有無にも、FIFO が満杯かどうかにも関係なく、読み出し中のサイクルでさえ書き込む。それでもポインタは正当な書き込みのときしか進まないので、write_ptr の指すスロットは、本物の書き込みがポインタを進めるまで、そのときどきの Data_in で上書きされ続ける。こうして作られた FIFO は単純なテストパターンでは動いて見える——ポインタが進む直前に書かれた値が生き残るからである——が、要求とエッジのあいだに Data_in が変わった瞬間にデータは壊れる。これは意図した動作ではなくスライドの転記ミスと見なし、セミコロン 1 個がどれほど高くつくかの教訓として受け取るとよい。

Defect 2 — a blocking assignment in a clocked block缺陷二 —— 時脈區塊裡的阻塞指定欠陥 2 — クロック同期ブロック内のブロッキング代入

The reset branch uses Data_out = 0; while the read branch uses Data_out <= stack[read_ptr];. The same variable is assigned with both operators in the same block. The language permits it, but it is forbidden by every coding standard and flagged by every linter, for a good reason: a blocking assignment schedules its update in the active region and a nonblocking one in the NBA region, so any other process in the same time step sees a different value depending on which branch fired. Here nothing else reads Data_out in the same time step, so no harm is done and synthesis produces the same twelve flip-flops with asynchronous reset either way. Fix it anyway — write Data_out <= 0; — because the cost of fixing it is zero and the cost of a reviewer wondering whether it was deliberate is not.重置分支用的是 Data_out = 0;，而讀取分支用的是 Data_out <= stack[read_ptr];。同一個變數在同一個區塊裡被兩種運算子指定。語言允許，但每一份程式碼規範都禁止，每一個 linter 都會標出來，而且理由充分：阻塞指定把更新排在 active 區間，非阻塞排在 NBA 區間，所以同一時間步裡任何其他行程看到的值，會隨著哪個分支啟動而不同。在這裡沒有別的東西會在同一時間步讀 Data_out，所以沒有造成傷害，合成出來兩種寫法都是同樣十二個帶非同步重置的正反器。還是改掉吧 —— 寫成 Data_out <= 0; —— 因為改它的成本是零，而讓審查者去猜「這是故意的嗎」的成本不是零。リセット分岐は Data_out = 0; を使い、読み出し分岐は Data_out <= stack[read_ptr]; を使っている。同じ変数が同じブロック内で両方の演算子によって代入されている。言語としては許されるが、どのコーディング規約も禁じ、どの linter も指摘する。理由は明快で、ブロッキング代入は更新をアクティブ領域に、ノンブロッキング代入は NBA 領域にスケジュールするため、同じ時間ステップの他のプロセスが見る値がどちらの分岐が発火したかで変わってしまう。ここでは同じ時間ステップで Data_out を読むものが他に無いので実害はなく、合成結果もどちらでも非同期リセット付きフリップフロップ 12 個で同じである。それでも Data_out <= 0; と直しておきたい。直すコストはゼロで、レビュアーに「これは意図的か」と考えさせるコストはゼロではないからである。

Defect 3 — simultaneous read and write do nothing缺陷三 —— 同時讀寫什麼都不做欠陥 3 — 同時の読み書きで何も起きない

This is the real design limitation, and unlike the first two it is clearly intentional in the code. Every branch in both blocks requires the opposite request to be low. When a producer and a consumer both act in the same cycle — the normal steady state of a FIFO that is being drained as fast as it is being filled — the FIFO stalls completely: the incoming word is dropped and the outgoing word is not fetched. Throughput collapses to zero in exactly the operating point you care about most.這才是真正的設計限制，而且不像前兩個，它在程式碼裡明顯是刻意的。兩個區塊裡的每一個分支都要求對方的請求為低。當生產者與消費者在同一個週期都動作 —— 也就是一個被填滿多快就被抽乾多快的 FIFO 的正常穩態 —— FIFO 會完全停擺：進來的字被丟掉，出去的字也沒被取出。恰恰在你最在意的那個工作點上，吞吐量塌成零。これこそ本物の設計上の制約であり、前の二つと違ってコード上明らかに意図的である。両ブロックのすべての分岐が、相手側の要求が Low であることを要求している。生産者と消費者が同じサイクルで動くとき——満たされるのと同じ速さで吸い出される FIFO の通常の定常状態である——FIFO は完全に停止する。入ってくるワードは捨てられ、出ていくワードも取り出されない。最も重要な動作点でスループットがゼロに落ちるのである。

else if (read_from_stack
      && !write_to_stack
      && !stack_empty)
  Data_out <= stack[read_ptr];
else if (write_to_stack
      && !read_from_stack
      && !stack_full)
  stack[write_ptr] <= Data_in;

if (do_read)
  Data_out <= stack[read_ptr];
// a separate statement, not an else-if
if (do_write)
  stack[write_ptr] <= Data_in;

// with
// do_read  = read_from_stack  && !stack_empty
// do_write = write_to_stack   && !stack_full

The corrected version raises a question the slide version never has to answer: when the FIFO is empty and a read and a write arrive together, should the incoming word pass straight through to Data_out? With the code above it does not — the write lands in memory and the read is suppressed because stack_empty is still high — so the word is available on the next read. That is the conventional, simple answer. A "first-word fall-through" FIFO would forward it combinationally, which costs a bypass multiplexer and lands Data_out in a longer timing path. Decide which you want and document it, because it is exactly the kind of corner case that two blocks of a chip will disagree about at integration.修正後的版本帶出一個投影片版永遠不必回答的問題：當 FIFO 是空的、而讀取與寫入同時到來時，進來的那個字應該直接穿到 Data_out 嗎？以上面的程式碼來說是不會的 —— 寫入落在記憶體裡，而讀取因為 stack_empty 仍為高而被抑制 —— 所以那個字要等下一次讀取才拿得到。這是傳統、簡單的答案。所謂「first-word fall-through」的 FIFO 會用組合邏輯把它直接轉送出去，代價是一個旁路多工器，而且把 Data_out 放進一條更長的時序路徑。決定你要哪一種並寫進文件，因為這正是晶片裡兩個區塊在整合時最容易各說各話的那種邊角案例。修正版は、スライド版なら答えずに済んだ問いを突きつける。FIFO が空のときに読み出しと書き込みが同時に来たら、入ってきたワードはそのまま Data_out へ抜けるべきか。上のコードでは抜けない。書き込みはメモリに入り、stack_empty がまだ High なので読み出しは抑止される。したがってそのワードは次の読み出しで得られる。これが従来どおりの単純な答えである。「first-word fall-through」型の FIFO なら組合せ的に転送するが、バイパス用のマルチプレクサを要し、Data_out をより長いタイミングパスに置くことになる。どちらを採るか決めて文書化しておきたい。統合時にチップ内の二つのブロックが食い違うのは、まさにこの種の境界ケースだからである。

3.7 Read latency and fall-through3.7 讀取延遲與直通輸出3.7 読み出しレイテンシとフォールスルー

Because Data_out is a register written at the clock edge, the word requested at edge $n$ appears at the output shortly after edge $n$ and is stable throughout cycle $n{+}1$. The consumer therefore sees its data one cycle after it asked. This is the standard or non-look-ahead FIFO interface, and it has a pleasant property: the output is a flip-flop, so the timing path leaving the FIFO is short and the design will not limit the clock frequency of whatever it drives.因為 Data_out 是在時脈邊緣被寫入的暫存器，所以在邊緣 $n$ 請求的字會在邊緣 $n$ 之後不久出現在輸出，並在整個週期 $n{+}1$ 保持穩定。消費者因此在提出要求的一個週期後才看到資料。這就是標準型或非預看型的 FIFO 介面，它有個很好的性質：輸出是一個正反器，所以離開 FIFO 的時序路徑很短，這個設計不會限制它所驅動對象的時脈頻率。Data_out はクロックエッジで書かれるレジスタなので、エッジ $n$ で要求されたワードはエッジ $n$ の直後に出力へ現れ、サイクル $n{+}1$ のあいだ安定している。したがって消費者は要求の 1 サイクル後にデータを見る。これが標準型あるいは先読みなしの FIFO インタフェースであり、好ましい性質を持つ。出力がフリップフロップなので FIFO から出るタイミングパスが短く、この設計が駆動先のクロック周波数を制限することがない。

The alternative is a first-word fall-through or show-ahead FIFO, in which the oldest word is presented on the output continuously, without a request, and read_from_stack behaves as an acknowledgement that discards it and presents the next. That interface is friendlier to the consumer — no latency, no need to pipeline the request — but it puts the memory's read multiplexer directly on the output, which for a 16-bit, 32-deep FIFO is a 32-to-1 multiplexer in the output path. In a cell-based ASIC flow you would almost always keep the registered output and let the consumer deal with the cycle of latency.另一種做法是 first-word fall-through（又稱 show-ahead）FIFO：最舊的那個字不必請求就一直呈現在輸出上，而 read_from_stack 的角色變成「確認收到」，把它丟掉並呈現下一個。那種介面對消費者比較友善 —— 沒有延遲，也不必把請求管線化 —— 但它把記憶體的讀取多工器直接放在輸出上，對一個 16 位元、32 字深的 FIFO 來說，那就是輸出路徑上一個 32 對 1 的多工器。在 cell-based 的 ASIC 流程裡，你幾乎總是會保留暫存輸出，讓消費者自己去處理那一個週期的延遲。もう一つの選択肢は first-word fall-through（show-ahead とも呼ぶ）型の FIFO である。最も古いワードが要求なしに常時出力へ提示され、read_from_stack はそれを破棄して次を提示する確認信号として働く。このインタフェースは消費者にやさしい——レイテンシがなく、要求をパイプライン化する必要もない——が、メモリの読み出しマルチプレクサを出力に直結させることになり、16 ビット・深さ 32 の FIFO なら出力経路に 32 対 1 のマルチプレクサが入る。セルベースの ASIC フローでは、ほぼ常にレジスタ出力を保ち、1 サイクルのレイテンシは消費者側に処理させる。

3.8 A testbench for the FIFO3.8 FIFO 的測試平台3.8 FIFO のテストベンチ

Lecture 2 gave you the machinery; this is where you point it at something. A FIFO testbench has a specific job: it must prove the ordering property, not merely that data comes out. Directed vectors cannot do that convincingly, so the standard approach is a reference model — a second, obviously correct implementation written with no regard for synthesis — and an automatic comparison.第 2 講給了你工具，這裡才是你把它對準目標的地方。FIFO 的測試平台有個特定任務：它必須證明順序性質，而不只是證明資料有出來。指向性向量無法有說服力地做到這件事，所以標準做法是一個參考模型 —— 第二個明顯正確、完全不顧合成的實作 —— 再加上自動比對。第 2 講が道具立てを与えた。ここはそれを実物に向ける場面である。FIFO のテストベンチには固有の仕事がある。データが出てくることではなく、順序の性質を証明しなければならない。指定ベクタではそれを説得力をもって示せないので、標準的な手口は参照モデル——合成をまったく気にせずに書いた、明らかに正しい第 2 の実装——と自動比較である。

`timescale 1ns/100ps

module FIFO_tb;
  parameter W = 12, D = 8;

  reg  [W-1:0] Data_in;
  reg          clk, rst, wr, rd;
  wire [W-1:0] Data_out;
  wire         empty, full;

  FIFO #(W, D, 3) DUT (Data_out, Data_in, empty, full, clk, rst, wr, rd);

  // ---- reference model: an untimed, unsynthesisable queue ----
  reg [W-1:0] golden [0:1023];
  integer     head, tail, errors;

  // ---- clock ----
  initial begin clk = 0; forever #5 clk = ~clk; end

  // ---- stimulus helpers ----
  task do_write (input [W-1:0] v);
    begin
      @(negedge clk);           // drive away from the active edge
      if (!full) begin
        Data_in = v; wr = 1;
        golden[tail] = v; tail = tail + 1;
      end
      @(negedge clk); wr = 0;
    end
  endtask

  task do_read;
    begin
      @(negedge clk);
      if (!empty) rd = 1;
      @(negedge clk); rd = 0;
      @(negedge clk);           // one cycle of read latency
      if (Data_out !== golden[head]) begin
        $display("%0t ERROR: expected %h, got %h", $time, golden[head], Data_out);
        errors = errors + 1;
      end
      head = head + 1;
    end
  endtask

  // ---- scenario ----
  integer i;
  initial begin
    $dumpfile("fifo.vcd"); $dumpvars(0, FIFO_tb);
    rst = 1; wr = 0; rd = 0; Data_in = 0;
    head = 0; tail = 0; errors = 0;
    @(negedge clk); rst = 0;

    for (i = 0; i < 12; i = i + 1) do_write(12'h100 + i);   // overfill: 8 land, 4 refused
    if (!full) $display("ERROR: FIFO should be full after 8 writes");

    for (i = 0; i < 8;  i = i + 1) do_read;                 // drain
    if (!empty) $display("ERROR: FIFO should be empty after 8 reads");

    $display("done, %0d errors", errors);
    $finish;
  end
endmodule

Several points of technique are worth lifting out of that listing.那段程式碼裡有幾個技巧值得單獨拉出來講。あのリストから取り出して述べておきたい技法がいくつかある。

• Drive on the inactive edge. Every stimulus task waits for negedge clk before changing an input. The design samples on posedge, so this gives a full half-cycle of setup and removes any question of whether the testbench and the design raced. This is the single most common cause of "it worked in simulation and the waveform looks insane".在非作用邊緣驅動。每一個刺激 task 在改變輸入之前都先等 negedge clk。設計是在 posedge 取樣的，所以這給了整整半個週期的 setup，也完全排除了測試平台與設計之間是否競爭的疑問。「模擬時明明會動，波形卻看起來瘋了」最常見的單一成因就是這個。非アクティブエッジで駆動する。各刺激タスクは入力を変える前に必ず negedge clk を待つ。設計は posedge でサンプルするので、これで半サイクル分のセットアップが丸ごと確保され、テストベンチと設計がレースしていないかという疑問も消える。「シミュレーションでは動いたのに波形が正気でない」の最大の原因がこれである。
• The golden queue is deliberately not synthesisable. A 1024-entry array with integer head and tail pointers has no business in a design, but it is the clearest possible statement of "first in, first out", and its clarity is exactly why it makes a trustworthy reference. The .nosyn badge belongs on the whole block: non-synthesisable黃金佇列是刻意不可合成的。一個用 integer 當頭尾指標的 1024 項陣列，放在設計裡毫無道理，但它是「先進先出」這句話最清楚的表述方式，而正是這份清楚讓它成為可信的參考。.nosyn 徽章該掛在整個區塊上：non-synthesisableゴールデンキューは意図的に合成不可である。integer のヘッド／テールポインタを持つ 1024 要素の配列など設計に置く理由はないが、「先入れ先出し」という言明としてはこれ以上なく明快であり、その明快さこそが参照として信頼できる理由である。.nosyn のバッジはブロック全体に付く。non-synthesisable
• Compare with !==, not !=. The case-inequality operator treats x and z as ordinary values, so an output that has gone unknown is reported as an error. With != a comparison against an x yields x, which is false-ish, and the error is silently swallowed. Lecture 3 covered the four-value logic; this is where it pays.要用 !== 比較，不是 !=。大小寫相等（case-inequality）運算子把 x 與 z 當成一般的值，所以輸出跑成未知時會被回報為錯誤。用 != 時，與 x 的比較結果是 x，那在判斷上接近假，於是錯誤被悄悄吞掉。第 3 講講過四值邏輯；這裡就是它派上用場的地方。比較には != ではなく !== を使う。ケース不等価演算子は x と z を普通の値として扱うので、出力が不定になればエラーとして報告される。!= では x との比較結果が x になり、判定上は偽寄りに扱われてエラーが黙って飲み込まれる。第 3 講で扱った 4 値論理が効いてくるのがここである。
• Test the refusals, not just the acceptances. The scenario writes twelve words into an eight-deep FIFO on purpose. A FIFO that silently accepts the ninth is broken, and only an overfill test will find it. Similarly, read past empty.要測被拒絕的情況，不是只測被接受的情況。這個情境故意往八字深的 FIFO 裡寫十二個字。會悄悄接受第九個字的 FIFO 就是壞的，而只有溢寫測試才找得出來。同理，也要讀到空之後再多讀。受け付けられる場合だけでなく、拒否される場合を試す。このシナリオは深さ 8 の FIFO にわざと 12 ワード書き込む。9 ワード目を黙って受け付ける FIFO は壊れており、それを見つけられるのは溢れさせる試験だけである。同様に、空になった先まで読んでみること。
• Count errors and print a verdict. A testbench that ends without saying "0 errors" is a testbench nobody will trust at three in the morning.計數錯誤並印出結論。結束時不會說出「0 errors」的測試平台，凌晨三點沒有人會相信它。エラーを数え、結論を印字する。最後に「0 errors」と言わないテストベンチを、午前 3 時に信じる人はいない。

Beyond this directed test, the serious verification of a FIFO is random: drive wr and rd from independent random streams with controllable densities, run for a hundred thousand cycles, and check the reference queue continuously. That exercises the full/empty boundaries, the wrap of both pointers and the concurrent-access corner far better than any hand-written sequence, and it is how the concurrent-access defect of §3.6 would be caught within a few hundred cycles.在這個指向性測試之外，FIFO 認真的驗證是隨機的：用兩條獨立、密度可調的隨機流去驅動 wr 與 rd，跑個十萬個週期，並持續檢查參考佇列。這樣對滿／空邊界、兩個指標的繞回，以及同時存取那個角落的操練，遠比任何手寫序列徹底；§3.6 那個同時存取的缺陷，用這種方式幾百個週期內就會被抓到。この指定テストの先にある、FIFO の本格的な検証はランダム検証である。wr と rd を密度を調整できる独立なランダム列で駆動し、10 万サイクル回しながら参照キューを常時照合する。満杯／空の境界、両ポインタの折り返し、同時アクセスの隅のケースを、手書きの系列よりはるかによく叩ける。§3.6 の同時アクセスの欠陥なら数百サイクルで捕まるだろう。

3.9 What the synthesiser builds3.9 合成器會造出什麼3.9 合成器が作るもの

Running this module through a standard-cell flow with the default effort gives a netlist with four recognisable pieces.把這個模組丟進標準元件流程、用預設的 effort 跑一次，會得到一個由四個可辨認部分組成的 netlist。このモジュールを標準セルのフローへ通し、既定の effort で合成すると、見分けのつく 4 つの部分からなる netlist が得られる。

Total: 118 flip-flops and a few hundred gates. The dominant cost by far is the memory — 96 of the 118 flops, and the 8-to-1 read multiplexer. That ratio is what motivates replacing a flop array with a compiled RAM as soon as the depth grows: at eight words a flop array is smaller and faster than a RAM macro plus its overhead, at 64 words it is a wash, and at 1024 words the flop array is absurd.合計：118 個正反器與幾百個閘。成本上遙遙領先的是記憶體 —— 118 個正反器裡有 96 個，再加上那個 8 對 1 讀取多工器。正是這個比例讓人一旦深度變大就想把正反器陣列換成編譯出來的 RAM：八個字時，正反器陣列比 RAM 巨集加上它的周邊更小也更快；64 個字時兩者打平；1024 個字時正反器陣列就荒謬了。合計：フリップフロップ 118 個と数百ゲート。圧倒的に支配的なコストはメモリであり、118 個のうち 96 個と、8 対 1 の読み出しマルチプレクサがそれにあたる。この比率こそ、深さが増えたらフリップフロップ配列をコンパイル済み RAM に置き換えたくなる理由である。8 ワードならフリップフロップ配列のほうが RAM マクロとその周辺より小さく速い。64 ワードで互角になり、1024 ワードではフリップフロップ配列は馬鹿げている。

wire do_write = write_to_stack  && !stack_full;
wire do_read  = read_from_stack && !stack_empty;

always @(posedge clk or posedge rst)
  if (rst) begin write_ptr <= 0; read_ptr <= 0; ptr_diff <= 0; end
  else begin
    if (do_write) write_ptr <= write_ptr + 1'b1;
    if (do_read)  read_ptr  <= read_ptr  + 1'b1;
    if (do_write && !do_read) ptr_diff <= ptr_diff + 1'b1;
    else if (do_read && !do_write) ptr_diff <= ptr_diff - 1'b1;
  end

4. Design Example I: The Temperature Monitor System4. 設計範例一：溫度監測系統4. 設計例 I：温度モニタシステム

4.1 Specification and dataflow4.1 規格與資料流4.1 仕様とデータフロー

The specification fits in four sentences. Two sensors deliver 12-bit Celsius readings on channel_1 and channel_2, one reading per clock. Each channel's reading is registered, converted to Fahrenheit, averaged over the last four samples and pushed into an eight-deep FIFO. A host asserts read with a 2-bit select to drain either FIFO, or to read a status word reporting the empty and full flags of both. When the host is not reading, both FIFOs are being written.規格四句話就寫得完。兩個感測器分別在 channel_1 與 channel_2 上送出 12 位元的攝氏讀數，每個時脈一筆。每條通道的讀數先被暫存，轉換成華氏，對最近四筆取平均，然後推進一個八字深的 FIFO。主機拉起 read 並給一個 2 位元的 select，就能抽取其中一個 FIFO，或讀一個回報兩邊空／滿旗標的狀態字。主機沒在讀的時候，兩個 FIFO 都在被寫入。仕様は 4 文で収まる。センサ 2 個が channel_1 と channel_2 に 12 ビットの摂氏値を 1 クロックあたり 1 サンプル送る。各チャネルの値はレジスタに取り込まれ、華氏へ変換され、直近 4 サンプルで平均され、深さ 8 の FIFO へ押し込まれる。ホストは 2 ビットの select とともに read を立てて、どちらかの FIFO を吸い出すか、両方の空・満杯フラグを報告するステータスワードを読む。ホストが読んでいないあいだ、両方の FIFO は書き込まれ続ける。

The architecture that follows from that specification is almost forced. Two identical channel pipelines, built from four modules each, and one shared controller at the output. Every stage is a module; the top level is nothing but nine instantiations and a handful of wires. This is the house style of structured hardware design and it is worth saying explicitly why it is used: a module with a clean port list can be simulated, verified and timed on its own, swapped for a different implementation without disturbing its neighbours, and instantiated twice — which is exactly what happens here, since both channels share the same four module definitions.從那份規格推出來的架構幾乎是被逼出來的。兩條完全相同的通道管線，每條由四個模組組成，輸出端再加一個共用的控制器。每一級都是一個模組；頂層除了九次實例化與幾條線之外什麼也沒有。這是結構化硬體設計的慣用風格，而它為什麼被採用值得明講：一個埠列表乾淨的模組可以單獨模擬、驗證與做時序分析，可以在不驚動鄰居的情況下換成另一種實作，也可以被實例化兩次 —— 這裡發生的正是這件事，因為兩條通道共用同樣那四個模組定義。この仕様から導かれるアーキテクチャはほとんど一意に決まる。同一のチャネルパイプラインを 2 本、それぞれ 4 モジュールで構成し、出力側に共有のコントローラを 1 個置く。各段がモジュールであり、トップレベルは 9 個のインスタンスと数本のワイヤしかない。これは構造化ハードウェア設計の定石であり、なぜそうするのかを明示しておく価値がある。ポートリストの整ったモジュールは単体でシミュレーション・検証・タイミング解析ができ、隣に影響を与えずに別実装へ差し替えられ、2 回インスタンス化もできる。ここで起きているのはまさにそれで、2 本のチャネルが同じ 4 つのモジュール定義を共有している。

Before the modules, trace a single sample through the pipeline and count the clocks, because this is the kind of question that gets asked and the kind of detail that gets lost. A reading presented on channel_1 is captured by the register at edge $n$. The converter is combinational, so the Fahrenheit value is available during cycle $n{+}1$ with no further delay. The filter samples on the falling edge, so the converted value enters temp[3] at the falling edge within cycle $n{+}1$ and needs three more falling edges to reach temp[0]; the average including this sample is available from that first falling edge onward, because the output is a combinational sum of all four stages. The FIFO stores the average at the next rising edge on which write is high. End to end, a reading influences the output of the system about two clock periods after it arrives and remains visible in the average for four sample periods.在看模組之前，先讓一筆樣本走完管線並數一數時脈數，因為這類問題會被考，而這類細節最容易被忽略。出現在 channel_1 上的一筆讀數，在邊緣 $n$ 被暫存器捕捉。轉換器是組合邏輯，所以華氏值在週期 $n{+}1$ 內就可得，沒有額外延遲。濾波器在下降緣取樣，所以轉換後的值在週期 $n{+}1$ 內的下降緣進入 temp[3]，還要再三個下降緣才會到 temp[0]；而包含這筆樣本的平均值，從那第一個下降緣起就可得，因為輸出是四級的組合總和。FIFO 則在下一個 write 為高的上升邊緣把平均值存起來。從頭到尾，一筆讀數大約在它抵達後兩個時脈週期開始影響系統輸出，並在平均值裡持續可見四個樣本週期。モジュールを見る前に、サンプルを 1 つパイプラインに通してクロック数を数えておきたい。こうした問いは実際に出るし、こうした細部こそ落としやすいからである。channel_1 に現れた値はエッジ $n$ でレジスタに捕捉される。変換器は組合せなので、華氏の値は追加の遅延なくサイクル $n{+}1$ のあいだに得られる。フィルタは立ち下がりエッジでサンプルするので、変換後の値はサイクル $n{+}1$ 内の立ち下がりエッジで temp[3] に入り、temp[0] へ届くにはさらに 3 回の立ち下がりエッジが要る。このサンプルを含む平均値は、その最初の立ち下がりエッジ以降ずっと得られる。出力が 4 段すべての組合せ和だからである。FIFO は write が High である次の立ち上がりエッジで平均値を格納する。端から端まで見ると、ある値は到着のおよそ 2 クロック後にシステム出力へ影響しはじめ、平均の中に 4 サンプル周期のあいだ残る。

4.2 Ckt 1 — the data register4.2 電路 1 — 資料暫存器4.2 回路 1 — データレジスタ

module temp_register (temp_out, temp_in, clk, rst);
  output [11:0] temp_out;
  input  [11:0] temp_in;
  input         clk, rst;
  reg    [11:0] temp_out;

  always @ (posedge clk or posedge rst)
    begin
      if (rst == 1) temp_out = 0;
      else          temp_out = temp_in;
    end
endmodule

Twelve D-type flip-flops with an asynchronous active-high reset, and nothing else. There is no enable, so the register samples the input on every clock without exception: the sample rate of the system is the clock rate. If you wanted a slower sample rate you would add an enable and a prescaler, and the register would become if (rst) ... else if (en) temp_out <= temp_in; — the standard enable-register template from Lecture 6, which infers a flop with a clock-enable pin rather than a latch, provided the else is genuinely absent.十二個帶非同步高電位有效重置的 D 型正反器，別無其他。沒有致能，所以暫存器每個時脈都無例外地取樣輸入：系統的取樣率就是時脈率。如果你想要較低的取樣率，就加一個致能與一個除頻器，暫存器會變成 if (rst) ... else if (en) temp_out <= temp_in; —— 那是第 6 講的標準致能暫存器樣板，只要那個 else 真的不存在，它推論出來的就是帶時脈致能腳位的正反器，而不是閂鎖。非同期アクティブ High リセット付きの D フリップフロップ 12 個、それだけである。イネーブルが無いので、レジスタは例外なく毎クロック入力をサンプルする。すなわちシステムのサンプルレートはクロックレートそのものである。もっと遅いサンプルレートが欲しければイネーブルとプリスケーラを足し、レジスタは if (rst) ... else if (en) temp_out <= temp_in; になる。これは第 6 講の標準的なイネーブル付きレジスタのテンプレートであり、else が本当に存在しない限り、ラッチではなくクロックイネーブルピン付きのフリップフロップが推論される。

Two remarks on style. First, the assignments use = rather than <= in a clocked block. As in the FIFO, this is harmless here because nothing else in the same time step reads temp_out — the converter that consumes it is a continuous assignment, which reacts after the fact either way — but it is not defensible as a habit, and if a second clocked block were ever added that read temp_out, it would become a race overnight. Second, if (rst == 1) is more verbose than if (rst) and subtly different in the presence of x: rst == 1 evaluates to x when rst is x, and so does if (rst), so in this case they behave identically. The habit of writing the explicit comparison comes from VHDL and is harmless.兩點風格上的評論。第一，時脈區塊裡的指定用的是 = 而不是 <=。跟 FIFO 一樣，這裡無害，因為同一時間步內沒有別的東西讀 temp_out —— 消費它的轉換器是連續指定，不管怎樣都是事後反應 —— 但把它當習慣是說不過去的，而且只要哪天多加一個會讀 temp_out 的時脈區塊，它一夜之間就變成競爭。第二，if (rst == 1) 比 if (rst) 囉嗦，在有 x 時還有微妙差異：rst 為 x 時 rst == 1 求值為 x，而 if (rst) 也是，所以在這裡兩者行為完全相同。明寫比較的習慣來自 VHDL，無害。スタイルについて二点。第一に、クロック同期ブロックの代入が <= ではなく = である。FIFO と同様ここでは無害で、同じ時間ステップに temp_out を読むものが他に無いからである（消費側の変換器は連続代入であり、いずれにせよ事後に反応する）。しかし習慣として擁護できるものではなく、temp_out を読むクロック同期ブロックがもう一つ加われば一夜にしてレースになる。第二に、if (rst == 1) は if (rst) より冗長で、x が絡むとわずかに違う。rst が x のとき rst == 1 は x に評価されるが、if (rst) も同じなので、この場合の振る舞いは一致する。明示的な比較を書く習慣は VHDL 由来で、害はない。

The slide's synthesis screenshot is worth decoding, because it is the simplest netlist in the lecture and establishes a reading you will reuse. Twelve identical cells named dffrpqb_a stand in a column. The dff prefix is a D flip-flop; r indicates a reset pin; p and q/qb name the output pins; the _a suffix is a drive-strength variant. The twelve bits of temp_in fan out one per cell, clk is bussed down the column, and rst arrives through a single inverter — because the library's flip-flop has an active-low reset pin, and the RTL asked for an active-high reset. That one inverter is the entire cost of the polarity mismatch, and it is a good illustration of the fact that synthesis maps your intent onto what the library actually offers rather than building what you literally wrote.投影片的合成截圖值得解讀一下，因為它是本講裡最簡單的 netlist，而且建立了一套你之後會重複使用的讀法。十二個同名的 dffrpqb_a 元件排成一欄。dff 前綴代表 D 型正反器；r 代表有重置腳；p 與 q/qb 是輸出腳的命名；_a 後綴是驅動強度的版本。temp_in 的十二個位元一個元件分一位，clk 沿著這一欄橫向配線，而 rst 是經過單一個反相器進來的 —— 因為元件庫的正反器有一個低電位有效的重置腳，而 RTL 要的是高電位有效的重置。那一個反相器就是極性不合的全部代價，也很好地說明了一件事：合成是把你的意圖對映到元件庫實際提供的東西上，而不是照字面把你寫的東西蓋出來。スライドの合成結果のスクリーンショットは読み解く価値がある。本講で最も単純な netlist であり、以後繰り返し使う読み方を定めてくれるからである。同じ名前の dffrpqb_a セルが 12 個、縦に並んでいる。dff という接頭辞は D フリップフロップ、r はリセットピンの存在、p と q/qb は出力ピンの名前、末尾の _a は駆動能力のバリアントを表す。temp_in の 12 ビットが 1 セルに 1 ビットずつ入り、clk は列を横切って配られ、rst はインバータ 1 個を通って届く。ライブラリのフリップフロップのリセットピンがアクティブ Low である一方、RTL はアクティブ High のリセットを要求したからである。そのインバータ 1 個が極性不一致のコストのすべてであり、合成が記述をそのまま形にするのではなく、意図をライブラリが実際に提供するものへ写像するのだ、という事実をよく示している。

4.3 Ckt 2 — the arithmetic problem4.3 電路 2 — 算術上的難題4.3 回路 2 — 算術の問題

Now the interesting block. The specification is a single formula.現在進入有趣的區塊。規格就是一條公式。ここから面白いブロックに入る。仕様は式 1 本である。

The obvious Verilog is the direct transcription, and the slides give two versions of it:最直覺的 Verilog 就是照字面抄過來，投影片給了兩個版本：最も素直な Verilog は式をそのまま書き写したもので、スライドはその 2 つの版を示している。

assign temp_out = temp_in * 9 / 5 + 32;     non-synthesisable
assign temp_out = (9 * temp_in) / 5 + 32;   non-synthesisable

Both are rejected, and it is important to be precise about why, because the two operators fail for different reasons.兩個都被否決，而為什麼被否決必須講精確，因為那兩個運算子失敗的理由並不相同。どちらも却下されるが、なぜ却下されるのかを正確に述べておく必要がある。二つの演算子は別々の理由で失敗するからである。

The multiplication by the constant 9 is not the problem. A synthesiser handles x * 9 easily: 9 is $8 + 1$, so x * 9 becomes (x << 3) + x, one shift (free) and one adder. Even a non-constant multiply is synthesisable in any modern tool — expensively, as an array of partial products — so * is a matter of cost, not legality.乘以常數 9 不是問題。合成器處理 x * 9 毫不費力：9 就是 $8 + 1$，所以 x * 9 變成 (x << 3) + x，一次移位（免費）加一個加法器。就算是非常數的乘法，任何現代工具也都能合成 —— 代價高昂，做成部分積陣列 —— 所以 * 是成本問題，不是合法性問題。定数 9 を掛けることは問題ではない。合成器は x * 9 を難なく処理する。9 は $8 + 1$ なので x * 9 は (x << 3) + x になり、シフト 1 回（タダ）と加算器 1 個で済む。定数でない乗算でさえ現代のツールなら合成できる——部分積の配列として高価にではあるが——ので、* はコストの問題であって合法性の問題ではない。

The division by 5 is the problem. Division by a power of two is a right shift and costs nothing; this is the one case every tool accepts. Division by any other constant, and division by a variable, requires a real divider: a sequential restoring or non-restoring algorithm taking one cycle per quotient bit, or a huge combinational SRT array. Verilog does not say how long an expression takes, so a combinational assign containing a general divide has no sensible hardware meaning, and the overwhelming majority of synthesis tools simply refuse it. That is the rule from Lecture 7: / and % are synthesisable only when the right operand is a constant power of two.除以 5 才是問題。除以 2 的冪次就是右移，不花成本；這是每個工具都接受的唯一情況。除以其他任何常數、以及除以變數，都需要一個真正的除法器：一個每求一個商位元花一個週期的循序回復式或不回復式演算法，或是一大片組合式的 SRT 陣列。Verilog 沒有規定一個運算式要花多久，所以含有一般性除法的組合 assign 沒有合理的硬體意義，絕大多數合成工具乾脆拒絕它。這就是第 7 講的規則：/ 與 % 只有在右運算元是 2 的冪次常數時才可合成。問題は 5 で割ることである。2 のべき乗による除算は右シフトであり、コストはかからない。すべてのツールが受け付ける唯一の場合である。それ以外の定数による除算、および変数による除算は本物の除算器を要する。商 1 ビットにつき 1 サイクルかかる逐次の復元法・非復元法か、巨大な組合せ SRT 配列である。Verilog は式にどれだけ時間がかかるかを規定しないので、一般の除算を含む組合せの assign には意味のあるハードウェア的解釈が存在せず、圧倒的多数の合成ツールはこれを単に拒否する。これが第 7 講の規則である。/ と % は右オペランドが 2 のべき乗の定数であるときにのみ合成できる。

So the divider must go, and with it the exactness. The engineering question becomes: what is the cheapest circuit whose answer is close enough? That question — replacing an exact operation with a cheap approximation whose error you can bound — is the heart of fixed-point datapath design, and the rest of this subsection is a worked instance of it.所以除法器必須拿掉，精確性也跟著拿掉。工程問題於是變成：答案夠接近的最便宜電路是哪一個？這個問題 —— 用一個誤差可以界定的便宜近似去取代精確運算 —— 正是定點資料路徑設計的核心，而本小節其餘部分就是它的一個實作範例。したがって除算器は捨てねばならず、厳密さも一緒に捨てることになる。工学的な問いはこう変わる。十分に近い答えを出す最も安い回路は何か。厳密な演算を、誤差を評価できる安価な近似で置き換えること——この問いこそ固定小数点データパス設計の核心であり、この節の残りはその実例である。

4.4 Ckt 2 — two shift-add forms4.4 電路 2 — 兩種移位相加寫法4.4 回路 2 — 二つのシフト加算形

Write 1.8 in binary. The integer part is 1; the fraction is obtained by repeated doubling: $0.8 \to 1.6 \to 1.2 \to 0.4 \to 0.8$, emitting 1, 1, 0, 0 and then repeating for ever.把 1.8 寫成二進位。整數部分是 1；小數部分用反覆加倍取得：$0.8 \to 1.6 \to 1.2 \to 0.4 \to 0.8$，依序吐出 1、1、0、0，然後永遠重複。1.8 を 2 進で書いてみる。整数部は 1、小数部は繰り返し 2 倍して得る。$0.8 \to 1.6 \to 1.2 \to 0.4 \to 0.8$ となり、1、1、0、0 を出したあと永久に繰り返す。

Because the expansion never terminates, no finite shift-add network computes $1.8x$ exactly; you must truncate it somewhere, and where you truncate is the accuracy/area trade-off. Cut after two fractional bits and you keep $1 + \frac12 + \frac14 = 1.75$, which is the choice the lecture makes and which it describes, accurately, as "synthesisable but incorrect" — then immediately notes that it is nevertheless the common approach in IC design. Both halves of that sentence are true and the tension between them is the lesson.因為展開永不終止，沒有任何有限的移位相加網路能精確算出 $1.8x$；你一定得在某處截斷，而截在哪裡就是精度／面積的取捨。切在兩個小數位之後，你保留 $1 + \frac12 + \frac14 = 1.75$，這就是本講的選擇，而它也準確地把這個選擇描述為「可合成但不正確」—— 然後立刻補上一句：這在 IC 設計裡仍然是常見做法。那句話的兩半都是真的，而兩者之間的張力正是這一課。展開が終わらないため、有限のシフト加算回路で $1.8x$ を厳密に計算することはできない。どこかで打ち切るしかなく、どこで打ち切るかが精度と面積のトレードオフになる。小数 2 桁で切れば $1 + \frac12 + \frac14 = 1.75$ が残る。これが本講の選択であり、本講はそれを「合成可能だが正確ではない」と正しく述べたうえで、それでも IC 設計では一般的な手法だと直ちに付け加える。この文の両方が真であり、その緊張関係こそが学ぶべき点である。

The slides give three codings of $1.75x + 32$. The first uses division by power-of-two constants held in parameters:投影片給了 $1.75x + 32$ 的三種寫法。第一種用放在參數裡的 2 冪次常數做除法：スライドは $1.75x + 32$ を 3 通りに記述している。1 つ目はパラメータに置いた 2 のべき乗の定数で割る形である。

  parameter k1  = 2'b10;        // 2
  parameter k2  = 3'b100;       // 4
  parameter k32 = 6'b100000;    // 32
  assign temp_out = (temp_in + temp_in / k1 + temp_in / k2) + k32;

This is legal and synthesises, because the divisors are constant powers of two and the tool turns each division into a right shift. It is, however, a roundabout way of saying what you mean, and it depends on the tool recognising that a parameter whose value is 4 is a power of two — which every tool does, but which is a dependency you did not need to create. The other two forms say it directly:這是合法的、也合成得出來，因為除數是常數的 2 冪次，工具會把每個除法變成右移。但這是個繞圈子的說法，而且它依賴工具認出「一個值為 4 的 parameter 是 2 的冪次」—— 每個工具都做得到，但這是你本來不必製造出來的依賴。另外兩種寫法則直截了當：これは合法で合成もできる。除数が定数の 2 のべき乗であり、ツールが各除算を右シフトに変えるからである。ただし言いたいことを遠回りに言う書き方であり、「値が 4 の parameter は 2 のべき乗である」とツールが認識することに依存する。どのツールもそうするが、作らずに済む依存である。残り 2 つの書き方はもっと直接的である。

module temp_converter (temp_out, temp_in);
  input  [11:0] temp_in;
  output [11:0] temp_out;
  parameter k32 = 6'b100000;   // decimal 32

  // F = 9/5 C + 32
  // 9/5 = 1.8 ~ 1 + .5 + .25
  assign temp_out = temp_in
                  + (temp_in >> 1)
                  + (temp_in >> 2)
                  + k32;
endmodule

module temp_converter (temp_out, temp_in);
  input  [11:0] temp_in;
  output [11:0] temp_out;
  parameter k32 = 6'b100000;

  assign temp_out = ((temp_in << 1)
                   - (temp_in >> 2))
                   + k32;
endmodule

Both are pure combinational logic with no sequential element, no enable and no clock. A shift by a constant is not a circuit at all — it is a renaming of wires. temp_in >> 2 means "take bits 11 down to 2 and call them bits 9 down to 0, and supply two zeros at the top", which the place-and-route tool implements with routing and nothing else. So the entire cost of each converter is the adders.兩者都是純組合邏輯，沒有循序元件、沒有致能、沒有時脈。常數移位根本不是電路 —— 它只是把線重新命名。temp_in >> 2 的意思是「取位元 11 到 2，把它們叫做位元 9 到 0，最上面補兩個零」，而繞線工具只用繞線就實現它，別無其他。所以每個轉換器的全部成本就是那些加法器。どちらも純粋な組合せ論理で、順序素子もイネーブルもクロックもない。定数シフトはそもそも回路ではなく、配線の呼び替えにすぎない。temp_in >> 2 は「ビット 11 から 2 を取り、それをビット 9 から 0 と呼び、上位に 0 を 2 個供給する」という意味で、配置配線ツールは配線だけでこれを実現する。したがって各変換器のコストは加算器がすべてである。

4.5 Ckt 2 — error analysis, with real numbers4.5 電路 2 — 用真實數字做誤差分析4.5 回路 2 — 実際の数値による誤差解析

Algebraically the two alternatives are the same number, $1.75x$. In integer hardware they are not the same circuit, and the difference is instructive.代數上兩種寫法是同一個數 $1.75x$。在整數硬體裡它們不是同一個電路，而這個差別很有啟發性。代数的には二つの方式は同じ数 $1.75x$ である。しかし整数ハードウェアでは同じ回路ではなく、その違いは示唆に富む。

Alternative 1 truncates twice, once in each shift, so it computes $x + \lfloor x/2 \rfloor + \lfloor x/4 \rfloor$. Each floor removes at most just under one, so the result is at most $1.75x$ and at least $1.75x - 1.5$. Alternative 2 truncates once, in a term that is subtracted, so it computes $2x - \lfloor x/4 \rfloor$; removing something from the subtrahend makes the result larger, so it is at least $1.75x$ and at most $1.75x + 0.75$.寫法一截斷兩次，每次移位各一次，所以它算的是 $x + \lfloor x/2 \rfloor + \lfloor x/4 \rfloor$。每個下取整最多拿掉略小於一，所以結果最多是 $1.75x$，最少是 $1.75x - 1.5$。寫法二只截斷一次，而且那一項是被減的，所以它算的是 $2x - \lfloor x/4 \rfloor$；從減數裡拿掉東西會讓結果變大，所以它最少是 $1.75x$，最多是 $1.75x + 0.75$。方式 1 はシフトごとに 1 回ずつ、計 2 回切り捨てるので、計算するのは $x + \lfloor x/2 \rfloor + \lfloor x/4 \rfloor$ である。各床関数が落とす量はいずれも 1 弱までなので、結果は高々 $1.75x$、最小で $1.75x - 1.5$ になる。方式 2 の切り捨ては 1 回だけで、しかもその項は引かれる側にある。計算するのは $2x - \lfloor x/4 \rfloor$ であり、引く側から取り除けば結果は大きくなるので、最小で $1.75x$、高々 $1.75x + 0.75$ である。

So Alternative 2 is never below the ideal $1.75x$ and Alternative 1 is never above it. Since the systematic error of the $1.75$ approximation itself is negative — $1.75x$ falls short of $1.8x$ by $0.05x$ — Alternative 2's upward truncation partially cancels the systematic error while Alternative 1's downward truncation adds to it. Alternative 2 is therefore not merely cheaper; it is also more accurate. That is a satisfying result and a rare one: usually you pay for accuracy.所以寫法二永遠不會低於理想的 $1.75x$，而寫法一永遠不會高於它。由於 $1.75$ 這個近似本身的系統誤差是負的 —— $1.75x$ 比 $1.8x$ 少了 $0.05x$ —— 寫法二向上的截斷會部分抵消系統誤差，而寫法一向下的截斷則是雪上加霜。所以寫法二不只比較便宜，也比較準。這是個令人滿意而且少見的結果：通常精度是要花錢買的。したがって方式 2 は理想値 $1.75x$ を決して下回らず、方式 1 は決して上回らない。$1.75$ という近似そのものの系統誤差は負であり——$1.75x$ は $1.8x$ より $0.05x$ 小さい——方式 2 の上向きの切り捨ては系統誤差を部分的に打ち消すのに対し、方式 1 の下向きの切り捨てはそれを増やす。つまり方式 2 は安いだけでなく、より正確でもある。これは気持ちのよい、そしてまれな結果である。普通、精度は代価を払って買うものだからである。

The systematic term dominates as soon as $x$ exceeds about 30, and it grows without bound: at 500 °C the error is 25 °F. A 2.8 % relative error is acceptable for a fan controller and unacceptable for anything that calls itself an instrument. The right engineering response is not to shrug but to ask what accuracy the specification actually demands and then buy exactly that much with the next subsection's techniques.只要 $x$ 超過大約 30，系統項就開始主導，而且它無上限地成長：500 °C 時誤差是 25 °F。2.8 % 的相對誤差對風扇控制器可以接受，對任何自稱儀器的東西都不可接受。正確的工程回應不是聳聳肩，而是去問規格到底要求多少精度，然後用下一小節的技巧精準地買到那麼多。$x$ が 30 程度を超えると系統項が支配しはじめ、しかも際限なく増える。500 °C では誤差が 25 °F になる。相対誤差 2.8 % はファンの制御器には許容できても、計測器を名乗るものには許容できない。工学的に正しい反応は肩をすくめることではなく、仕様が実際にどれだけの精度を要求しているかを問い、次の節の手法でちょうどその分だけを買うことである。

4.6 Ckt 2 — doing better4.6 電路 2 — 做得更準4.6 回路 2 — より高精度に

Suppose the specification demands better than 0.2 % relative error. You have three options, and knowing all three is what distinguishes a datapath designer from someone who copies a slide.假設規格要求相對誤差優於 0.2 %。你有三個選項，而三個都知道，正是資料路徑設計者與照抄投影片的人之間的差別。仕様が相対誤差 0.2 % 未満を要求しているとしよう。選択肢は三つあり、その三つを知っていることが、データパス設計者とスライドを書き写す人との差である。

Option A — keep more bits of the expansion. Continue the binary expansion of 1.8 past the second fractional bit. The next two set bits are at $2^{-5}$ and $2^{-6}$:選項 A —— 保留展開式的更多項。把 1.8 的二進位展開繼續寫過第二個小數位。接下來兩個為 1 的位元在 $2^{-5}$ 與 $2^{-6}$：選択肢 A — 展開の項をもっと残す。1.8 の 2 進展開を小数第 2 位より先へ続ける。次に 1 が立つのは $2^{-5}$ と $2^{-6}$ である。

assign temp_out = temp_in + (temp_in >> 1) + (temp_in >> 2)
                          + (temp_in >> 5) + (temp_in >> 6) + k32;

Two extra adders buy a sixteen-fold reduction in systematic error. At 100 °C the result is $100 + 50 + 25 + 3 + 1 + 32 = 211$ against the exact 212 — and the remaining shortfall is now mostly truncation, not approximation. An equivalent and cheaper formulation computes it as one multiply-by-115 followed by a right shift of 6, which a good synthesiser will restructure into a carry-save tree.多兩個加法器，換來系統誤差縮小十六倍。在 100 °C 時結果是 $100 + 50 + 25 + 3 + 1 + 32 = 211$，對上精確的 212 —— 而剩下的差額現在主要來自截斷，不是來自近似。另一種等價而且更便宜的寫法，是算成「乘以 115 再右移 6」，好的合成器會把它重整成一棵進位保留樹。加算器 2 個の追加で、系統誤差は 16 分の 1 になる。100 °C では $100 + 50 + 25 + 3 + 1 + 32 = 211$ となり、厳密値 212 に対する残りの不足はもはや近似ではなく主に切り捨てによる。等価でより安い定式化は、115 倍して 6 ビット右シフトする形であり、よい合成器ならこれをキャリーセーブ木に組み替える。

Option B — scale and round instead of truncating the expansion. Choose a power of two $2^k$, take $m = \mathrm{round}(1.8 \times 2^k)$, compute $m \cdot x$ with shifts and adds, and shift right by $k$ at the end. With $k = 8$, $m = \mathrm{round}(460.8) = 461$:選項 B —— 先放大再捨入，而不是截斷展開式。挑一個 2 的冪次 $2^k$，取 $m = \mathrm{round}(1.8 \times 2^k)$，用移位與加法算出 $m \cdot x$，最後再右移 $k$ 位。取 $k = 8$ 時，$m = \mathrm{round}(460.8) = 461$：選択肢 B — 展開を打ち切るのではなく、スケールして丸める。2 のべき乗 $2^k$ を選び、$m = \mathrm{round}(1.8 \times 2^k)$ とし、$m \cdot x$ をシフトと加算で計算して、最後に $k$ ビット右シフトする。$k = 8$ なら $m = \mathrm{round}(460.8) = 461$ である。

and $461 = 512 - 32 - 16 - 2 - 1$, a canonical-signed-digit form needing four subtractions, or $461 = 256 + 128 + 64 + 8 + 4 + 1$, needing five additions. Crucially, the single final shift means there is only one truncation in the whole datapath instead of one per term, which removes most of the $\varepsilon$ noise as well. Add a rounding constant of $2^{k-1} = 128$ before the shift and the remaining error becomes symmetric and bounded by half a degree.而 $461 = 512 - 32 - 16 - 2 - 1$ 是一個需要四次減法的 CSD（正負數位）形式，或 $461 = 256 + 128 + 64 + 8 + 4 + 1$，需要五次加法。關鍵在於：最後只移位一次，代表整條資料路徑裡只有一次截斷，而不是每一項各一次，這也把大部分的 $\varepsilon$ 雜訊一併去掉。在移位前再加上一個 $2^{k-1} = 128$ 的捨入常數，剩下的誤差就變成對稱、且以半度為界。$461 = 512 - 32 - 16 - 2 - 1$ は減算 4 回で済む CSD（正負数字表現）形であり、$461 = 256 + 128 + 64 + 8 + 4 + 1$ なら加算 5 回になる。重要なのは最後のシフトが 1 回だけであることで、データパス全体での切り捨てが項ごとではなく1 回に減り、$\varepsilon$ 由来の雑音の大半も消える。シフトの前に丸め定数 $2^{k-1} = 128$ を足せば、残る誤差は対称になり、半度以内に収まる。

Option C — a lookup table. If the input range is genuinely bounded — a thermometer covering 0 to 127 °C, say — then a 128-entry ROM holding the exactly rounded Fahrenheit value is 128 × 9 bits = 1152 bits of ROM, which in a standard-cell flow synthesises to a few hundred gates of decoded logic and is exact by construction. For small input ranges a table beats arithmetic every time, and the mistake students make is to assume a table is always too big without working out how big it actually is.選項 C —— 查表。如果輸入範圍真的有界 —— 比如一支只涵蓋 0 到 127 °C 的溫度計 —— 那麼一張存放精確捨入後華氏值的 128 項 ROM 就是 128 × 9 位元 = 1152 位元，在標準元件流程裡會合成成幾百個閘的解碼邏輯，而且本質上就是精確的。對小的輸入範圍，查表每次都贏算術，而學生常犯的錯是沒算過到底多大，就先假設表一定太大。選択肢 C — ルックアップテーブル。入力範囲が本当に有界なら——たとえば 0〜127 °C をカバーする温度計——正しく丸めた華氏値を持つ 128 エントリの ROM は 128 × 9 ビット = 1152 ビットであり、標準セルのフローでは数百ゲートのデコード論理に合成され、構成上そもそも厳密である。入力範囲が小さい場合、テーブルは常に算術に勝つ。学生がしがちな誤りは、実際にどれほどの大きさか計算せずに、テーブルは必ず大きすぎると決めてかかることである。

4.7 Ckt 3 — the shift register4.7 電路 3 — 移位暫存器4.7 回路 3 — シフトレジスタ

module temp_filter (av_temp, clk, rst, temp_data);
  output [11:0] av_temp;
  input         clk;
  input  [11:0] temp_data;
  reg    [11:0] temp [3:0];

  always @ (negedge clk or posedge rst)
    if (rst) begin
      temp[0] <= 0; temp[1] <= 0; temp[2] <= 0; temp[3] <= 0;
    end
    else begin: data_pipeline
      temp[3] <= temp_data;
      temp[2] <= temp[3];
      temp[1] <= temp[2];
      temp[0] <= temp[1];
    end

  assign av_temp = (temp[3] + temp[2] + temp[1] + temp[0]) >> 2;
endmodule

The module as printed has a defect you must fix before it will even compile: rst appears in the sensitivity list and in the body but is never declared as an input. Add input rst;. (Verilog would otherwise create an implicit one-bit wire with no driver, which is permanently z, so the reset branch would be unreachable and the simulation would start with x in every stage.)印出來的模組有一個缺陷，不修它連編譯都過不了：rst 出現在敏感列表與本體裡，卻從未被宣告成輸入。請加上 input rst;。（否則 Verilog 會造出一條沒有驅動者的隱含一位元 wire，它永遠是 z，於是重置分支永遠進不去，模擬一開始每一級都是 x。）印刷されたモジュールには、コンパイルすら通らない欠陥がある。rst が感度リストと本体に現れるのに、入力として宣言されていない。input rst; を追加する必要がある。（さもなければ Verilog は駆動元のない暗黙の 1 ビット wire を作る。それは永久に z なのでリセット分岐へ到達できず、シミュレーションは全段 x で始まる。）

With that fixed, the block is a four-deep, twelve-bit shift register: 48 flip-flops. The newest sample lives in temp[3] and the oldest in temp[0], and every clock each stage copies from its neighbour. The ordering of the four statements is the thing to look at, because it is the clearest illustration of the nonblocking rule you will find.修好之後，這個區塊就是一個四級、十二位元的移位暫存器：48 個正反器。最新的樣本住在 temp[3]，最舊的在 temp[0]，每個時脈每一級都從鄰居複製過來。要看的是那四個敘述的順序，因為這是你能找到最清楚的非阻塞規則例示。修正すれば、このブロックは 4 段・12 ビットのシフトレジスタ、すなわちフリップフロップ 48 個になる。最新のサンプルは temp[3] に、最も古いものは temp[0] にあり、毎クロック各段が隣から値を写す。注目すべきは 4 つの文の順序である。ノンブロッキング規則のこれ以上なく明快な例になっているからである。

temp[3] <= temp_data;
temp[2] <= temp[3];
temp[1] <= temp[2];
temp[0] <= temp[1];

temp[3] = temp_data;
temp[2] = temp[3];
temp[1] = temp[2];
temp[0] = temp[1];

Note the asymmetry of the failure: with blocking assignments written in the reverse order — temp[0] = temp[1]; first and temp[3] = temp_data; last — the block behaves correctly again, because each stage is read before it is overwritten. That is exactly why the rule is "always use nonblocking in a clocked block" rather than "be careful about ordering". A rule that depends on statement order is a rule that a later edit will break.注意這個失效的不對稱性：如果阻塞指定以相反順序寫 —— 先 temp[0] = temp[1];，最後 temp[3] = temp_data; —— 這個區塊又正確了，因為每一級都在被覆寫之前先被讀取。這正是為什麼規則是「時脈區塊裡一律用非阻塞」，而不是「小心順序」。一條依賴敘述順序的規則，就是一條日後某次修改一定會打破的規則。この破綻の非対称性に注意したい。ブロッキング代入を逆順に書けば——先に temp[0] = temp[1];、最後に temp[3] = temp_data;——各段は上書きされる前に読まれるので、ブロックは再び正しく動く。だからこそ規則は「順序に気をつける」ではなく「クロック同期ブロックでは常にノンブロッキングを使う」なのである。文の順序に依存する規則は、いつか誰かの編集で壊れる規則である。

4.8 Ckt 3 — divide by four4.8 電路 3 — 除以四4.8 回路 3 — 4 で割る

The averaging itself is a single continuous assignment: add the four stages and shift right by two. Division by four is a right shift because four is a power of two; this is the one case Lecture 7 blesses, and it costs nothing.平均本身就是一個連續指定：把四級加起來再右移兩位。除以四就是右移，因為四是 2 的冪次；這是第 7 講唯一放行的情況，而且不花成本。平均そのものは連続代入 1 本である。4 段を足して 2 ビット右シフトするだけである。4 は 2 のべき乗なので 4 で割ることは右シフトであり、これは第 7 講が唯一認める場合で、コストもかからない。

The floor is the price. Shifting right discards the two least significant bits of the sum, which is truncation towards zero, so the computed average is never larger than the true average and is up to $3/4$ smaller. Averaged over uniformly distributed remainders $r \in \{0,1,2,3\}$ the expected error is $-\mathbb{E}[r]/4 = -1.5/4 = -0.375$ — a systematic downward bias of three eighths of a degree, on top of whatever the converter already cost you.代價是那個下取整。右移會丟掉總和最低的兩個位元，那是朝零截斷，所以算出來的平均永遠不會大於真平均，而且最多小 $3/4$。在餘數 $r \in \{0,1,2,3\}$ 均勻分布的假設下，期望誤差是 $-\mathbb{E}[r]/4 = -1.5/4 = -0.375$ —— 一個系統性的、向下八分之三度的偏差，而且是疊在轉換器已經讓你付出的代價之上。代償は床関数である。右シフトは総和の下位 2 ビットを捨てる。これはゼロ方向への切り捨てなので、計算される平均は真の平均を決して上回らず、最大で $3/4$ 小さくなる。余り $r \in \{0,1,2,3\}$ が一様分布だとすると期待誤差は $-\mathbb{E}[r]/4 = -1.5/4 = -0.375$、すなわち8 分の 3 度ぶんの系統的な下向きバイアスであり、しかも変換器ですでに払った分の上に乗る。

A bias is worse than noise, because noise averages out over repeated measurements and a bias does not. Removing it costs one constant addition:偏差比雜訊糟，因為雜訊在反覆量測下會平均掉，偏差不會。去掉它只要一次常數加法：バイアスは雑音より厄介である。雑音は測定を繰り返せば平均で消えるが、バイアスは消えない。除くには定数加算 1 回で足りる。

  wire [13:0] sum = temp[3] + temp[2] + temp[1] + temp[0];
  assign av_temp = (sum + 14'd2) >> 2;      // round to nearest instead of truncating

Adding half the divisor before dividing is round-half-up. The error now lies in $[-0.5, +0.5)$ and its mean is close to zero, for the cost of forcing a 1 into bit 1 of a carry chain that was being computed anyway. There is essentially never a reason not to do this in a datapath that will be read by a human.在除之前先加上除數的一半，就是四捨五入。現在誤差落在 $[-0.5, +0.5)$，平均值接近零，代價只是在一條本來就要算的進位鏈上把位元 1 強制設為 1。在一條會被人類閱讀的資料路徑裡，基本上找不到不這麼做的理由。割る前に除数の半分を足す、すなわち四捨五入である。誤差は $[-0.5, +0.5)$ に収まり、その平均はほぼゼロになる。代償は、どのみち計算されるキャリーチェーンのビット 1 に 1 を押し込むことだけである。人が読むデータパスで、これをやらない理由は事実上存在しない。

4.9 Ckt 3 — edge choice, and what the filter does to a signal4.9 電路 3 — 邊緣的選擇，以及濾波器對訊號做了什麼4.9 回路 3 — エッジの選択と、フィルタが信号に何をするか

The filter clocks on negedge clk while every other register in the system clocks on posedge clk. Why? Because the converter sits between the register and the filter as a block of combinational logic, and using the opposite edge gives that logic half a clock period instead of a whole one — or, read the other way, it makes the filter sample the converter's output half a period after the register launched it, which in a slow design is simply "a bit of extra margin by accident".這個濾波器用 negedge clk 觸發，而系統裡其他每一個暫存器都用 posedge clk。為什麼？因為轉換器以一團組合邏輯的身分夾在暫存器與濾波器之間，用相反的邊緣，等於給那團邏輯半個時脈週期而不是一整個 —— 或者反過來讀：它讓濾波器在暫存器送出資料後半個週期才取樣轉換器的輸出，在一個慢速設計裡，這不過就是「不小心多了一點餘裕」。このフィルタは negedge clk で動作するが、システムの他のレジスタはすべて posedge clk である。なぜか。変換器が組合せ論理の塊としてレジスタとフィルタのあいだに挟まっており、反対のエッジを使えばその論理に 1 クロック周期ではなく半周期が与えられる——逆から読めば、レジスタが送り出してから半周期後にフィルタが変換器の出力をサンプルする——ということであり、低速な設計なら要するに「たまたま余裕が少し増えた」だけである。

In a cell-based ASIC flow this is a bad habit, and you should be able to say why in an interview.在 cell-based 的 ASIC 流程裡，這是個壞習慣，而你應該能在面試時說出原因。セルベースの ASIC フローではこれは悪い習慣であり、その理由を面接で言えるようにしておきたい。

• It halves your timing budget, it does not double it. The path from the posedge register through the converter to the negedge filter has only half a clock period, not a full one. The design looks like it has slack and actually has less.它把你的時序預算砍半，不是加倍。從 posedge 暫存器經過轉換器到 negedge 濾波器的路徑只有半個時脈週期，不是一整個。這個設計看起來有餘裕，實際上更少。タイミング予算は倍ではなく半分になる。posedge のレジスタから変換器を通って negedge のフィルタへ至る経路に与えられるのは半周期であって 1 周期ではない。余裕があるように見えて、実際には減っている。
• It makes the clock duty cycle a timing constraint. With both edges active, a clock tree that delivers 45/55 instead of 50/50 eats directly into a timing path. Clock trees are optimised for insertion delay and skew, not duty cycle.它讓時脈的工作週期比變成一項時序約束。兩個邊緣都在用的時候，一棵送出 45/55 而非 50/50 的時脈樹，會直接吃掉一條時序路徑。時脈樹是為插入延遲與 skew 最佳化的，不是為工作週期比。クロックのデューティ比がタイミング制約になってしまう。両エッジを使うと、50/50 ではなく 45/55 を配るクロックツリーがそのままタイミングパスを食う。クロックツリーは挿入遅延とスキューのために最適化されるのであって、デューティ比のためではない。
• It complicates static timing analysis and test. Scan chains are built from same-edge flip-flops; a negedge bank needs its own chain or a lockup latch between domains.它讓靜態時序分析與測試都變複雜。掃描鏈是用同一邊緣的正反器串起來的；一組 negedge 的正反器需要自己的鏈，或是在兩個域之間加一個 lockup latch。静的タイミング解析とテストが複雑になる。スキャンチェーンは同一エッジのフリップフロップで構成される。negedge のバンクには専用のチェーンか、ドメイン間のロックアップラッチが要る。

The correct structure is to clock everything on the rising edge and, if the converter's delay is a problem, to register the converter output — adding one pipeline stage and one cycle of latency rather than borrowing half a clock.正確的結構是全部用上升邊緣，而如果轉換器的延遲真的是問題，就把轉換器的輸出暫存起來 —— 多一級管線、多一個週期的延遲，而不是去借半個時脈。正しい構成はすべてを立ち上がりエッジにすることであり、変換器の遅延が本当に問題なら、変換器の出力をレジスタに取る——パイプラインを 1 段、レイテンシを 1 サイクル増やすのであって、半クロックを借りるのではない。

What the filter does to the data is worth one paragraph of signal theory, since this is a communications course. A four-tap moving average is an FIR filter with impulse response $h = \frac14[1,1,1,1]$.濾波器對資料做了什麼，值得用一段訊號理論說明，畢竟這是一門通訊課。四抽頭的移動平均是一個脈衝響應為 $h = \frac14[1,1,1,1]$ 的 FIR 濾波器。フィルタがデータに何をするかは、通信の講義である以上、信号理論で一段落ぶん述べておく価値がある。4 タップの移動平均はインパルス応答 $h = \frac14[1,1,1,1]$ を持つ FIR フィルタである。

Its gain at DC is exactly 1, so steady temperatures pass through unchanged — which is what you want from a smoothing filter. It has exact nulls at $\omega = \pi/2$, $\pi$ and $3\pi/2$, that is at one quarter, one half and three quarters of the sampling rate, so periodic interference at those frequencies is annihilated. Its group delay is $(N-1)/2 = 1.5$ samples, constant with frequency because the response is linear phase, so all frequency components are delayed equally and the shape of a transient is preserved rather than smeared asymmetrically. And for white measurement noise of variance $\sigma^2$ the output variance is $\sigma^2/4$, a factor of two in standard deviation or 6 dB — the classic "averaging $N$ samples buys $\sqrt{N}$" result. All of that for 48 flip-flops and three adders.它在直流的增益正好是 1，所以穩定的溫度原封不動通過 —— 這正是你要平滑濾波器做的事。它在 $\omega = \pi/2$、$\pi$ 與 $3\pi/2$，也就是取樣率的四分之一、二分之一與四分之三處有精確的零點，所以落在這些頻率的週期性干擾會被完全消滅。它的群延遲是 $(N-1)/2 = 1.5$ 個樣本，與頻率無關，因為它是線性相位響應，所以所有頻率成分被延遲同樣多，暫態的形狀被保留而不是被不對稱地抹開。而對變異數 $\sigma^2$ 的白色量測雜訊，輸出變異數是 $\sigma^2/4$，標準差差兩倍，也就是 6 dB —— 這就是經典的「平均 $N$ 筆換到 $\sqrt{N}$」結果。這一切只花 48 個正反器與三個加法器。直流での利得はちょうど 1 なので、一定の温度はそのまま通る。平滑フィルタに求めるのはまさにそれである。$\omega = \pi/2$、$\pi$、$3\pi/2$、すなわちサンプリング周波数の 1/4、1/2、3/4 に厳密な零点を持つので、その周波数の周期的な干渉は完全に消える。群遅延は $(N-1)/2 = 1.5$ サンプルで周波数によらない。応答が直線位相だからであり、すべての周波数成分が等しく遅れるので、過渡の形は非対称に滲むことなく保たれる。また分散 $\sigma^2$ の白色測定雑音に対して出力分散は $\sigma^2/4$、標準偏差で 2 分の 1、すなわち 6 dB となる。「$N$ サンプル平均すれば $\sqrt{N}$ 得をする」という古典的な結果である。これらすべてがフリップフロップ 48 個と加算器 3 個で手に入る。

One structural note: because the sum is recomputed from all four stages every cycle, the filter is a sliding window that produces a new output on every sample, not a block average that produces one output per four samples. The distinction matters when you count how fast the FIFO fills: the filter emits one word per clock, exactly as fast as the sensor supplies one.一點結構上的補充：因為總和每個週期都從四級重新算一次，這個濾波器是一個滑動視窗，每筆樣本都產生一個新輸出，而不是每四筆樣本才產生一個輸出的區塊平均。要算 FIFO 多快填滿時，這個區別就有關係：濾波器每個時脈吐一個字，跟感測器供應的速度完全一樣快。構造についての補足を一つ。総和は毎サイクル 4 段すべてから計算し直されるので、このフィルタはスライディング窓であり、サンプルごとに新しい出力を出す。4 サンプルごとに 1 出力を出すブロック平均ではない。FIFO がどれだけ速く埋まるかを数えるときにこの違いが効く。フィルタはセンサが供給するのとまったく同じ速さで、毎クロック 1 ワードを出す。

4.10 Ckt 4 — the FIFO controller4.10 電路 4 — FIFO 控制器4.10 回路 4 — FIFO コントローラ

module fifo_controller (data_out, data_1, data_2, select, read, write,
                        empty_1, full_1, read_1, empty_2, full_2, read_2);
  input  [11:0] data_1, data_2;
  input  [1:0]  select;
  input         read, full_1, empty_1, full_2, empty_2;
  output [11:0] data_out;
  output        read_1, read_2, write;
  reg    [11:0] data_out;
  reg           read_1, read_2, write;

  always @ (select or data_1 or data_2 or read or full_1
            or empty_1 or full_2 or empty_2) begin
    read_1 = 0;
    read_2 = 0;
    if (read == 1)
      begin
        write = 0;
        case (select)
          2'b01:   begin data_out = data_1; read_1 <= 1; end
          2'b10:   begin data_out = data_2; read_2 <= 1; end
          2'b00:   begin data_out = {empty_1, empty_2, full_1, full_2}; end
          default: data_out = 12'bz;
        endcase
      end
    else if (read == 0)
      begin
        data_out = 12'bz;
        write = 1;
      end
    else data_out = 12'bz;
  end
endmodule

This is a level-sensitive always block, so by the Lecture 5 rules it must assign every output on every path or it will infer latches. Walk the paths and the behaviour falls out:這是一個位準觸發的 always 區塊，所以照第 5 講的規則，它必須在每一條路徑上都指定每一個輸出，否則就會推論出閂鎖。把路徑走一遍，行為自然就出來了：これはレベル記述の always ブロックなので、第 5 講の規則により、すべての経路ですべての出力に代入しなければラッチが推論される。経路をたどれば動作はおのずと見えてくる。

The status word deserves a note. {empty_1, empty_2, full_1, full_2} is a four-bit concatenation assigned to a twelve-bit target, so it is zero-extended on the left: the flags land in bits 3 down to 0 and bits 11 down to 4 are zero. Concatenations are always self-determined — their width is the sum of their parts, regardless of the target — which makes them the one place in Verilog where you can rely on the width being exactly what you wrote.那個狀態字值得補一句。{empty_1, empty_2, full_1, full_2} 是一個四位元的串接，被指定給十二位元的目標，所以左邊補零：旗標落在位元 3 到 0，位元 11 到 4 都是零。串接永遠是自定寬度的 —— 它的寬度就是各部分之和，與目標無關 —— 這讓它成為 Verilog 裡唯一一個你可以放心相信「寬度就是你寫的那樣」的地方。ステータスワードについて一言。{empty_1, empty_2, full_1, full_2} は 4 ビットの連結で、12 ビットの代入先に入るので左側がゼロ拡張される。フラグはビット 3 から 0 に入り、ビット 11 から 4 はゼロになる。連結は常に自己決定幅であり——幅は代入先に関係なく各部分の和である——Verilog の中で幅が書いたとおりであると当てにできる唯一の場所になっている。

The 12'bz assignments infer three-state drivers: twelve buffers whose enable is the OR of the conditions under which a real value is driven. Inside a cell-based ASIC, internal three-state nets are strongly discouraged — they cannot be analysed for contention by static timing, they float when no driver is enabled, and they need bus holders to avoid crowbar current in the receivers. The modern equivalent is a multiplexer with an explicit default. Three-state is still normal at the chip boundary, where data_out would go to a bidirectional pad; if this controller's output is genuinely a chip pin shared with other devices, the code is right, and if it is an internal net, it is not.那些 12'bz 的指定會推論出三態驅動器：十二個緩衝器，致能訊號是「會驅動真值的那些條件」的 OR。在 cell-based ASIC 內部，內部三態 net 是強烈不建議的 —— 靜態時序分析無法分析它們的爭用、沒有驅動者致能時它們會浮接、而且還需要 bus holder 以免接收端出現貫穿電流。現代的等價做法是一個帶明確預設值的多工器。三態在晶片邊界仍然正常，那裡 data_out 會接到一個雙向的 pad；如果這個控制器的輸出真的是一支與其他裝置共用的晶片腳位，那程式碼就是對的；如果它是一條內部 net，那就不對。12'bz の代入はトライステートドライバを推論する。実値を駆動する条件の OR をイネーブルとする 12 個のバッファである。セルベース ASIC の内部ではトライステートのネットは強く非推奨である。静的タイミング解析で競合を解析できず、どのドライバもイネーブルでないとき浮き、受け側の貫通電流を避けるためにバスホルダが必要になる。現代的な等価物は既定値を明示したマルチプレクサである。チップ境界ではトライステートは今も普通で、そこでは data_out は双方向パッドへ向かう。このコントローラの出力が本当に他のデバイスと共有するチップのピンならコードは正しく、内部ネットなら正しくない。

One timing subtlety to carry forward. read_1 is produced combinationally from read and select, and the FIFO samples it at the next rising edge. The FIFO's Data_out is registered. So in the cycle during which the host asserts read, data_1 still carries the previous word, and the controller is multiplexing stale data onto data_out. The host sees the requested word one cycle later. If you draw the system waveform without noticing this you will conclude the FIFO is off by one; it is not, it is pipelined, and the protocol the host must follow is "assert read, wait one cycle, sample".一個要帶著走的時序細節。read_1 是從 read 與 select 組合產生的，而 FIFO 在下一個上升邊緣才取樣它。FIFO 的 Data_out 是暫存的。所以在主機拉起 read 的那個週期裡，data_1 上帶的還是前一個字，控制器把舊資料多工到 data_out 上。主機要再過一個週期才看到它要的字。如果你畫系統波形時沒注意到這一點，你會下結論說 FIFO 差了一拍；它沒有，它是管線化的，而主機必須遵守的協定是「拉起 read，等一個週期，再取樣」。先へ持っていくべきタイミング上の細部がある。read_1 は read と select から組合せ的に作られ、FIFO はそれを次の立ち上がりエッジでサンプルする。FIFO の Data_out はレジスタ出力である。したがってホストが read を立てたサイクルでは data_1 はまだ前のワードを運んでおり、コントローラは古いデータを data_out へ多重化している。ホストが要求したワードを見るのは 1 サイクル後である。これに気づかずにシステムの波形を描けば、FIFO が 1 拍ずれていると結論してしまう。ずれてはおらず、パイプライン化されているだけで、ホストが守るべきプロトコルは「read を立て、1 サイクル待ち、サンプルする」である。

4.11 Top level and integration traps4.11 頂層模組與整合陷阱4.11 トップレベルと統合時の落とし穴

module temp_monitor_unit (channel_1, channel_2, select, clk, rst, read, data_out);
  output [11:0] data_out;
  input  [11:0] channel_1, channel_2;
  input  [1:0]  select;
  input         clk, rst, read;
  wire   [11:0] temp1_out, temp2_out, temp_conv1, temp_conv2, av_temp1, av_temp2;
  wire   [11:0] Data_out1, Data_out2;

  temp_register   M1 (temp1_out, channel_1, clk, rst);          // (1)
  temp_register   M2 (temp2_out, channel_2, clk, rst);
  temp_converter  M3 (temp_conv1, temp1_out);                   // (2)
  temp_converter  M4 (temp_conv2, temp2_out);
  temp_filter     M5 (av_temp1, clk, rst, temp_conv1);          // (3)
  temp_filter     M6 (av_temp2, clk, rst, temp_conv2);

  FIFO M7 (Data_out1, av_temp1, stack_empty1, stack_full1, clk, rst,
           write_to_stack, read_from_stack1);                   // (5)
  FIFO M8 (Data_out2, av_temp2, stack_empty2, stack_full2, clk, rst,
           write_to_stack, read_from_stack2);

  fifo_controller M9 (data_out, Data_out1, Data_out2,            // (4)
           select, read, write_to_stack, stack_empty1, stack_full1,
           read_from_stack1, stack_empty2, stack_full2, read_from_stack2);
endmodule

Twelve lines of instantiation and no logic at all — this is what a good top level looks like. Three integration hazards are visible in it, and all three are the kind of thing that survives a code review and dies in silicon.十二行實例化，完全沒有邏輯 —— 好的頂層就長這樣。裡面看得到三個整合上的危險，而且三個都是那種「通過程式碼審查、死在矽片上」的東西。インスタンス化 12 行、論理はまったく無し——よいトップレベルとはこういうものである。その中に統合上の危険が三つ見えており、三つとも「コードレビューを通り抜けてシリコンで死ぬ」種類のものである。

Implicit nets. stack_empty1, stack_full1, read_from_stack1, write_to_stack and their channel-2 partners are never declared. Verilog creates an implicit one-bit wire for any undeclared identifier used in a port connection, so the module compiles and works. The danger is that a typo also creates a wire: write stack_emtpy1 in one of the two places and you get two separate, silent, one-bit nets, one driven and never read, the other read and never driven, and the design simulates with an x that you will chase for an afternoon. Put `default_nettype none at the top of the file and every undeclared identifier becomes a compile error. There is no downside and it is the single highest-value one-line change you can make to a Verilog project.隱含 net。stack_empty1、stack_full1、read_from_stack1、write_to_stack 以及它們在通道 2 的夥伴，都從未被宣告。Verilog 會為任何用在埠連接上的未宣告識別字造出一條隱含的一位元 wire，所以模組編譯得過也能動。危險在於打錯字也會造出一條 wire：在兩處之一寫成 stack_emtpy1，你就得到兩條各自獨立、沉默的一位元 net，一條有驅動卻沒人讀，另一條有人讀卻沒驅動，於是設計模擬出一個 x，讓你追一個下午。在檔案開頭放上 `default_nettype none，每一個未宣告的識別字就會變成編譯錯誤。這沒有任何壞處，而且是你能對一個 Verilog 專案做的、單行改動裡價值最高的一個。暗黙のネット。stack_empty1、stack_full1、read_from_stack1、write_to_stack とそのチャネル 2 の相方は、どれも宣言されていない。Verilog はポート接続に使われた未宣言の識別子に対して暗黙の 1 ビット wire を作るので、モジュールはコンパイルも動作もする。危険なのは綴り誤りでも wire ができてしまうことである。2 か所のうち一方を stack_emtpy1 と書けば、独立した無言の 1 ビットネットが 2 本でき、一方は駆動されるが読まれず、他方は読まれるが駆動されない。設計は x を出し、半日それを追うことになる。ファイルの先頭に `default_nettype none を置けば、未宣言の識別子はすべてコンパイルエラーになる。欠点は無く、Verilog プロジェクトに加えられる 1 行の変更としては最も価値が高い。

Implicit nets are one bit wide. If an undeclared identifier is connected to a multi-bit port, you get a one-bit wire and eleven dangling bits, usually with a warning you will not read. All the implicit nets here happen to be one bit, so no harm is done, but the mechanism is waiting.隱含 net 只有一位元寬。如果一個未宣告的識別字被接到多位元的埠上，你會得到一條一位元 wire 與十一個懸空的位元，通常還附帶一個你不會去讀的警告。這裡所有的隱含 net 剛好都是一位元，所以沒出事，但這個機制一直在等。暗黙のネットは 1 ビット幅である。未宣言の識別子を多ビットのポートに接続すると、1 ビットの wire と宙に浮いた 11 ビットが得られる。たいてい読まれない警告が付いてくるだけである。ここでは暗黙のネットがたまたますべて 1 ビットなので実害はないが、この仕組みは待ち構えている。

Positional port binding. Every instance binds by position. M9's argument list has twelve entries that must line up exactly with fifo_controller's port order (data_out, data_1, data_2, select, read, write, empty_1, full_1, read_1, empty_2, full_2, read_2). Check them: stack_empty1 against empty_1, stack_full1 against full_1, read_from_stack1 against read_1 — correct. Now imagine somebody adds a port to fifo_controller in the middle of its list. Every instance in the project silently misconnects and nothing flags it, because all the ports are one bit wide and all the types match. Named binding makes the whole class of bug impossible:位置式埠綁定。每個實例都用位置綁定。M9 的引數列有十二項，必須與 fifo_controller 的埠順序 (data_out, data_1, data_2, select, read, write, empty_1, full_1, read_1, empty_2, full_2, read_2) 完全對齊。檢查一下：stack_empty1 對 empty_1、stack_full1 對 full_1、read_from_stack1 對 read_1 —— 正確。現在想像有人在 fifo_controller 的埠列中間插進一個新埠。專案裡的每一個實例都會悄悄接錯，而且沒有任何東西會示警，因為所有埠都是一位元寬、型別也都相符。具名綁定讓這整類 bug 不可能發生：位置指定のポート結合。どのインスタンスも位置で結合している。M9 の引数リストは 12 項目あり、fifo_controller のポート順 (data_out, data_1, data_2, select, read, write, empty_1, full_1, read_1, empty_2, full_2, read_2) と正確に並ばなければならない。確かめてみると、stack_empty1 は empty_1 に、stack_full1 は full_1 に、read_from_stack1 は read_1 に対応しており正しい。では誰かが fifo_controller のポートリストの途中にポートを 1 本足したらどうなるか。プロジェクト中のすべてのインスタンスが黙って誤接続になり、何も警告しない。すべてのポートが 1 ビット幅で型も一致するからである。名前指定の結合なら、この種のバグはそもそも起こりえない。

  fifo_controller M9 (
    .data_out (data_out),        .data_1 (Data_out1),       .data_2 (Data_out2),
    .select   (select),          .read   (read),            .write  (write_to_stack),
    .empty_1  (stack_empty1),    .full_1 (stack_full1),     .read_1 (read_from_stack1),
    .empty_2  (stack_empty2),    .full_2 (stack_full2),     .read_2 (read_from_stack2));

It is more typing and it is worth every character. Use positional binding only for trivial, stable, two-or-three-port primitives, and named binding for everything else.打字量是多了，而且每一個字元都值得。位置式綁定只留給瑣碎、穩定、兩三個埠的基本元件，其餘一律用具名綁定。打つ量は増えるが、その 1 文字ずつに価値がある。位置指定の結合は、ポートが 2〜3 本の些細で安定したプリミティブだけに留め、それ以外はすべて名前指定にする。

4.12 Verification and synthesis of the whole unit4.12 整個單元的驗證與合成4.12 ユニット全体の検証と合成

A system testbench for this unit has to do three things the module-level benches could not: drive both channels with physically plausible data, check the arithmetic end to end against a behavioural model of the specification, and exercise the controller's select codes including the status read.這個單元的系統級測試平台必須做三件模組級測試平台做不到的事：用物理上合理的資料驅動兩條通道、拿整條路徑的算術去對規格的行為模型做端對端比對，以及把控制器的 select 碼（含狀態讀取）都操練過。このユニットのシステムレベルのテストベンチは、モジュール単体のベンチにはできない三つのことをしなければならない。物理的にありうるデータで両チャネルを駆動すること、仕様の振る舞いモデルに対して算術を端から端まで照合すること、そしてステータス読み出しを含むコントローラの select コードをすべて叩くことである。

  // stimulus: a slow ramp on channel 1, a step with noise on channel 2
  integer k;
  initial begin
    rst = 1; read = 0; select = 2'b00; channel_1 = 0; channel_2 = 0;
    @(negedge clk); rst = 0;
    for (k = 0; k < 64; k = k + 1) begin
      @(negedge clk);
      channel_1 = k;                                // 0..63 degrees C
      channel_2 = (k < 32) ? 20 : 20 + ($random % 3);   // step plus +/-2 noise
    end
    // now drain FIFO 1, then read the status word
    select = 2'b01; read = 1;  repeat (8) @(negedge clk);
    read = 0;                  @(negedge clk);
    select = 2'b00; read = 1;  @(negedge clk);
    $display("status = %b (empty1 empty2 full1 full2)", data_out[3:0]);
    $finish;
  end

  // reference model of the whole channel, written for clarity not synthesis
  function [11:0] golden_channel (input [11:0] c0, c1, c2, c3);
    reg [15:0] f0, f1, f2, f3;
    begin
      f0 = c0 + (c0 >> 1) + (c0 >> 2) + 32;   // repeat for c1, c2, c3
      f1 = c1 + (c1 >> 1) + (c1 >> 2) + 32;
      f2 = c2 + (c2 >> 1) + (c2 >> 2) + 32;
      f3 = c3 + (c3 >> 1) + (c3 >> 2) + 32;
      golden_channel = (f0 + f1 + f2 + f3) >> 2;
    end
  endfunction

The reference deliberately models the implementation's arithmetic, including the 1.75 approximation, not the ideal $1.8T + 32$. That is the right choice for a regression test — it checks that the RTL does what was designed — but it means the reference cannot catch a wrong approximation. The accuracy question must be answered separately, by comparing the reference against floating-point over the whole input range and recording the worst-case error as a specification item. Keeping those two checks separate (does the RTL match the model? does the model meet the spec?) is a discipline worth acquiring early.這個參考模型刻意模擬的是實作的算術，包含 1.75 的近似，而不是理想的 $1.8T + 32$。對回歸測試而言這是正確的選擇 —— 它檢查 RTL 有沒有做到當初設計的事 —— 但這也表示參考模型抓不到「近似選錯了」。精度問題必須另外回答：把參考模型拿去跟整個輸入範圍上的浮點值比對，並把最壞情況誤差記錄成一條規格項目。把這兩個檢查分開（RTL 有沒有符合模型？模型有沒有達到規格？），是一項值得早點養成的紀律。この参照モデルは意図的に実装の算術を、すなわち 1.75 の近似を含む形でモデル化しており、理想的な $1.8T + 32$ ではない。回帰テストとしてはこれが正しい選択である——RTL が設計どおりかを調べるものだからである——が、裏を返せば近似そのものの誤りは参照モデルでは捕まえられない。精度の問いは別に答えねばならない。参照モデルを入力範囲全体にわたって浮動小数点と比較し、最悪誤差を仕様項目として記録するのである。この二つの検査（RTL はモデルと一致するか、モデルは仕様を満たすか）を分けておくのは、早く身につけておきたい規律である。

For the synthesis result, count what the slides show. Per channel: 12 flops in the register, 0 in the converter, 48 in the filter, and 118 in the FIFO — 178 flops. Two channels is 356 flops, plus a purely combinational controller. The tool's schematic for the whole unit, which the final slide shows, is recognisably the block diagram of §4.1 with the two FIFOs at the top, the controller to their right, and the register/converter/filter chains below — which is the point of writing the design hierarchically in the first place. If your elaborated schematic does not look like the block diagram you drew, either you wrote something other than what you meant or the tool flattened a hierarchy you wanted preserved.合成結果就數一數投影片上顯示的東西。每條通道：暫存器 12 個正反器、轉換器 0 個、濾波器 48 個、FIFO 118 個 —— 共 178 個。兩條通道就是 356 個正反器，再加上一個純組合的控制器。工具為整個單元畫出的電路圖（最後一張投影片）認得出來就是 §4.1 的方塊圖：兩個 FIFO 在上、控制器在它們右邊、暫存器／轉換器／濾波器鏈在下方 —— 而這正是一開始就把設計寫成階層式的意義所在。如果你 elaborate 出來的電路圖跟你畫的方塊圖長得不一樣，不是你寫的東西跟你想的不同，就是工具把你想保留的階層攤平了。合成結果はスライドが示すものを数えればよい。1 チャネルあたり、レジスタ 12 個、変換器 0 個、フィルタ 48 個、FIFO 118 個で計 178 個のフリップフロップ。2 チャネルで 356 個、これに純粋な組合せのコントローラが加わる。最後のスライドが示すユニット全体の回路図は、見ればそれと分かる §4.1 のブロック図そのものである。上に FIFO が 2 つ、その右にコントローラ、下にレジスタ／変換器／フィルタの連なりが並ぶ。設計を最初から階層的に書く意義はここにある。elaborate した回路図が自分の描いたブロック図と似ていないなら、意図と違うものを書いたか、保ちたかった階層をツールが平坦化したかのどちらかである。

module temp_converter_fine (temp_out, temp_in);
  input  [11:0] temp_in;
  output [11:0] temp_out;

  // 9/5 = 1.8 ~ 115/64 = 1 + 1/2 + 1/4 + 1/32 + 1/64   (error 0.174%)
  wire [12:0] scaled = {1'b0, temp_in}
                     + {2'b0, temp_in[11:1]}
                     + {3'b0, temp_in[11:2]}
                     + {6'b0, temp_in[11:5]}
                     + {7'b0, temp_in[11:6]};
  assign temp_out = scaled[11:0] + 12'd32;
endmodule

5. Design Example II: AMD2901 Architecture and Instruction Set5. 設計範例二：AMD2901 架構與指令集5. 設計例 II：AMD2901 のアーキテクチャと命令セット

5.1 Bit slices and microcode5.1 bit slice 與微碼5.1 ビットスライスとマイクロコード

The Am2901 was introduced by Advanced Micro Devices in 1975 and is the most successful bit-slice component ever made. The idea behind a bit slice is simple and, in an era before you could put a whole processor on one die, decisive: build a 4-bit-wide vertical cross-section of a processor's datapath — register file, ALU, shifters, flag logic — and bring out, as pins, every signal that would have crossed the cut. Four of those chips side by side, with the cut signals wired together, make a 16-bit datapath. Eight make a 32-bit one. The architecture is set by the system designer, not by the chip vendor.Am2901 由 Advanced Micro Devices 在 1975 年推出，是有史以來最成功的bit-slice元件。bit slice 背後的想法很簡單，而且在一顆晶粒放不下整顆處理器的年代具有決定性：做出處理器資料路徑的一個 4 位元寬垂直剖面 —— 暫存器檔、ALU、移位器、旗標邏輯 —— 並把每一條會穿過這個切面的訊號都拉成腳位。四顆這樣的晶片並排，把切面訊號接起來，就是一條 16 位元資料路徑。八顆就是 32 位元。架構由系統設計者決定，而不是晶片廠商。Am2901 は 1975 年に Advanced Micro Devices が発表した、史上最も成功したビットスライス部品である。ビットスライスの発想は単純で、プロセッサ全体を 1 つのダイに載せられなかった時代には決定的だった。プロセッサのデータパスの 4 ビット幅の縦断面——レジスタファイル、ALU、シフタ、フラグ論理——を作り、その切断面を横切る信号をすべてピンとして出すのである。そのチップを 4 個並べ、切断面の信号を互いに配線すれば 16 ビットのデータパスになる。8 個なら 32 ビットである。アーキテクチャはチップベンダではなくシステム設計者が決める。

The signals that cross the cut are exactly the ones you would expect: the carry (c_in into the bottom slice, c_out out of the top), the shift chain of the register file (ram0 at the bottom, ram3 at the top), the shift chain of the Q register (qs0, qs3), and the group carry-generate and carry-propagate signals g_bar and p_bar, which feed a companion look-ahead carry generator so that the carry does not have to ripple through every slice in sequence. Understanding this is understanding why the module's port list looks the way it does: almost every "odd" port exists because the design is a slice of something bigger.穿過切面的訊號正是你會預期的那些：進位（進入最低位 slice 的 c_in、從最高位出來的 c_out）、暫存器檔的移位鏈（底部的 ram0、頂部的 ram3）、Q 暫存器的移位鏈（qs0、qs3），以及群組進位產生與進位傳遞訊號 g_bar 與 p_bar，它們餵給一顆配套的進位預看產生器，讓進位不必依序漣波穿過每一片 slice。看懂這點，就看懂了這個模組的埠列為什麼長成那樣：幾乎每一個「奇怪」的埠，都是因為這個設計是更大東西的一片切片。切断面を横切る信号は、まさに予想どおりのものである。キャリー（最下位スライスへ入る c_in、最上位から出る c_out）、レジスタファイルのシフト連鎖（下端の ram0、上端の ram3）、Q レジスタのシフト連鎖（qs0、qs3）、そしてグループのキャリー生成・伝搬信号 g_bar と p_bar である。後者は付属のキャリー先見生成器へ入り、キャリーが各スライスを順に伝わらずに済むようにする。これが分かれば、このモジュールのポートリストがなぜこの形なのかも分かる。「奇妙」に見えるポートのほとんどは、この設計がより大きなものの一切片だからこそ存在している。

The second idea is microprogramming. The 2901 has no instruction decoder and no program counter. It is a datapath with a 9-bit control word, and something else must supply a fresh control word every cycle. That something is a microcode ROM addressed by a microprogram sequencer — in the AMD family, an Am2910 — and the "instruction set" of the resulting machine is whatever the microcode author writes. This is why the 2901 is such a good teaching example: it separates the datapath, which you are about to read in Verilog, from the control, which is a table of bits in a ROM, as cleanly as any real design ever has.第二個想法是微程式化。2901 沒有指令解碼器，也沒有程式計數器。它是一條帶 9 位元控制字的資料路徑，而每個週期都得由別的東西供應一個新的控制字。那個別的東西，就是由微程式定序器定址的微碼 ROM —— 在 AMD 家族裡就是 Am2910 —— 而由此得到的機器的「指令集」，就是微碼作者寫出來的任何東西。這正是為什麼 2901 是這麼好的教學範例：它把資料路徑（你馬上要用 Verilog 讀的東西）與控制（ROM 裡一張位元表）分得乾乾淨淨，乾淨程度不輸任何真實設計。第二の発想はマイクロプログラミングである。2901 には命令デコーダもプログラムカウンタもない。9 ビットの制御語を持つデータパスであり、毎サイクル新しい制御語を供給するものが別に必要である。それがマイクロプログラムシーケンサ——AMD ファミリなら Am2910——でアドレスされるマイクロコード ROM であり、そうして得られる機械の「命令セット」とは、マイクロコードの書き手が書いたものに他ならない。2901 が優れた教材である理由はここにある。これから Verilog で読むデータパスと、ROM の中のビット表である制御とを、実在のどの設計にも劣らないほどきれいに分離しているからである。

5.2 A tour of the datapath5.2 資料路徑巡禮5.2 データパスを一巡する

Follow one cycle around that loop and the whole architecture becomes concrete.跟著那個迴路走一圈，整個架構就具體了。そのループを 1 周たどれば、アーキテクチャ全体が具体的になる。

1. The address fields a and b present two words from the register file on the combinational read ports ad and bd. These reads are asynchronous — the moment a changes, ad changes — so the register file behaves like two 16-to-1 multiplexers, not like a memory with a read cycle.位址欄位 a 與 b 把暫存器檔裡的兩個字送上組合式讀取埠 ad 與 bd。這些讀取是非同步的 —— a 一變，ad 就變 —— 所以暫存器檔的行為像兩個 16 對 1 的多工器，而不像有讀取週期的記憶體。アドレスフィールド a と b が、レジスタファイルの 2 ワードを組合せ読み出しポート ad、bd に提示する。この読み出しは非同期であり——a が変わった瞬間に ad が変わる——レジスタファイルは読み出しサイクルを持つメモリではなく、16 対 1 のマルチプレクサ 2 個のように振る舞う。
2. The operand selector, steered by i[2:0], chooses the ALU's two inputs r and s from a menu of five sources: ad, bd, the Q register, the external data input d, and the constant zero.運算元選擇器由 i[2:0] 操控，從五個來源的選單裡挑出 ALU 的兩個輸入 r 與 s：ad、bd、Q 暫存器、外部資料輸入 d，以及常數零。オペランドセレクタは i[2:0] で制御され、5 つの供給源——ad、bd、Q レジスタ、外部データ入力 d、定数ゼロ——から ALU の 2 入力 r と s を選ぶ。
3. The ALU, steered by i[5:3], computes one of eight functions of r, s and c_in, and emits alu_out together with c_out, ovr, g_bar and p_bar.ALU 由 i[5:3] 操控，計算 r、s 與 c_in 的八種函數之一，並輸出 alu_out 以及 c_out、ovr、g_bar 與 p_bar。ALU は i[5:3] で制御され、r、s、c_in の 8 種の関数のいずれかを計算して、alu_out とともに c_out、ovr、g_bar、p_bar を出す。
4. The destination field i[8:6] decides three independent things at once: whether the register file is written (and whether what is written is alu_out, alu_out shifted up, or alu_out shifted down), whether the Q register is loaded (and whether shifted), and whether the output y shows alu_out or the register-file word ad.目的地欄位 i[8:6] 一次決定三件互相獨立的事：暫存器檔要不要寫入（以及寫進去的是 alu_out、上移後的 alu_out、還是下移後的 alu_out）、Q 暫存器要不要載入（以及要不要先移位），還有輸出 y 顯示的是 alu_out 還是暫存器檔的字 ad。デスティネーションフィールド i[8:6] は、互いに独立な三つのことを同時に決める。レジスタファイルに書き込むか（書くのは alu_out か、上方向にシフトした alu_out か、下方向にシフトした alu_out か）、Q レジスタにロードするか（シフトするか）、そして出力 y が alu_out を見せるかレジスタファイルのワード ad を見せるか、である。
5. At the rising clock edge the register file and the Q register capture their new values, and the loop is ready to run again.在時脈上升邊緣，暫存器檔與 Q 暫存器捕捉各自的新值，迴路就準備好再跑一圈。クロックの立ち上がりエッジでレジスタファイルと Q レジスタが新しい値を取り込み、ループは次の一巡に備える。

Everything in steps 1 to 4 is combinational. The only state in the whole slice is the 16-word register file and the 4-bit Q register — 68 flip-flops. The entire cycle time of a machine built from these slices is the delay of that combinational loop, and §7.4 walks it.步驟 1 到 4 裡的一切都是組合邏輯。整片 slice 裡唯一的狀態就是那個 16 字的暫存器檔與 4 位元的 Q 暫存器 —— 68 個正反器。用這些 slice 組成的機器，整個週期時間就是那個組合迴路的延遲，而 §7.4 會把它走一遍。手順 1 から 4 まではすべて組合せである。このスライス全体で状態を持つのは 16 ワードのレジスタファイルと 4 ビットの Q レジスタだけ、合計 68 個のフリップフロップである。これらのスライスで組む機械のサイクルタイムは、その組合せループの遅延そのものであり、§7.4 でそれをたどる。

5.3 The nine-bit instruction5.3 九位元的指令5.3 9 ビットの命令

Three fields of three bits, eight codes each, giving $8 \times 8 \times 8 = 512$ microinstructions — every combination legal, which is a deliberate property of an orthogonal encoding. Together with the two 4-bit addresses and the carry-in, a complete 2901 control word is 9 + 4 + 4 + 1 = 18 bits wide, and that is the width of one slice of microcode ROM.三個欄位、各三位元、各八種碼，給出 $8 \times 8 \times 8 = 512$ 個微指令 —— 每一種組合都合法，這是正交編碼刻意具備的性質。再加上兩個 4 位元位址與進位輸入，一個完整的 2901 控制字寬 9 + 4 + 4 + 1 = 18 位元，那也就是一片微碼 ROM 的寬度。3 ビットのフィールドが三つ、各 8 コードで $8 \times 8 \times 8 = 512$ 通りのマイクロ命令になる。どの組み合わせも合法であり、これは直交符号化が意図して備える性質である。これに 4 ビットのアドレス 2 本とキャリー入力を加えると、完全な 2901 の制御語は 9 + 4 + 4 + 1 = 18 ビット幅となり、それがマイクロコード ROM 1 面の幅になる。

It is traditional to write 2901 instructions as three octal digits, most significant field first, because each 3-bit field is exactly one octal digit. "3 0 1" means destination 3 (ramf), function 0 (add), source 1 (ab). Get comfortable with that notation; examination questions use it.2901 的指令傳統上寫成三個八進位數字，最高位欄位在前，因為每個 3 位元欄位剛好是一個八進位數字。「3 0 1」的意思是目的地 3（ramf）、功能 0（add）、來源 1（ab）。請習慣這個記法；考題會用。2901 の命令は伝統的に 8 進 3 桁で、上位フィールドから順に書く。各 3 ビットフィールドがちょうど 8 進 1 桁だからである。「3 0 1」はデスティネーション 3（ramf）、機能 0（add）、ソース 1（ab）を意味する。この記法に慣れておきたい。試験問題はこれを使う。

Notice what the orthogonality buys and what it costs. It buys a decoder of trivial size — each field is decoded independently, with no cross-product — and complete freedom for the microcode author. It costs encoding efficiency: many of the 512 combinations are useless (adding two registers and then throwing the result away is legal and pointless), and the field widths are fixed even where fewer codes would do. For a microcode ROM whose width you control, the trade is worth it. For a user-visible instruction set with a fixed 32-bit word, it usually is not, which is why real ISAs are full of irregular encodings.注意正交性買到什麼、又付出什麼。它買到一個小到微不足道的解碼器 —— 每個欄位各自獨立解碼，沒有交叉乘積 —— 以及微碼作者的完全自由。它付出的是編碼效率：512 種組合裡很多是沒用的（把兩個暫存器相加再把結果丟掉是合法而無意義的），而且就算某欄位用不了那麼多碼，寬度仍然固定。對一個寬度由你決定的微碼 ROM 來說，這筆交易划算。對一個使用者可見、字長固定為 32 位元的指令集來說，通常就不划算了，這也是為什麼真實的 ISA 充滿不規則編碼。直交性が何を買い、何を支払うかに注意したい。買えるのは、ほとんど無視できる大きさのデコーダ——各フィールドを独立にデコードでき、交差項がない——と、マイクロコードの書き手にとっての完全な自由である。支払うのは符号化効率で、512 通りの多くは役に立たない（レジスタ 2 本を足して結果を捨てる命令は合法だが無意味である）し、より少ないコードで足りる場所でもフィールド幅は固定である。幅を自分で決められるマイクロコード ROM なら、この取引は割に合う。語長 32 ビット固定の、ユーザから見える命令セットなら普通は割に合わない。実在の ISA が不規則な符号化だらけなのはそのためである。

5.4 Source field i[2:0] — where the operands come from5.4 來源欄位 i[2:0] —— 運算元從哪裡來5.4 ソースフィールド i[2:0] — オペランドはどこから来るか

Two readings help here. First, r only ever takes three values — ad, zero, or d — so the r multiplexer is 3-to-1, while s takes four — q, bd, ad, zero — so its multiplexer is 4-to-1. The eight source codes are not eight independent selections; they are eight of the twelve possible pairs, chosen because they are the useful ones. Second, the mnemonics are mnemonic: the first letter names the r source and the second names the s source, with z meaning zero. Once you see that, the table does not need memorising. (The slide's table writes the zero as the letter "o" in the operand columns; it is a zero.)這裡有兩種讀法有幫助。第一，r 只會取三種值 —— ad、零或 d —— 所以 r 的多工器是 3 對 1；而 s 取四種 —— q、bd、ad、零 —— 所以它的多工器是 4 對 1。那八個來源碼不是八次獨立的選擇；它們是十二種可能配對裡的八種，挑出來是因為它們有用。第二，助記符真的是「助記」的：第一個字母是 r 的來源，第二個字母是 s 的來源，z 代表零。看懂這點之後，這張表就不必背了。（投影片的表在運算元欄裡把零寫成字母「o」；那是零。）ここでは二通りの読み方が助けになる。第一に、r が取る値は ad、ゼロ、d の 3 つだけなので r 側のマルチプレクサは 3 対 1 であり、s は q、bd、ad、ゼロの 4 つを取るので 4 対 1 である。8 つのソースコードは 8 回の独立な選択ではなく、12 通りの組のうち有用な 8 通りを選んだものである。第二に、ニーモニックは文字どおり記憶の助けになっている。1 文字目が r の供給源、2 文字目が s の供給源を表し、z はゼロを意味する。そこに気づけば、この表を暗記する必要はない。（スライドの表はオペランド欄でゼロを文字「o」と書いているが、あれはゼロである。）

5.5 Function field i[5:3] — what the ALU does5.5 功能欄位 i[5:3] —— ALU 做什麼5.5 機能フィールド i[5:3] — ALU は何をするか

5.6 Destination field i[8:6] — where the result goes5.6 目的地欄位 i[8:6] —— 結果要去哪裡5.6 デスティネーションフィールド i[8:6] — 結果の行き先

This is the densest table in the lecture and the one most worth slowing down over, because it controls three separate pieces of hardware simultaneously.這是本講最密的一張表，也是最值得放慢速度看的一張，因為它同時控制三塊各自獨立的硬體。本講で最も情報密度の高い表であり、最も速度を落として読む価値のある表でもある。三つの独立したハードウェアを同時に制御しているからである。

Four facts to extract from it, each of which is a potential examination question on its own.從這張表要抽出四個事實，每一個本身都可能是考題。この表から取り出すべき事実が四つある。どれも単独で試験問題になりうる。

• The register file is always written at address b, never at a. Address a is read-only. A register-to-register operation therefore always overwrites its second operand, and a move from a to b is za + add + rama-or-ramf.暫存器檔永遠寫在位址 b，絕不寫在 a。位址 a 是唯讀的。因此暫存器對暫存器的運算一定會覆寫它的第二個運算元，而「把 a 搬到 b」就是 za + add + rama 或 ramf。レジスタファイルへの書き込みは常にアドレス b であり、a へは決して書かない。アドレス a は読み出し専用である。したがってレジスタ間演算は必ず第 2 オペランドを上書きし、a から b への移動は za + add + rama または ramf になる。
• Only rama sends something other than alu_out to y. On rama the output shows reg_f[a], the register-file word at address a, while the ALU result goes quietly into address b. That is the "write and simultaneously read something else" instruction, and it exists so that you can move data out of the machine without spending a cycle.只有 rama 會把 alu_out 以外的東西送到 y。在 rama 時輸出顯示的是 reg_f[a]，也就是位址 a 的暫存器檔字，而 ALU 的結果則靜靜地寫進位址 b。那是「一邊寫入、一邊讀出另一個東西」的指令，它存在的目的是讓你不必多花一個週期就能把資料搬出機器。alu_out 以外のものを y へ送るのは rama だけである。rama では出力にアドレス a のレジスタファイルのワード reg_f[a] が現れ、ALU の結果は静かにアドレス b へ入る。これは「書き込みつつ別のものを読み出す」命令であり、1 サイクルを費やさずにデータを機械の外へ出せるようにするために存在する。
• The shift happens before the load. The footnote on the slide says so explicitly. The value stored is the ALU output shifted, not the stored value shifted afterwards; there is one shifter, between the ALU and the register-file write port, not a shift register in the file.移位發生在載入之前。投影片的註腳明白這麼說。存進去的是移位後的 ALU 輸出，而不是存好之後再移位；移位器只有一個，位在 ALU 與暫存器檔寫入埠之間，而不是在檔案裡放一個移位暫存器。シフトはロードより先に行われる。スライドの脚注が明記している。格納されるのはシフト後の ALU 出力であり、格納した値を後からシフトするのではない。シフタは ALU とレジスタファイルの書き込みポートのあいだに 1 つあるだけで、ファイル内にシフトレジスタがあるわけではない。
• The end bits come from, and go to, pins. On a down-shift the register file's bit 3 is filled from the ram3 pin and its bit 0 leaves on the ram0 pin; on an up-shift the directions reverse. The same for Q with qs3 and qs0. That is what makes a multi-slice shift possible — and, as §7.1 shows, it is also what makes the double-length shift of a multiply possible within a single slice.端點位元來自腳位，也送往腳位。下移時，暫存器檔的位元 3 由 ram3 腳位填入，位元 0 則由 ram0 腳位離開；上移時方向反轉。Q 與 qs3、qs0 也一樣。這就是多片 slice 聯合移位之所以可能的原因 —— 而且如 §7.1 所示，這也是單片 slice 內能做乘法所需雙倍長度移位的原因。端のビットはピンから来て、ピンへ出ていく。下方向シフトではレジスタファイルのビット 3 が ram3 ピンから埋められ、ビット 0 は ram0 ピンから出ていく。上方向シフトでは向きが逆になる。Q も qs3、qs0 で同様である。これが複数スライスにまたがるシフトを可能にしており、§7.1 で見るように、1 スライス内で乗算に必要な倍長シフトを可能にしているのも同じ仕組みである。

5.7 Mnemonics with `define5.7 用 `define 寫助記符5.7 `define によるニーモニック

// amd2901 bit slice microprocessor
// operands: instruction[2:0]
`define aq    3'b000
`define ab    3'b001
`define zq    3'b010
`define zb    3'b011
`define za    3'b100
`define da    3'b101
`define dq    3'b110
`define dz    3'b111
// opcodes: instruction[5:3]
`define add   3'b000
`define subr  3'b001
`define subs  3'b010
`define orrs  3'b011
`define andrs 3'b100
`define notrs 3'b101
`define exor  3'b110
`define exnor 3'b111
// destination mnemonics: instruction[8:6]
`define qreg  3'b000
`define nop   3'b001
`define rama  3'b010
`define ramf  3'b011
`define ramqd 3'b100
`define ramd  3'b101
`define ramqu 3'b110
`define ramu  3'b111

`define is a compiler directive, handled by the pre-processor before the parser ever sees the file, exactly as #define is in C. The expansion is textual, it happens once, and synthesis therefore sees only 3'b100 — the symbolic names cost nothing in area, delay or power, which is the whole point. Lecture 7 covered directives; this is the canonical use of them.`define 是編譯器指令，由前置處理器在剖析器看到檔案之前就處理掉，跟 C 的 #define 完全一樣。展開是文字層級的、只發生一次，因此合成只看到 3'b100 —— 符號名稱在面積、延遲與功耗上都不花成本，這正是重點。第 7 講講過指令；這就是它們的典型用途。`define はコンパイラ指令であり、C の #define とまったく同じく、パーサがファイルを見る前にプリプロセッサが処理する。展開はテキストレベルで一度だけ起こるので、合成が見るのは 3'b100 だけである。記号名は面積にも遅延にも電力にもコストを足さない。そこがすべてである。第 7 講でコンパイラ指令を扱ったが、これはその典型的な用法である。

Several details are worth lifting out.有幾個細節值得拉出來講。いくつかの細部を取り出しておきたい。

• The back-tick is required at the use site too. `define ramqd 3'b100 defines the macro; dest_ctl == `ramqd uses it. Forgetting the back-tick at the use site gives you an undeclared identifier, which — if `default_nettype has not been set to none — becomes an implicit one-bit wire of value z, and the comparison is never true. The symptom is a decoder arm that never fires.使用處也必須加反引號。`define ramqd 3'b100 定義這個巨集；dest_ctl == `ramqd 使用它。在使用處忘了反引號，你得到的是一個未宣告的識別字 —— 如果 `default_nettype 沒設成 none，它會變成一條值為 z 的隱含一位元 wire，於是那個比較永遠不成立。症狀就是某個解碼分支永遠不會啟動。使用側にもバッククォートが要る。`define ramqd 3'b100 がマクロを定義し、dest_ctl == `ramqd がそれを使う。使用側でバッククォートを忘れると未宣言の識別子になり——`default_nettype を none にしていなければ——値 z の暗黙の 1 ビット wire になって、比較は決して真にならない。症状は、あるデコード分岐が決して発火しないことである。
• Three names had to change. The function table calls three operations or, and and notrs, but or and and are Verilog gate primitives and cannot be macro names without confusing every reader and some tools. They become `orrs and `andrs. This is a general hazard of macros: the name space is global and flat.有三個名字不得不改。功能表把三個運算叫做 or、and 與 notrs，但 or 與 and 是 Verilog 的閘級基本元件，拿來當巨集名會讓每個讀者、還有某些工具都混淆。於是它們變成 `orrs 與 `andrs。這是巨集普遍的危險：名稱空間是全域而且扁平的。三つの名前は変更を強いられた。機能表は三つの演算を or、and、notrs と呼ぶが、or と and は Verilog のゲートプリミティブであり、マクロ名にすればすべての読者と一部のツールを混乱させる。そこで `orrs、`andrs になった。これはマクロ一般の危険で、名前空間がグローバルかつ平坦だからである。
• Macros are global and they persist. A `define stays in effect for every file compiled after it in the same invocation, across module boundaries. In a large project this is a real hazard — two blocks each defining `add differently will silently take whichever was compiled last. The disciplined answers are to prefix every macro (`AMD_ADD), to `undef at the end of the file, or to use localparam instead, which is scoped to the module and visible in the waveform viewer as a named value.巨集是全域的，而且會殘留。一個 `define 在同一次呼叫中，對它之後編譯的每一個檔案都持續有效，跨越模組邊界。在大型專案裡這是真實的危險 —— 兩個區塊各自把 `add 定義成不同的東西，最後會悄悄採用最後編譯的那個。有紀律的做法是：給每個巨集加前綴（`AMD_ADD）、在檔案結尾 `undef，或改用 localparam（它的範圍限於模組，而且在波形檢視器裡會以具名值顯示）。マクロはグローバルで、しかも残り続ける。`define は同じ呼び出しの中でそれ以降にコンパイルされるすべてのファイルに、モジュール境界を越えて効き続ける。大規模プロジェクトではこれは現実の危険であり、二つのブロックが `add を別々に定義していれば、最後にコンパイルされた方が黙って採用される。規律ある答えは、マクロに接頭辞を付ける（`AMD_ADD）、ファイル末尾で `undef する、あるいは localparam を使うことである。後者はモジュールにスコープが限られ、波形ビューアでも名前付きの値として見える。
• Why not parameter? Because these constants are used in three different modules and would have to be declared in each. A `define in a shared header is the Verilog-1995 way to share a constant across modules. SystemVerilog's packages and enumerated types are the modern answer and give you type checking and waveform decoding as well.為什麼不用 parameter？因為這些常數用在三個不同的模組裡，用 parameter 就得在每個模組各宣告一次。把 `define 放在共用標頭檔，是 Verilog-1995 跨模組共用常數的做法。SystemVerilog 的 package 與列舉型別才是現代答案，而且還附帶型別檢查與波形解碼。なぜ parameter ではないのか。これらの定数は三つの異なるモジュールで使われ、parameter ならそれぞれで宣言し直す必要があるからである。共有ヘッダに `define を置くのが、Verilog-1995 でモジュール間に定数を共有する方法である。SystemVerilog の package と列挙型が現代的な答えであり、型検査と波形上のデコードまで付いてくる。

6. The AMD2901 Modules in Verilog6. AMD2901 各模組的 Verilog6. AMD2901 各モジュールの Verilog

6.1 Ckt 1 — the register file6.1 電路 1 — 暫存器檔6.1 回路 1 — レジスタファイル

module Register_file (clk, rst, a, b, f, dest_ctl, ram0, ram3, ad, bd);
  input        clk, rst;
  input  [3:0] a, b, f;
  input  [2:0] dest_ctl;
  inout        ram0, ram3;
  output [3:0] ad, bd;
  reg    [3:0] ab_data [15:0];   // the memory: 16 elements of 4 bits
  wire   [3:0] data;
  wire         ram_en;
  reg    [4:0]  row_index;        // note: the size of row_index is critical

  assign ram_en = ((dest_ctl == `qreg) || (dest_ctl == `nop)) ? 0 : 1;

  always @ (posedge clk or posedge rst)
    if (rst == 1) for (row_index = 0; row_index < 16; row_index = row_index + 1)
                    ab_data[row_index] = 0;
    else if (ram_en) ab_data[b] = data;

  assign data = (dest_ctl == `ramqu || dest_ctl == `ramu) ? {f[2], f[1], f[0], ram0} :
                (dest_ctl == `ramqd || dest_ctl == `ramd) ? {ram3, f[3], f[2], f[1]} :
                (dest_ctl == `rama  || dest_ctl == `ramf) ? f : 4'bxxxx;

  assign ad   = ab_data[a];
  assign bd   = ab_data[b];
  assign ram3 = (dest_ctl == `ramu || dest_ctl == `ramqu) ? f[3] : 1'bz;
  assign ram0 = (dest_ctl == `ramd || dest_ctl == `ramqd) ? f[0] : 1'bz;
endmodule

The port f is the ALU output; the top level connects alu_out to it. dest_ctl is instruction[8:6].埠 f 是 ALU 的輸出；頂層把 alu_out 接到它。dest_ctl 就是 instruction[8:6]。ポート f は ALU の出力であり、トップレベルが alu_out をそこへ接続する。dest_ctl は instruction[8:6] である。

The write enable. ram_en is low for exactly two destination codes, qreg and nop, which are the two that the table says write nothing to the register file. Every other code writes. This single line is the complete write-enable decode, and it is a nice illustration of coding against a table rather than enumerating cases: six positive cases collapse into two negative ones.寫入致能。ram_en 只在兩個目的地碼 qreg 與 nop 時為低，而那兩個正是表上說「不寫暫存器檔」的碼。其餘每一個碼都會寫。這一行就是完整的寫入致能解碼，也漂亮地示範了「照著表寫程式」而不是逐一列舉：六個正面情況塌成兩個反面情況。書き込みイネーブル。ram_en が Low になるのはデスティネーションコード qreg と nop のちょうど二つだけで、これは表が「レジスタファイルに何も書かない」とする二つである。残りはすべて書き込む。この 1 行が書き込みイネーブルのデコードのすべてであり、場合を列挙するのではなく表に沿って書く好例でもある。肯定形の 6 ケースが否定形の 2 ケースに畳み込まれている。

The reset loop. The highlighted declaration is the one the comment flags as critical. The loop runs row_index from 0 while it is less than 16, so the index must be able to hold 16 in order for the test to fail and the loop to end. Four bits cannot: 4'b1111 + 1 is 4'b0000, the test 0 < 16 is true again, and the loop runs for ever. In simulation that is an infinite loop inside a zero-delay block — the simulator hangs at time zero with no output, which is a uniquely unhelpful failure. In synthesis the tool must unroll the loop statically and will report that the bounds cannot be determined. Five bits fix it. The general rule from Lecture 7: a loop index must be able to represent a value that fails the termination test.重置迴圈。被標示出來的那個宣告，就是註解標為關鍵的那一行。迴圈讓 row_index 從 0 開始、在小於 16 時持續執行，所以索引必須裝得下 16，測試才會失敗、迴圈才會結束。四位元裝不下：4'b1111 + 1 是 4'b0000，測試 0 < 16 又為真，迴圈就永遠跑下去。在模擬裡那是一個零延遲區塊內的無窮迴圈 —— 模擬器在時間零卡住、什麼輸出都沒有，這是一種格外沒有幫助的失效方式。在合成時，工具必須靜態展開迴圈，它會回報邊界無法決定。五位元就解決了。第 7 講的通則是：迴圈索引必須能表示一個會使終止測試失敗的值。リセットループ。強調された宣言が、コメントで critical と記された行である。ループは row_index を 0 から始め、16 未満のあいだ回る。したがって判定が偽になってループが終わるには、ループ変数が 16 を保持できる必要がある。4 ビットでは保持できない。4'b1111 + 1 は 4'b0000 となり、判定 0 < 16 は再び真になってループは終わらない。シミュレーションでは遅延ゼロのブロック内の無限ループとなり、シミュレータは時刻 0 で何も出力せずに固まる。これは格別に手掛かりの乏しい失敗の仕方である。合成ではツールがループを静的に展開しなければならず、境界が決定できないと報告してくる。5 ビットなら解決する。第 7 講の一般則はこうである。ループ変数は、終了判定を偽にする値を表現できなければならない。

Reading is combinational, writing is clocked. ad and bd are continuous assignments indexing the memory, so they follow a and b with only gate delay: two asynchronous read ports. The write happens in the clocked block at address b: one synchronous write port. A 16×4 file with two asynchronous reads and one synchronous write synthesises to 64 flip-flops, a 4-to-16 decoder producing 16 enables, and two 16-to-1 four-bit multiplexers — about 64 flops and 150 to 200 gates. There is no commodity RAM macro with this shape, so a flop-based file is the right implementation; for a larger file you would use a two-port register-file compiler.讀取是組合的，寫入是時脈同步的。ad 與 bd 是索引記憶體的連續指定，所以它們只隔一點閘延遲就跟著 a 與 b 走：兩個非同步讀取埠。寫入發生在時脈區塊裡、寫到位址 b：一個同步寫入埠。一個帶兩個非同步讀取與一個同步寫入的 16×4 暫存器檔，會合成成 64 個正反器、一個產生 16 條致能的 4 對 16 解碼器，以及兩個 16 對 1 的四位元多工器 —— 大約 64 個正反器加 150 到 200 個閘。市面上沒有這種形狀的 RAM 巨集，所以用正反器做是正確的實作；檔案更大時，你會改用雙埠暫存器檔編譯器。読み出しは組合せ、書き込みはクロック同期である。ad と bd はメモリを添字参照する連続代入なので、ゲート遅延だけで a、b に追従する。すなわち非同期読み出しポート 2 本である。書き込みはクロック同期ブロック内でアドレス b に対して行われる。同期書き込みポート 1 本である。非同期読み出し 2 本と同期書き込み 1 本を持つ 16×4 のファイルは、フリップフロップ 64 個、16 本のイネーブルを作る 4-to-16 デコーダ、4 ビット 16 対 1 のマルチプレクサ 2 個に合成される。フリップフロップ 64 個とゲート 150〜200 個ほどである。この形の汎用 RAM マクロは存在しないので、フリップフロップによる実装が正解である。もっと大きなファイルなら 2 ポートのレジスタファイルコンパイラを使うことになる。

Read-during-write. Because the reads come from flip-flop outputs and the write lands at the clock edge, ad and bd show the old contents throughout the cycle in which a write to the same address is in flight. There is no write-through. That is exactly what makes instruction (d) of Practice 10 work: rama writes the ALU result into address b while y shows the pre-write value of address a.寫入當下的讀取。因為讀取取自正反器輸出，而寫入落在時脈邊緣，所以在一次對同位址的寫入進行中的整個週期裡，ad 與 bd 顯示的都是舊內容。沒有寫入直通。這正是練習 10 的指令 (d) 能成立的原因：rama 把 ALU 結果寫進位址 b，而 y 顯示的是位址 a 寫入前的值。書き込み中の読み出し。読み出しはフリップフロップ出力から来て、書き込みはクロックエッジで着地するので、同じアドレスへの書き込みが進行中のサイクル全体にわたって ad と bd は古い内容を示す。ライトスルーは無い。練習 10 の命令 (d) が成立するのはまさにこれによる。rama が ALU の結果をアドレス b に書くあいだ、y はアドレス a の書き込み前の値を示す。

The shift multiplexer. data is a three-way conditional selecting what actually gets written:移位多工器。data 是一個三向條件式，選出真正要被寫入的東西：シフト用マルチプレクサ。data は三方向の条件式で、実際に書き込まれるものを選ぶ。

Writing the shifts as concatenations rather than as f >> 1 is deliberate and necessary: a shift operator would fill the vacated bit with a zero, and here it must be filled from a pin. Concatenation is the only way to express "shift and insert this particular bit", and it is the standard idiom for any shifter with a serial input.把移位寫成串接而不是 f >> 1，是刻意而且必要的：移位運算子會把空出來的位元補零，但這裡它必須由腳位填入。串接是唯一能表達「移位並插入這個特定位元」的寫法，也是任何帶串列輸入的移位器的標準慣用法。シフトを f >> 1 ではなく連結で書くのは意図的であり、かつ必要である。シフト演算子は空いたビットをゼロで埋めるが、ここではピンから埋めなければならない。「シフトしつつこの特定のビットを挿入する」を表現できるのは連結だけであり、シリアル入力を持つシフタの標準的な書き方でもある。

The bidirectional pins. ram0 and ram3 are declared inout and driven through conditional continuous assignments that produce 1'bz when not driving. On an up-shift the slice drives its top bit out on ram3 and receives the bit below on ram0; on a down-shift the directions swap. Because every slice follows the same rule, wiring slice $k$'s ram3 to slice $k{+}1$'s ram0 gives a shift chain of any length with no extra logic, and the fact that only one end of each wire ever drives means there is no contention. The lowest slice's ram0 and the highest slice's ram3 are left for the system designer to tie — to zero for a logical shift, to the sign bit for an arithmetic right shift, to the carry for a rotate through carry, or, as §7.1 shows, to the other shift chain for a multiply.雙向腳位。ram0 與 ram3 宣告成 inout，由條件式連續指定驅動，不驅動時產生 1'bz。上移時，這片 slice 把自己的最高位元由 ram3 送出，同時由 ram0 接收下面那一位元；下移時方向對調。因為每片 slice 都遵守同一條規則，把第 $k$ 片的 ram3 接到第 $k{+}1$ 片的 ram0，就得到任意長度的移位鏈，不需要額外邏輯；而每條線上永遠只有一端在驅動，所以不會有爭用。最低那片的 ram0 與最高那片的 ram3 留給系統設計者去接 —— 邏輯移位就接零、算術右移就接符號位元、帶進位旋轉就接進位，或者如 §7.1 所示，接到另一條移位鏈去做乘法。双方向ピン。ram0 と ram3 は inout として宣言され、条件付きの連続代入で駆動され、駆動しないときは 1'bz を出す。上方向シフトではスライスは自分の最上位ビットを ram3 から出し、同時に下のビットを ram0 から受け取る。下方向シフトでは向きが入れ替わる。すべてのスライスが同じ規則に従うので、$k$ 番目のスライスの ram3 を $k{+}1$ 番目の ram0 へ配線すれば、追加の論理なしに任意長のシフト連鎖ができる。各配線の駆動側は常に片方だけなので競合も起きない。最下位スライスの ram0 と最上位スライスの ram3 は、システム設計者が接続すべく残されている。論理シフトならゼロへ、算術右シフトなら符号ビットへ、キャリー付きローテートならキャリーへ、あるいは §7.1 で見るように乗算のためにもう一方のシフト連鎖へつなぐ。

6.2 Ckt 2 — the operand selector6.2 電路 2 — 運算元選擇器6.2 回路 2 — オペランドセレクタ

module operand_selector (d, ad, bd, q, op_sel, r, s);
  input  [3:0] d, ad, bd, q;
  input  [2:0] op_sel;
  output [3:0] r, s;
  reg    [3:0] r, s;

  // operand codes
  always @ (op_sel) begin
    case (op_sel)
      `aq, `ab:      assign r = ad;
      `zq, `zb, `za: assign r = 4'b0;
      default:       assign r = d;
    endcase
    case (op_sel)
      `aq, `zq, `dq: assign s = q;
      `ab, `zb:      assign s = bd;
      `za, `da:      assign s = ad;
      default:       assign s = 4'b0;
    endcase
  end
endmodule

Check it against the table of §5.4 arm by arm. For r: aq and ab give ad; zq, zb and za give zero; the default catches da, dq and dz, all of which give d. For s: aq, zq, dq give q; ab, zb give bd; za, da give ad; the default catches dz alone and gives zero. Every one of the sixteen entries matches. This module is correct.拿它逐個分支對照 §5.4 的表。r 方面：aq 與 ab 給 ad；zq、zb、za 給零；default 接住 da、dq、dz，它們都給 d。s 方面：aq、zq、dq 給 q；ab、zb 給 bd；za、da 給 ad；default 只接住 dz，給零。十六項全部吻合。這個模組是對的。§5.4 の表と分岐ごとに突き合わせてみる。r 側では、aq と ab が ad、zq・zb・za がゼロ、default が da・dq・dz を受けてすべて d を与える。s 側では、aq・zq・dq が q、ab・zb が bd、za・da が ad、default は dz だけを受けてゼロを与える。16 項目すべてが一致する。このモジュールは正しい。

What is unusual is the construct. The sensitivity list contains only op_sel, yet r and s depend on ad, bd, q and d as well. In an ordinary combinational block that would be an incomplete sensitivity list and a classic Lecture 5 bug: the outputs would freeze whenever a data input changed without op_sel changing, simulation would disagree with the synthesised hardware, and the mismatch would surface only at gate level. Here it is not a bug, because the assignments are not ordinary procedural assignments. They are procedural continuous assignments.不尋常的是它的寫法。敏感列表裡只有 op_sel，但 r 與 s 還依賴 ad、bd、q 與 d。在一般的組合區塊裡，那會是一個不完整的敏感列表，也是第 5 講的經典 bug：只要資料輸入改變而 op_sel 沒變，輸出就凍住，模擬會與合成出的硬體不一致，而這個不一致只會在閘級浮現。但這裡不是 bug，因為那些指定不是一般的程序性指定，而是程序式連續指定（PCA）。変わっているのはその書き方である。感度リストには op_sel しかないのに、r と s は ad、bd、q、d にも依存している。通常の組合せブロックならこれは不完全な感度リストであり、第 5 講の典型的なバグである。op_sel が変わらずにデータ入力だけが変われば出力は凍りつき、シミュレーションと合成後のハードウェアが食い違い、その不一致はゲートレベルでしか表面化しない。しかしここではバグではない。これらの代入が通常の手続き型代入ではなく、手続き型連続代入（PCA）だからである。

Should you write code this way? No. Three reasons: procedural continuous assignments are poorly supported by synthesis tools and some will reject the module outright; they were deprecated in IEEE 1364-2005 and removed from the SystemVerilog synthesisable subset; and the efficiency they buy is irrelevant on any simulator built in the last twenty years, all of which use event-driven scheduling that already skips unchanged inputs. The portable equivalent is three lines shorter and will synthesise anywhere:你應該這樣寫程式嗎？不應該。三個理由：程序式連續指定在合成工具裡支援很差，有些工具會直接拒絕這個模組；它在 IEEE 1364-2005 被標為棄用，並從 SystemVerilog 的可合成子集中移除；而且它買到的效率，在過去二十年內做出來的任何模擬器上都無關緊要，那些模擬器用的事件驅動排程本來就會跳過沒變的輸入。可攜的等價寫法短三行，而且到哪裡都合成得出來：こう書くべきか。書くべきではない。理由は三つある。手続き型連続代入は合成ツールのサポートが乏しく、モジュールごと拒否するツールもある。IEEE 1364-2005 で非推奨となり、SystemVerilog の合成可能部分集合からは削除された。そして、それが買う効率はここ 20 年に作られたどのシミュレータでも無意味である。いずれもイベント駆動のスケジューリングで、変化していない入力はもともと飛ばすからである。移植性のある等価な書き方は 3 行短く、どこでも合成できる。

always @ (op_sel) begin
  case (op_sel)
    `aq, `ab:      assign r = ad;
    `zq, `zb, `za: assign r = 4'b0;
    default:       assign r = d;
  endcase
  ...
end

always @* begin
  case (op_sel)
    `aq, `ab:      r = ad;
    `zq, `zb, `za: r = 4'b0;
    default:       r = d;
  endcase
  ...
end
// or, even better, two continuous assignments
// with nested conditionals and no always block

Both case statements have a default, so every path assigns both outputs and no latch can be inferred. Both are also full and parallel — all eight codes appear exactly once across the arms — so the synthesiser builds a plain multiplexer rather than a priority chain. The result is a 3-to-1 four-bit mux for r and a 4-to-1 four-bit mux for s: roughly 30 gates in total, and about two gate delays.兩個 case 都有 default，所以每一條路徑都指定了兩個輸出，推論不出閂鎖。兩者也都是完整且互斥的 —— 八個碼在各分支中各出現恰好一次 —— 所以合成器建的是單純的多工器，而不是優先鏈。結果是 r 一個 3 對 1 的四位元多工器、s 一個 4 對 1 的四位元多工器：總共大約 30 個閘，約兩級閘延遲。どちらの case にも default があるので、すべての経路で両方の出力に代入され、ラッチは推論されない。どちらも full かつ parallel であり——8 つのコードが各分岐にちょうど 1 回ずつ現れる——合成器はプライオリティ連鎖ではなく素直なマルチプレクサを作る。結果は r 用の 3 対 1 の 4 ビットマルチプレクサと s 用の 4 対 1 のそれで、合計おおよそ 30 ゲート、遅延にして 2 段ほどである。

6.3 Ckt 3 — the ALU6.3 電路 3 — ALU6.3 回路 3 — ALU

module ALU_amd2901 (r, s, c_in, ctl, alu_out, g_bar, p_bar, ovr, c_out);
  input  [3:0] r, s;
  input        c_in;
  input  [2:0] ctl;
  output [3:0] alu_out;
  output       g_bar, p_bar, ovr, c_out;
  reg    [3:0] alu_out;
  reg          c_out;

  always @ (r or s or c_in or ctl)
    case (ctl)
      `add:    {c_out, alu_out} = r + s + c_in;
      `subr:   {c_out, alu_out} = r + ~s + c_in;
      `subs:   {c_out, alu_out} = s + ~r + ~c_in;
      `orrs:   {c_out, alu_out} = {1'b0, r | s};
      `andrs:  {c_out, alu_out} = {1'b0, r & s};
      `notrs:  {c_out, alu_out} = {1'b0, (~r) & s};
      `exor:   {c_out, alu_out} = {1'b0, r ^ s};
      `exnor:  {c_out, alu_out} = {1'b0, r ~^ s};
      default: {c_out, alu_out} = 5'bx;
    endcase

  assign ovr   = c_out ^ alu_out[3];
  assign g_bar = ~( (r[3] & s[3]) |
                    ((r[3] | s[3]) & (r[2] & s[2])) |
                    ((r[3] | s[3]) & (r[2] | s[2]) & (r[1] & s[1])) |
                    ((r[3] | s[3]) & (r[2] | s[2]) & (r[1] | s[1]) & (r[0] & s[0])) );
  assign p_bar = ~((r[3] ^ s[3]) & (r[2] ^ s[2]) & (r[1] ^ s[1]) & (r[0] ^ s[0]));
endmodule

Start with what is right. The case is complete in all eight codes and has a default, so there is no latch. The sensitivity list names every input, so the block is a genuine combinational description. And the use of a concatenation on the left-hand side — {c_out, alu_out} — is the idiom you should take away from this module: it makes the assignment target five bits wide, so the five-bit sum of a four-bit addition is captured in full, with the carry landing in c_out instead of being discarded. Writing alu_out = r + s + c_in; with a four-bit target would throw the carry away, and you would need a second, separately computed expression to recover it.先說對的地方。case 八個碼都齊全，而且有 default，所以沒有閂鎖。敏感列表列出每一個輸入，所以這是一個貨真價實的組合描述。而在左手邊用串接 —— {c_out, alu_out} —— 是你該從這個模組帶走的慣用法：它讓指定目標寬五位元，於是四位元加法的五位元和被完整收下，進位落在 c_out 裡而不是被丟掉。寫成四位元目標的 alu_out = r + s + c_in; 會把進位扔掉，你得另外再寫一個獨立運算式把它救回來。まず正しい点から。case は 8 コードすべてを網羅し、default も持つのでラッチは生じない。感度リストはすべての入力を挙げており、本物の組合せ記述になっている。そして左辺に連結を使う {c_out, alu_out} こそ、このモジュールから持ち帰るべき書き方である。代入先が 5 ビット幅になるので、4 ビット加算の 5 ビットの和が丸ごと受け取られ、キャリーは捨てられずに c_out へ入る。4 ビットの代入先で alu_out = r + s + c_in; と書けばキャリーは失われ、それを取り戻すために別の式をもう一本書く羽目になる。

The logical functions are handled differently and correctly: {1'b0, r | s} explicitly supplies the carry bit as zero. Because that concatenation is itself five bits, the inner r | s is self-determined at four bits and is not affected by the surrounding width. That distinction is about to matter enormously.邏輯功能則用了不同而且正確的處理：{1'b0, r | s} 明確地把進位位元供成零。因為那個串接本身是五位元，裡面的 r | s 是在四位元下自定寬度的，不受外圍寬度影響。這個區別馬上就要變得極其重要。論理演算は別のやり方で、しかも正しく扱われている。{1'b0, r | s} はキャリービットを明示的にゼロとして与える。この連結自体が 5 ビットなので、内側の r | s は 4 ビットで自己決定され、外側の幅に影響されない。この区別がこの直後に決定的な意味を持つ。

6.4 The inversion-width trap6.4 取反後位元寬度的陷阱6.4 反転とビット幅の落とし穴

Now the subtle one, and it is genuinely subtle — subtle enough that it survives in textbooks. Consider現在講微妙的那個，而且它是真的微妙 —— 微妙到連教科書裡都還留著。考慮ここからが微妙な話であり、本当に微妙である。教科書にすら生き残っているほどに。次を考えてみる。

{c_out, alu_out} = r + ~s + c_in;

and ask what ~s evaluates to. The intuitive answer is "the four-bit complement of s", so for s = 4'b0101 it would be 4'b1010 = 10. That is not what the language says.然後問 ~s 求值是多少。直覺的答案是「s 的四位元補數」，所以 s = 4'b0101 時應該是 4'b1010 = 10。語言規定的不是那樣。そして ~s が何に評価されるかを問う。直感的な答えは「s の 4 ビットの補数」であり、s = 4'b0101 なら 4'b1010 = 10 になるはずである。言語が定めているのはそうではない。

IEEE 1364 sizes an expression in two steps. First, the expression's width is the maximum of the widths of all its context-determined operands and of the assignment target. Here the target is the five-bit concatenation {c_out, alu_out}, so the expression width is five. Second, every context-determined operand is extended to that width before the operator is applied. The operand of a bitwise negation is context-determined. So s is first zero-extended to 5'b00101 and then complemented, giving 5'b11010 = 26, not 10.IEEE 1364 以兩個步驟決定運算式的寬度。第一，運算式的寬度是「所有由上下文決定寬度的運算元以及指定目標」的寬度最大值。這裡目標是五位元的串接 {c_out, alu_out}，所以運算式寬度是五。第二，每一個由上下文決定的運算元都會先被擴展到那個寬度，然後才套用運算子。逐位元取反的運算元是由上下文決定的。所以 s 先被零擴展成 5'b00101，然後才取反，得到 5'b11010 = 26，而不是 10。IEEE 1364 は式の幅を 2 段階で決める。第一に、式の幅は文脈で幅が決まるすべてのオペランドと代入先の幅の最大値である。ここでの代入先は 5 ビットの連結 {c_out, alu_out} なので、式の幅は 5 になる。第二に、文脈で決まるオペランドはその幅へ拡張されてから演算子が適用される。ビット単位否定のオペランドは文脈で決まる。したがって s はまず 5'b00101 へゼロ拡張され、その後で反転されて 5'b11010 = 26 となり、10 にはならない。

`subr: {c_out, alu_out} = r + {1'b0, ~s} + c_in;
// or, clearer still:
wire [3:0] s_bar = ~s;
wire [3:0] r_bar = ~r;
...
`subr: {c_out, alu_out} = r + s_bar + c_in;

6.5 Overflow, generate and propagate6.5 溢位、generate 與 propagate6.5 オーバフロー・generate・propagate

The overflow flag. The code computes ovr = c_out ^ alu_out[3]. Signed two's-complement overflow is not that. It is the exclusive-OR of the carry into the most significant bit position and the carry out of it:溢位旗標。程式碼算的是 ovr = c_out ^ alu_out[3]。帶號二補數的溢位不是那個。它是「進入最高位元位置的進位」與「從最高位元位置出來的進位」的互斥或：オーバフローフラグ。コードは ovr = c_out ^ alu_out[3] を計算している。符号付き 2 の補数のオーバフローはそれではない。最上位ビット位置への桁上げと、そこからの桁上げの排他的論理和である。

The second form is the one to remember in words: overflow can only happen when the two addends have the same sign, and it has happened when the result's sign differs from theirs. Adding a positive to a negative can never overflow, because the magnitude of the result is bounded by the larger operand.第二種形式是值得用白話記住的：只有兩個加數同號時才可能溢位，而當結果的符號與它們不同時，溢位就發生了。正數加負數永遠不可能溢位，因為結果的大小不會超過較大的那個運算元。第二の形は言葉で覚えておく価値がある。オーバフローは二つの加数の符号が同じときにしか起こりえず、結果の符号がそれらと異なればオーバフローが起きている。正と負を足してオーバフローすることは決してない。結果の大きさが大きい方のオペランドで抑えられるからである。

Check the slide's formula on the example above. There, $c_4 = 0$ (taking the four-bit interpretation) and $f_3 = 1$, so ovr = 0 ^ 1 = 1 — the slide's flag claims an overflow. But $3 - 5 = -2$ fits comfortably in four bits, so there is none. Using the sign rule: the adder's operands are $r = 0011$ (positive) and $\bar s = 1010$ (negative), different signs, so overflow is impossible. The slide's expression is really "carry out exclusive-OR sign", which is a different and far less useful quantity. The correct implementation needs the internal carry, which the expression r + s + c_in does not expose; you must either compute the carry chain explicitly or use the sign-comparison form:拿投影片的公式去驗上面那個例子。那裡 $c_4 = 0$（採四位元解讀）而 $f_3 = 1$，所以 ovr = 0 ^ 1 = 1 —— 投影片的旗標宣稱溢位了。但 $3 - 5 = -2$ 在四位元裡綽綽有餘，根本沒有溢位。用符號規則看：加法器的運算元是 $r = 0011$（正）與 $\bar s = 1010$（負），符號不同，所以不可能溢位。投影片的運算式其實是「進位輸出互斥或符號位元」，那是另一個、而且有用得多的量。正確的實作需要內部進位，而運算式 r + s + c_in 並不暴露它；你得自己明確算出進位鏈，或改用符號比較的形式：上の例にスライドの式を当ててみる。そこでは（4 ビットで解釈すれば）$c_4 = 0$、$f_3 = 1$ なので ovr = 0 ^ 1 = 1 となり、スライドのフラグはオーバフローを主張する。しかし $3 - 5 = -2$ は 4 ビットに余裕で収まり、オーバフローは起きていない。符号の規則で見れば、加算器のオペランドは $r = 0011$（正）と $\bar s = 1010$（負）で符号が異なるため、オーバフローはありえない。スライドの式は実のところ「キャリー出力と符号ビットの排他的論理和」であり、別物でしかも有用性ははるかに劣る。正しい実装には内部キャリーが必要だが、式 r + s + c_in はそれを外に出さない。キャリー連鎖を明示的に計算するか、符号比較の形を使うことになる。

  // correct for the add function; the operands of the adder are r and sx,
  // where sx is s for `add and ~s for a subtract
  assign ovr = (r[3] == sx[3]) & (alu_out[3] != r[3]);

Generate and propagate. The last two assignments compute the inverted group-generate and group-propagate signals that feed an external carry-look-ahead generator (in the AMD family, an Am2902). For a four-bit group with bit generate $g_i = r_i s_i$ and bit propagate $p_i = r_i + s_i$:generate 與 propagate。最後那兩個指定算的是反相後的群組 generate 與群組 propagate 訊號，它們要餵給外部的進位預看產生器（在 AMD 家族裡是 Am2902）。對一個四位元群組，位元 generate 為 $g_i = r_i s_i$、位元 propagate 為 $p_i = r_i + s_i$：generate と propagate。最後の二つの代入は、外部のキャリー先見生成器（AMD ファミリでは Am2902）へ入る、反転されたグループ generate とグループ propagate を計算している。4 ビットのグループについて、ビット generate を $g_i = r_i s_i$、ビット propagate を $p_i = r_i + s_i$ とすると：

and the carry out of the group is $C_4 = G + P\,C_0$, computed in two gate delays no matter how many groups you chain. Compare the g_bar expression line by line with the formula and you will find it is exactly $\overline{G}$ with $p_i$ written as (r[i] | s[i]). The p_bar expression uses the exclusive-or form of the bit propagate, $p_i = r_i \oplus s_i$, rather than the OR form. Both are valid in the look-ahead equation — the two differ only when $r_i = s_i = 1$, in which case $g_i = 1$ and the carry is generated anyway, so the value of $P$ is irrelevant — and the XOR form is preferred in practice because the same XOR gate also produces the half-sum needed for the sum bit, saving a gate per bit.而群組的進位輸出是 $C_4 = G + P\,C_0$，不論你串接多少個群組，都只花兩級閘延遲。把 g_bar 的運算式逐行對照這條公式，你會發現它正好是 $\overline{G}$，其中 $p_i$ 寫成 (r[i] | s[i])。p_bar 的運算式用的是位元 propagate 的互斥或形式 $p_i = r_i \oplus s_i$，而不是 OR 形式。兩者在預看方程式裡都有效 —— 它們只在 $r_i = s_i = 1$ 時不同，而那時 $g_i = 1$、進位本來就會產生，所以 $P$ 的值無關緊要 —— 實務上偏好 XOR 形式，因為同一個 XOR 閘也產生和位元所需的半和，每一位元省下一個閘。グループのキャリー出力は $C_4 = G + P\,C_0$ であり、グループをいくつ縦続しても 2 段のゲート遅延で求まる。g_bar の式をこの公式と 1 行ずつ照合すれば、それがちょうど $\overline{G}$ であり、$p_i$ が (r[i] | s[i]) と書かれていることが分かる。p_bar の式はビット propagate の OR 形ではなく排他的論理和形 $p_i = r_i \oplus s_i$ を使っている。どちらも先見の式として妥当である——両者が異なるのは $r_i = s_i = 1$ のときだけで、そのときは $g_i = 1$ でキャリーはどのみち生成されるため $P$ の値は関係ない——が、実務では XOR 形が好まれる。同じ XOR ゲートが和ビットに必要な半加算も作るので、ビットごとにゲートが 1 個節約できるからである。

6.6 Ckt 4 — the Q register6.6 電路 4 — Q 暫存器6.6 回路 4 — Q レジスタ

module Q_register (clk, rst, data_in, dest_ctl, qs0, qs3, q);
  // parameterized register with shift left (up), shift right (down)
  // and transfer of interface bits to/from companion slices
  input        clk, rst;
  input  [3:0] data_in;
  input  [2:0] dest_ctl;
  inout        qs0, qs3;
  output [3:0] q;
  reg    [3:0] data;
  reg          q_en;

  reg_load_R #(4) M1 (data, clk, rst, q_en, q);

  bufif1 (qs3, data_in[3], (dest_ctl == `ramu || dest_ctl == `ramqu));
  bufif1 (qs0, data_in[0], (dest_ctl == `ramd || dest_ctl == `ramqd));

  always @ (dest_ctl)
    case (dest_ctl)
      `qreg, `ramqd, `ramqu: assign q_en = 1;
      default:               assign q_en = 0;
    endcase

  always @ (dest_ctl or qs0 or qs3)
    case (dest_ctl)
      // shift left (up)
      `ramqu:  assign data = {data_in[2], data_in[1], data_in[0], qs0};
      // shift right (down)
      `ramqd:  assign data = {qs3, data_in[3], data_in[2], data_in[1]};
      // pass through
      `qreg:   assign data = data_in;
      default: assign data = 4'bx;
    endcase
endmodule

module reg_load_R (data, clk, reset, load, q);
  parameter size = 8;
  input  [size-1:0] data;
  input             clk, reset, load;
  output [size-1:0] q;
  reg    [size-1:0] q;

  always @ (posedge clk or posedge reset)
    if (reset == 1) q = 0;
    else if (load == 1) q = data;
endmodule

Three pieces: a generic loadable register instantiated with a parameter override, a pair of three-state drivers for the serial pins, and two decoders built from the destination field.三個部分：一個帶參數覆寫實例化的通用可載入暫存器、一對給串列腳位用的三態驅動器，以及兩個由目的地欄位建出來的解碼器。三つの部分からなる。パラメータを上書きしてインスタンス化された汎用のロード可能レジスタ、シリアルピン用のトライステートドライバ 2 個、そしてデスティネーションフィールドから作られる二つのデコーダである。

The parameter override. reg_load_R #(4) M1 (...) sets size to 4 for this instance. The module's default is 8, which is the trap: omit the #(4) and you instantiate an eight-bit register whose top four bits are unconnected and whose four-bit output is silently truncated from an eight-bit q. There is no error, and the symptom — a Q register that works perfectly — never appears, because the extra bits simply cost area. This is the single strongest argument for named parameter overrides, #(.size(4)), which Verilog-2001 allows and which at least makes the intent legible.參數覆寫。reg_load_R #(4) M1 (...) 把這個實例的 size 設成 4。模組的預設值是 8，而那就是陷阱：漏掉 #(4)，你實例化出來的是一個八位元暫存器，它最上面四位元沒接、而四位元的輸出是從八位元的 q 被悄悄截斷來的。不會報錯，而症狀 —— 一個運作完美的 Q 暫存器 —— 永遠不會出現，因為多出來的位元只是多佔面積。這是支持具名參數覆寫 #(.size(4)) 最有力的單一論據；Verilog-2001 允許這種寫法，而且至少讓意圖可讀。パラメータの上書き。reg_load_R #(4) M1 (...) はこのインスタンスの size を 4 に設定する。モジュールの既定値は 8 であり、そこが落とし穴である。#(4) を落とせば 8 ビットのレジスタがインスタンス化され、上位 4 ビットは未接続、4 ビットの出力は 8 ビットの q から黙って切り詰められたものになる。エラーは出ず、症状——完璧に動く Q レジスタ——は決して現れない。余分なビットは面積を食うだけだからである。これは名前付きのパラメータ上書き #(.size(4)) を支持する最も強い論拠である。Verilog-2001 はこの書き方を許し、少なくとも意図が読み取れるようになる。

The loadable register. reg_load_R is the enable-register template from Lecture 6 §4.4: an edge-triggered block with an asynchronous reset and, under the else, a single conditional load with no else branch. The absence of that final else is deliberate and is what makes it a flip-flop with a clock-enable pin rather than a latch. The reason it is not a latch is that the block is edge-sensitive: holding is the default behaviour of a flip-flop, so "assign nothing" means "hold", and nothing is inferred. In a level-sensitive block the same code would infer a latch, which is why Lecture 5 and Lecture 6 state the apparently contradictory rules that they do. (The module again uses blocking assignments in a clocked block; use <=.)可載入暫存器。reg_load_R 就是第 6 講 §4.4 的致能暫存器樣板：一個帶非同步重置的邊緣觸發區塊，在 else 之下有一個單一的條件載入，而且沒有 else 分支。最後那個 else 的缺席是刻意的，也正是它讓這成為一個帶時脈致能腳位的正反器而不是閂鎖。它之所以不是閂鎖，是因為這個區塊是邊緣觸發的：保持本來就是正反器的預設行為，所以「什麼都不指定」就是「保持」，不會推論出任何東西。在位準觸發區塊裡，同樣的程式碼會推論出閂鎖，這也是第 5 講與第 6 講那兩條看似矛盾的規則的由來。（這個模組同樣在時脈區塊裡用阻塞指定；請用 <=。）ロード可能レジスタ。reg_load_R は第 6 講 §4.4 のイネーブル付きレジスタのテンプレートそのものである。非同期リセット付きのエッジ記述ブロックがあり、else の下に条件付きロードが一つだけあって、その else 分岐は無い。最後の else が無いのは意図的であり、それがこれをラッチではなくクロックイネーブルピン付きフリップフロップにしている。ラッチにならないのはブロックがエッジ記述だからである。保持はフリップフロップの既定の振る舞いなので「何も代入しない」は「保持する」を意味し、何も推論されない。レベル記述ブロックなら同じコードはラッチを推論する。第 5 講と第 6 講が一見矛盾する規則を述べているのはそのためである。（このモジュールもクロック同期ブロックでブロッキング代入を使っている。<= にすべきである。）

The three-state serial pins. bufif1 is a Verilog gate primitive: a buffer whose output is driven when its control input is 1 and is high-impedance otherwise. The two instances here are unnamed, which is legal for primitives, and they drive qs3 with data_in[3] while shifting up and qs0 with data_in[0] while shifting down. The purpose is the same as for the register file's ram0/ram3: a slice sends the bit that falls off its end to its neighbour, and because only one slice drives each wire at a time there is no contention.三態的串列腳位。bufif1 是 Verilog 的閘級基本元件：一個緩衝器，控制輸入為 1 時驅動輸出，否則為高阻抗。這裡的兩個實例是未命名的，對基本元件而言這合法；它們在上移時用 data_in[3] 驅動 qs3，在下移時用 data_in[0] 驅動 qs0。目的與暫存器檔的 ram0/ram3 相同：一片 slice 把從自己端點掉出去的位元送給鄰居，而因為每條線同一時間只有一片在驅動，所以不會爭用。トライステートのシリアルピン。bufif1 は Verilog のゲートプリミティブで、制御入力が 1 のとき出力を駆動し、それ以外ではハイインピーダンスになるバッファである。ここの 2 インスタンスは無名だが、プリミティブでは合法である。上方向シフトでは data_in[3] で qs3 を、下方向シフトでは data_in[0] で qs0 を駆動する。目的はレジスタファイルの ram0/ram3 と同じで、スライスは自分の端から落ちるビットを隣へ送る。各配線を同時に駆動するのは 1 スライスだけなので競合は起きない。

The two decoders. The first produces the load enable q_en, which is high for exactly the three destinations that the table says load Q — qreg, ramqd, ramqu. Correct. The second produces the value to load, choosing between an up-shift, a down-shift, a pass-through, and 4'bx for the four destinations that do not load at all, which is a true don't-care because q_en is low for all of them.兩個解碼器。第一個產生載入致能 q_en，它在表上說會載入 Q 的那三個目的地 —— qreg、ramqd、ramqu —— 時為高。正確。第二個產生要載入的值，在上移、下移、直通之間選擇，並對那四個根本不載入的目的地給 4'bx，那是真正的 don't care，因為對它們而言 q_en 都是低的。二つのデコーダ。一つ目はロードイネーブル q_en を作り、表が Q をロードするとする三つのデスティネーション——qreg、ramqd、ramqu——でちょうど High になる。正しい。二つ目はロードする値を作り、上方向シフト・下方向シフト・素通しの中から選び、まったくロードしない四つのデスティネーションには 4'bx を与える。それらでは q_en が Low なので、これは真のドントケアである。

      `ramqu:  data = {q[2], q[1], q[0], qs0};   // Q << 1, qs0 in at the bottom
      `ramqd:  data = {qs3, q[3], q[2], q[1]};   // Q >> 1, qs3 in at the top
      `qreg:   data = data_in;                   // load alu_out unshifted

Finally, the two always blocks here use the same procedural-continuous-assignment style as the operand selector, with the same caveats — and the same portable rewrite is to delete the word assign, change the sensitivity list to @*, and be done.最後，這裡的兩個 always 區塊跟運算元選擇器一樣用了程序式連續指定的寫法，注意事項也一樣 —— 而同樣可攜的改寫就是：刪掉 assign 這個字、把敏感列表改成 @*，完事。最後に、ここの二つの always ブロックもオペランドセレクタと同じ手続き型連続代入の流儀で書かれており、注意点も同じである。移植性のある書き換えも同じで、assign という語を削り、感度リストを @* にすれば済む。

6.7 Ckt 5 — the output selector6.7 電路 5 — 輸出選擇器6.7 回路 5 — 出力セレクタ

module output_selector (mux_out, channel_1, channel_2, sel, enable);
  input  [3:0] channel_1, channel_2;
  input  [2:0] sel;
  input        enable;           // active low
  output [3:0] mux_out;

  assign mux_out = (enable == 0 && sel == `rama) ? channel_1 :
                   (enable == 0)                  ? channel_2 : 4'bz;
endmodule

The smallest module in the design and the easiest to misread, because its port names are generic while its connection is specific. The top level instantiates it as output_selector M3 (y, ad, alu_out, instruction[8:6], enable);, so channel_1 is ad, channel_2 is alu_out, and sel is the destination field. Substituting:這是整個設計裡最小的模組，也是最容易讀錯的，因為它的埠名很通用而它的接線很具體。頂層把它實例化成 output_selector M3 (y, ad, alu_out, instruction[8:6], enable);，所以 channel_1 是 ad、channel_2 是 alu_out、sel 是目的地欄位。代入之後：設計中で最も小さいモジュールであり、最も読み違えやすいモジュールでもある。ポート名が一般的である一方、接続は具体的だからである。トップレベルは output_selector M3 (y, ad, alu_out, instruction[8:6], enable); としてインスタンス化するので、channel_1 は ad、channel_2 は alu_out、sel はデスティネーションフィールドである。代入すると次のようになる。

which is exactly the "Output y" column of the destination table: reg_f[a] for rama and alu_out for everything else. The nested conditional operator is being used as a two-level priority multiplexer, which is the natural continuous-assignment idiom for this shape; it synthesises to a 2-to-1 multiplexer followed by a three-state buffer, four bits wide.這正好就是目的地表的「輸出 y」那一欄：rama 時是 reg_f[a]，其餘一律是 alu_out。巢狀的條件運算子在這裡被當成兩層的優先多工器，對這種形狀而言那是連續指定最自然的慣用法；它會合成成一個 2 對 1 多工器後面接一個三態緩衝器，寬四位元。これはデスティネーション表の「出力 y」の欄そのものである。rama では reg_f[a]、それ以外はすべて alu_out である。入れ子になった条件演算子は 2 段のプライオリティマルチプレクサとして使われており、この形に対しては連続代入としてごく自然な書き方である。合成すると 2 対 1 のマルチプレクサの後ろにトライステートバッファが続く、4 ビット幅の回路になる。

enable is active low, and the code says so only in a comment. That is how active-low signals become bugs. Verilog has no type system to help, so the convention is naming: call it enable_n, n_enable or enable_bar, pick one convention for the whole project, and the comment becomes unnecessary. The three-state output is appropriate here, because y on a real Am2901 is a chip pin that shares a bus with other devices; this is one of the few places in the design where internal three-state logic is genuinely the right answer, because it is not internal.enable 是低電位有效，而程式碼只在註解裡說了這件事。低電位有效訊號就是這樣變成 bug 的。Verilog 沒有型別系統可以幫忙，所以慣例只能靠命名：叫它 enable_n、n_enable 或 enable_bar，整個專案挑一種用，註解就不必要了。這裡的三態輸出是恰當的，因為真實 Am2901 上的 y 是一支與其他裝置共用匯流排的晶片腳位；這是整個設計裡少數幾個內部三態邏輯真的正確的地方，因為它其實不是內部的。enable はアクティブ Low であり、コードはそれをコメントでしか述べていない。アクティブ Low の信号はこうしてバグになる。Verilog には助けになる型システムが無いので、規約は命名で担うしかない。enable_n、n_enable、enable_bar のどれかに決め、プロジェクト全体で一つの流儀に揃えれば、コメントは不要になる。ここでのトライステート出力は適切である。実物の Am2901 の y は他のデバイスとバスを共有するチップのピンだからである。この設計の中で内部トライステート論理が本当に正しい数少ない箇所であり、それは実のところ内部ではないからである。

6.8 The top-level module6.8 頂層模組6.8 トップレベルモジュール

module amd2901 (clk, rst, enable, c_in, a, b, d, instruction, ram0, ram3,
                qs0, qs3, y, g_bar, p_bar, ovr, c_out, f_0, f_3);
  input        clk, rst, c_in, enable;
  input  [3:0] a, b, d;
  input  [8:0] instruction;
  inout        ram0, ram3;
  inout        qs0, qs3;
  output [3:0] y;
  output       g_bar, p_bar, ovr, c_out, f_0, f_3;
  wire   [3:0] ad, bd, q, r, s, alu_out;

  Register_file M1 (
    clk,                // system clock
    rst,                // global reset
    a, b,               // addresses into the register file
    alu_out,            // data path from the ALU
    instruction[8:6],   // microinstruction bits for the destination
    ram0, ram3,         // LSB and MSB of the memory word
    ad, bd              // the two 4-bit read ports
  );
  ALU_amd2901      M2 (r, s, c_in, instruction[5:3], alu_out, g_bar, p_bar, ovr, c_out);
  output_selector  M3 (y, ad, alu_out, instruction[8:6], enable);
  operand_selector M4 (d, ad, bd, q, instruction[2:0], r, s);
  Q_register       M5 (clk, rst, alu_out, instruction[8:6], qs0, qs3, q);

  assign f_0 = (alu_out == 4'b0) ? 0 : 1'bz;
  assign f_3 = alu_out[3];
endmodule

Five instances and two assignments. The wires ad, bd, q, r, s and alu_out are the internal nets of the loop in §5.2, and tracing them through the five port lists is the most useful ten minutes you can spend on this design.五個實例與兩個指定。wire ad、bd、q、r、s 與 alu_out 就是 §5.2 那個迴路的內部 net，而把它們穿過五份埠列表追一遍，是你能花在這個設計上最有用的十分鐘。インスタンス 5 個と代入 2 本。ワイヤ ad、bd、q、r、s、alu_out は §5.2 のループの内部ネットであり、それらを 5 つのポートリストを通して追いかける 10 分が、この設計に費やせる最も有益な時間である。

One structural question deserves an answer, because the diagram looks alarming: is there a combinational loop? The loop on the diagram is register file → operand selector → ALU → register file. Follow it in the netlist: ad and bd come from flip-flop outputs through a read multiplexer; they feed the operand selector combinationally; r and s feed the ALU combinationally; alu_out feeds the register file's data multiplexer combinationally and then stops at the write port, which is a clocked input. It also feeds the Q register's shift multiplexer and stops at that register's D input. And it feeds the output selector, which leaves the chip. So every path from a flip-flop output back to a flip-flop input passes through exactly one combinational cone and terminates at a clocked element. No loop. The apparent cycle in the block diagram is closed by registers, which is exactly how every datapath loop is closed.有一個結構性的問題值得回答，因為那張圖看起來很嚇人：這裡有組合迴路嗎？圖上的迴路是暫存器檔 → 運算元選擇器 → ALU → 暫存器檔。在 netlist 裡跟著走：ad 與 bd 經由讀取多工器來自正反器輸出；它們以組合方式餵進運算元選擇器；r 與 s 以組合方式餵進 ALU；alu_out 以組合方式餵進暫存器檔的 data 多工器，然後停在寫入埠，那是一個時脈同步的輸入。它也餵進 Q 暫存器的移位多工器，停在那個暫存器的 D 輸入。它還餵進輸出選擇器，然後離開晶片。所以每一條從正反器輸出回到正反器輸入的路徑，都恰好穿過一團組合邏輯錐並終止於一個時脈元件。沒有迴路。方塊圖上那個看似的循環，是由暫存器閉合的，而每一條資料路徑迴路都正是這樣閉合的。一つ構造上の問いに答えておく価値がある。あの図は不穏に見えるからである。組合せループはあるのか。図のループはレジスタファイル → オペランドセレクタ → ALU → レジスタファイルである。netlist でたどってみる。ad と bd は読み出しマルチプレクサを介してフリップフロップ出力から来て、組合せ的にオペランドセレクタへ入る。r と s は組合せ的に ALU へ入る。alu_out は組合せ的にレジスタファイルの data マルチプレクサへ入り、クロック同期の入力である書き込みポートで止まる。また Q レジスタのシフト用マルチプレクサへも入り、そのレジスタの D 入力で止まる。さらに出力セレクタへ入ってチップの外へ出る。つまりフリップフロップ出力からフリップフロップ入力へ戻るどの経路も、ちょうど一つの組合せコーンを通ってクロック素子で終わる。ループは無い。ブロック図上の見かけの循環はレジスタによって閉じられており、あらゆるデータパスのループはまさにそのように閉じられる。

  assign f_0 = (alu_out == 4'b0) ? 1'bz : 1'b0;   // open-drain, wired-AND across slices

integer i;                              // an integer is 32 bits; always safe
...
if (rst) for (i = 0; i < 16; i = i + 1) ab_data[i] <= 0;

7. Putting It Together: Multiply, Cascade, Verify, Synthesise7. 整合起來：乘法、串接、驗證、合成7. 組み合わせる：乗算・縦続接続・検証・合成

7.1 A worked 4 × 4 multiply7.1 實際做一次 4 × 4 乘法7.1 4 × 4 乗算を実際にたどる

Everything in the 2901 exists for a reason, and the reason for the double-length shift — the ramqd destination that shifts the register file and the Q register together — is multiplication. There is no multiplier in the datapath; there is a shift-and-add loop in the microcode, and following one all the way through is the best possible test of whether you have understood the machine.2901 裡的每樣東西都有存在的理由，而雙倍長度移位 —— 也就是讓暫存器檔與 Q 暫存器一起移位的 ramqd 目的地 —— 的理由就是乘法。這條資料路徑裡沒有乘法器；乘法是微碼裡的一個移位相加迴圈，而把它從頭到尾走一遍，是檢驗你是否真的懂這台機器的最好測試。2901 のすべての要素には存在理由があり、倍長シフト——レジスタファイルと Q レジスタを一緒にシフトする ramqd デスティネーション——の理由は乗算である。このデータパスに乗算器は無い。あるのはマイクロコード内のシフト加算ループであり、それを最後までたどることが、この機械を本当に理解したかを測る最良の試験になる。

The algorithm is the one you do by hand, read from the bottom. To compute $M \times Q$, keep a double-length accumulator in two halves: the high half in a register-file word, the low half in the Q register. Repeat once per bit of the multiplier: if the bit of $Q$ that is about to fall off the bottom is 1, add the multiplicand to the high half; then shift the whole double-length pair right by one. After four iterations the product occupies the pair, high half first, and the multiplier has been consumed bit by bit.這個演算法就是你用手算的那一個，由下往上讀。要算 $M \times Q$，就用兩個半邊保存一個雙倍長度的累加器：高半邊放在暫存器檔的一個字裡，低半邊放在 Q 暫存器裡。乘數的每一個位元重複一次：如果 $Q$ 底部即將掉出去的那個位元是 1，就把被乘數加到高半邊；然後把整個雙倍長度的一對右移一位。四次迭代之後，乘積就佔據這一對、高半邊在前，而乘數則被一位一位地消耗掉了。アルゴリズムは手計算でやるのと同じもので、下から読む。$M \times Q$ を計算するには、倍長のアキュムレータを二つの半分に分けて持つ。上半分はレジスタファイルのワード、下半分は Q レジスタである。乗数のビットごとに次を繰り返す。$Q$ の下端からこぼれようとしているビットが 1 なら被乗数を上半分に加える。そのうえで倍長の対を丸ごと 1 ビット右シフトする。4 回の反復のあと、積はこの対に上半分を先頭として収まり、乗数は 1 ビットずつ消費され尽くしている。

Two things in that trace are worth dwelling on. First, the multiplier bits are consumed from the bottom of Q and the product bits arrive from the top of Q, filling the space the multiplier vacates — the two halves share one register and never collide, which is the elegance of the algorithm. Second, the choice between "add" and "pass through" is made by the microcode branching on $q_0$, which the slice exposes as a pin precisely so that the sequencer can test it. The datapath is dumb; the loop lives in the ROM.那段追蹤裡有兩件事值得多停留一下。第一，乘數的位元從 Q 的底部被消耗掉，而乘積的位元從 Q 的頂部進來，填滿乘數空出來的位置 —— 兩個半邊共用一個暫存器卻從不相撞，這正是這個演算法優雅的地方。第二，「加」與「直接穿過」之間的選擇，是由微碼依 $q_0$ 分支做出的，而 slice 把 $q_0$ 拉成腳位，正是為了讓定序器可以測試它。資料路徑是笨的；迴圈住在 ROM 裡。このトレースには、立ち止まる価値のある点が二つある。第一に、乗数のビットは Q の下端から消費され、積のビットは Q の上端から入ってきて、乗数が空けた場所を埋めていく。二つの半分が一つのレジスタを共有しながら決して衝突しない。そこがこのアルゴリズムの優美さである。第二に、「加える」か「そのまま通す」かの選択は、マイクロコードが $q_0$ を見て分岐して決めている。スライスが $q_0$ をピンとして出しているのは、まさにシーケンサがそれを判定できるようにするためである。データパスは愚かで、ループは ROM の中に住んでいる。

And one caveat: the trace above assumes the Q register shifts its own contents, as the datasheet specifies. With the slide's Q register, which shifts alu_out instead, every step would load a shifted copy of the accumulator into Q, the multiplier would be destroyed on the first step, and the algorithm would produce nothing. That is the practical consequence of the discrepancy flagged in §6.6, and it is the strongest evidence that the discrepancy is a transcription error rather than a design choice.還有一個但書：上面那段追蹤假設 Q 暫存器移位的是它自己的內容，也就是資料手冊所規定的行為。若換成投影片那個改為移位 alu_out 的 Q 暫存器，每一步都會把累加器的移位副本載入 Q，乘數在第一步就被毀掉，演算法什麼也算不出來。這就是 §6.6 標出的那個不一致在實務上的後果，也是那個不一致是謄寫錯誤而非設計選擇的最強證據。もう一つ但し書きがある。上のトレースは、データシートの規定どおり Q レジスタが自分自身の内容をシフトすることを前提にしている。alu_out をシフトするスライドの Q レジスタでは、各手順でアキュムレータのシフト版が Q にロードされ、乗数は最初の手順で破壊され、アルゴリズムは何も生まない。これが §6.6 で指摘した食い違いの実務上の帰結であり、その食い違いが設計上の選択ではなく転記ミスであることの最も強い証拠でもある。

7.2 Cascading slices7.2 串接多片 slice7.2 スライスの縦続接続

To build a 16-bit machine, instantiate four slices and wire the cut signals. The rules follow directly from what each pin does.要建一台 16 位元的機器，就實例化四片 slice 並把切面訊號接起來。規則直接從每支腳位的作用推出來。16 ビットの機械を作るには、スライスを 4 枚インスタンス化して切断面の信号を配線する。規則は各ピンの役割からそのまま導かれる。

The arithmetic of the carry is the interesting part. A ripple chain across four slices costs four slice-delays of carry propagation in series, which for a 16-bit machine is the dominant term in the cycle time. The look-ahead alternative computes all four carries in parallel from the g_bar/p_bar pairs in two gate delays, at the cost of one extra chip and eight extra pins per slice. That trade — spend pins and a part to buy a shorter critical path — is the whole reason g_bar and p_bar exist, and it is a decision you will make again every time you size an adder.進位的算術是有意思的部分。四片 slice 的漣波鏈，進位傳播要串四個 slice 延遲，對一台 16 位元機器而言那是週期時間裡的主導項。預看的替代方案從各片的 g_bar/p_bar 對以兩級閘延遲平行算出全部四個進位，代價是多一顆晶片、每片多八支腳位。那個取捨 —— 花腳位與一顆零件去買一條更短的關鍵路徑 —— 正是 g_bar 與 p_bar 存在的全部理由，而每次你決定加法器規模時，都會再做一次這個決定。面白いのはキャリーの算術である。4 枚にまたがるリップル連鎖は、キャリー伝搬がスライス遅延 4 段分直列になり、16 ビットの機械ではそれがサイクルタイムの支配項になる。先見方式は各スライスの g_bar/p_bar の対から 4 本のキャリーを 2 段のゲート遅延で並列に求める。代償はチップ 1 個とスライスあたり 8 本の追加ピンである。このトレードオフ——ピンと部品を払ってクリティカルパスの短さを買う——こそ g_bar と p_bar が存在する理由のすべてであり、加算器の規模を決めるたびに同じ判断を繰り返すことになる。

7.3 A testbench for the slice7.3 單片 slice 的測試平台7.3 スライスのテストベンチ

Because the 2901 is a controlled datapath, its testbench is a microprogram: an array of control words played into the instruction port one per cycle, with the expected state checked at the end of each.因為 2901 是一條受控資料路徑，它的測試平台本身就是一段微程式：一個控制字的陣列，每週期送一個進指令埠，並在每個週期結束時檢查預期的狀態。2901 は制御されたデータパスなので、そのテストベンチ自体がマイクロプログラムである。制御語の配列を 1 サイクルに 1 語ずつ命令ポートへ流し込み、各サイクルの終わりに期待される状態を照合する。

module amd2901_tb;
  reg        clk, rst, c_in, enable;
  reg  [3:0] a, b, d;
  reg  [8:0] instruction;
  wire [3:0] y;
  wire       g_bar, p_bar, ovr, c_out, f_0, f_3;
  wire       ram0, ram3, qs0, qs3;

  // pull-ups model the open-drain flag and the floating shift pins
  pullup (f_0); pullup (ram0); pullup (ram3); pullup (qs0); pullup (qs3);

  amd2901 DUT (clk, rst, enable, c_in, a, b, d, instruction,
               ram0, ram3, qs0, qs3, y, g_bar, p_bar, ovr, c_out, f_0, f_3);

  initial begin clk = 0; forever #5 clk = ~clk; end

  // one microinstruction per call
  task micro (input [2:0] dest, input [2:0] func, input [2:0] src,
              input [3:0] aa, bb, dd, input cc);
    begin
      @(negedge clk);
      instruction = {dest, func, src};
      a = aa; b = bb; d = dd; c_in = cc;
      @(posedge clk);          // the edge that stores the result
      #1;                      // settle before sampling
      $display("%0t  i=%o%o%o a=%0d b=%0d d=%0d | y=%h c_out=%b ovr=%b f_0=%b",
               $time, dest, func, src, aa, bb, dd, y, c_out, ovr, f_0);
    end
  endtask

  initial begin
    rst = 1; enable = 0; instruction = 9'o111; a = 0; b = 0; d = 0; c_in = 0;
    @(negedge clk); rst = 0;

    // load 5 into register 1:  dest=ramf, func=add, src=dz, d=5, b=1
    micro(3'o3, 3'o0, 3'o7, 4'd0, 4'd1, 4'd5, 1'b0);
    // load 0 into register 0
    micro(3'o3, 3'o0, 3'o7, 4'd0, 4'd0, 4'd0, 1'b0);
    // load 3 into Q:            dest=qreg, func=add, src=dz, d=3
    micro(3'o0, 3'o0, 3'o7, 4'd0, 4'd0, 4'd3, 1'b0);
    // four multiply steps, choosing the source field from q[0]
    //   q[0]==1 -> src=ab (add),  q[0]==0 -> src=zb (pass)
    // (a real sequencer reads q0; here the testbench knows the answer)
    micro(3'o4, 3'o0, 3'o1, 4'd1, 4'd0, 4'd0, 1'b0);
    micro(3'o4, 3'o0, 3'o1, 4'd1, 4'd0, 4'd0, 1'b0);
    micro(3'o4, 3'o0, 3'o3, 4'd1, 4'd0, 4'd0, 1'b0);
    micro(3'o4, 3'o0, 3'o3, 4'd1, 4'd0, 4'd0, 1'b0);
    // read back register 0 (the high half) with dest=rama
    micro(3'o2, 3'o0, 3'o4, 4'd0, 4'd0, 4'd0, 1'b0);
    $finish;
  end
endmodule

Technique notes. The micro task drives on the falling edge and samples after the rising edge, which is the same discipline as the FIFO bench and for the same reason. The pullup primitives are essential: without them every three-state net in the design floats at z, every comparison against it yields x, and the whole simulation turns red. Modelling the external pull-ups in the testbench is how you verify an open-drain flag, and doing so would have exposed the polarity error of §6.8 immediately — with four slices and the slide's code, the wired-AND line reads low whenever any nibble is zero, which a two-slice test with values 0 and 5 reveals in one cycle.技巧上的幾點。micro task 在下降緣驅動、在上升緣之後取樣，這跟 FIFO 測試平台是同樣的紀律、同樣的理由。那些 pullup 基本元件是必要的：沒有它們，設計裡每一條三態 net 都浮在 z，每一次對它的比較都得到 x，整個模擬一片紅。在測試平台裡把外部上拉模型出來，正是驗證開汲極旗標的方法，而這麼做本來可以立刻揭露 §6.8 的極性錯誤 —— 用四片 slice 加上投影片的程式碼，只要任何一個 nibble 是零，那條 wired-AND 線就讀到低，而一個用 0 與 5 兩個值的雙 slice 測試，一個週期就看得出來。技法上の注意点。micro タスクは立ち下がりで駆動し立ち上がりの後にサンプルする。FIFO のベンチと同じ規律で、理由も同じである。pullup プリミティブは必須である。これが無ければ設計中のトライステートのネットはすべて z に浮き、それとの比較はすべて x になり、シミュレーション全体が真っ赤になる。外部プルアップをテストベンチでモデル化することが、オープンドレインのフラグを検証する方法であり、そうしていれば §6.8 の極性の誤りはただちに露呈したはずである。4 枚のスライスとスライドのコードでは、どれか一つのニブルがゼロであればワイヤード AND の線が Low を示す。値 0 と 5 を使う 2 スライスの試験なら 1 サイクルで分かる。

A serious verification plan for this slice would add: a reference model of the ALU written as a function and compared on all $8 \times 16 \times 16 \times 2 = 4096$ combinations of function, r, s and c_in — small enough to be exhaustive, which is a luxury you rarely get and should always take; a directed test for every destination code checking the register file, Q and the four serial pins; and a multi-slice instance to check the shift chains and the carry.這片 slice 認真的驗證計畫還會加上：一個寫成 function 的 ALU 參考模型，對功能、r、s 與 c_in 的全部 $8 \times 16 \times 16 \times 2 = 4096$ 種組合逐一比對 —— 小到可以窮舉，這是你很少有、而且一有就該拿的奢侈；對每一個目的地碼做指向性測試，檢查暫存器檔、Q 與四支串列腳位；以及一個多片 slice 的實例，用來檢查移位鏈與進位。このスライスの本格的な検証計画には、さらに次を加えたい。function として書いた ALU の参照モデルを用意し、機能・r・s・c_in の全 $8 \times 16 \times 16 \times 2 = 4096$ 通りで照合する——網羅できるほど小さく、これは滅多に得られない贅沢であり、得られるなら必ず取るべきである。各デスティネーションコードに対する指定テストでレジスタファイル・Q・4 本のシリアルピンを確認する。そして複数スライスのインスタンスでシフト連鎖とキャリーを確認する。

7.4 Critical path and the netlist7.4 關鍵路徑與 netlist7.4 クリティカルパスと netlist

The cycle time of a 2901-based machine is the delay of one trip around the loop. Walk it with the netlist in front of you:一台 2901 機器的週期時間，就是繞那個迴路跑一圈的延遲。對著 netlist 走一遍：2901 ベースの機械のサイクルタイムは、ループを 1 周する遅延そのものである。netlist を見ながらたどってみる。

1. Clock edge to ab_data flip-flop output: one clock-to-Q.時脈邊緣到 ab_data 正反器輸出：一個 clock-to-Q。クロックエッジから ab_data のフリップフロップ出力まで：clock-to-Q 1 回分。
2. Through the 16-to-1 read multiplexer to ad or bd: typically four levels of 2-to-1 muxes, or two levels if the library has 4-to-1 cells.穿過 16 對 1 的讀取多工器到 ad 或 bd：典型是四層 2 對 1 多工器，若元件庫有 4 對 1 元件則是兩層。16 対 1 の読み出しマルチプレクサを通って ad または bd まで：通常は 2 対 1 マルチプレクサ 4 段、ライブラリに 4 対 1 セルがあれば 2 段。
3. Through the operand selector's 4-to-1 mux to r/s: two levels.穿過運算元選擇器的 4 對 1 多工器到 r/s：兩層。オペランドセレクタの 4 対 1 マルチプレクサを通って r/s まで：2 段。
4. Through the ALU: the function multiplexer plus a four-bit carry chain, three to five levels.穿過 ALU：功能多工器加上一條四位元進位鏈，三到五層。ALU を通る：機能マルチプレクサと 4 ビットのキャリー連鎖で 3〜5 段。
5. Through the register-file write-data multiplexer (the shifter): one level.穿過暫存器檔的寫入資料多工器（也就是移位器）：一層。レジスタファイルの書き込みデータ用マルチプレクサ（すなわちシフタ）を通る：1 段。
6. Setup at the ab_data flip-flop input.在 ab_data 正反器輸入處的 setup。ab_data のフリップフロップ入力でのセットアップ。

Roughly twelve to fourteen levels of logic, which in a modern standard-cell process is a few hundred picoseconds and in 1975 bipolar LSI was about 100 nanoseconds — the Am2901's quoted cycle time was indeed in that range. The two longest contributors are the register-file read multiplexer and the ALU carry chain, which is exactly why the look-ahead pins exist and why larger register files are pipelined with a registered read port.大約十二到十四層邏輯，在現代標準元件製程裡是幾百皮秒，而在 1975 年的雙極 LSI 裡大約是 100 奈秒 —— Am2901 標稱的週期時間確實就在那個範圍。兩個最長的貢獻者是暫存器檔的讀取多工器與 ALU 的進位鏈，這正是預看腳位存在的原因，也是更大的暫存器檔要用暫存式讀取埠來管線化的原因。およそ 12〜14 段の論理であり、現代の標準セルプロセスなら数百ピコ秒、1975 年のバイポーラ LSI なら 100 ナノ秒ほどになる。実際 Am2901 の公称サイクルタイムはその範囲にあった。最も長い二つの寄与はレジスタファイルの読み出しマルチプレクサと ALU のキャリー連鎖であり、先見用のピンが存在する理由も、より大きなレジスタファイルを読み出しポートのレジスタ化でパイプライン化する理由も、まさにそこにある。

In parallel with that path, the dest_ctl field must be decoded in time to steer the shifter and to produce ram_en. That is a short path and will not limit anything, but it is a reminder that in a controlled datapath there are always two kinds of path — data and control — and the tool reports them together.與那條路徑平行地，dest_ctl 欄位必須及時解碼，才能操控移位器並產生 ram_en。那是一條短路徑，不會限制任何東西，但它提醒你：在一條受控資料路徑裡，永遠有兩種路徑 —— 資料與控制 —— 而工具會把它們一起回報。その経路と並行して、dest_ctl フィールドはシフタを操り ram_en を作れるよう間に合わなければならない。これは短い経路で何かを制限することはないが、制御されたデータパスには常にデータと制御という二種類の経路があり、ツールはそれらをまとめて報告する、ということを思い出させてくれる。

The elaborated schematic on the final slide shows all five sub-blocks preserved as separate boxes with the loop clearly visible, plus two pieces of glue at the top level: the four-input OR and the inverting three-state cell for f_0. If your own synthesis run flattens the hierarchy and gives you an undifferentiated mat of gates, you have lost the ability to read the result; set the tool to preserve the hierarchy for a first look and flatten only when you are optimising.最後一張投影片上 elaborate 後的電路圖，把五個子區塊都保留成各自的方框，迴路清楚可見，再加上頂層的兩塊膠合邏輯：給 f_0 用的四輸入 OR 與反相三態元件。如果你自己跑合成時工具把階層攤平、給你一團難以分辨的閘海，你就失去了讀懂結果的能力；第一次看的時候請設定工具保留階層，等到要最佳化時再攤平。最後のスライドの elaborate 後の回路図は、5 つのサブブロックを別々の箱として保ち、ループがはっきり見える形になっている。これにトップレベルの糊付け論理が二つ加わる。f_0 用の 4 入力 OR と反転トライステートセルである。自分で合成を回したときにツールが階層を平坦化して区別のつかないゲートの海を返してきたら、結果を読む力を失ったということである。最初に眺めるときは階層を保つよう設定し、最適化の段階になってから平坦化すべきである。