《计算机组成原理》第 3 章 - 系统总线

/**
 * PCIe总线通信模拟
 * 功能：主设备（CPU）向从设备（显卡）发送数据
 */
public class PCIeSimulation {
    // 模拟PCIe总线宽度（64位）
    private static final int BUS_WIDTH = 64;
    // 模拟总线时钟频率（1GHz）
    private static final int CLOCK_FREQ = 1_000_000_000;

    public static void main(String[] args) {
        // 主设备（CPU）发送数据
        byte[] dataToSend = {0x01, 0x02, 0x03, 0x04, 0x05}; // 示例数据（5字节）
        int deviceAddress = 0x1000; // 设备地址

        // 模拟总线传输过程
        sendDataOverPCIe(deviceAddress, dataToSend);
        System.out.println("数据传输完成！");
    }

    /**
     * 通过PCIe总线发送数据
     * @param address 目标设备地址
     * @param data    待发送数据
     */
    private static void sendDataOverPCIe(int address, byte[] data) {
        // 解析总线宽度对应的单次传输最大字节数（64位=8字节）
        int maxTransferSize = BUS_WIDTH / 8;
        int totalBytes = data.length;

        System.out.println("开始通过PCIe总线传输数据...");
        System.out.println("总线宽度：" + BUS_WIDTH + "位，时钟频率：" + CLOCK_FREQ/1000000 + "MHz");
        System.out.println("目标设备地址：0x" + Integer.toHexString(address));

        // 分块传输数据（模拟实际突发传输）
        for (int i = 0; i < totalBytes; i += maxTransferSize) {
            int end = Math.min(i + maxTransferSize, totalBytes);
            byte[] chunk = Arrays.copyOfRange(data, i, end);

            // 模拟时序控制（简化版）
            simulateClockCycle();
            System.out.println("传输第 " + (i/maxTransferSize + 1) + " 块数据：" + Arrays.toString(chunk));
        }
    }

    /**
     * 模拟总线时钟周期（简化时序逻辑）
     */
    private static void simulateClockCycle() {
        try {
            // 模拟时钟周期耗时（1ns）
            Thread.sleep(0, 1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

"""
链式查询总线仲裁模拟
设备优先级：设备0 > 设备1 > 设备2
"""
class ChainArbiter:
    def __init__(self, num_devices):
        self.devices = [False] * num_devices  # 设备请求状态（False=未请求，True=请求中）
        self.grant_line = 0  # 授权信号当前位置（从0开始）

    def request_bus(self, device_id):
        """设备发起总线请求"""
        if 0 <= device_id < len(self.devices):
            self.devices[device_id] = True
            print(f"设备{device_id}发起总线请求")
        else:
            print("无效设备ID")

    def grant_access(self):
        """仲裁器按优先级分配总线"""
        for i in range(len(self.devices)):
            if self.devices[i]:
                # 授权给当前设备
                self.grant_line = i
                self.devices[i] = False  # 清除请求
                print(f"总线授权给设备{self.grant_line}")
                return
        print("无设备请求总线")

# 测试案例
if __name__ == "__main__":
    arbiter = ChainArbiter(3)
    arbiter.request_bus(2)  # 低优先级设备请求
    arbiter.request_bus(0)  # 高优先级设备请求
    arbiter.grant_access()  # 应授权给设备0
    arbiter.grant_access()  # 设备2此时请求已被设备0覆盖，无请求则提示

/**
 * 同步总线通信时序模拟
 * 功能：主设备与从设备通过时钟信号同步传输数据
 */
public class SynchronousCommunication {
    private static int clockCycle = 0;

    public static void main(String[] args) {
        int[] data = {0xA1, 0xB2, 0xC3}; // 待传输数据
        communicateWithClock(data);
    }

    private static void communicateWithClock(int[] data) {
        for (int d : data) {
            clockCycle++;
            System.out.println("时钟周期 " + clockCycle + ":");
            System.out.println("- 主设备发送地址和数据：0x" + Integer.toHexString(d));
            System.out.println("- 从设备在时钟上升沿接收数据");
            System.out.println("---------------------------");
        }
    }
}