Rust 構建 CHIP-8 虛擬機器核心元件與架構

– 14 分鐘閱讀

在現代系統程式設計中，虛擬機器扮演著重要的角色。本文將深入探討如何使用 Rust 語言構建一個 CHIP-8 虛擬機器，著重介紹其核心元件，包括 CPU、記憶體和指令集的設計與實作。我們將從 CPU 的基本結構開始，逐步新增功能，例如指令讀取、整數溢位處理、堆積疊操作以及函式呼叫等，最終構建一個功能完備的 CHIP-8 虛擬機器。過程中，我們會運用 Rust 的語言特性，例如結構體、匹配模式和溢位處理機制，來確保程式碼的效率和安全性。同時，我們也會探討如何處理 CHIP-8 架構中的特殊情況，例如有限的暫存器數量和記憶體空間。

虛擬機器的核心元件

虛擬機器的核心元件包括中央處理器（CPU）、記憶體和輸入/輸出系統。在 CHIP-8 虛擬機器中，CPU 負責執行指令，記憶體用於儲存程式和資料，輸入/輸出系統則負責與使用者互動。

實作 CPU

在 Rust 中，我們可以使用結構體來實作 CPU。CPU 結構體應該包含以下欄位：

  • current_operation: 目前正在執行的指令。
  • registers: 一組暫存器，用於儲存資料。
struct CPU {
    current_operation: u16,
    registers: [u8; 16], // CHIP-8 有 16 個 8 位元暫存器
}

初始化 CPU

初始化 CPU 時，我們需要設定 current_operation 和 registers 的初始值。

fn main() {
    let mut cpu = CPU {
        current_operation: 0,
        registers: [0; 16],
    };

    cpu.current_operation = 0x8014;
    cpu.registers[0] = 5;
    cpu.registers[1] = 10;
}

處理指令

在 CHIP-8 虛擬機器中，每個指令都是 2 個位元組（16 位元）。指令的格式如下：

  • 最高 4 位元（nibble）表示指令的型別。
  • 其餘 12 位元用於儲存指令的引數。
  flowchart TD
    A[取得指令] --> B[解析指令]
    B --> C[執行指令]
    C --> D[更新 CPU 狀態]

圖表翻譯：

此圖表描述了 處理指令的流程。首先，虛擬機器取得一條指令，然後解析指令以確定其型別和引數。接著，虛擬機器執行指令，並根據指令的結果更新 CPU 的狀態。

未來，我們可以繼續實作 CHIP-8 虛擬機器的其他功能，例如記憶體管理、輸入/輸出系統等。此外，我們也可以嘗試實作其他虛擬機器或編譯器，以加深對電腦科學的理解。

CPU 架構與記憶體擴充

在之前的 CPU 架構中，我們只實作了基本的加法運算。現在，我們要進一步擴充 CPU 的功能，讓它能夠支援記憶體存取和多指令序列的執行。

CPU RIA/2：乘法器

CPU RIA/2 是一個可以執行多個指令的乘法器。它包括 RAM、工作主迴圈和一個變數 position_in_memory，用於指示下一個要執行的指令。

修改內容

相較於之前的 CPU RIA/1，CPU RIA/2 做出了以下修改：

  • 增加了 4 KB 的記憶體（第 8 行）。
  • 包含了一個完整的主迴圈和停止條件（第 14-31 行）。在迴圈的每一步，記憶體中的 position_in_memory 位置被存取和解碼成操作碼。然後，position_in_memory 被遞增到下一個記憶體地址，操作碼被執行。CPU 會持續執行，直到遇到停止條件（操作碼為 0x0000）。
  • 移除了 CPU 結構中的 current_instruction 欄位，改用 position_in_memory（第 15-17 行）。
  • 將操作碼寫入記憶體（第 51-53 行）。

CPU 記憶體擴充

為了使 CPU 更加有用，我們需要實施一些修改，以支援記憶體存取。

CPU 結構定義

以下是 CPU RIA/2 的定義，摘自 listing 5.26：

struct CPU {
    registers: [u8; 16],
    position_in_memory: usize,
    memory: [u8; 4096], // 4 KB 的記憶體
}

在這個結構中，我們包含了：

  • registers：16 個通用暫存器，用於計算。
  • position_in_memory：一個特殊用途的暫存器，指示下一個要執行的指令的位置。
  • memory：系統的記憶體，作為 CPU 結構的一部分。

主迴圈和停止條件

CPU 的主迴圈如下所示：

loop {
    let opcode = self.memory[self.position_in_memory];
    self.position_in_memory += 1;
    
    match opcode {
        0x00 => break, // 停止條件
        0x01 => { /* 執行加法指令 */ }
        0x02 => { /* 執行乘法指令 */ }
        _ => panic!("未知操作碼"),
    }
}

在這個迴圈中，我們存取記憶體中的 position_in_memory 位置，解碼操作碼，然後遞增 position_in_memory 到下一個記憶體地址。根據操作碼的不同，我們執行相應的指令。當遇到停止條件（操作碼為 0x00）時，迴圈終止。

實作乘法指令

為了實作乘法指令，我們可以新增一個新的操作碼（例如 0x02），然後在匹配陳述式中新增相應的執行邏輯：

0x02 => {
    let operand1 = self.registers[0];
    let operand2 = self.registers[1];
    let result = operand1 * operand2;
    self.registers[0] = result as u8;
}

在這個例子中，我們假設乘法指令使用暫存器 0 和 1 作為運算元，然後將結果存回暫存器 0。

圖表翻譯：
  graph LR
    A[CPU] -->|存取記憶體|> B[記憶體]
    B -->|傳回操作碼|> A
    A -->|執行指令|> C[暫存器]
    C -->|儲存結果|> B

這個圖表展示了 CPU、記憶體和暫存器之間的互動作用。CPU 存取記憶體以取得操作碼，然後根據操作碼執行相應的指令。結果被儲存回暫存器和記憶體中。

CHIP-8 處理器架構與指令讀取

CHIP-8 處理器是一種簡單的 8 位元 處理器，具有 16 個暫存器、4096 個位元組的 RAM 和一個簡單的指令集。下面是 CHIP-8 處理器架構的 Rust 實作：

struct Cpu {
    registers: [u8; 16],
    memory: [u8; 0x1000],
    position_in_memory: u16,
}

其中，registers 是 16 個暫存器的陣列，memory 是 4096 個位元組的 RAM 陣列，position_in_memory 是目前的記憶體位置。

指令讀取

指令讀取是從記憶體中讀取一個 16 位元的 opcode。以下是 read_opcode 方法的實作：

fn read_opcode(&self) -> u16 {
    let p = self.position_in_memory;
    let op_byte1 = self.memory[p] as u16;
    let op_byte2 = self.memory[p + 1] as u16;
    op_byte1 << 8 | op_byte2
}

這個方法讀取目前記憶體位置的兩個位元組，然後將它們組合成一個 16 位元的 opcode。

整數溢位處理

在 CHIP-8 中，最後一個暫存器用作 carry flag。如果設定，這個 flag 表示一個操作已經溢位了 u8 暫存器大小。以下是 add_xy 方法的實作：

fn add_xy(&mut self, x: u8, y: u8) {
    let arg1 = self.registers[x as usize];
    //...
}

這個方法將兩個 u8 數值相加，如果結果溢位了 u8 暫存器大小，就設定 carry flag。

Mermaid 圖表：CHIP-8 處理器架構

  graph LR
    A[CHIP-8 處理器] --> B[16 個暫存器]
    A --> C[4096 個位元組的 RAM]
    A --> D[指令讀取]
    D --> E[read_opcode 方法]
    E --> F[組合 opcode]
    F --> G[執行指令]
    G --> H[整數溢位處理]
    H --> I[設定 carry flag]

圖表翻譯：

這個 Mermaid 圖表展示了 CHIP-8 處理器的架構，包括 16 個暫存器、4096 個位元組的 RAM 和指令讀取過程。指令讀取過程涉及 read_opcode 方法，該方法讀取目前記憶體位置的兩個位元組，然後將它們組合成一個 16 位元的 opcode。執行指令過程可能涉及整數溢位處理，如果結果溢位了 u8 暫存器大小，就設定 carry flag。

處理CHIP-8運算中的溢位

在實作CHIP-8指令集時，需要考慮到溢位的情況。以下是相關的程式碼片段：

let arg2 = self.registers[y as usize];
let (val, overflow) = arg1.overflowing_add(arg2);
self.registers[x as usize] = val;

這段程式碼使用了Rust的overflowing_add方法來進行加法運算，並檢測是否發生溢位。如果溢位發生，則將self.registers[0xF]設為1，否則設為0。

if overflow {
    self.registers[0xF] = 1;
} else {
    self.registers[0xF] = 0;
}

這裡使用了usize而不是u16是因為Rust允許使用usize作為索引。雖然這與原始規範有所不同，但這樣做可以簡化程式碼。

內容解密：

在這段程式碼中，我們首先從self.registers中讀取arg2的值。然後，我們使用overflowing_add方法將arg1和arg2相加，並檢測是否發生溢位。結果儲存在val中，溢位標誌儲存在overflow中。最後，我們根據溢位標誌設定self.registers[0xF]的值。

圖表翻譯：

  flowchart TD
    A[開始] --> B[讀取arg2]
    B --> C[進行加法運算]
    C --> D[檢測溢位]
    D --> E[設定溢位標誌]
    E --> F[結束]

這個流程圖描述了程式碼的執行流程。首先，讀取arg2的值，然後進行加法運算，檢測是否發生溢位，最後根據溢位標誌設定self.registers[0xF]的值。

CPU 乘法器的實作：RISCV2

以下是第二個工作模擬器——乘法器的完整程式碼。你可以在 ch5/ch5-cpu2/src/main.rs 中找到這個程式碼的來源。

struct CPU {
    // 註冊器：16 個 8 位元的儲存空間
    registers: [u8; 16],
    
    // 目前記憶體位置
    position_in_memory: usize,
    
    // 16KB 的記憶體空間
    memory: [u8; 0x1000],
}

impl CPU {
    // 讀取操作碼
    fn read_opcode(&self) -> u16 {
        // 取得目前記憶體位置
        let p = self.position_in_memory;
        
        // 讀取第一個操作碼 byte
        let op_byte1 = self.memory[p] as u16;
        
        // 讀取第二個操作碼 byte
        let op_byte2 = self.memory[p + 1] as u16;
        
        // 組合兩個 byte 成為一個 16 位元的操作碼
        op_byte1 << 8 | op_byte2
    }
}

內容解密：

這個程式碼定義了一個 CPU 結構，包含 16 個 8 位元的註冊器、目前記憶體位置和 16KB 的記憶體空間。read_opcode 方法用於讀取操作碼，首先取得目前記憶體位置，然後讀取兩個 byte 的操作碼，並將其組合成一個 16 位元的操作碼。這個過程是 CPU 執行指令的基礎。

圖表翻譯：

  flowchart TD
    A[取得目前記憶體位置] --> B[讀取第一個操作碼 byte]
    B --> C[讀取第二個操作碼 byte]
    C --> D[組合兩個 byte 成為一個 16 位元的操作碼]

這個流程圖描述了 read_opcode 方法的執行過程，從取得目前記憶體位置開始，到讀取兩個 byte 的操作碼，最後組合成一個 16 位元的操作碼。

虛擬機器的執行迴圈

虛擬機器的核心是執行迴圈，這個迴圈不斷地從記憶體中讀取指令，然後執行它們。下面是虛擬機器執行迴圈的核心部分：

fn run(&mut self) {
    loop {
        // 讀取當前的指令
        let opcode = self.read_opcode();
        
        // 將記憶體位置指標向前移動 2 個單位
        self.position_in_memory += 2;
        
        // 將指令碼分解為不同的部分
        let c = ((opcode & 0xF000) >> 12) as u8;
        let x = ((opcode & 0x0F00) >> 8) as u8;
        let y = ((opcode & 0x00F0) >> 4) as u8;
        let d = ((opcode & 0x000F) >> 0) as u8;
        
        // 根據指令碼的不同部分進行不同的操作
        match (c, x, y, d) {
            // 如果指令碼為 0x0000，則結束執行迴圈
            (0, 0, 0, 0) => { return; },
            
            // 如果指令碼為 0x8004，則執行加法操作
            (0x8, _, _, 0x4) => self.add_xy(x, y),
            
            // 對於其他指令碼，目前尚未實作
            _ => todo!("opcode {:04x}", opcode),
        }
    }
}

內容解密：

這段程式碼定義了虛擬機器的執行迴圈。執行迴圈不斷地從記憶體中讀取指令，然後根據指令碼的不同部分進行不同的操作。目前已經實作了加法操作和結束執行迴圈的操作，但仍然有很多其他指令碼尚未實作。

圖表翻譯：

  flowchart TD
    A[開始執行迴圈] --> B[讀取指令]
    B --> C[分解指令碼]
    C --> D[根據指令碼進行操作]
    D --> E[結束執行迴圈]
    E --> F[傳回]

這個流程圖描述了虛擬機器的執行迴圈。它從開始執行迴圈開始，然後讀取指令，分解指令碼，根據指令碼進行不同的操作，最後結束執行迴圈並傳回。

處理器指令集擴充：增加加法指令

為了增強虛擬機器的功能，我們需要新增更多指令來使其變得更有用。讓我們從實作一個基本的加法指令開始。

加法指令實作

fn add_xy(&mut self, x: u8, y: u8) {
    let arg1 = self.registers[x as usize];
    let arg2 = self.registers[y as usize];
    let (val, overflow) = arg1.overflowing_add(arg2);
    self.registers[x as usize] = val;
    
    if overflow {
        // 處理溢位情況
    }
}

在這個實作中，add_xy 函式負責將兩個暫存器的值相加，並將結果存回其中一個暫存器中。這裡使用 overflowing_add 方法來進行加法運算，以便能夠檢測到是否發生了溢位。

執行多條指令

為了使虛擬機器能夠執行多條指令，我們需要維護一個指令計數器，並根據計數器的值來決定下一步要執行哪條指令。

fn execute(&mut self) {
    loop {
        let instruction = self.fetch_instruction();
        match instruction.opcode {
            // 處理不同的指令
            0x01 => self.add_xy(instruction.arg1, instruction.arg2),
            //...
        }
    }
}

在這個例子中，execute 函式負責不斷地從記憶體中提取指令，並根據指令的操作碼來決定要執行哪個函式。

指令集擴充

為了使虛擬機器變得更有用，我們需要新增更多的指令。這些指令可以包括但不限於：

  • 載入指令：從記憶體中載入資料到暫存器中。
  • 儲存指令：將暫存器中的資料儲存到記憶體中。
  • 跳轉指令：根據條件跳轉到程式中的不同位置。
  • 邏輯運算指令：對暫存器中的資料進行邏輯運算。
  flowchart TD
    A[開始] --> B[提取指令]
    B --> C[執行指令]
    C --> D[檢查是否完成]
    D -->|是| E[結束]
    D -->|否| B

圖表翻譯：

這個流程圖描述了虛擬機器的執行流程。首先，虛擬機器會提取一條指令，然後執行這條指令。執行完成後，虛擬機器會檢查是否已經完成所有指令。如果已經完成，虛擬機器就會結束執行。如果尚未完成，虛擬機器就會繼續提取下一條指令並執行。

CPU架構與指令集設計

在設計一款CPU時，瞭解指令集架構（ISA）至關重要。ISA定義了CPU可以執行的指令集，包括載入、儲存、算術運算等基本操作。在本文中，我們將探討如何實作一個簡單的CPU，以展示指令集的工作原理。

指令集架構

指令集架構是CPU設計的核心。它定義了CPU可以執行的指令，包括指令的格式、運算碼（opcode）和運算元。指令集架構可以分為兩類別：CISC（複雜指令集電腦）和RISC（精簡指令集電腦）。

實作一個簡單的CPU

下面是一個簡單的CPU實作範例，使用Rust語言編寫：

struct CPU {
    registers: [u8; 16],
    pc: u16, // 程式計數器
}

impl CPU {
    fn new() -> Self {
        CPU {
            registers: [0; 16],
            pc: 0,
        }
    }

    fn execute(&mut self, opcode: u8) {
        match opcode {
            0x00 => self.halt(), // 停止執行
            0x01 => self.load(), // 載入資料
            0x02 => self.store(), // 儲存資料
            _ => self.illegal_opcode(), // 非法運算碼
        }
    }

    fn halt(&mut self) {
        self.pc = 0; // 重置程式計數器
    }

    fn load(&mut self) {
        // 載入資料到暫存器
        self.registers[0xF] = 1;
    }

    fn store(&mut self) {
        // 儲存資料從暫存器
        self.registers[0xF] = 0;
    }

    fn illegal_opcode(&mut self) {
        // 處理非法運算碼
        println!("非法運算碼");
    }
}

fn main() {
    let mut cpu = CPU::new();
    cpu.execute(0x01); // 載入資料
    cpu.execute(0x02); // 儲存資料
    cpu.execute(0x00); // 停止執行
}

在這個範例中，我們定義了一個簡單的CPU結構，包含16個暫存器和一個程式計數器（pc）。我們實作了四個基本指令：停止執行（halt）、載入資料（load）、儲存資料（store）和非法運算碼（illegal_opcode）。

內容解密：

在上面的範例中，我們使用Rust語言編寫了一個簡單的CPU實作。這個實作包含了一個CPU結構，包含16個暫存器和一個程式計數器。我們實作了四個基本指令：停止執行、載入資料、儲存資料和非法運算碼。這些指令是CPU工作原理的基礎。

圖表翻譯：

  graph LR
    A[CPU] -->|execute|> B[指令集]
    B -->|halt|> C[停止執行]
    B -->|load|> D[載入資料]
    B -->|store|> E[儲存資料]
    B -->|illegal_opcode|> F[非法運算碼]

這個圖表展示了CPU和指令集之間的關係。CPU執行指令集中的指令，包括停止執行、載入資料、儲存資料和非法運算碼。

內容解密：

這段程式碼是用Rust語言撰寫的，主要目的是初始化一個簡單的CPU結構，並進行一些基本的操作。讓我們逐步拆解這段程式碼。

首先，定義了一個名為CPU的結構體，它包含四個欄位：registers、memory、position_in_memory。其中，registers是一個長度為16的陣列，用於模擬CPU的暫存器；memory是一個長度為4096的陣列，用於模擬CPU的記憶體；position_in_memory是一個整數，用於記錄當前記憶體位置。

接下來，建立了一個名為cpu的CPU例項，並初始化其欄位。其中，registers陣列被初始化為所有元素為0的狀態；memory陣列也被初始化為所有元素為0的狀態；position_in_memory被設定為0，表示當前記憶體位置在起始位置。

然後，對cpu例項的某些暫存器進行了指定操作：將第0號暫存器設為5，第1號暫存器設為10，第2號暫存器設為10，第3號暫存器設為10。

之後，取得了對cpu.memory陣列的可變參照，並進行了一些記憶體寫入操作：在記憶體位置0和1寫入了十六進位制值0x80和0x14，在記憶體位置2和3寫入了十六進位制值0x80和0x24，在記憶體位置4和5寫入了十六進位制值0x80和0x34。

這段程式碼展示瞭如何在Rust中定義和操作一個簡單的CPU結構，並對其暫存器和記憶體進行指定和寫入操作。

圖表翻譯：

  flowchart TD
    A[初始化CPU] --> B[設定暫存器]
    B --> C[設定記憶體]
    C --> D[寫入記憶體]
    D --> E[完成]

這個流程圖描述了程式碼的執行流程：首先初始化CPU結構，然後設定暫存器，接著設定記憶體，接著寫入記憶體，最後完成操作。

CPU 架構擴充套件：支援堆積疊和函式呼叫

在前面的章節中，我們已經建立了基本的 CPU 架構，現在是時候來擴充套件它以支援堆積疊和函式呼叫。這個擴充套件將使我們的 CPU 能夠執行更複雜的程式，並且更好地模擬現實世界中的電腦行為。

堆積疊的介紹

堆積疊是一種特殊的記憶體結構，允許我們儲存和還原資料。它的運作方式類別似於一個堆積疊的 plates：當我們將一個新的 plate 推入堆積疊時，它會被放在最上面，而當我們取出一個 plate 時，它會被從最上面移除。這種資料結構對於實作函式呼叫和傳回非常重要。

CPU 架構的擴充套件

為了支援堆積疊和函式呼叫，我們需要在 CPU 中新增一些新的 opcode。這些 opcode 包括：

  • CALL opcode（0x2nnn）：設定 position_in_memory 為 nnn，即函式的記憶體地址。
  • RETURN opcode（0x00EE）：設定 position_in_memory 為之前 CALL opcode 的記憶體地址。

為了使這些 opcode 能夠正常工作，CPU 需要有一塊特殊的記憶體來儲存地址，這就是堆積疊。每次 CALL opcode 被執行時，堆積疊上會新增一個新的地址，而每次 RETURN opcode 被執行時，堆積疊上的頂部地址會被移除。

實作細節

以下是實作 CPU 架構擴充套件的詳細步驟：

  1. 定義堆積疊結構：我們需要定義一個堆積疊結構來儲存地址。這可以是一個陣列或是一個連結串列，具體實作取決於你的需求。
  2. 實作 CALL opcode：當 CALL opcode 被執行時，CPU 需要將目前的 position_in_memory 值推入堆積疊，並設定新的 position_in_memory 值為 nnn。
  3. 實作 RETURN opcode：當 RETURN opcode 被執行時，CPU 需要從堆積疊上彈出頂部地址，並設定新的 position_in_memory 值為彈出的地址。

深入剖析虛擬機器的核心架構後，可以發現，從最初的CPU、記憶體和I/O系統的基礎建構，到實作加法、乘法等指令，再到支援堆積疊和函式呼叫，逐步完善的CHIP-8虛擬機器展現了電腦系統設計的核心思想。透過模擬指令讀取、執行和溢位處理等關鍵流程，我們得以深入理解CPU的運作機制。然而，目前實作的指令集仍然有限，距離完整模擬真實世界電腦系統仍有距離。未來發展方向包括擴充指令集，支援更複雜的運算和控制流程，以及整合圖形顯示和聲音輸出等功能。從技術演進角度，建構虛擬機器是理解電腦底層架構的有效途徑，值得深入研究。玄貓認為，持續精進虛擬機器的功能，將有助於我們更深入地探索電腦科學的奧妙。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。