開放電腦計畫 -- 計算機硬體結構

Transcription

1

2 開 放 電 腦 計 畫 -- 計 算 機 硬 體 結 構 2014 年 7 月 出 版 作 者 : 陳 鍾 誠 ( 創 作 共 用 : 姓 名 標 示 相 同 方 式 分 享 授 權 )

3 開 放 電 腦 計 畫 -- 計 算 機 硬 體 結 構 前 言 序 授 權 聲 明 開 放 電 腦 計 畫 簡 介 硬 體 : 計 算 機 結 構 軟 體 : 系 統 程 式 結 語 參 考 文 獻 電 腦 硬 體 架 構 電 腦 的 結 構 CPU0 處 理 器 CPU0 的 指 令 集 CPU0 指 令 格 式 狀 態 暫 存 器 位 元 組 順 序 中 斷 程 序 CPU0 的 組 合 語 言 與 機 器 碼 參 考 文 獻 硬 體 描 述 語 言 -- Verilog Verilog 基 礎 區 塊 式 設 計 流 程 式 設 計 結 語 參 考 文 獻 組 合 邏 輯 (Combinatorial Logic) 簡 介 加 法 器 32 位 元 加 法 器 前 瞻 進 位 加 法 器 (Carry Lookahead Adder) 結 語 參 考 文 獻 算 術 邏 輯 單 元 ALU 的 設 計 加 減 器 採 用 CASE 語 法 設 計 ALU 模 組 完 整 的 ALU 設 計 ( 含 測 試 程 式 ) 結 語 參 考 文 獻 記 憶 單 元 (Memory Unit) 時 序 邏 輯 (Sequential Logic)

4 正 反 器 ( 閂 鎖 器 ) SR 正 反 器 有 enable 的 正 反 器 閘 級 延 遲 (Gate Delay) 利 用 閘 級 延 遲 製 作 脈 波 變 化 偵 測 器 (Pulse Transition Detector, PTD) 使 用 脈 衝 偵 測 電 路 製 作 邊 緣 觸 發 正 反 器 使 用 脈 衝 偵 測 電 路 設 計 邊 緣 觸 發 暫 存 器 使 用 脈 衝 偵 測 電 路 製 作 計 數 電 路 暫 存 器 單 元 記 憶 體 結 語 控 制 單 元 簡 介 流 程 式 設 計 區 塊 式 設 計 微 處 理 器 (Micro Processor) MCU0 的 迷 你 版 -- mcu0m MCU0 的 區 塊 式 設 計 -- MCU0bm.v MCU0 完 整 版 輸 出 入 單 元 (I/O) 前 言 BUS ( 總 線, 匯 流 排 ) 同 步 匯 流 排 (Synchronous BUS) 異 步 匯 流 排 (Asynchronous BUS) 匯 流 排 仲 裁 (BUS arbitery) 循 序 與 平 行 輸 出 入 (Serial vs. Parallel) 常 見 的 輸 出 入 協 定 MCU0 的 輸 出 入 -- 輪 詢 篇 記 憶 系 統 (Storage) 記 憶 體 階 層 (Memory Hierarchy) 快 取 記 憶 體 (Cache) 高 階 處 理 器 (Processor) 哈 佛 架 構 (Harvard Architecture) 流 水 線 架 構 (Pipeline) CPU0 迷 你 版 - CPU0m CPU0 完 整 版 -- cpu0s 速 度 議 題 乘 法 與 除 法 浮 點 數 運 算 繪 圖 加 速 功 能 (Graphics) 平 行 處 理 (Parallel) 結 語

5 附 錄 本 書 內 容 與 相 關 資 源

6 前 言 序 本 書 是 開 放 電 腦 計 畫 的 硬 體 部 份, 描 述 如 何 設 計 電 腦 硬 體 的 方 法, 透 過 這 本 書, 我 們 希 望 讓 計 算 機 結 構 這 門 課 程, 變 成 是 可 以 動 手 實 作 的 我 們 相 信, 透 過 實 作 的 訓 練, 您 將 對 理 論 會 有 更 深 刻 的 體 會, 而 這 些 體 會, 將 會 進 一 步 讓 您 更 瞭 解 現 代 電 腦 工 業 的 結 構 是 如 何 建 構 出 來 的 授 權 聲 明 本 書 許 多 資 料 修 改 自 維 基 百 科, 採 用 創 作 共 用 : 姓 名 標 示 相 同 方 式 分 享 授 權, 若 您 想 要 修 改 本 書 產 生 衍 生 著 作 時, 至 少 應 該 遵 守 下 列 授 權 條 件 : 1. 標 示 原 作 者 姓 名 ( 包 含 該 文 章 作 者, 若 有 來 自 維 基 百 科 的 部 份 也 請 一 併 標 示 ) 2. 採 用 創 作 共 用 : 姓 名 標 示 相 同 方 式 分 享 的 方 式 公 開 衍 生 著 作 另 外 當 本 書 中 有 文 章 或 素 材 並 非 採 用 姓 名 標 示 相 同 方 式 分 享 時, 將 會 在 該 文 章 或 素 材 後 面 標 示 其 授 權, 此 時 該 文 章 將 以 該 標 示 的 方 式 授 權 釋 出, 請 修 改 者 注 意 這 些 授 權 標 示, 以 避 免 產 生 侵 權 糾 紛 例 如 有 些 文 章 可 能 不 希 望 被 作 為 商 業 性 使 用, 此 時 就 可 能 會 採 用 創 作 共 用 : 姓 名 標 示 非 商 業 性 相 同 方 式 分 享 的 授 權, 此 時 您 就 不 應 當 將 該 文 章 用 於 商 業 用 途 上 最 後 若 讀 者 有 需 要 轉 貼 或 修 改 這 些 文 章 使 用, 請 遵 守 創 作 共 用 的 精 神, 讓 大 家 都 可 以 在 開 放 原 始 碼 的 基 礎 上 逐 步 改 進 這 些 作 品

7 開 放 電 腦 計 畫 簡 介 如 果 您 是 資 工 系 畢 業 的 學 生, 必 然 會 上 過 計 算 機 結 構 編 譯 器 作 業 系 統 系 統 程 式 等 等 課 程, 這 些 課 程 都 是 設 計 出 一 台 電 腦 所 必 需 的 基 本 課 程 但 是 如 果 有 人 問 您 您 是 否 會 設 計 電 腦 呢?, 相 信 大 部 分 人 的 回 答 應 該 是 : 我 不 會, 也 沒 有 設 計 過 光 是 設 計 一 個 作 業 系 統, 就 得 花 上 十 年 的 工 夫, 遑 論 還 要 自 己 設 計 CPU 匯 流 排 組 譯 器 編 譯 器 作 業 系 統 等 等 因 此, 我 們 都 曾 經 有 過 這 樣 的 夢 想, 然 後 在 年 紀 越 大, 越 來 越 瞭 解 整 個 工 業 結 構 之 後, 我 們 就 放 棄 了 這 樣 一 個 夢 想, 因 為 我 們 必 須 與 現 實 妥 協 但 是, 身 為 一 個 大 學 教 師, 我 有 責 任 教 導 學 生, 告 訴 他 們 電 腦 是 怎 麼 做 出 來 的, 因 此 我 不 自 量 力 的 提 出 了 這 樣 一 個 計 畫, 那 就 是 開 放 電 腦 計 畫, 我 們 將 以 千 里 之 行 始 於 足 下 的 精 神, 設 計 出 一 台 全 世 界 最 簡 單 且 清 楚 的 電 腦, 包 含 軟 體 與 硬 體 從 2007 年 我 開 始 寫 系 統 程 式 這 本 書 以 來, 就 有 一 個 想 法 逐 漸 在 內 心 發 酵, 這 個 想 法 就 是 : 我 想 從 CPU 設 計 組 譯 器 虛 擬 機 編 譯 器 到 作 業 系 統, 自 己 打 造 一 台 電 腦, 於 是 開 放 電 腦 計 畫 就 誕 生 了! 那 麼 開 放 電 腦 計 畫 的 產 品 會 是 什 麼 呢? 應 該 有 些 人 會 認 為 是 一 套 自 行 編 寫 的 軟 硬 體 程 式, 當 然 這 部 份 是 包 含 在 開 放 電 腦 計 畫 當 中 的 但 是 更 重 要 的 事 情 是, 我 們 希 望 透 過 開 放 電 腦 計 畫 讓 學 生 能 夠 學 會 整 個 電 腦 的 軟 硬 體 設 計 方 式, 並 且 透 過 這 個 踏 腳 石 瞭 解 整 個 電 腦 軟 硬 體 工 業, 進 而 能 夠 達 到 以 理 論 指 導 實 務 以 實 務 驗 證 理 論 的 目 標 為 了 達 成 這 個 目 標, 我 們 將 開 放 電 腦 計 畫 分 成 三 個 階 段, 也 就 是 簡 單 設 計 ( 程 式 ) => 理 論 闡 述 ( 書 籍 ) => 開 源 實 作 ( 工 業 軟 硬 體 與 流 程 ), 整 體 的 構 想 說 明 如 下 : 1. 簡 單 設 計 ( 程 式 ): 採 用 Verilog + C 設 計 CPU 組 譯 器 編 譯 器 作 業 系 統 等 軟 硬 體, 遵 循 KISS (Keep It Simple and Stupid) 原 則, 不 考 慮 效 能 與 商 業 競 爭 力 等 問 題, 甚 至 在 實 用 性 上 進 行 了 不 少 妥 協, 一 律 採 用 容 易 理 解 為 最 高 指 導 原 則, 目 的 是 清 楚 的 展 現 整 個 軟 硬 體 系 統 的 架 構 2. 理 論 闡 述 ( 書 籍 ): 但 是 要 瞭 解 像 處 理 器 系 統 軟 體 編 譯 器 作 業 系 統 這 些 領 域, 只 有 程 式 是 不 夠 的 因 為 程 式 通 常 不 容 易 懂, 而 且 對 於 沒 有 背 景 知 識 的 人 而 言, 往 往 難 如 天 書 所 以 我 們 將 撰 寫 一 系 列 書 籍, 用 來 說 明 上 述 簡 單 程 式 的 設 計 原 理, 然 後 開 始 進 入 計 算 機 結 構 編 譯 器 作 業 系 統 系 統 程 式 的 理 論 體 系 中, 導 引 出 進 一 步 的 設 計 可 能 性 與 工 業 考 量 等 議 題 3. 開 源 實 作 ( 工 業 ): 一 但 有 了 前 述 的 理 論 與 實 作 基 礎 之 後, 我 們 就 會 採 用 開 放 原 始 碼 來 進 行 案 例 研 究 舉 例 而 言 在 計 算 機 結 構 上 我 們 會 以 ARM 為 實 務 核 心 編 譯 器 領 域 則 以 gcc, LLVM 為 研 究 標 的, 作 業 系 統 上 則 會 對 FreeRTOS Linux 等 進 行 案 例 研 究, 虛 擬 機 上 則 會 以 QEMU V8 等 開 源 案 例 為 研 究 對 象

8 圖 開 放 電 腦 計 畫 地 圖 根 據 以 上 規 劃, 本 書 乃 為 一 系 列 書 籍 中 的 一 本, 完 整 的 書 籍 架 構 如 下 : 開 放 電 腦 計 畫 書 籍 簡 易 程 式 工 業 實 作 系 統 程 式 as0, vm0, cc0, os0 gcc/llvm 計 算 機 結 構 mcu0, cpu0 ARM/OpenRISC 編 譯 器 c 0c, j0c g cc/llvm 作 業 系 統 os0, XINU, MINIX FreeRTOS, Linux 這 些 書 籍 分 別 描 述 不 同 的 面 向, 其 涵 蓋 範 圍 如 下 圖 所 示 :

9 圖 開 放 電 腦 計 畫 書 籍 圖 硬 體 : 計 算 機 結 構 在 硬 體 方 面, 我 們 將 自 行 設 計 兩 款 處 理 器, 一 款 是 用 來 展 示 簡 單 微 處 理 器 設 計 原 理 的 16 位 元 微 控 制 器 MCU0, 而 另 一 款 則 是 用 來 展 示 高 階 處 理 器 設 計 原 理 的 32 位 元 處 理 器 CPU0 透 過 MCU0, 我 們 希 望 展 示 一 顆 最 簡 易 微 處 理 器 的 設 計 方 法, 我 們 將 採 用 流 程 式 與 區 塊 式 的 方 法 分 別 實 作 一 遍, 讓 讀 者 可 以 分 別 從 硬 體 人 與 軟 體 人 的 角 度 去 體 會 處 理 器 的 設 計 方 式 由 於 流 程 式 的 方 法 比 較 簡 單, 因 此 我 們 會 先 用 此 法 進 行 設 計, 當 讀 者 理 解 何 謂 微 處 理 器 之 後, 在 將 同 樣 的 功 能 改 用 區 塊 式 的 方 法 實 作 一 遍, 這 樣 應 該 就 能 逐 漸 由 易 至 難 由 淺 入 深 了 在 MCU0 當 中, 我 們 採 用 CPU 與 記 憶 體 合 一 的 設 計 方 式, 這 種 方 式 比 較 像 系 統 單 晶 片 (SOC) 的 設 計 方 法, 其 記 憶 體 容 量 較 小, 因 此 可 以 直 接 用 Verilog 陣 列 宣 告 放 入 FPGA 當 中 使 用, 不 需 考 慮 外 部 DRAM 存 取 速 度 較 慢 的 問 題, 也 不 用 考 慮 記 憶 階 層 的 速 度 問 題, 因 此 設 計 起 來 會 相 對 容 易 許 多 接 著, 我 們 將 再 度 設 計 一 個 32 位 元 的 處 理 器 -- CPU0 並 透 過 CPU0 來 討 論 當 CPU 速 度 比 DRAM 記 憶 體 快 上 許 多 的 時 候, 如 何 能 透 過 快 取 (cache) 與 記 憶 體 管 理 單 元 (MMU) 達 到 又 快 又 大 的 目 的, 並 且 討 論 如 何 透 過 流 水 線 架 構 (Pipeline) 達 到 加 速 的 目 的, 這 些 都 屬 於 高 階 處 理 器 所 需 要 討 論 的 問 題 軟 體 : 系 統 程 式

10 有 了 MCU0 與 CPU0 等 硬 體 之 後, 我 們 就 可 以 建 構 運 作 於 這 些 硬 體 之 上 的 軟 體 了, 這 些 軟 體 包 含 組 譯 器 虛 擬 機 編 譯 器 作 業 系 統 等 等 我 們 已 經 分 別 用 C 與 JavaSript 建 構 出 簡 易 的 組 譯 器 虛 擬 機 編 譯 器 工 具 了, 讓 我 們 先 說 明 一 下 在 CPU0 上 這 些 程 式 的 使 用 方 法, 以 下 示 範 是 採 用 node.js+javascript 實 作 的 工 具 版 本, 因 此 必 須 安 裝 node.js 才 能 執 行 組 合 語 言 (Assembly Language) 接 著 讓 我 們 從 組 合 語 言 的 角 度, 來 看 看 CPU0 處 理 器 的 設 計, 以 下 是 一 個 可 以 計 算 的 程 式, 計 算 完 成 之 後 會 透 過 呼 叫 軟 體 中 斷 SWI 程 序 ( 類 似 DOS 時 代 的 INT 中 斷 ), 在 螢 幕 上 印 出 下 列 訊 息 =55 以 下 的 檔 案 sum.as0 正 是 完 成 這 樣 功 能 的 一 個 CPU0 組 合 語 言 程 式 檔 案 :sum.as0 LD R1, sum ; R1 = sum = 0 LD R2, i ; R2 = i = 1 LDI R3, 10 ; R3 = 10 FOR: CMP R2, R3 ; if (R2 > R3) JGT EXIT ; goto EXIT ADD R1, R1, R2 ; R1 = R1 + R2 (sum = sum + i) ADDI R2, R2, 1 ; R2 = R2 + 1 ( i = i + 1) JMP FOR ; goto FOR EXIT: ST R1, sum ; sum = R1 ST R2, i ; i = R2 LD R9, msgptr ; R9= pointer(msg) = &msg SWI 3 ; SWI 3 : 印 出 R9 (=&msg) 中 的 字 串 MOV R9, R1 ; R9 = R1 = sum SWI 4 ; SWI 4 : 印 出 R9 (=R1=sum) 中 的 整 數 RET ; return 返 回 上 一 層 呼 叫 函 數 i: RESW 1 ; int i sum: WORD 0 ; int sum=0 msg: BYTE " =", 0 ; char *msg = "sum=" msgptr: WORD msg ; char &msgptr = &msg 組 譯 器 (Assembler) 我 們 可 以 用 以 下 指 令 呼 叫 組 譯 器 AS0 對 上 述 檔 案 進 行 組 譯 :

11 node as0 sum.as0 sum.ob0 上 述 的 程 式 經 過 組 譯 之 後, 會 輸 出 組 譯 報 表, 如 下 所 示 sum.as0 的 組 譯 報 表 0000 LD R1,sum L F003C 0004 LD R2,i L F LDI R3,10 L A 000C FOR CMP R2,R3 A JGT EXIT J C 0014 ADD R1,R1,R2 A ADDI R2,R2,1 A 1B 1B C JMP FOR J 26 26FFFFEC 0020 EXIT ST R1,sum L F001C 0024 ST R2,i L F LD R9,msgptr L F C SWI 3 J 2A 2A MOV R9,R1 A SWI 2 J 2A 2A RET J 2C 2C C i RESW 1 D F sum WORD 0 D F msg BYTE " =",0 D F3 312B2E2E2E2B31303D00 004E msgptr WORD msg D F 最 後 組 譯 器 AS0 會 輸 出 機 器 碼 到 目 的 檔 sum.ob0 當 中, 其 內 容 如 下 所 示 sum.as0 的 機 器 碼 ( 以 16 進 位 顯 示 ) 001F003C 002F A C B FFFFEC 011F001C 012F F0022 2A A C B2E2E 2E2B3130 3D 虛 擬 機 (Virtual Machine) 如 果 我 們 用 虛 擬 機 VM0 去 執 行 上 述 的 目 的 檔 sum.ob0, 會 看 到 程 式 的 執 行 結 果, 是 在 螢 幕 上 列 印 出 =55, 以 下 是 我 們 的 操 作 過 程

12 =55 編 譯 器 (Compiler) 當 然 一 個 完 整 的 現 代 電 腦 應 該 包 含 比 組 譯 器 更 高 階 的 工 具, 不 只 支 援 組 合 語 言, 還 要 支 援 高 階 語 言 因 此 我 們 設 計 了 一 個 稱 為 J0 的 高 階 語 言, 語 法 有 點 像 JavaScript, 但 卻 是 經 過 簡 化 的 版 本 然 後 我 們 又 設 計 了 一 個 可 以 用 來 編 譯 J0 語 言 的 編 譯 器, 稱 為 J0C (J0 Compiler), 可 以 用 來 將 J0 語 言 編 譯 成 中 間 碼, 也 可 以 直 接 將 中 間 碼 轉 換 為 CPU0 的 組 合 語 言 以 下 是 一 個 J0 語 言 的 範 例, 檔 案 :sum.j0 s = sum(10); return s; function sum(n) { s = 0; i=1; while (i<=10) { s = s + i; i++; } return s; } 當 我 們 使 用 j0c 編 譯 器 將 上 述 程 式 編 譯 之 後, 會 輸 出 兩 個 檔 案, 一 個 是 sum.ir, 是 編 譯 器 中 間 格 式 (Intermediate Representation, 虛 擬 碼 pcode) 的 輸 出 檔, 其 內 容 如 下 : D:\Dropbox\Public\web\oc\code>node j0c sum arg 10 call T1 sum = s T1 return s sum function param n = s 0 = i 1 L1 <= T2 i 10

13 L2 if0 T2 L2 + T3 s i = s T3 ++ i goto L1 return s f 另 一 個 是 將 上 述 中 間 格 式 轉 換 成 轉 換 成 CPU0 組 合 語 言 之 後 的 結 果, 如 下 所 示 : sum L1 else1 POP n LDI R1 0 ST R1 s LDI R1 1 ST R1 i LD R1 i LDI R2 10 LDI R3 0 CMP R1 R2 JLE else1 LDI R3 1 ST R3 T1 LDI R1 T1 CMP R1 0 JEQ L2 LD R1 s LD R2 i ADD R3 R1 R2 ST R3 T2 LDI R1 T2 ST R1 s LD R1 i ADDI R1 R1 1 ST R1 i

14 L2 JMP L1 LD R1 s RET LDI R1 10 PUSH R1 CALL sum ST R1 T3 LDI R1 T3 ST R1 s s WORD 0 i WORD 0 T1 WORD 0 T2 WORD 0 T3 WORD 0 上 述 由 j0c 所 編 譯 產 生 的 組 合 語 言, 感 覺 相 對 冗 長, 是 因 為 這 個 編 譯 器 是 最 簡 版 本, 完 全 沒 有 做 任 何 優 化 動 作, 甚 至 連 暫 存 器 都 是 每 次 重 新 載 入 的, 所 以 效 率 並 不 會 很 好 作 業 系 統 (Operating System) 當 然 囉! 一 個 完 整 的 電 腦 還 必 須 要 有 作 業 系 統, 不 過 如 果 是 嵌 入 式 系 統 的 話, 沒 有 作 業 系 統 也 沒 關 係, 只 要 將 全 部 的 程 式 連 結 在 一 起, 就 可 以 形 成 一 台 電 腦 了, 目 前 開 放 電 腦 計 畫 的 作 業 系 統 還 在 研 究 開 發 當 中, 希 望 很 快 就 能 提 供 大 家 一 個 最 簡 單 的 作 業 系 統 版 本 目 前 我 們 已 經 寫 了 一 個 可 以 進 行 兩 個 行 程 切 換 Task Switching 範 例, 接 著 我 們 將 參 考 UNIXv6, L4 等 作 業 系 統, 以 建 構 更 完 整 的 簡 易 作 業 系 統 結 語 當 然 即 使 我 們 從 CPU 硬 體 一 路 設 計 到 組 譯 器 虛 擬 機 編 譯 器 作 業 系 統 等, 未 來 仍 然 有 更 多 領 域 等 待 我 們 去 探 索, 例 如 網 路 模 組 TCP/IP Ethernet 無 線 RF 的 硬 體 模 組 繪 圖 卡 OpenGL... 等 等, 希 望 我 們 能 夠 用 最 簡 單 的 話 語, 將 這 些 電 腦 的 原 理 說 明 清 楚, 並 用 簡 單 的 方 式 實 作 得 更 完 整 參 考 文 獻 陳 鍾 誠 的 網 站 / 免 費 電 子 書 :Verilog 電 路 設 計 系 統 程 式 陳 鍾 誠 著, 旗 標 出 版 社. JavaScript (6) Node.js 命 令 列 程 式 設 計

15 電 腦 硬 體 架 構 電 腦 的 結 構 傳 統 的 電 腦 架 構, 最 經 典 的 模 型 是 由 數 學 大 師 馮 紐 曼 (Von Neumann) 所 描 述 的, 因 此 稱 為 馮 紐 曼 架 構, 如 以 下 兩 個 圖 片 所 示 : 圖 馮 紐 曼 架 構 (1) 圖 片 來 源 : 圖 馮 紐 曼 架 構 (2) 圖 片 來 源 : 在 早 期 晶 片 線 路 成 本 還 算 高 的 時 候, 最 常 見 的 馮 紐 曼 架 構 電 腦, 是 採 用 單 匯 流 排 的 架 構, 如 下 圖 所 示 :

16 圖 單 一 匯 流 排 的 馮 紐 曼 架 構 圖 片 來 源 : 但 是 自 從 RISC 精 簡 指 令 集 電 腦 出 現, 由 於 pipeline 必 須 讓 指 令 與 資 料 可 以 同 時 被 存 取, 很 多 電 腦 改 採 以 下 指 令 與 資 料 分 開 的 哈 佛 架 構 (Harvard Architecture): 圖 指 令 與 資 料 匯 流 排 分 開 的 哈 佛 架 構 圖 片 來 源 : 必 須 注 意 的 是, 雖 然 哈 佛 架 構 當 中 的 指 令 與 資 料 是 完 全 分 開 的, 但 是 如 果 真 的 將 指 令 與 資 料 個 記 憶 體 整 個 分 開 的 話, 會 需 要 兩 套 記 憶 體 與 匯 流 排, 這 會 讓 CPU 的 接 腳 數 大 增, 也 會 讓 記 憶 體 運 用 沒 效 率, 因 此 在 實 務 上, 通 常 是 將 快 取 記 憶 體 分 成 兩 邊, 一 邊 是 指 令 快 取, 一 邊 是 資 料 快 取, 這 樣 就 只 有 內 部 匯 流 排 需 要 分 開 成 兩 套, 而 CPU 對 外 則 只 要 一 套 匯 流 排 與 記 憶 體, 這 種 架 構 可 以 看 成 哈 佛 架 構 的 一 種 變 形 CPU0 處 理 器 CPU0 是 一 個 簡 易 的 32 位 元 單 匯 流 排 處 理 器, 其 架 構 如 下 圖 所 示, 包 含 R0..R15, IR, MAR, MDR 等 暫 存 器, 其 中 IR 是 指 令 暫 存 器, R0 是 一 個 永 遠 為 常 數 0 的 唯 讀 暫 存 器,R15 是 程 式 計 數 器 (Program Counter : PC),R14 是 連 結 暫 存 器 (Link Register : LR), R13 是 堆 疊 指 標 暫 存 器 (Stack Pointer : SP), 而 R12 是 狀 態 暫 存

17 器 (Status Word : SW) 圖 CPU0 的 架 構 圖 CPU0 的 指 令 集 CPU0 包 含 載 入 儲 存 運 算 指 令 跳 躍 指 令 堆 疊 指 令 等 四 大 類 指 令, 以 下 表 格 是 CPU0 的 指 令 編 碼 表, 記 載 了 CPU0 的 指 令 集 與 每 個 指 令 的 編 碼 格 式 指 令 OP 說 明 語 法 語 意 L LD 00 載 入 word LD Ra, [Rb+Cx] Ra=[Rb+Cx] L ST 01 儲 存 word ST Ra, [Rb+Cx] Ra=[Rb+Cx] L LDB 02 載 入 byte LDB Ra, [Rb+Cx] Ra=(byte)[Rb+Cx] L STB 03 儲 存 byte STB Ra, [Rb+Cx] Ra=(byte)[Rb+Cx] A LDR 04 LD 的 暫 存 器 版 LDR Ra, [Rb+Rc] Ra=[Rb+Rc] A STR 05 ST 的 暫 存 器 版 STR Ra, [Rb+Rc] Ra=[Rb+Rc] A LBR 06 LDB 的 暫 存 器 版 LBR Ra, [Rb+Rc] Ra=(byte)[Rb+Rc] A SBR 07 STB 的 暫 存 器 版 SBR Ra, [Rb+Rc] Ra=(byte)[Rb+Rc] L LDI 08 載 入 常 數 LDI Ra, Cx Ra=Cx A CMP 10 比 較 CMP Ra, Rb SW=Ra >=< Rb A MOV 12 移 動 MOV Ra, Rb Ra=Rb

18 A ADD 13 加 法 ADD Ra, Rb, Rc Ra=Rb+Rc A SUB 14 減 法 SUB Ra, Rb, Rc Ra=Rb-Rc A MUL 15 乘 法 MUL Ra, Rb, Rc Ra=Rb*Rc A DIV 16 除 法 DIV Ra, Rb, Rc Ra=Rb/Rc A AND 18 邏 輯 AND AND Ra, Rb, Rc Ra=Rb and Rc A OR 19 邏 輯 OR OR Ra, Rb, Rc Ra=Rb or Rc A XOR 1A 邏 輯 XOR XOR Ra, Rb, Rc Ra=Rb xor Rc A ADDI 1B 常 數 加 法 ADDI Ra, Rb, Cx Ra=Rb + Cx A ROL 1C 向 左 旋 轉 ROL Ra, Rb, Cx Ra=Rb rol Cx A ROR 1D 向 右 旋 轉 ROR Ra, Rb, Cx Ra=Rb ror Cx A SHL 1E 向 左 移 位 SHL Ra, Rb, Cx Ra=Rb << Cx A SHR 1F 向 右 移 位 SHR Ra, Rb, Cx Ra=Rb >> Cx J JEQ 20 跳 躍 ( 相 等 ) JEQ Cx if SW(=) PC=PC+Cx J JNE 21 跳 躍 ( 不 相 等 ) JNE Cx if SW(!=) PC=PC+Cx J JLT 22 跳 躍 (<) JLT Cx if SW(<) PC=PC+Cx J JGT 23 跳 躍 (>) JGT Cx if SW(>) PC=PC+Cx J JLE 24 跳 躍 (<=) JLE Cx if SW(<=) PC=PC+Cx J JGE 25 跳 躍 (>=) JGE Cx if SW(>=) PC=PC+Cx J JMP 26 跳 躍 ( 無 條 件 ) JMP Cx PC=PC+Cx J SWI 2A 軟 體 中 斷 SWI Cx LR=PC; PC=Cx; INT=1 J CALL 2B 跳 到 副 程 式 CALL Cx LR=PC; PC=PC+Cx J RET 2C 返 回 RET PC=LR J IRET 2D 中 斷 返 回 IRET PC=LR; INT=0 A PUSH 30 推 入 word PUSH Ra SP-=4; [SP]=Ra; A POP 31 彈 出 word POP Ra Ra=[SP]; SP+=4; A PUSHB 32 推 入 byte PUSHB Ra SP--; [SP]=Ra; (byte)

19 A POPB 33 彈 出 byte POPB Ra Ra=[SP]; SP++; (byte) CPU0 指 令 格 式 CPU0 所 有 指 令 長 度 均 為 32 位 元, 這 些 指 令 也 可 根 據 編 碼 方 式 分 成 三 種 不 同 的 格 式, 分 別 是 A 型 J 型 與 L 型 大 部 分 的 運 算 指 令 屬 於 A (Arithmatic) 型, 而 載 入 儲 存 指 令 通 常 屬 於 L (Load & Store) 型, 跳 躍 指 令 則 通 常 屬 於 J (Jump) 型, 這 三 種 型 態 的 指 令 格 式 如 下 圖 所 示 圖 CPU0 的 指 令 格 式 狀 態 暫 存 器 R12 狀 態 暫 存 器 (Status Word : SW) 是 用 來 儲 存 CPU 的 狀 態 值, 這 些 狀 態 是 許 多 旗 標 的 組 合 例 如, 零 旗 標 (Zero, 簡 寫 為 Z) 代 表 比 較 的 結 果 為 0, 負 旗 標 (Negative, 簡 寫 為 N) 代 表 比 較 的 結 果 為 負 值, 另 外 常 見 的 旗 標 還 有 進 位 旗 標 (Carry, 簡 寫 為 C), 溢 位 旗 標 (Overflow, 簡 寫 為 V) 等 等 下 圖 顯 示 了 CPU0 的 狀 態 暫 存 器 格 式, 最 前 面 的 四 個 位 元 N Z C V 所 代 表 的, 正 是 上 述 的 幾 個 旗 標 值 圖 CPU0 中 狀 態 暫 存 器 SW 的 結 構 條 件 旗 標 的 N Z 旗 標 值 可 以 用 來 代 表 比 較 結 果 是 大 於 (>) 等 於 (=) 還 是 小 於 (<), 當 執 行 CMP Ra, Rb 動 作 後, 會 有 下 列 三 種 可 能 的 情 形 1. 若 Ra > Rb, 則 N=0, Z=0 2. 若 Ra < Rb, 則 N=1, Z=0 3. 若 Ra = Rb, 則 N=0, Z=1 如 此, 用 來 進 行 條 件 跳 躍 的 JGT JGE JLT JLE JEQ JNE 指 令, 就 可 以 根 據 SW 暫 存 器 當 中 的 N Z 等 旗 標 決 定 是 否 進 行 跳 躍 SW 中 還 包 含 中 斷 控 制 旗 標 I (Interrupt) 與 T (Trap), 用 以 控 制 中 斷 的 啟 動 與 禁 止 等 行 為, 假 如 將 I 旗 標 設 定

20 為 0, 則 CPU0 將 禁 止 所 有 種 類 的 中 斷, 也 就 是 對 任 何 中 斷 都 不 會 起 反 應 但 如 果 只 是 將 T 旗 標 設 定 為 0, 則 只 會 禁 止 軟 體 中 斷 指 令 SWI (Software Interrupt), 不 會 禁 止 由 硬 體 觸 發 的 中 斷 SW 中 還 儲 存 有 處 理 器 模 式 的 欄 位,M=0 時 為 使 用 者 模 式 (user mode) 與 M=1 時 為 特 權 模 式 (super mode) 等, 這 在 作 業 系 統 的 設 計 上 經 常 被 用 來 製 作 安 全 保 護 功 能 在 使 用 者 模 式 當 中, 任 何 設 定 狀 態 暫 存 器 R12 的 動 作 都 會 被 視 為 是 非 法 的, 這 是 為 了 進 行 保 護 功 能 的 緣 故 但 是 在 特 權 模 式 中, 允 許 進 行 任 何 動 作, 包 含 設 定 中 斷 旗 標 與 處 理 器 模 式 等 位 元, 通 常 作 業 系 統 會 使 用 特 權 模 式 (M=1), 而 一 般 程 式 只 能 處 於 使 用 者 模 式 (M=0) 位 元 組 順 序 CPU0 採 用 大 者 優 先 (Big Endian) 的 位 元 組 順 序 (Byte Ordering), 因 此 代 表 值 越 大 的 位 元 組 會 在 記 憶 體 的 前 面 ( 低 位 址 處 ), 代 表 值 小 者 會 在 高 位 址 處 由 於 CPU0 是 32 位 元 的 電 腦, 因 此, 一 個 字 組 (Word) 占 用 4 個 位 元 組 (Byte), 因 此, 像 LD R1, [100] 這 樣 的 指 令, 其 實 是 將 記 憶 體 中 的 字 組 取 出, 存 入 到 暫 存 器 R1 當 中 LDB 與 STB 等 指 令, 其 中 的 B 是 指 Byte, 因 此,LDB R1, [100] 會 將 記 憶 體 100 中 的 byte 取 出, 載 入 到 R1 當 中 但 是, 由 於 R1 的 大 小 是 32 bits, 相 當 於 4 個 byte, 此 時,LDB 與 STB 指 令 到 底 是 存 取 四 個 byte 當 中 的 哪 一 個 byte 呢? 這 個 問 題 的 答 案 是 byte 3, 也 就 是 最 後 的 一 個 byte 中 斷 程 序 CPU0 的 中 斷 為 不 可 重 入 式 中 斷, 其 中 斷 分 為 軟 體 中 斷 SWI (Trap) 與 硬 體 中 斷 HWI (Interrupt) 兩 類 硬 體 中 斷 發 生 時, 中 段 代 號 INT_ADDR 會 從 中 段 線 路 傳 入, 此 時 執 行 下 列 動 作 : 1. LR=PC; INT=1 2. PC=INT_ADDR 軟 體 中 斷 SWI Cx 發 生 時, 會 執 行 下 列 動 作 : 1. LR=PC; INT=1 2. PC=Cx; 中 斷 最 後 可 以 使 用 IRET 返 回, 返 回 前 會 設 定 允 許 中 斷 狀 態 1. PC=LR; INT=0 CPU0 的 組 合 語 言 與 機 器 碼 接 著 讓 我 們 從 組 合 語 言 的 角 度, 來 看 看 CPU0 處 理 器 的 設 計, 以 下 是 一 個 可 以 計 算 的 程 式, 計 算 完 成 之 後 會 透 過 呼 叫 軟 體 中 斷 SWI 程 序 ( 類 似 DOS 時 代 的 INT 中 斷 ), 在 螢 幕 上 印 出 下 列 訊 息 =55 以 下 的 檔 案 sum.as0 正 是 完 成 這 樣 功 能 的 一 個 CPU0 組 合 語 言 程 式

21 檔 案 :sum.as0 LD R1, sum ; R1 = sum = 0 LD R2, i ; R2 = i = 1 LDI R3, 10 ; R3 = 10 FOR: CMP R2, R3 ; if (R2 > R3) JGT EXIT ; goto EXIT ADD R1, R1, R2 ; R1 = R1 + R2 (sum = sum + i) ADDI R2, R2, 1 ; R2 = R2 + 1 ( i = i + 1) JMP FOR ; goto FOR EXIT: ST R1, sum ; sum = R1 ST R2, i ; i = R2 LD R9, msgptr ; R9= pointer(msg) = &msg SWI 3 ; SWI 3 : 印 出 R9 (=&msg) 中 的 字 串 MOV R9, R1 ; R9 = R1 = sum SWI 4 ; SWI 4 : 印 出 R9 (=R1=sum) 中 的 整 數 RET ; return 返 回 上 一 層 呼 叫 函 數 i: RESW 1 ; int i sum: WORD 0 ; int sum=0 msg: BYTE " =", 0 ; char *msg = "sum=" msgptr: WORD msg ; char &msgptr = &msg 我 們 可 以 用 以 下 指 令 呼 叫 組 譯 器 AS0 對 上 述 檔 案 進 行 組 譯 : node as0 sum.as0 sum.ob0 上 述 的 程 式 經 過 組 譯 之 後, 會 輸 出 組 譯 報 表, 如 下 所 示 sum.as0 的 組 譯 報 表 0000 LD R1,sum L F003C 0004 LD R2,i L F LDI R3,10 L A 000C FOR CMP R2,R3 A JGT EXIT J C 0014 ADD R1,R1,R2 A ADDI R2,R2,1 A 1B 1B C JMP FOR J 26 26FFFFEC 0020 EXIT ST R1,sum L F001C 0024 ST R2,i L F0014

22 0028 LD R9,msgptr L F C SWI 3 J 2A 2A MOV R9,R1 A SWI 2 J 2A 2A RET J 2C 2C C i RESW 1 D F sum WORD 0 D F msg BYTE " =",0 D F3 312B2E2E2E2B31303D00 004E msgptr WORD msg D F 最 後 組 譯 器 AS0 會 輸 出 機 器 碼 到 目 的 檔 sum.ob0 當 中, 其 內 容 如 下 所 示 sum.as0 的 機 器 碼 ( 以 16 進 位 顯 示 ) 001F003C 002F A C B FFFFEC 011F001C 012F F0022 2A A C B2E2E 2E2B3130 3D 如 果 我 們 用 虛 擬 機 VM0 去 執 行 上 述 的 目 的 檔 sum.ob0, 會 看 到 程 式 的 執 行 結 果, 是 在 螢 幕 上 列 印 出 =55, 以 下 是 我 們 的 操 作 過 程 =55 參 考 文 獻 系 統 程 式 ( 陳 鍾 誠 著, 旗 標 出 版 社 ) -- JavaScript (6) Node.js 命 令 列 程 式 設 計

23 硬 體 描 述 語 言 -- Verilog Verilog 與 VHDL 都 是 用 來 設 計 數 位 電 路 的 硬 體 描 述 語 言, 但 VHDL 在 1983 年 被 提 出 後,1987 防 部 和 IEEE 確 定 為 標 準 的 硬 體 描 述 語 言 年 被 美 國 國 Verilog 是 由 Gateway Design Automation 公 司 於 1984 年 開 始 發 展 的, Cadence Design Systems 公 司 於 1990 年 購 併 了 Gateway 公 司,Cadence 隨 後 將 Verilog 提 交 到 Open Verilog International 成 為 開 放 公 用 標 準,1995 年 Verilog 被 IEEE 認 可 成 為 IEEE 標 準, 簡 稱 為 Verilog-95 此 一 標 準 於 2001 年 更 新 後 成 為 Verilog 相 較 於 VHDL 而 言,Verilog 的 語 法 較 為 簡 潔, 因 此 經 常 被 專 業 的 數 位 電 路 設 計 者 採 用, 而 VHDL 的 使 用 族 群 則 有 較 多 的 初 學 者 當 我 們 想 學 習 數 位 電 路 設 計 時, 經 常 會 難 以 選 擇 要 用 哪 一 種 語 言, 因 為 VHDL 的 書 籍 與 教 材 似 乎 比 Verilog 多 一 些, 但 是 Verilog 的 高 階 設 計 電 路 ( 像 是 開 放 原 始 碼 CPU 等 ) 則 比 VHDL 多 很 多 筆 者 是 為 了 要 設 計 CPU 而 學 習 數 位 電 路 設 計 的, 因 此 決 定 學 習 Verilog 語 言, 而 非 VHDL 語 言 雖 然 筆 者 也 學 過 VHDL 語 言, 但 後 來 發 現 Verilog 相 當 好, 相 對 而 言 語 法 簡 潔 了 許 多, 因 此 筆 者 比 較 偏 好 Verilog 語 言 在 本 文 中, 我 們 將 介 紹 Verilog 的 基 本 語 法, 並 且 採 用 Icarus 作 為 主 要 開 發 測 試 工 具, 以 便 讓 讀 者 能 很 快 的 進 入 Verilog 硬 體 設 計 的 領 域 Verilog 基 礎 Verilog 的 基 本 型 態 在 一 般 的 程 式 語 言 當 中, 資 料 的 最 基 本 型 態 通 常 是 位 元 (bit), 但 是 在 Verilog 這 種 硬 體 描 述 語 言 當 中, 我 們 必 須 有 面 向 硬 體 的 思 考 方 式, 因 此 最 基 本 的 型 態 從 位 元 轉 換 為 線 路 (wire) 一 條 線 路 的 可 能 值, 除 了 0 與 1 之 外, 還 有 可 能 是 未 定 值 X, 以 及 高 阻 抗 Z, 如 下 表 所 示 : 值 意 義 說 明 0 低 電 位 布 林 代 數 中 的 假 值 1 高 電 位 布 林 代 數 中 的 真 值 Z 高 阻 抗 三 態 緩 衝 器 的 輸 出, 高 阻 抗 斷 線 X 未 定 值 像 是 線 路 未 初 始 化 之 前, 以 及 有 0,1 兩 者 衝 突 的 線 路 值, 或 者 是 輸 入 為 Z 的 輸 出 值 其 中 的 0 對 應 到 低 電 位 1 對 應 到 高 電 位, 這 是 比 較 容 易 理 解 的 部 分, 但 是 未 定 值 X 與 高 阻 抗 Z 各 代 表 甚 麼 意 義 呢? 對 於 一 條 沒 有 阻 抗 的 線 路 而 言, 假 如 我 們 在 某 點 對 該 線 路 輸 出 1, 另 一 點 對 該 線 路 輸 出 0, 那 麼 這 條 線 路 到 底 應 該 是 高 電 位 還 是 低 電 位 呢?

24 圖 造 成 未 定 值 X 的 情 況 對 於 這 種 衝 突 的 情 況,Verilog 採 用 X 來 代 表 該 線 路 的 值 而 高 阻 抗, 則 基 本 上 是 代 表 斷 線, 您 可 以 想 像 該 線 路 如 果 是 非 導 體, 例 如 塑 膠 木 頭 開 關 開 路 或 者 是 處 於 高 阻 抗 情 況 的 半 導 體 等, 就 會 使 用 者 種 Z 值 來 代 表 根 據 這 樣 的 四 種 線 路 狀 態, 一 個 原 本 簡 易 的 AND 閘, 在 數 位 邏 輯 中 只 要 用 2*2 的 真 值 表 就 能 表 示 了, 但 在 Verilog 當 中 則 有 4*4 種 可 能 的 情 況, 以 下 是 Verilog 中 各 種 運 算 (AND, OR, XOR, XNOR) 在 這 四 種 型 態 上 的 真 值 表 定 義 : AND 0 1 X Z (&) X X X 0 X X X Z 0 X X X OR ( ) 0 1 X Z X X X X 1 X X Z X 1 X X XOR(^) 0 1 X Z X X X X X X X X X Z 1 X X X XNOR(^~) 0 1 X Z X X X X X X X X X Z X X X X 在 Verilog 當 中, 如 果 我 們 要 宣 告 一 條 線 路, 只 要 用 下 列 語 法 就 可 以 了 : wire w1; 如 果 我 們 想 一 次 宣 告 很 多 條 線 路, 那 麼 我 們 可 以 用 很 多 個 變 數 描 述 :

25 wire w, x, y, z; 但 是 如 果 我 們 想 宣 告 一 整 個 排 線 ( 例 如 匯 流 排 ), 那 我 們 就 可 以 用 下 列 的 陣 列 語 法 : wire [31:0] bus; 如 果 想 要 一 次 宣 告 很 多 組 排 線, 那 我 們 就 可 以 用 下 列 的 陣 列 群 語 法 : wire [31:0] bus [0:3]; 當 然 除 了 線 路 之 外,Verilog 還 有 可 以 穩 定 儲 存 位 元 的 型 態, 稱 為 reg ( 暫 存 器 ),reg 可 以 用 來 儲 存 位 元, 而 非 像 線 路 一 樣 只 是 一 種 連 接 方 式 而 已, 以 下 是 一 些 reg 的 宣 告 方 式 : reg w; reg x, y, z; reg [31:0] r1; reg [31:0] R [0:15]; // 宣 告 一 位 元 的 暫 存 器 變 數 w // 宣 告 三 個 一 位 元 的 暫 存 器 變 數 x, y, z // 宣 告 32 位 元 的 暫 存 器 r1 // 宣 告 16 個 32 位 元 的 暫 存 器 群 組 R[0..15] 在 Verilog 中,wire 與 reg 是 比 較 常 用 的 基 本 型 態, 另 外 還 有 一 些 較 不 常 用 的 基 本 型 態, 像 是 tri ( 三 態 線 路 ) trireg ( 三 態 暫 存 器 ) integer ( 整 數 ) 等, 在 此 我 們 先 不 進 行 介 紹 Icarus : Verilog 的 編 譯 執 行 工 具 Icarus 是 由 Stephen Williams 所 設 計 的 Verilog 開 發 工 具, 採 用 GPL 授 權 協 議, 並 且 可 以 在 Linux, BSD, OS X, MS Windows 等 環 境 下 執 行 Icarus 支 援 Verilog 的 IEEE 1995 IEEE 2001 和 IEEE 2005 三 種 標 準 語 法, 也 支 援 部 分 的 SystemVerilog 語 法, 其 官 方 網 站 網 址 如 下 : 如 果 您 是 MS Windows 的 使 用 者, 可 以 從 以 下 網 址 中 下 載 Icarus 的 MS Windows 版 本, 其 安 裝 非 常 容 易 : 範 例 1:XOR3 的 電 路 module xor3(input a, b, c, output abc); wire ab; xor g1(ab, a, b); xor g2(abc, c, ab); module module xor3test;

26 reg a, b, c; wire abc; xor3 g(a,b,c, abc); initial begin a = 0; b = 0; c = 0; always #50 begin a = a+1; $monitor("%4dns monitor: a=%d b=%d c=%d a^b^c=%d", $stime, a, b, c, abc ); always #100 begin b = b+1; always #200 begin c = c+1; initial #2000 $finish; module Icarus 執 行 結 果 D:\ccc101\icarus\ccc>iverilog -o xor3test xor3test.v D:\ccc101\icarus\ccc>vvp xor3test 50ns monitor: a=1 b=0 c=0 a^b^c=1 100ns monitor: a=0 b=1 c=0 a^b^c=1 150ns monitor: a=1 b=1 c=0 a^b^c=0

27 200ns monitor: a=0 b=0 c=1 a^b^c=1 250ns monitor: a=1 b=0 c=1 a^b^c=0 300ns monitor: a=0 b=1 c=1 a^b^c=0 350ns monitor: a=1 b=1 c=1 a^b^c=1 400ns monitor: a=0 b=0 c=0 a^b^c=0 450ns monitor: a=1 b=0 c=0 a^b^c=1 500ns monitor: a=0 b=1 c=0 a^b^c=1 550ns monitor: a=1 b=1 c=0 a^b^c=0 600ns monitor: a=0 b=0 c=1 a^b^c=1 650ns monitor: a=1 b=0 c=1 a^b^c=0 700ns monitor: a=0 b=1 c=1 a^b^c=0 750ns monitor: a=1 b=1 c=1 a^b^c=1 800ns monitor: a=0 b=0 c=0 a^b^c=0 850ns monitor: a=1 b=0 c=0 a^b^c=1 900ns monitor: a=0 b=1 c=0 a^b^c=1 950ns monitor: a=1 b=1 c=0 a^b^c=0 1000ns monitor: a=0 b=0 c=1 a^b^c=1 1050ns monitor: a=1 b=0 c=1 a^b^c=0 1100ns monitor: a=0 b=1 c=1 a^b^c=0 1150ns monitor: a=1 b=1 c=1 a^b^c=1 1200ns monitor: a=0 b=0 c=0 a^b^c=0 1250ns monitor: a=1 b=0 c=0 a^b^c=1 1300ns monitor: a=0 b=1 c=0 a^b^c=1 1350ns monitor: a=1 b=1 c=0 a^b^c=0 1400ns monitor: a=0 b=0 c=1 a^b^c=1 1450ns monitor: a=1 b=0 c=1 a^b^c=0 1500ns monitor: a=0 b=1 c=1 a^b^c=0 1550ns monitor: a=1 b=1 c=1 a^b^c=1 1600ns monitor: a=0 b=0 c=0 a^b^c=0 1650ns monitor: a=1 b=0 c=0 a^b^c=1 1700ns monitor: a=0 b=1 c=0 a^b^c=1 1750ns monitor: a=1 b=1 c=0 a^b^c=0 1800ns monitor: a=0 b=0 c=1 a^b^c=1 1850ns monitor: a=1 b=0 c=1 a^b^c=0 1900ns monitor: a=0 b=1 c=1 a^b^c=0 1950ns monitor: a=1 b=1 c=1 a^b^c=1 2000ns monitor: a=0 b=0 c=0 a^b^c=0

28 仔 細 觀 察 上 述 輸 出 結 果, 您 會 發 現 這 個 結 果 與 真 值 表 的 內 容 完 全 一 致, 因 此 驗 證 了 該 設 計 的 正 確 性! 透 過 這 種 方 式, 您 就 可 以 用 Verilog 設 計 電 路 的 程 式, 然 後 用 Icarus 編 譯 並 驗 證 電 路 是 否 正 確 區 塊 式 設 計 閘 級 的 線 路 設 計 方 法 Verilog 既 然 是 硬 體 描 述 語 言, 那 當 然 會 有 邏 輯 閘 的 表 示 法,Verilog 提 供 的 邏 輯 閘 有 and, nand, or, nor, xor, xnor, not 等 元 件, 因 此 您 可 以 用 下 列 Verilog 程 式 描 述 一 個 全 加 器 : module fulladder (input a, b, c_in, output sum, c_out); wire s1, c1, c2; xor g1(s1, a, b); xor g2(sum, s1, c_in); and g3(c1, a,b); and g4(c2, s1, c_in) ; or g5(c_out, c2, c1) ; module 上 述 程 式 所 對 應 的 電 路 如 下 圖 所 示 : 全 加 器 電 路 圖 這 些 邏 輯 閘 並 不 受 限 於 兩 個 輸 入, 也 可 以 是 多 個 輸 入 的, 例 如 以 下 範 例 中 的 g 閘, 就 一 次 將 三 個 輸 入 a, b, c_in 進 行 xor 運 算, 產 生 輸 出 sum 的 結 果 xor g(sum, a, b, c_in);

29 範 例 2: 全 加 器 的 閘 級 設 計 傳 統 的 數 位 邏 輯 課 程 當 中, 我 們 通 常 會 用 邏 輯 閘 的 組 合 方 式, 來 設 計 出 所 要 的 電 路, 以 下 我 們 就 用 全 加 器 當 範 例, 說 明 如 何 用 閘 級 的 語 法, 在 Verilog 當 中 設 計 數 位 電 路 全 加 器 總 共 有 3 個 輸 入 (a, b, c_in), 兩 個 輸 出 值 (sum, c_out), 其 真 值 表 如 下 所 示 : a b c_in c_out sum 根 據 這 個 真 值 表, 我 們 可 以 用 卡 諾 圖 得 到 化 簡 後 的 電 路 ( 但 必 須 注 意 的 是, 卡 諾 圖 化 簡 出 來 的 電 路 只 有 AND, OR, NOT, 沒 有 XOR), 然 後 根 據 化 簡 後 的 算 式 繪 製 電 路 圖 ( 在 此 範 例 中,c_out 可 以 採 用 卡 諾 圖 化 簡 出 來, 但 sum 使 用 的 並 非 化 簡 的 結 果, 而 是 以 經 驗 得 到 的 XOR 組 合 式 ) 當 您 完 成 邏 輯 運 算 式 設 計 之 後, 就 可 以 用 TinyCAD 這 個 軟 體, 繪 製 出 全 加 器 的 電 路 如 下 圖 所 示 : 用 TinyCAD 繪 製 的 全 加 器 電 路 圖 接 著 我 們 可 以 按 照 以 上 的 線 路, 根 據 Verilog 的 語 法, 設 計 出 對 應 元 件 與 測 試 程 式 如 下 所 示 :

30 程 式 :fulladder.v // 以 下 為 全 加 器 模 組 的 定 義 module fulladder (input a, b, c_in, output sum, c_out); wire s1, c1, c2; xor g1(s1, a, b); xor g2(sum, s1, c_in); and g3(c1, a,b); and g4(c2, s1, c_in) ; or g5(c_out, c2, c1) ; module // 以 下 為 測 試 程 式 module main; reg a, b, c_in; wire sum, c_out; fulladder fa1(a, b, c_in, sum, c_out); initial begin a = 0; b = 0; c_in = 0; $monitor("%04dns monitor: a=%d b=%d c_in=%d c_out=%d sum=%d", $stime, a, b, c_in, c_out, sum); #1000 $finish; always #50 c_in = c_in+1; always #100 b = b+1; always #200 a = a+1; module 然 後 我 們 就 可 以 利 用 Icarus 進 行 編 譯 與 測 試, 看 看 fulladder.v 的 模 擬 執 行 結 果 是 否 正 確 編 譯 執 行 結 果 :

31 D:\Dropbox\Public\pmag\201306\code>iverilog -o fulladder fulladder.v D:\Dropbox\Public\pmag\201306\code>vvp fulladder 0000ns monitor: a=0 b=0 c_in=0 c_out=0 sum=0 0050ns monitor: a=0 b=0 c_in=1 c_out=0 sum=1 0100ns monitor: a=0 b=1 c_in=0 c_out=0 sum=1 0150ns monitor: a=0 b=1 c_in=1 c_out=1 sum=0 0200ns monitor: a=1 b=0 c_in=0 c_out=0 sum=1 0250ns monitor: a=1 b=0 c_in=1 c_out=1 sum=0 0300ns monitor: a=1 b=1 c_in=0 c_out=1 sum=0 0350ns monitor: a=1 b=1 c_in=1 c_out=1 sum=1 0400ns monitor: a=0 b=0 c_in=0 c_out=0 sum=0 0450ns monitor: a=0 b=0 c_in=1 c_out=0 sum=1 0500ns monitor: a=0 b=1 c_in=0 c_out=0 sum=1 0550ns monitor: a=0 b=1 c_in=1 c_out=1 sum=0 0600ns monitor: a=1 b=0 c_in=0 c_out=0 sum=1 0650ns monitor: a=1 b=0 c_in=1 c_out=1 sum=0 0700ns monitor: a=1 b=1 c_in=0 c_out=1 sum=0 0750ns monitor: a=1 b=1 c_in=1 c_out=1 sum=1 0800ns monitor: a=0 b=0 c_in=0 c_out=0 sum=0 0850ns monitor: a=0 b=0 c_in=1 c_out=0 sum=1 0900ns monitor: a=0 b=1 c_in=0 c_out=0 sum=1 0950ns monitor: a=0 b=1 c_in=1 c_out=1 sum=0 1000ns monitor: a=1 b=0 c_in=0 c_out=0 sum=1 習 題 1: 請 證 明 nand 閘 是 全 能 的 ( 提 示 : 只 要 用 nand 做 出 and, or, not 就 行 了 ) 習 題 2: 請 用 卡 諾 圖 去 化 簡 全 加 器 的 Cout 電 路 習 題 3: 請 寫 一 個 Verilog 程 式 用 nand 兜 出 or 電 路, 並 測 試 之 區 塊 式 設 計 的 注 意 事 項 當 您 採 用 區 塊 式 設 計 時, 有 一 些 常 見 的 初 學 者 錯 誤 必 須 注 意, 列 舉 如 下 : 1. assign 的 指 定 是 針 對 線 路, 而 暫 存 器 的 指 定 必 須 放 在 always 或 initial 區 塊 裏 因 此, 下 列 程 式 中 在 assign 指 定 reg 型 態 的 變 數 o1 = i1 是 錯 的, 必 須 將 reg 去 掉, 或 者 改 放 到 always 區 塊 裏

32 圖 在 assign 裏 只 能 指 定 wire 型 態 的 變 數, 不 能 指 定 reg 型 態 的 2. 相 反 的,always 區 塊 裏 的 指 定, 只 能 針 對 reg 型 態 的 變 數 進 行, 不 能 套 用 在 線 路 (wire: 含 input, output, inout) 型 態 的 變 數 上 因 此 下 列 程 式 當 中 若 沒 有 將 o1 加 上 reg 型 態, 則 會 發 生 錯 誤 圖 在 always 裏 才 能 指 定 reg 型 態 的 變 數 3. 上 述 的 參 數 output reg o1 其 實 是 一 種 將 暫 存 器 與 線 路 同 時 宣 告 的 縮 寫, 事 實 上 我 們 可 以 將 該 宣 告 拆 開 成 相 同 名 稱 的 兩 部 份 (output o1, reg o1) 或 者 甚 至 乾 脆 使 用 不 同 的 名 稱 來 宣 告 暫 存 器, 然 後 再 透 過 assign 將 線 路 與 暫 存 器 綁 在 一 起, 這 三 種 寫 法 的 意 義 其 實 都 是 相 同 的, 請 參 考 下 圖 :

33 圖 同 時 具 備 wire + reg 的 宣 告 方 式 4. assign 裏 面 除 了 指 定 敘 述 = 與 基 本 運 算 (&!^...) 之 外, 還 可 以 用 (cond)?case1:case2; 的 這 種 語 法 舉 例 而 言, 以 下 是 微 控 制 器 mcu0 裏 控 制 單 元 的 範 例, 您 可 以 看 到 類 似 層 次 性 if else 的 語 法 也 可 用 這 種 方 式 在 aluop 這 個 語 句 上 實 現 module control(input [3:0] op, input z, output mw, aw, pcmux, sww, outpu t [3:0] aluop); assign mw=(op==mcu0.st); assign aw=(op==mcu0.ld op==mcu0.add); assign sww=(op==mcu0.cmp); assign pcmux=(op==mcu0.jmp (op==mcu0.jeq && z)); assign aluop=(op==mcu0.ld)?alu0.apass: (op==mcu0.cmp)?alu0.cmp: (op==mcu0.add)?alu0.add:alu0.zero; module 流 程 式 設 計 所 謂 RTL 是 Register Transfer Language 的 縮 寫, 也 就 是 暫 存 器 轉 換 語 言, 這 種 寫 法 與 C, Java 等 高 階 語 言 非 常 相 似, 因 此 讓 程 式 人 也 有 機 會 透 過 Verilog 設 計 自 己 的 硬 體 舉 例 而 言, 在 數 位 邏 輯 當 中, 多 工 器 是 一 個 很 有 用 的 電 路, 假 如 我 們 想 設 計 一 個 二 選 一 的 多 工 器, 那 麼 我 們 可 以 很 直 覺 得 用 以 下 的 RTL 寫 法, 去 完 成 這 樣 的 電 路 設 計 module mux(f, a, b, sel);

34 output f; input a, b, sel; reg f; // reg 型 態 會 記 住 某 些 值, 直 到 被 某 個 assign 指 定 改 變 為 止 or b or sel) // 當 任 何 變 數 改 變 的 時 候, 會 執 行 內 部 區 塊 if (sel) f = a; // Always 內 部 的 區 塊 採 用 imperative 程 式 語 言 的 寫 法 else f = b; module 對 於 上 述 程 式, 您 還 可 以 進 一 步 的 將 參 數 部 分 化 簡, 將 型 態 寫 入 到 參 數 中, 成 為 以 下 的 形 式 : module mux(output reg f, input a, b, sel); or b or sel) // 當 任 何 變 數 改 變 的 時 候, 會 執 行 內 部 區 塊 if (sel) f = a; // Always 內 部 的 區 塊 採 用 imperative 程 式 語 言 的 寫 法 else f = b; module 在 verilog 當 中,if, case 等 陳 述 一 定 要 放 在 always 或 initial 的 理 代 表 在 cond 的 條 件 之 下 要 執 行 該 區 塊, 例 如 上 述 的 or b or sel) 則 是 在 a, b, 或 sel 有 改 變 的 時 後, 就 必 須 執 行 裏 面 的 動 作 有 時 我 們 只 希 望 在 波 型 的 正 邊 緣 或 負 邊 緣 時, 才 執 行 某 些 動 作, 這 時 候 就 可 以 用 posedge 或 negedge 這 兩 個 修 飾 詞, 例 如 以 下 的 程 式 : clock) begin // 當 clock 時 脈 在 正 邊 緣 時 才 執 行 f = a; 而 initial 則 通 常 是 在 測 試 程 式 test bench 當 中 使 用 的, 在 一 開 始 初 始 化 的 時 後, 可 以 透 過 initial 設 定 初 值, 例 如 以 下 的 程 式 : initial begin clock = 0 Verilog 程 式 的 許 多 地 方, 都 可 以 用 #delay 指 定 時 間 延 遲, 例 如 #50 就 是 延 遲 50 單 位 的 時 間 ( 通 常 一 單 位 時 間 是 一 奈 秒 ns) 舉 例 而 言, 假 如 我 們 想 要 每 個 50 奈 秒 讓 clock 變 化 一 次, 那 麼 我 們 就 可 以 用 下 列 寫 法 達 到 目 的 : always #50 begin clock = ~clock; // 將 clock 反 相 (0 變 1 1 變 0)

35 以 上 的 延 遲 也 可 以 寫 在 裡 面, 而 不 是 直 接 寫 在 always 後 面, 例 如 改 用 以 下 寫 法, 也 能 得 到 相 同 的 結 果 always begin #50; clock = ~clock; // 將 clock 反 相 (0 變 1 1 變 0) 範 例 3: 計 數 器 的 RTL 設 計 接 著 讓 我 們 用 一 個 整 合 的 計 數 器 範 例, 來 示 範 這 些 語 法 的 實 際 用 途, 以 下 是 我 們 的 程 式 內 容 檔 案 :counter.v // 定 義 計 數 器 模 組 counter, 包 含 重 置 reset, 時 脈 clock 與 暫 存 器 count module counter(input reset, clock, output reg [7:0] count); // 當 reset 有 任 何 改 變 時 if (reset) count = 0; // 如 果 reset 是 1, 就 將 count 重 置 為 0 clock) begin // 在 clock 時 脈 的 正 邊 緣 時 count = count + 1; // 將 count 加 1 module module main; // 測 試 主 程 式 開 始 wire [7:0] i; // i: 計 數 器 的 輸 出 值 reg reset, clock; // reset: 重 置 訊 號, clock: 時 脈 // 宣 告 一 個 counter 模 組 c0 計 數 器 的 值 透 過 線 路 i 輸 出, 以 便 觀 察 counter c0(reset, clock, i); initial begin $display("%4dns: reset=%d clock=%d i=%d", $stime, reset, clock, i); // 印 出 0ns: reset=x clock=x i= x #10 reset = 1; clock=0; // 10ns 之 後, 將 啟 動 重 置 訊 號, 並 將 clock 初 值 設 為 0 $display("%4dns: reset=%d clock=%d i=%d", $stime, reset, clock, i); // 印 出 10ns: reset=1 clock=0 i= x #10 reset = 0; // 又 經 過 10ns 之 後, 重 置 完 畢, 將 reset 歸 零 $display("%4dns: reset=%d clock=%d i=%d", $stime, reset, clock, i); //

36 印 出 20ns: reset=0 clock=0 i= 0 #500 $finish; // 再 經 過 500ns 之 後, 結 束 程 式 always #40 begin // 延 遲 40ns 之 後, 開 始 作 下 列 動 作 clock=~clock; // 將 時 脈 反 轉 (0 變 1 1 變 0) #10; // 再 延 遲 10ns 之 後 $display("%4dns: reset=%d clock=%d i=%d", $stime, reset, clock, i); // 印 出 reset, clock 與 i 等 變 數 值 module 在 上 述 程 式 中,$display() 函 數 可 以 用 來 顯 示 變 數 的 內 容, 其 作 用 就 像 C 語 言 的 printf() 一 樣 不 過 由 於 Verilog 設 計 的 是 硬 體, 因 此 像 $display() 這 樣 前 面 有 錢 字 $ 符 號 的 指 令, 其 實 是 不 會 被 合 成 為 電 路 的, 只 是 方 便 除 錯 時 使 用 而 已 以 下 是 我 們 用 icarus 軟 體 編 譯 並 執 行 上 述 程 式 的 過 程 與 輸 出 結 果 : D:\Dropbox\Public\pmag\201307\code>iverilog -o counter counter.v D:\Dropbox\Public\pmag\201307\code>vvp counter 0ns: reset=x clock=x i= x 10ns: reset=1 clock=0 i= x 20ns: reset=0 clock=0 i= 0 50ns: reset=0 clock=1 i= 1 100ns: reset=0 clock=0 i= 1 150ns: reset=0 clock=1 i= 2 200ns: reset=0 clock=0 i= 2 250ns: reset=0 clock=1 i= 3 300ns: reset=0 clock=0 i= 3 350ns: reset=0 clock=1 i= 4 400ns: reset=0 clock=0 i= 4 450ns: reset=0 clock=1 i= 5 500ns: reset=0 clock=0 i= 5 您 可 以 看 到, 在 一 開 始 的 時 候 以 下 的 initial 區 塊 會 被 執 行, 但 由 於 此 時 reset, clock, i 都 尚 未 被 賦 值, 所 以 第 一 個 $display() 印 出 了 代 表 未 定 值 的 x 符 號 initial begin

37 $display("%4dns: reset=%d clock=%d i=%d", $stime, reset, clock, i); // 印 出 0ns: reset=x clock=x i= x #10 reset = 1; clock=0; // 10ns 之 後, 將 啟 動 重 置 訊 號, 並 將 clock 初 值 設 為 0 $display("%4dns: reset=%d clock=%d i=%d", $stime, reset, clock, i); // 印 出 10ns: reset=1 clock=0 i= x #10 reset = 0; // 又 經 過 10ns 之 後, 重 置 完 畢, 將 reset 歸 零 $display("%4dns: reset=%d clock=%d i=%d", $stime, reset, clock, i); // 印 出 20ns: reset=0 clock=0 i= 0 #500 $finish; // 再 經 過 500ns 之 後, 結 束 程 式 接 著 #10 reset = 1; clock=0 指 令 在 延 遲 10ns 後, 執 行 reset=1; clock=0, 於 是 後 來 的 $display() 就 印 出 了 10ns: reset=1 clock=0 i= x 的 結 果 但 是 就 在 reset 被 設 為 1 的 時 候, 由 於 reset 的 值 有 所 改 變, 因 此 下 列 模 組 中 的 被 觸 發 了, 於 是 開 始 執 行 if (reset) count = 0 這 個 陳 述, 將 count 暫 存 器 設 定 為 0 module counter(input reset, clock, output reg [7:0] count); // 當 reset 有 任 何 改 變 時 if (reset) count = 0; // 如 果 reset 是 1, 就 將 count 重 置 為 0 clock) begin // 在 clock 時 脈 的 正 邊 緣 時 count = count + 1; // 將 count 加 1 module 然 後 #10 reset = 0 指 令 又 在 延 遲 10ns 後 執 行 了 reset = 0, 之 後 再 用 $display() 時, 由 於 count 已 經 被 設 定 為 0, 所 以 此 時 印 出 的 結 果 為 20ns: reset=0 clock=0 i= 0 initial 區 塊 的 最 後 一 個 陳 述,#500 $finish, 會 在 520ns 的 時 候 才 執 行, 執 行 時 $finish 會 將 整 個 測 試 程 式 結 束 但 在 程 式 結 束 之 前, 以 下 的 程 式 會 在 延 遲 40ns 之 後, 開 始 將 clock 反 相, 然 後 再 等 待 10ns 之 後 用 $display() 印 出 變 數 內 容, 因 此 整 個 區 塊 每 50ns (=40ns+10ns) 會 被 執 行 一 次 always #40 begin // 延 遲 40ns 之 後, 開 始 作 下 列 動 作 clock=~clock; // 將 時 脈 反 轉 (0 變 1 1 變 0) #10; // 再 延 遲 10ns 之 後 $display("%4dns: reset=%d clock=%d i=%d", $stime, reset, clock, i); // 印 出 reset, clock 與 i 等 變 數 值

38 所 以 您 才 會 看 到 像 下 面 的 輸 出 結 果, 如 果 仔 細 觀 察, 會 發 現 clock 每 50ns 變 換 一 次, 符 合 上 述 的 程 式 邏 輯, 而 且 每 當 clock 從 0 變 成 1 的 正 邊 緣, 就 會 觸 發 counter 模 組, 讓 count 變 數 加 1, 並 且 透 過 線 路 i 的 輸 出 被 我 們 觀 察 到 50ns: reset=0 clock=1 i= 1 100ns: reset=0 clock=0 i= 1 150ns: reset=0 clock=1 i= 2 200ns: reset=0 clock=0 i= 2 250ns: reset=0 clock=1 i= 3 300ns: reset=0 clock=0 i= 3 ( 註 : 或 許 您 有 注 意 到 上 期 當 中 我 們 用 $monitor() 來 觀 察 全 加 器 的 輸 出,$display() 與 $monitor() 的 語 法 幾 乎 一 模 一 樣, 但 是 $display() 是 顯 示 該 時 間 點 的 變 數 內 容, 而 $monitor() 則 會 在 受 觀 察 的 變 數 有 改 變 時 就 列 印 變 數 內 容, 兩 者 的 的 功 能 有 明 顯 的 差 異 ) 阻 塞 vs. 非 阻 塞 (Blocking vs. Nonblocking) 您 可 能 會 注 意 到 在 Verilog 當 中 有 兩 種 指 定 方 式, 一 種 用 = 表 示, 另 一 種 用 <= 表 示, 這 兩 種 指 定 方 法 看 來 很 類 似, 但 意 義 上 卻 有 很 細 緻 的 差 異, 一 般 Verilog 初 學 者 往 往 分 不 清 楚, 因 而 造 成 很 多 程 式 上 的 錯 誤 基 本 上 = 指 令 是 阻 塞 式 的 (Blocking), 因 此 程 式 會 按 照 循 序 的 方 式, 一 個 指 令 接 著 一 個 指 令 執 行, 就 像 C 語 言 裏 的 a=b, b=c 這 樣,b=c 會 在 a=b 執 行 完 之 後 才 執 行, 以 下 是 一 個 範 例 但 是 <= 指 令 卻 是 非 阻 塞 式 的 (Nonblocking), 所 以 程 式 會 採 用 平 行 的 方 式 執 行 舉 例 而 言, 像 是 a<=b, b<=c 會 同 時 執 行 兩 者, 所 以 a 會 取 得 上 一 輪 的 b 值, 而 b 則 會 取 得 上 一 輪 的 c 值 Blocking 的 語 法 (=) 通 常 用 在 組 合 電 路 上, 也 就 是 語 句 裏 面, 而 Nonblocking 的 語 法 (<=) 通 常 用 在 採 用 邊 緣 觸 發 的 循 序 電 路 上, 也 就 是 clock) 的 語 句 裏 面 且 讓 我 們 用 幾 個 範 例 來 說 明 blocking = 與 Nonblocking <= 的 差 別 範 例 1: 阻 塞 式 (Blocking =) 非 阻 塞 式 (Nonblocking <=) or b or c) begin a=0; b=a; c=b; clock or reset) begi n a<=0; b<=a; c<=b; 結 果 :a=0; b= 上 一 輪 的 a 值 ; c= 上 一 輪 的 b 值 合 成 電 路 :

39 結 果 : a=b=c=0; 合 成 電 路 : 注 意 : 通 常 blocking assignment = 會 用 在 語 句 裏 面 注 意 : 通 常 nonblocking assignment <= 會 用 在 clock or reset) 語 句 裏 面 結 語 有 些 人 說 在 設 計 Verilog 程 式 的 時 候, 必 須 先 心 中 有 電 路, 才 能 夠 設 計 的 出 來 但 是 從 我 這 樣 一 個 程 式 人 的 角 度 看 來, 並 非 如 此, 採 用 流 程 式 的 寫 法 也 可 以 設 計 得 出 Verilog 程 式, 不 需 一 定 要 有 電 路 圖 當 然 採 用 流 程 式 寫 法 的 話, 如 果 是 用 blocking 的 = 方 式, 那 麼 可 能 會 造 成 很 長 的 鏈 狀 結 構, 這 或 許 會 讓 電 路 效 能 變 差 但 是 由 於 流 程 式 寫 法 簡 單 又 清 楚, 因 此 程 式 碼 往 往 比 區 塊 式 寫 法 短, 而 且 更 容 易 懂, 這 是 流 程 式 寫 法 的 好 處 當 然 如 果 兩 種 寫 法 都 會, 那 是 最 好 的 了, 我 們 將 在 後 續 的 章 節 當 中 陸 續 用 完 整 的 案 例 示 範 如 何 用 這 兩 種 寫 法 分 別 撰 寫 開 放 電 腦 計 畫 中 的 處 理 器, 以 便 讓 讀 者 能 深 入 體 會 兩 種 寫 法 的 好 處 與 缺 點 參 考 文 獻 ( 筆 記 ) dispaly() strobe() monitor() fwrite() 與 blocking / nonblocking 的 關 係

40 組 合 邏 輯 (Combinatorial Logic) 簡 介 在 數 位 電 路 當 中, 邏 輯 電 路 通 常 被 分 為 兩 類, 一 類 是 沒 有 回 饋 線 路 (No feedback) 的 組 合 邏 輯 電 路 (Combinatorial Logic), 另 一 類 是 有 回 饋 線 路 的 循 序 邏 輯 電 路 (Sequential Logic) 組 合 邏 輯 的 線 路 只 是 將 輸 入 訊 號 轉 換 成 輸 出 訊 號, 像 是 加 法 器 多 工 器 等 都 是 組 合 邏 輯 電 路 的 範 例, 由 於 中 間 不 會 暫 存, 因 此 無 法 記 憶 位 元 而 循 序 邏 輯 由 於 有 回 饋 線 路, 所 以 可 以 製 作 出 像 Flip-Flop,Latch 等 記 憶 單 元, 可 以 記 憶 位 元 在 本 文 中, 我 們 將 先 專 注 在 組 合 邏 輯 上, 看 看 如 何 用 基 本 的 閘 級 寫 法, 寫 出 像 多 工 器 加 法 器 減 法 器 等 組 成 CPU 的 基 礎 電 路 元 件 加 法 器 接 著 讓 我 們 用 先 前 已 經 示 範 過 的 全 加 器 範 例, 一 個 一 個 連 接 成 四 位 元 的 加 法 器, 電 路 圖 如 下 所 示 圖 用 4 個 全 加 器 組 成 4 位 元 加 法 器 上 圖 寫 成 Verilog 就 變 成 以 下 adder4 模 組 的 程 式 內 容 module adder4(input signed [3:0] a, input signed [3:0] b, input c_in, ou tput signed [3:0] sum, output c_out); wire [3:0] c; fulladder fa1(a[0],b[0], c_in, sum[0], c[1]) ; fulladder fa2(a[1],b[1], c[1], sum[1], c[2]) ; fulladder fa3(a[2],b[2], c[2], sum[2], c[3]) ; fulladder fa4(a[3],b[3], c[3], sum[3], c_out) ; module 以 下 是 完 整 的 4 位 元 加 法 器 之 Verilog 程 式

41 檔 案 :adder4.v module fulladder (input a, b, c_in, output sum, c_out); wire s1, c1, c2; xor g1(s1, a, b); xor g2(sum, s1, c_in); and g3(c1, a,b); and g4(c2, s1, c_in) ; xor g5(c_out, c2, c1) ; module module adder4(input signed [3:0] a, input signed [3:0] b, input c_in, ou tput signed [3:0] sum, output c_out); wire [3:0] c; fulladder fa1(a[0],b[0], c_in, sum[0], c[1]) ; fulladder fa2(a[1],b[1], c[1], sum[1], c[2]) ; fulladder fa3(a[2],b[2], c[2], sum[2], c[3]) ; fulladder fa4(a[3],b[3], c[3], sum[3], c_out) ; module module main; reg signed [3:0] a; reg signed [3:0] b; wire signed [3:0] sum; wire c_out; adder4 DUT (a, b, 1'b0, sum, c_out); initial begin a = 4'b0101; b = 4'b0000;

42 always #50 begin b=b+1; $monitor("%dns monitor: a=%d b=%d sum=%d", $stime, a, b, sum); initial #2000 $finish; module 執 行 結 果 D:\ccc101\icarus\ccc>iverilog -o sadd4 sadd4.v D:\ccc101\icarus\ccc>vvp sadd4 50ns monitor: a= 5 b= 1 sum= 6 100ns monitor: a= 5 b= 2 sum= 7 150ns monitor: a= 5 b= 3 sum=-8 200ns monitor: a= 5 b= 4 sum=-7 250ns monitor: a= 5 b= 5 sum=-6 300ns monitor: a= 5 b= 6 sum=-5 350ns monitor: a= 5 b= 7 sum=-4 400ns monitor: a= 5 b=-8 sum=-3 450ns monitor: a= 5 b=-7 sum=-2 500ns monitor: a= 5 b=-6 sum=-1 550ns monitor: a= 5 b=-5 sum= 0 600ns monitor: a= 5 b=-4 sum= 1 650ns monitor: a= 5 b=-3 sum= 2 700ns monitor: a= 5 b=-2 sum= 3 750ns monitor: a= 5 b=-1 sum= 4 800ns monitor: a= 5 b= 0 sum= 5 850ns monitor: a= 5 b= 1 sum= 6 900ns monitor: a= 5 b= 2 sum= 7 950ns monitor: a= 5 b= 3 sum= ns monitor: a= 5 b= 4 sum= ns monitor: a= 5 b= 5 sum= ns monitor: a= 5 b= 6 sum= ns monitor: a= 5 b= 7 sum= ns monitor: a= 5 b=-8 sum=-3

43 1250ns monitor: a= 5 b=-7 sum= ns monitor: a= 5 b=-6 sum= ns monitor: a= 5 b=-5 sum= ns monitor: a= 5 b=-4 sum= ns monitor: a= 5 b=-3 sum= ns monitor: a= 5 b=-2 sum= ns monitor: a= 5 b=-1 sum= ns monitor: a= 5 b= 0 sum= ns monitor: a= 5 b= 1 sum= ns monitor: a= 5 b= 2 sum= ns monitor: a= 5 b= 3 sum= ns monitor: a= 5 b= 4 sum= ns monitor: a= 5 b= 5 sum= ns monitor: a= 5 b= 6 sum= ns monitor: a= 5 b= 7 sum= ns monitor: a= 5 b=-8 sum=-3 在 上 述 執 行 結 果 中, 您 可 以 看 到 在 沒 有 溢 位 的 情 況 下,sum = a+b, 但 是 一 但 加 總 值 超 過 7 之 後, 那 就 會 變 成 負 值, 這 也 正 是 有 號 二 補 數 表 示 法 溢 位 時 會 產 生 的 結 果 32 位 元 加 法 器 當 然 上 述 的 四 位 元 加 法 器 的 範 圍, 只 能 從 -8 到 +7, 這 個 範 圍 實 在 太 小 了, 並 不 具 備 任 何 實 用 性, 但 是 萬 事 起 頭 難, 只 要 您 能 夠 做 出 四 位 元 加 法 器, 那 麼 就 可 以 利 用 這 個 元 件 進 行 串 接, 將 8 個 四 位 元 加 法 器 串 接 起 來, 立 刻 得 到 了 一 組 32 位 元 的 加 法 器, 以 下 是 這 個 32 位 元 加 法 器 的 模 組 定 義 module adder32(input signed [31:0] a, input signed [31:0] b, input c_in, output signed [31:0] sum, output c_out); wire [7:0] c; adder4 a0(a[3:0],b[3:0], c_in, sum[3:0], c[0]) ; adder4 a1(a[7:4],b[7:4], c[0], sum[7:4], c[1]) ; adder4 a2(a[11:8],b[11:8], c[1], sum[11:8], c[2]) ; adder4 a3(a[15:12],b[15:12], c[2], sum[15:12],c[3]) ; adder4 a4(a[19:16],b[19:16], c[3], sum[19:16],c[4]) ; adder4 a5(a[23:20],b[23:20], c[4], sum[23:20],c[5]) ; adder4 a6(a[27:24],b[27:24], c[5], sum[27:24],c[6]) ; adder4 a7(a[31:28],b[31:28], c[6], sum[31:28],c_out);

44 module 有 了 這 個 模 組 之 後, 您 就 可 以 寫 出 下 列 完 整 的 程 式, 以 測 試 驗 證 該 32 位 元 加 法 器 是 否 正 確 了 module fulladder (input a, b, c_in, output sum, c_out); wire s1, c1, c2; xor g1(s1, a, b); xor g2(sum, s1, c_in); and g3(c1, a,b); and g4(c2, s1, c_in) ; xor g5(c_out, c2, c1) ; module module adder4(input signed [3:0] a, input signed [3:0] b, input c_in, ou tput signed [3:0] sum, output c_out); wire [3:0] c; fulladder fa1(a[0],b[0], c_in, sum[0], c[1]) ; fulladder fa2(a[1],b[1], c[1], sum[1], c[2]) ; fulladder fa3(a[2],b[2], c[2], sum[2], c[3]) ; fulladder fa4(a[3],b[3], c[3], sum[3], c_out) ; module module adder32(input signed [31:0] a, input signed [31:0] b, input c_in, output signed [31:0] sum, output c_out); wire [7:0] c; adder4 a0(a[3:0],b[3:0], c_in, sum[3:0], c[0]) ; adder4 a1(a[7:4],b[7:4], c[0], sum[7:4], c[1]) ; adder4 a2(a[11:8],b[11:8], c[1], sum[11:8], c[2]) ; adder4 a3(a[15:12],b[15:12], c[2], sum[15:12],c[3]) ; adder4 a4(a[19:16],b[19:16], c[3], sum[19:16],c[4]) ; adder4 a5(a[23:20],b[23:20], c[4], sum[23:20],c[5]) ; adder4 a6(a[27:24],b[27:24], c[5], sum[27:24],c[6]) ; adder4 a7(a[31:28],b[31:28], c[6], sum[31:28],c_out);

45 module module main; reg signed [31:0] a; reg signed [31:0] b; wire signed [31:0] sum; wire c_out; adder32 DUT (a, b, 0, sum, c_out); initial begin a = ; b = ; $monitor("%dns monitor: a=%d b=%d sum=%d", $stime, a, b, sum); always #50 begin b=b ; initial #500 $finish; module 然 後 我 們 就 可 以 用 icarus 進 行 測 試, 以 下 是 測 試 結 果 : D:\Dropbox\Public\web\oc\code>iverilog -o adder32 adder32.v D:\Dropbox\Public\web\oc\code>vvp adder32 0ns monitor: a= b= sum= ns monitor: a= b= sum= ns monitor: a= b= sum= ns monitor: a= b= sum= ns monitor: a= b= sum= ns monitor: a= b= sum=

46 300ns monitor: a= b= sum= ns monitor: a= b= sum= ns monitor: a= b= sum= ns monitor: a= b= sum= ns monitor: a= b= sum= 您 可 以 看 到 sum 的 確 是 a+b 的 結 果, 因 此 這 個 32 位 元 加 法 器 的 初 步 驗 證 是 正 確 的 前 瞻 進 位 加 法 器 (Carry Lookahead Adder) 圖 4 位 元 前 瞻 進 位 加 法 器 圖 片 來 源 : 檔 案 :cladder4.v module cladder4(output [3:0] S, output Cout,PG,GG, input [3:0] A,B, inpu t Cin); wire [3:0] G,P,C; assign G = A & B; //Generate assign P = A ^ B; //Propagate assign C[0] = Cin; assign C[1] = G[0] (P[0]&C[0]); assign C[2] = G[1] (P[1]&G[0]) (P[1]&P[0]&C[0]); assign C[3] = G[2] (P[2]&G[1]) (P[2]&P[1]&G[0]) (P[2]&P[1]&P[0]& C[0]); assign Cout = G[3] (P[3]&G[2]) (P[3]&P[2]&G[1]) (P[3]&P[2]&P[1]& G[0]) (P[3]&P[2]&P[1]&P[0]&C[0]);

47 assign S = P ^ C; assign PG = P[3] & P[2] & P[1] & P[0]; assign GG = G[3] (P[3]&G[2]) (P[3]&P[2]&G[1]) (P[3]&P[2]&P[1]&G[ 0]); module module main; reg signed [3:0] a; reg signed [3:0] b; wire signed [3:0] sum; wire c_out; cladder4 DUT (sum, cout, pg, gg, a, b, 0); initial begin a = 5; b = -3; $monitor("%dns monitor: a=%d b=%d sum=%d", $stime, a, b, sum); module 執 行 結 果 D:\Dropbox\Public\web\oc\code>iverilog -o cladder4 cladder4.v D:\Dropbox\Public\web\oc\code>vvp cladder4 0ns monitor: a= 5 b=-3 sum= 2 結 語 在 本 文 中, 我 們 大 致 將 CPU 設 計 當 中 最 重 要 的 組 合 邏 輯 電 路, 也 就 是 多 工 器 加 法 器 減 法 器 的 設 計 原 理 說 明 完 畢 了, 希 望 透 過 Verilog 的 實 作 方 式, 能 讓 讀 者 更 瞭 解 數 位 電 路 的 設 計 原 理, 並 且 為 接 下 來 所 要 介 紹 的 處 理 器 設 計 進 行 鋪 路 的 工 作 參 考 文 獻

48 LSU EE Spring Computer Organization : Verilog Notes 7 -- Integer Multiply and Divide 陳 鍾 誠 的 網 站 :Verilog 電 路 設 計 -- 多 工 器 陳 鍾 誠 的 網 站 :Verilog 電 路 設 計 -- 4 位 元 加 法 器 陳 鍾 誠 的 網 站 :Verilog 電 路 設 計 -- 加 減 器 Wikipedia:Adder Wikipedia:Adder subtractor Wikipedia:Multiplexer 本 文 由 陳 鍾 誠 取 材 ( 主 要 為 圖 片 ) 並 修 改 自 維 基 百 科

49 算 術 邏 輯 單 元 ALU 的 設 計 在 上 一 章 中, 我 們 探 討 了 組 合 邏 輯 電 路 的 設 計 方 式, 採 用 閘 級 的 拉 線 方 式 設 計 了 多 工 器 與 加 法 器 等 元 件, 在 本 章 當 中, 我 們 將 從 加 法 器 再 度 往 上, 探 討 如 何 設 計 一 個 ALU 單 元 加 減 器 我 們 只 要 把 加 法 器, 加 上 一 組 控 制 的 互 斥 或 閘, 並 控 制 輸 入 進 位 與 否, 就 可 以 成 為 加 減 器 了, 這 是 因 為 我 們 採 用 了 二 補 數 的 關 係 二 補 數 讓 我 們 可 以 很 容 易 的 延 伸 加 法 器 電 路 就 能 做 出 減 法 器 我 們 可 以 在 運 算 元 B 之 前 加 上 2 選 1 多 工 器 或 XOR 閘 來 控 制 B 是 否 應 該 取 補 數, 並 且 運 用 OP 控 制 線 路 來 進 行 控 制, 以 下 是 採 用 2 選 1 多 工 器 的 電 路 做 法 圖 圖 採 用 2 選 1 多 工 器 控 制 的 加 減 器 電 路 另 一 種 更 簡 單 的 做 法 是 採 用 XOR 閘 去 控 制 B 是 否 要 取 補 數, 如 下 圖 所 示 :

50 圖 採 用 XOR 控 制 的 加 減 器 電 路 清 楚 了 電 路 圖 的 布 局 之 後, 讓 我 們 來 看 看 如 何 用 Verilog 實 做 加 減 器 吧! 關 鍵 部 分 的 程 式 如 下 所 示, 這 個 模 組 就 對 應 到 上 述 的 採 用 XOR 控 制 的 加 減 器 電 路 之 圖 形 module addsub4(input op, input signed [3:0] a, input signed [3:0] b, output signed [3:0] sum, output c_out); wire [3:0] bop; xor4 x1(b, {op,op,op,op}, bop); adder4 a1(a, bop, op, sum, c_out); module 接 著 讓 我 們 來 看 看 完 整 的 加 減 器 程 式 與 測 試 結 果 檔 案 :addsub4.v module fulladder (input a, b, c_in, output sum, c_out); wire s1, c1, c2; xor g1(s1, a, b); xor g2(sum, s1, c_in); and g3(c1, a,b); and g4(c2, s1, c_in) ; xor g5(c_out, c2, c1) ; module module adder4(input signed [3:0] a, input signed [3:0] b, input c_in, wire [3:0] c; output signed [3:0] sum, output c_out); fulladder fa1(a[0],b[0], c_in, sum[0], c[1]) ; fulladder fa2(a[1],b[1], c[1], sum[1], c[2]) ; fulladder fa3(a[2],b[2], c[2], sum[2], c[3]) ; fulladder fa4(a[3],b[3], c[3], sum[3], c_out) ;

51 module module xor4(input [3:0] a, input [3:0] b, output [3:0] y); assign y = a ^ b; module module addsub4(input op, input signed [3:0] a, input signed [3:0] b, output signed [3:0] sum, output c_out); wire [3:0] bop; xor4 x1(b, {op,op,op,op}, bop); adder4 a1(a, bop, op, sum, c_out); module module main; reg signed [3:0] a; reg signed [3:0] b; wire signed [3:0] sum; reg op; wire c_out; addsub4 DUT (op, a, b, sum, c_out); initial begin a = 4'b0101; b = 4'b0000; op = 1'b0; always #50 begin op=op+1; $monitor("%dns monitor: op=%d a=%d b=%d sum=%d", $stime, op, a, b, sum) ;

52 always #100 begin b=b+1; initial #2000 $finish; module 執 行 結 果 : D:\ccc101\icarus\ccc>iverilog -o addsub4 addsub4.v D:\ccc101\icarus\ccc>vvp addsub4 50ns monitor: op=1 a= 5 b= 0 sum= 5 100ns monitor: op=0 a= 5 b= 1 sum= 6 150ns monitor: op=1 a= 5 b= 1 sum= 4 200ns monitor: op=0 a= 5 b= 2 sum= 7 250ns monitor: op=1 a= 5 b= 2 sum= 3 300ns monitor: op=0 a= 5 b= 3 sum=-8 350ns monitor: op=1 a= 5 b= 3 sum= 2 400ns monitor: op=0 a= 5 b= 4 sum=-7 450ns monitor: op=1 a= 5 b= 4 sum= 1 500ns monitor: op=0 a= 5 b= 5 sum=-6 550ns monitor: op=1 a= 5 b= 5 sum= 0 600ns monitor: op=0 a= 5 b= 6 sum=-5 650ns monitor: op=1 a= 5 b= 6 sum=-1 700ns monitor: op=0 a= 5 b= 7 sum=-4 750ns monitor: op=1 a= 5 b= 7 sum=-2 800ns monitor: op=0 a= 5 b=-8 sum=-3 850ns monitor: op=1 a= 5 b=-8 sum=-3 900ns monitor: op=0 a= 5 b=-7 sum=-2 950ns monitor: op=1 a= 5 b=-7 sum= ns monitor: op=0 a= 5 b=-6 sum= ns monitor: op=1 a= 5 b=-6 sum= ns monitor: op=0 a= 5 b=-5 sum= ns monitor: op=1 a= 5 b=-5 sum= ns monitor: op=0 a= 5 b=-4 sum= 1

53 1250ns monitor: op=1 a= 5 b=-4 sum= ns monitor: op=0 a= 5 b=-3 sum= ns monitor: op=1 a= 5 b=-3 sum= ns monitor: op=0 a= 5 b=-2 sum= ns monitor: op=1 a= 5 b=-2 sum= ns monitor: op=0 a= 5 b=-1 sum= ns monitor: op=1 a= 5 b=-1 sum= ns monitor: op=0 a= 5 b= 0 sum= ns monitor: op=1 a= 5 b= 0 sum= ns monitor: op=0 a= 5 b= 1 sum= ns monitor: op=1 a= 5 b= 1 sum= ns monitor: op=0 a= 5 b= 2 sum= ns monitor: op=1 a= 5 b= 2 sum= ns monitor: op=0 a= 5 b= 3 sum= ns monitor: op=1 a= 5 b= 3 sum= ns monitor: op=0 a= 5 b= 4 sum=-7 在 上 述 結 果 中, 您 可 以 看 到 當 op=0 時, 電 路 所 作 的 是 加 法 運 算, 例 如 :200ns monitor: op=0 a= 5 b= 2 sum= 7 而 當 op=1 時, 電 路 所 做 的 是 減 法 運 算, 例 如 :250ns monitor: op=1 a= 5 b= 2 sum= 3 採 用 CASE 語 法 設 計 ALU 模 組 其 實 在 Verilog 當 中, 我 們 並 不 需 要 自 行 設 計 加 法 器, 因 為 Verilog 提 供 了 高 階 的 +, -, *, / 等 基 本 運 算, 可 以 讓 我 們 直 接 使 用, 更 方 便 的 是, 只 要 搭 配 case 語 句, 我 們 就 可 以 很 輕 易 的 設 計 出 一 個 ALU 單 元 了 以 下 是 一 個 簡 易 的 ALU 單 元 之 程 式 碼, // 輸 入 a, b 後 會 執 行 op 所 指 定 的 運 算, 然 後 將 結 果 放 在 暫 存 器 y 當 中 module alu(input [7:0] a, input [7:0] b, input [2:0] op, output reg [7:0 ] y); always@(a or b or op) begin // 當 a, b 或 op 有 改 變 時, 就 進 入 此 區 塊 執 行 case(op) // 根 據 op 決 定 要 執 行 何 種 運 算 3'b000: y = a + b; // op=000, 執 行 加 法 3'b001: y = a - b; // op=000, 執 行 減 法 3'b010: y = a * b; // op=000, 執 行 乘 法 3'b011: y = a / b; // op=000, 執 行 除 法 3'b100: y = a & b; // op=000, 執 行 AND 3'b101: y = a b; // op=000, 執 行 OR 3'b110: y = ~a; // op=000, 執 行 NOT

54 3'b111: y = a ^ b; // op=000, 執 行 XOR case module Verilog 語 法 的 注 意 事 項 上 述 這 種 寫 法 感 覺 就 好 像 在 用 高 階 寫 程 式 一 樣, 這 讓 ALU 的 設 計 變 得 非 常 簡 單 但 是 仍 然 需 要 注 意 以 下 幾 點 與 高 階 語 言 不 同 之 處 : 注 意 事 項 1. always 語 句 的 用 法 case 等 陳 述 句 的 外 面 一 定 要 有 always 或 initial 語 句, 因 為 這 是 硬 體 線 路, 所 以 是 採 用 連 線 wiring 的 方 式,always 語 句 只 有 中 間 的 trigger 觸 發 條 件 符 合 時 才 會 被 觸 發 當 trigger 中 的 變 數 有 任 何 改 變 的 時 候,always 語 句 就 會 被 觸 發, 像 是 always@(a or b or op) 就 代 表 當 (a, b, op) 當 中 任 何 一 個 有 改 變 的 時 候, 該 語 句 就 會 被 觸 發 有 時 我 們 可 以 在 always 語 句 當 中 加 上 posedge 的 條 件, 指 定 只 有 在 正 邊 緣 ( 上 昇 邊 緣 ) 時 觸 發 或 者 加 上 negedge 的 條 件, 指 定 只 有 在 負 邊 緣 ( 下 降 邊 緣 ) 的 時 候 觸 發, 例 如 我 們 可 以 常 常 在 Verilog 當 中 看 到 下 列 語 句 : clock) begin... 上 述 語 句 就 只 有 在 clock 這 一 條 線 路 的 電 波 上 昇 邊 緣 會 被 觸 發, 如 此 我 們 就 能 更 精 細 的 控 制 觸 發 的 動 作, 採 用 正 邊 緣 或 負 邊 緣 觸 發 的 方 式 注 意 事 項 2. 指 定 陳 述 的 左 項 之 限 制 在 上 述 程 式 中,a, b, op 被 宣 告 為 input ( 輸 入 線 路 ), 而 y 則 宣 告 為 output reg ( 輸 出 暫 存 器 ), 在 這 裏 必 須 注 意 的 是 y 不 能 只 宣 告 為 output 而 不 加 上 reg, 因 為 只 有 reg 型 態 的 變 數 才 能 被 放 在 always 區 塊 裡 的 等 號 左 方, 進 行 指 定 的 動 作 事 實 上 在 Verilog 當 中, 像 output reg [7:0] y 這 樣 的 宣 告, 其 實 也 可 以 用 比 較 繁 雜 的 兩 次 宣 告 方 式, 一 次 宣 告 output, 另 一 次 則 宣 告 reg, 如 下 所 示 : module alu(input [7:0] a, input [7:0] b, input [2:0] op, output [7:0] y) ; reg y; always@(a or b or op) begin... 甚 至, 您 也 可 以 將 該 變 數 分 開 為 兩 個 不 同 名 稱, 然 後 再 利 用 assign 的 方 式 指 定, 如 下 所 示 :

55 // 輸 入 a, b 後 會 執 行 op 所 指 定 的 運 算, 然 後 將 結 果 放 在 暫 存 器 y 當 中 module alu(input [7:0] a, input [7:0] b, input [2:0] op, output [7:0] y) ; reg ty; always@(a or b or op) begin // 當 a, b 或 op 有 改 變 時, 就 進 入 此 區 塊 執 行 case(op) // 根 據 op 決 定 要 執 行 何 種 運 算 3'b000: ty = a + b; // op=000, 執 行 加 法 3'b001: ty = a - b; // op=000, 執 行 減 法 3'b010: ty = a * b; // op=000, 執 行 乘 法 3'b011: ty = a / b; // op=000, 執 行 除 法 3'b100: ty = a & b; // op=000, 執 行 AND 3'b101: ty = a b; // op=000, 執 行 OR 3'b110: ty = ~a; // op=000, 執 行 NOT 3'b111: ty = a ^ b; // op=000, 執 行 XOR case $display("base 10 : %dns : op=%d a=%d b=%d y=%d", $stime, op, a, b, y); // 印 出 op, a, b, y 的 10 進 位 值 $display("base 2 : %dns : op=%b a=%b b=%b y=%b", $stime, op, a, b, y); // 印 出 op, a, b, y 的 2 進 位 值 assign y=ty; module 在 上 述 程 式 中, 由 於 只 有 reg 型 態 的 變 數 可 以 放 在 always 區 塊 內 的 等 號 左 邊, 因 此 我 們 必 須 用 reg 型 態 的 ty 去 儲 存 運 算 結 果 但 是 在 assign 指 令 的 等 號 左 邊, 則 不 需 要 是 暫 存 器 型 態 的 變 數, 也 可 以 是 線 路 型 態 的 變 數, 因 此 我 們 可 以 用 assign y=ty 這 樣 一 個 指 令 去 將 ty 的 暫 存 器 內 容 輸 出 事 實 上,assign 語 句 代 表 的 是 一 種 不 需 儲 存 的 立 即 輸 出 接 線, 因 此 我 們 才 能 將 output 型 態 的 變 數 寫 在 等 號 左 邊 啊! 完 整 的 ALU 設 計 ( 含 測 試 程 式 ) 瞭 解 了 這 些 Verilog 語 法 特 性 之 後, 我 們 就 可 以 搭 配 測 試 程 式, 對 這 個 ALU 模 組 進 行 測 試, 以 下 是 完 整 的 程 式 碼 : 檔 案 :alu.v // 輸 入 a, b 後 會 執 行 op 所 指 定 的 運 算, 然 後 將 結 果 放 在 暫 存 器 y 當 中 module alu(input [7:0] a, input [7:0] b, input [2:0] op, output reg [7:0