logo
ZhangKeyaoo
banner
^_^

PA2实验记录

Scroll down

PA2 - 简单复杂的机器: 冯诺依曼计算机系统

  • 首先切换到pa2分支
  • task PA2.1: 实现更多的指令, 在NEMU中运行大部分cpu-tests
  • task PA2.2: 实现klib和基础设施
  • task PA2.3: 运行FCEUX, 提交完整的实验报告

不停计算的机器

  • CPU究竟是怎么执行一条指令的：
    • 对于大部分指令来说, 执行它们都可以抽象成取指-译码-执行的指令周期.
  • 计算机不断重复下面四个步骤

1.取指(instruction fetch, IF)

  • “存储控制，程序控制”——指令在存储器中, 由PC指出当前指令的位置.
    • 事实上, PC就是一个指针
  • 取指令要做的事情：将PC指向的指令从内存读入到CPU中.

2.译码(instruction decode, ID)

  • 取指后发现是个01组成的比特串
  • 指令是做什么的：CPU是用来处理数据的, 指令则是用来指示CPU具体对什么数据进行什么样的处理.
    • CPU需要从指令中解读出”操作码“和”操作数“两部分信息
  • 译码：CPU拿到一条指令之后, 可以通过查表的方式得知这条指令的操作数和操作码.

3.执行(execute, EX)

  • 执行阶段就是真正完成指令的工作

4.更新PC

  • 执行完一条指令之后, CPU就要执行下一条指令. 在这之前, CPU需要更新PC的值
  • 让PC加上刚才执行完的指令的长度, 即可指向下一条指令的位置.

YEMU: 一个简单的CPU模拟器

  • 一个简单计算机：
    • 有4个8位的寄存器, 一个4位PC, 以及一段16字节的内存.
    • 它支持R型和M型两种指令格式, 4条指令.

必做：理解YEMU如何执行程序

1
2
3
4
YEMU可以看成是一个简化版的NEMU, 它们的原理是相通的, 因此你需要理解YEMU是如何执行程序的. 具体地, 你需要
    1. 画出在YEMU上执行的加法程序的状态机
    2. 通过RTFSC理解YEMU如何执行一条指令
思考一下, 以上两者有什么联系?
  1. 画出在YEMU上执行的加法程序的状态机
1
2
3
4
5
6
7
8
9
10
11
12
+---------+    +---------+    +---------+    +---------+    +---------+
|         |    |         |    |         |    |         |    |         |
|  取指    +--->|  译码   +--->|  加法    +--->|  写回    +--->|  更新PC |
|         |    |         |    |         |    |         |    |         |
+---------+    +---------+    +---------+    +---------+    +---------+
                                                        |
                                                        v
                                                    +---------+
                                                    |         |
                                                    |  结束   |
                                                    |         |
                                                    +---------+
  1. 通过RTFSC理解YEMU如何执行一条指令
    1. 取指
    1
    this.inst = M[pc]; // 从内存中取出当前PC指向的指令
    1. 译码
    1
    switch (this.rtype.op) {...}
    1. 执行
      • 对于操作码0b0000 (复制操作):
      1
      case 0b0000: { DECODE_R(this); R[rt] = R[rs]; break; }
      • 对于操作码0b0001 (加法操作):
      1
      case 0b0001: { DECODE_R(this); R[rt] += R[rs]; break; }
      • 对于操作码0b1110 (从内存加载):
      1
      case 0b1110: { DECODE_M(this); R[0] = M[addr]; break; }
      • 对于操作码0b1111 (存储到内存):
      1
      case 0b1111: { DECODE_M(this); M[addr] = R[0]; break; }
    2. 更新PC
    1
    pc ++; // 更新PC
    1. 结束
      • 如果遇到无效指令:
      1
      2
      3
      4
      default:
      printf("Invalid instruction with opcode = %x, halting...\n", this.rtype.op);
      halt = 1;
      break;
  2. 两者联系
    • 状态机图展示了YEMU执行加法程序的各个阶段，从取指到更新PC，再到结束。
    • RTFSC分析展示了这些阶段在代码中的具体实现。

RTFSC(2)

RTFM

  • 决定往TRM中添加各种高效指令
  • ISA手册(riscv32)中一般都会有以下内容, 尝试RTFM并寻找这些内容的位置:
    1. 每一条指令具体行为的描述
    2. 指令opcode的编码表格
    • 在PA中, riscv32的客户程序只会由RV32I和RV32M两类指令组成
  • 例子：在RISC-V手册中查找加法指令ADD的具体行为的描述和操作码编码表格
    1. 具体行为的描述
      • ADD rd, rs1, rs2：将寄存器rs1和rs2的值相加，并将结果存储到寄存器rd中。
      • 功能：rd = rs1 + rs2
      • 操作数：rd、rs1、rs2
      • 执行结果：rd中存储相加结果
      • 副作用：无
    2. 操作码编码表格
      • 操作码：0b0110011
      • 功能码：0b000
      • 表格：
      1
      2
      3
      4
      5
      +---------+---------+---------+---------+---------+---------+
      | funct7  | rs2     | rs1     | funct3  | rd      | opcode  |
      +---------+---------+---------+---------+---------+---------+
      | 0000000 | rs2(5)  | rs1(5)  | 000     | rd(5)   | 0110011 |
      +---------+---------+---------+---------+---------+---------+

RTFSC(2)

  • 介绍NEMU的框架代码如何实现指令的执行.

NEMU ISA相关的API说明文档

  • 全局类型
    • word_t表示与ISA字长等长的无符号类型, 在32位的ISA中为uint32_t
    • sword_t表示与ISA字长等长的有符号类型, 在32位的ISA中为int32_t
    • char *FMT_WORDword_t类型对应的十六进制格式化说明符, 在32位的ISA中为”0x%08x”
  • Monitor相关
    • unsigned char isa_logo[];用于在未实现指令的报错信息中提示开发者阅读相关的手册.
    • ``word_t RESET_VECTOR;`表示PC的初始值.
    • void init_isa();在monitor初始化时调用, 进行至少如下ISA相关的初始化工作:
      • 设置必要的寄存器初值, 如PC等
      • 加载内置客户程序
  • 寄存器相关
    •   struct {
  // ...
  word_t pc;
  } CPU_state;
  
      1
      2
      3
      4
      5
      6
      7
      8
      9
              寄存器结构的类型定义, 其中必须包含一个名为pc, 类型为word_t的成员.
          - ``CPU_state cpu;``寄存器结构的全局定义.
          - ``void isa_reg_display();``打印寄存器当前的值.
          - ``word_t isa_reg_str2val(const char *name, bool *success);``若存在名称为name的寄存器, 则返回其当前值, 并设置success为true; 否则设置success为false.
      - 指令执行相关
          - ```
              struct {
              // ...
              } ISADecodeInfo;
      
  用于存放ISA相关的译码信息, 会嵌入在译码信息结构体Decode的定义中.
    • int isa_exec_once(Decode *s);取出s->pc指向的指令并译码执行, 同时更新s->snpc.
  • 虚拟内存相关
    • int isa_mmu_check(vaddr_t vaddr, int len, int type);检查当前系统状态下对内存区间为(vaddr, vaddr + len), 类型为type的访问是否需要经过地址转换.
    • paddr_t isa_mmu_translate(vaddr_t vaddr, int len, int type);对内存区间为(vaddr, vaddr + len), 类型为type的内存访问进行地址转换.
  • 中断异常相关
    • vaddr_t isa_raise_intr(word_t NO, vaddr_t epc);抛出一个号码为NO的异常, 其中epc为触发异常的指令PC, 返回异常处理的出口地址.
    • word_t isa_query_intr();查询当前是否有未处理的中断, 若有则返回中断号码, 否则返回INTR_EMPTY.
  • DiffTest相关
    • bool isa_difftest_checkregs(CPU_state *ref_r, vaddr_t pc);检查当前的寄存器状态是否与ref_r相同, 其中pc为cpu.pc的上一条动态指令的PC, 即cpu.pc的旧值. 如果状态相同, 则返回true, 否则返回false.
    • void isa_difftest_attach();将当前的所有状态同步到REF, 并在之后的执行中开启DiffTest.

取指(instruction fetch, IF)

  1. 在NEMU中, 有一个函数inst_fetch()(在nemu/include/cpu/ifetch.h中定义)专门负责取指令的工作.
  2. inst_fetch()最终会根据参数len来调用vaddr_ifetch()(在nemu/src/memory/vaddr.c中定义), 而目前vaddr_ifetch()又会通过paddr_read()来访问物理内存中的内容.
  • 取指操作的本质：一次内存的访存
  1. isa_exec_once()在调用inst_fetch()的时候传入了s->snpc的地址, 因此inst_fetch()最后还会根据len来更新s->snpc, 从而让s->snpc指向下一条指令.

译码(instruction decode, ID)

指令的具体操作

  • 代码进入decode_exec()函数, 它首先进行的是译码相关的操作
    • 译码的目的是得到指令的操作和操作对象, 这主要是通过查看指令的opcode来决定的
  • NEMU的译码方式：模式匹配, NEMU可以通过一个模式字符串来指定指令中opcode
  • riscv32中有如下模式:例子（auipc指令，是将当前PC值与立即数相加并写入寄存器）
1
2
3
4
INSTPAT_START();
INSTPAT("??????? ????? ????? ??? ????? 00101 11", auipc, U, R(rd) = s->pc + imm);
// ...
INSTPAT_END();
  • 其中INSTPAT(意思是instruction pattern)是一个宏(在nemu/include/cpu/decode.h中定义), 它用于定义一条模式匹配规则. 其格式如下:
1
INSTPAT(模式字符串, 指令名称, 指令类型, 指令执行操作);
  1. 模式字符串中只允许出现4种字符:
    1. 0表示相应的位只能匹配0
    2. 1表示相应的位只能匹配1
    3. ?表示相应的位可以匹配0或1
    4. 空格是分隔符, 只用于提升模式字符串的可读性, 不参与匹配
  2. 指令名称在代码中仅当注释使用, 不参与宏展开;
  3. 指令类型用于后续译码过程;
  4. 指令执行操作则是通过C代码来模拟指令执行的真正行为.
  • 此外, nemu/include/cpu/decode.h中还定义了宏INSTPAT_START和INSTPAT_END. INSTPAT又使用了另外两个宏INSTPAT_INST和INSTPAT_MATCH, 它们在nemu/src/isa/$ISA/inst.c中定义.
  • 对上述代码进行宏展开并简单整理代码之后, 最后将会得到: 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    { const void * __instpat_end = &&__instpat_end_;
    do {
    uint64_t key, mask, shift;
    pattern_decode("??????? ????? ????? ??? ????? 00101 11", 38, &key, &mask, &shift);
    if ((((uint64_t)s->isa.inst >> shift) & mask) == key) {
        {
        int rd = 0;
        word_t src1 = 0, src2 = 0, imm = 0;
        decode_operand(s, &rd, &src1, &src2, &imm, TYPE_U);
        R(rd) = s->pc + imm;
        }
        goto *(__instpat_end);
    }
    } while (0);
    // ...
    __instpat_end_: ; }
    • 上述代码中的&&__instpat_end_使用了GCC提供的标签地址扩展功能, goto语句将会跳转到最后的__instpat_end_标签.
    • pattern_decode()函数在nemu/include/cpu/decode.h中定义, 它用于将模式字符串转换成3个整型变量
      • pattern_decode()函数将模式字符串中的0和1抽取到整型变量key中, mask表示key的掩码, 而shift则表示opcode距离最低位的比特数量, 用于帮助编译器进行优化.
    • NEMU取指令的时候会把指令记录到s->isa.inst中, 此时指令满足上述宏展开的if语句, 表示匹配到auipc指令的编码, 因此将会进行进一步的译码操作.

指令的操作对象

  • eg:已知auipc是将当前PC值与立即数相加并写入寄存器, 但我们还是不知道操作对象(比如立即数是多少, 写入到哪个寄存器).
    • 调用decode_operand()函数来完成
  • decode_operand()函数
    • 会根据传入的指令类型type来进行操作数的译码,
    • 译码结果将记录到函数参数rd, src1, src2和imm中, 它们分别代表目的操作数的寄存器号码, 两个源操作数和立即数.
  • 为了进一步实现操作数译码和指令译码的解耦, 我们对这些操作数的译码进行了抽象封装:
    • 框架代码定义了src1R()和src2R()两个辅助宏, 用于寄存器的读取结果记录到相应的操作数变量中
    • 框架代码还定义了immI等辅助宏, 用于从指令中抽取出立即数
  • 例如RISC-V中I型指令的译码过程可以通过如下代码实现: 
    1
    case TYPE_I: src1R(); immI(); break;

立即数背后的故事

  • Motorola 68k系列的处理器都是大端架构的. 现在问题来了, 考虑以下两种情况:
    1. 假设我们需要将NEMU运行在Motorola 68k的机器上(把NEMU的源代码编译成Motorola 68k的机器码)
    2. 假设我们需要把Motorola 68k作为一个新的ISA加入到NEMU中
      在这两种情况下, 你需要注意些什么问题? 为什么会产生这些问题? 怎么解决它们?
      事实上不仅仅是立即数的访问, 长度大于1字节的内存访问都需要考虑类似的问题.
  1. 情况1：将NEMU运行在Motorola 68k的机器上
    • 问题
      1. 字节序问题
        • Motorola 68k是大端架构，而NEMU可能是为小端架构设计的。
        • 需要确保数据在内存中的存储顺序正确。
      2. 编译器和工具链
        • 需要使用支持Motorola 68k架构的编译器和工具链。
        • 可能需要修改Makefile或构建脚本以适应新的编译环境。
      3. 系统调用和库函数
        • 需要确保NEMU使用的系统调用和库函数在Motorola 68k平台上可用。
        • 可能需要对代码进行移植和适配。
    • 解决方案
      1. 字节序处理
        • 使用条件编译或宏定义来处理大端和小端的差异。
        • 例如：
        1
        2
        3
        4
        5
        #ifdef BIG_ENDIAN
        // 大端处理代码
        #else
        // 小端处理代码
        #endif
      2. 编译器和工具链
        • 安装并配置支持Motorola 68k的编译器和工具链。
        • 修改构建脚本以使用新的编译器。
      3. 系统调用和库函数
        • 检查并移植系统调用和库函数，确保它们在Motorola 68k平台上正常工作。
  2. 情况 2: 将Motorola 68k作为一个新的ISA加入到NEMU中
    • 问题+解决方案
      1. 指令集架构 (ISA) 支持
        • 需要在NEMU中添加对Motorola 68k指令集的支持。
        • 包括指令的译码、执行和模拟。
      2. 寄存器和内存模型
        • 需要定义Motorola 68k的寄存器和内存模型。
        • 确保模拟器能够正确处理寄存器和内存操作。
      3. 异常和中断处理
        • 需要实现Motorola 68k的异常和中断处理机制。
        • 确保模拟器能够正确模拟这些行为。

立即数背后的故事(2)

  • mips32和riscv32的指令长度只有32位, 因此它们不能像x86那样, 把C代码中的32位常数直接编码到一条指令中. 思考一下, mips32和riscv32应该如何解决这个问题?
    • MIPS32和RISC-V32通过组合使用两条指令和伪指令li来加载32位立即数。

执行(execute, EX)

  • 模式匹配规则中指定的指令执行操作
  • 译码的结果+C代码——模拟指令执行的真正行为
  • eg：如对于auipc指令
    • 由于译码阶段已经把U型立即数记录到操作数imm中了
    • 只需要通过R(rd) = s->pc + imm将立即数与当前PC值相加并写入目标寄存器中, 这样就完成了指令的执行.
  • 指令执行的阶段结束之后, decode_exec()函数将会返回0, 并一路返回到exec_once()函数中. 不过目前代码并没有使用这个返回值, 因此可以忽略它

更新PC

  • 更新PC：把s->dnpc赋值给cpu.pc

静态指令snpc和动态指令dnpc

  • 在程序分析领域中, 静态指令是指程序代码中的指令, 动态指令是指程序运行过程中的指令. 例如对于以下指令序列
1
2
3
100: jmp 102
101: add
102: xor
  • jmp指令的下一条静态指令是add指令, 而下一条动态指令则是xor指令.
  • snpc和dnpc的区别: snpc是下一条静态指令, 而dnpc是下一条动态指令
    • 对于顺序执行的指令, 它们的snpc和dnpc是一样的;
    • 对于跳转指令, snpc和dnpc就会有所不同, dnpc应该指向跳转目标的指令.
    • 显然, 我们应该使用s->dnpc来更新PC, 并且在指令执行的过程中正确地维护s->dnpc.

结构化程序设计

  • 如果指令集越复杂, 指令之间的共性特征就越多——Copy-Paste的话，维护难度很大！
    • 对于同一条指令的不同形式, 它们的执行阶段是相同的
    • 对于不同指令的同一种形式, 它们的译码阶段是相同的
    • 对于同一条指令同一种形式的不同操作数宽度
  • 一种好的做法是把译码, 执行和操作数宽度的相关代码分离开来, 实现解耦, 也就是在程序设计课上提到的结构化程序设计.

必做：RTFSC理解指令执行的过程

  • 请整理一条指令在NEMU中的执行过程
  1. 取指
    • 从内存中取出当前PC指向的指令
    • 更新PC，指向下一条指令 cpu.pc += 4;
  2. 译码
    • 解析指令的操作码&操作数
    • 根据指令类型和操作数，确定指令的具体操作
  3. 执行
    • 根据译码结果执行指令的具体操作
      • 对于算术运算指令，执行相应的算术运算
      • 对于跳转指令。计算跳转目标地址
  4. 访存
    • 如果指令需要访问内存（加载/存储指令）
  5. 写回
    • 将执行结果写回寄存器或内存
  6. 更新PC
    • 在指令执行完毕后，根据指令的类型和执行结果更新PC。
    • 对于顺序执行的指令，PC已经在取指阶段更新过了，这里不需要再次更新。
    • 对于跳转指令，PC需要更新为跳转目标地址。
    1
    cpu.pc = s->dnpc; // 将dnpc的值赋给cpu.pc，更新PC

运行第一个C程序

  • 开始实践啦！

必做：准备交叉编译环境

  • 准备相应的gcc和binutils, 才能正确地进行编译
  • riscv32(64)
    • apt-get install g++-riscv64-linux-gnu binutils-riscv64-linux-gnu
  1. 报错 /usr/riscv64-linux-gnu/include/gnu/stubs.h:8:11: fatal error: gnu/stubs-ilp32.h: No such file or directory
  2. 键入sudo code --no-sandbox --user-data-dir=/home/xiaoyao/.vscode-root /usr/riscv64-linux-gnu/include/gnu/stubs.h
  3. 修改
1
2
3
4
#if __WORDSIZE == 32 && defined __riscv_float_abi_soft
-# include <gnu/stubs-ilp32.h>
+//# include <gnu/stubs-ilp32.h>
 #endif
  1. 报错
1
2
3
4
5
+ OBJCOPY -> build/dummy-riscv32-nemu.bin
/bin/sh: 1: python: not found
make[1]: *** [/home/xiaoyao/ics2024/abstract-machine/scripts/platform/nemu.mk:22：insert-arg] 错误 127
test list [1 item(s)]: dummy
[         dummy] ***FAIL***
  1. 检查python3已安装，则创建python命令的符号链接sudo ln -s /usr/bin/python3 /usr/bin/python
    • python --version确保可用后，重新运行
  2. 输入c,报错
    • 这是因为你还没有实现0x00000413的指令, 因此, 你需要开始在NEMU中添加指令了.
为什么执行了未实现指令会出现上述报错信息

  • RTFSC, 理解执行未实现指令的时候, NEMU具体会怎么做.

  • 因为NEMU在执行指令时，会检查指令是否已实现。如果指令未实现，NEMU会触发异常并输出错误信息。

  • 查看反汇编结果am-kernels/tests/cpu-tests/build/dummy-$ISA-nemu.txt

    • 你只需实现那些目前还没实现的指令
    • 为了实现一条新指令, 你只需要在nemu/src/isa/$ISA/inst.c中添加正确的模式匹配规则即可

必做：运行第一个客户程序

  • 在NEMU中实现上文提到的指令, 具体细节请务必参考手册. 实现成功后, 在NEMU中运行客户程序dummy, 你将会看到HIT GOOD TRAP的信息. 如果你没有看到这一信息, 说明你的指令实现不正确, 你可以使用PA1中实现的简易调试器帮助你调试.
  • li是一个伪指令，在riscv32里面汇编器会将它替换为lui和/或addi
    • 根据func3字段判断,这里其实是要实现addi指令
1
INSTPAT("??????? ????? ????? ??? ????? 00100 11", li     , I, R(rd) = imm);
  • jal
    1. 添加TYPE_J
    2. #define immJ() do { *imm = (SEXT(BITS(i, 31, 31), 1) << 20) | BITS(i, 30, 21) << 1| BITS(i, 20, 20) << 11 | BITS(i, 19, 12) << 12 ; } while(0)
    3. case TYPE_J: immJ(); break; // 新增 J 类型
1
INSTPAT("??????? ????? ????? ??? ????? 11011 11", jal    , J, R(rd) = s -> pc + 4; s -> dnpc += imm -4;); // jal指令
  • sw
1
INSTPAT("??????? ????? ????? 010 ????? 01000 11", sw     , S, Mw(src1 + imm, 4, src2)); // 新增 sw 指令
  • src/cpu/cpu-exec.c:126 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000030成功！

运行更多的程序

  • 测试用例：am-kernels/tests/cpu-tests/
    • 在该目录下执行make ARCH=$ISA-nemu ALL=xxx run
      • 其中xxx为测试用例的名称(不包含.c后缀).

必做：实现更多的指令

1. add.c
  1. lw
    0x80000078: 00 0a a9 03 lw s2, 0(s5)
  • INSTPAT("??????? ????? ????? 010 ????? 00000 11", lw , I, R(rd) = Mr(src1 + imm, 4));
  1. add
    0x80000090: 00 a9 05 33 add a0, s2, a0
  • INSTPAT("0000000 ????? ????? 000 ????? 01100 11", add , R, R(rd) = src1 + src2);
  1. sub
    0x80000094: 40 f5 05 33 sub a0, a0, a5
  • INSTPAT("0100000 ????? ????? 000 ????? 01100 11", sub , R, R(rd) = src1 - src2);
  1. seqz：0x80000098: 00 15 35 13 seqz a0, a0
    • 此伪指令的实现原理为，使用SLTIU指令，并将立即数设置为1；此时只有当rs1寄存器值为0时，才能小于立即数，rd寄存器才会被赋值为1：
  • INSTPAT("??????? ????? ????? 011 ????? 00100 11", seqz , I, R(rd) = (uint32_t)src1 < (uint32_t)imm ? 1: 0);
  1. beqz：0x80000010: 00 05 04 63 beqz a0, 8
    • 伪指令，可用beq指令来实现
    • INSTPAT("??????? ????? ????? 000 ????? 11000 11", beqz , B, if (src1 == src2) s->dnpc = s->pc + imm);
    • #define immB() do { *imm = (SEXT(BITS(i, 31, 31), 1) << 12) | (BITS(i, 7, 7) << 11) | (BITS(i, 30, 25) << 5) | (BITS(i, 11, 8) << 1); } while(0)
  2. bne:0x800000a4: fe 89 90 e3 bne s3, s0, -0x20
    • INSTPAT("??????? ????? ????? 001 ????? 11000 11", bne , B, if (src1 != src2) s->dnpc = s->pc + imm);
    • bne，比较两个寄存器的值，如果它们不相等，则跳转到目标地址
  • HIT GOOD TRAP at pc = 0x80000120,add.c成功！
2. add—longlong.c
  1. sltu:0x800000a0: 01 97 b6 b3 sltu a3, a5, s9
    • INSTPAT("0000000 ????? ????? 011 ????? 01100 11", sltu , R, R(rd) = (uint32_t)src1 < (uint32_t)src2 ? 1: 0);
    • sltu，无符号比较两个寄存器的值，如果第一个寄存器的值小于第二个，则将目标寄存器设置为 1，否则设置为 0
  2. xor:0x800000ac: 00 f5 45 33 xor a0, a0, a5
    • INSTPAT("0000000 ????? ????? 100 ????? 01100 11", xor , R, R(rd) = src1 ^ src2);
    • xor，异或运算，将两个寄存器的值进行异或运算，结果存入目标寄存器
  3. or:0x800000b4: 00 f5 65 33 or a0, a0, a5
    • INSTPAT("0000000 ????? ????? 110 ????? 01100 11", or , R, R(rd) = src1 | src2);
    • or，或运算，将两个寄存器的值进行或运算，结果存入目标寄存器
  • HIT GOOD TRAP at pc = 0x80000138,成功！
3. bit.c
  1. sh:0x800000bc: 00 f1 16 23 sh a5, 0xc(sp)
    • INSTPAT("??????? ????? ????? 001 ????? 01000 11", sh , S, Mw(src1 + imm, 2, src2));
    • sh,将src2的低16位存入src1+imm地址
  2. srai:0x80000028: 40 35 d7 93 srai a5, a1, 3
    • INSTPAT("0100000 ????? ????? 101 ????? 00100 11", srai , I, R(rd) = (int32_t)src1 >> (imm & 0x1F));
    • srai,算术右移，将src1的值右移imm位，空位用src1的符号位填充，结果存入rd
  3. andi:0x80000034: 00 75 f5 93 andi a1, a1, 7
    • INSTPAT("??????? ????? ????? 111 ????? 00100 11", andi , I, R(rd) = src1 & imm);
    • andi,与立即数，将src1的值与imm进行与运算，结果存入rd
  4. sll:0x8000003c: 00 b7 97 b3 sll a5, a5, a1
    • INSTPAT("0000000 ????? ????? 001 ????? 01100 11", sll , R, R(rd) = src1 << (src2 & 0x1F));
    • sll,逻辑左移，将src1的值左移src2位，空位用0填充，结果存入rd
  5. and：
    • INSTPAT("0000000 ????? ????? 111 ????? 01100 11", and , R, R(rd) = src1 & src2);
    • and,与运算，将src1的值与src2的值进行与运算，结果存入rd
  6. xori:
    • INSTPAT("??????? ????? ????? 100 ????? 00100 11", xori , I, R(rd) = src1 ^ imm);
    • xori,异或立即数，将src1的值与imm进行异或运算，结果存入rd
  • HIT GOOD TRAP at pc = 0x8000021c成功！
4. bubble-sort.c
  1. blez:0x80000040: 02 b0 50 63 blez a1, 0x20
    • INSTPAT("??????? ????? ????? 101 ????? 11000 11", blez , B, if (src1 >= src2) s->dnpc +=imm-4);
    • blez,伪指令可用bgz,当寄存器的值小于等于0时跳转，可用bgez指令实现
  • HIT GOOD TRAP at pc = 0x80000140成功！
5. crc32.c
  • 看tests/cpu-tests/build/crc32-riscv32-nemu.txt
  1. lui:0x80000038: ed b8 88 b7 lui a7, 0xedb88
    • INSTPAT("??????? ????? ????? ??? ????? 01101 11", lui , U, R(rd) = imm);
    • lui,将imm的值左移12位存入rd
  2. srli:0x8000005c: 00 17 d7 93 srli a5, a5, 1
    • INSTPAT("0000000 ????? ????? 101 ????? 00100 11", srli , I, R(rd) = (uint32_t)src1 >> (imm & 0x1F));
    • srli,逻辑右移，将src1的值右移imm位，空位用0填充，结果存入rd
  3. bgeu:8000008c: 02c5fc63 bgeu a1,a2,800000c4 <rc_crc32+0x9c>
    • INSTPAT("??????? ????? ????? 111 ????? 11000 11", bgeu , B, if ((uint32_t)src1 >= (uint32_t)src2) s->dnpc = s->pc + imm);
    • bgeu，无符号比较两个寄存器的值，如果第一个寄存器的值大于等于第二个，则跳转到目标地址
  4. slli:800000a8: 00279793 slli a5,a5,0x2
    • INSTPAT("0000000 ????? ????? 001 ????? 00100 11", slli , I, R(rd) = src1 << (imm & 0x1F));
  • slli,逻辑左移，将src1的值左移imm位，空位用0填充，结果存入rd
  • HIT GOOD TRAP at pc = 0x8000012c成功！
6. div.c
  • tests/cpu-tests/build/div-riscv32-nemu.txt
  1. mul:8000007c: 02f70733 mul a4,a4,a5
    • INSTPAT("0000001 ????? ????? 000 ????? 01100 11", mul , R, R(rd) = src1 * src2);
  2. div:800000a8: 02f74733 div a4,a4,a5
    • INSTPAT("0000001 ????? ????? 100 ????? 01100 11", div , R, R(rd) = (int32_t)src1 / (int32_t)src2);
  • HIT GOOD TRAP at pc = 0x80000124成功！
7. fact.c+fib.c
  • 直接HIT GOOD TRAP了
8. goldbach.c
  1. rem:8000007c: 02f666b3 rem a3,a2,a5
    • INSTPAT("0000001 ????? ????? 110 ????? 01100 11", rem , R, R(rd) = (int32_t)src1 % (int32_t)src2);
    • 求余
  • HIT GOOD TRAP at pc = 0x80000118成功
9. if-else.c
  1. blt:80000080: 02f94063 blt s2,a5,800000a0 <main+0x78>
    • INSTPAT("??????? ????? ????? 100 ????? 11000 11", blt , B, if ((int32_t)src1 <(int32_t)src2) s->dnpc += imm-4);
    • blt,比较两个寄存器的值，如果第一个小于第二个，则跳转到目标地址
  2. slt:80000084: 00fa2733 slt a4,s4,a5
    • INSTPAT("0000000 ????? ????? 010 ????? 01100 11", slt , R, R(rd) = (int32_t)src1 < (int32_t)src2 ? 1 : 0);
    • slt,有符号比较两个寄存器的值，如果第一个寄存器的值小于第二个，则将目标寄存器设置为 1，否则设置为 0
  • HIT GOOD TRAP at pc = 0x80000110成功！
10. leap-year.c+load-store.c
  • HIT GOOD TRAP at pc = 0x800000dc
  1. lh:80000064: 00049503 lh a0,0(s1)
    • INSTPAT("??????? ????? ????? 001 ????? 00000 11", lh , I, R(rd) = SEXT(Mr(src1 + imm, 2), 16));
    • lh,将src1+imm地址的值的低16位存入rd
  2. lhu:8000008c: 00045503 lhu a0,0(s0)
    • INSTPAT("??????? ????? ????? 101 ????? 00000 11", lhu , I, R(rd) = Mr(src1 + imm, 2));
    • lhu,将src1+imm地址的值存入rd
  • HIT GOOD TRAP at pc = 0x800001ec
11. matrix-mul.c+max.c
  • HIT GOOD TRAP at pc = 0x8000015c
  • 出错：0x8000008c: 01 25 54 63 bge a0, s2, 8
  • bge：INSTPAT("??????? ????? ????? 101 ????? 11000 11", blez , B, if ((int)src1 >= (int)src2) s->dnpc +=imm-4);
    • 无符号改成有符号（加上（int））！
  • HIT GOOD TRAP at pc = 0x80000124
12. mersenne.c
  1. mulh:80000098: 02f795b3 mulh a1,a5,a5
    • INSTPAT("0000001 ????? ????? 001 ????? 01100 11", mulh , R, R(rd) = ((int64_t)src1 * (int64_t)src2) >> 32);
  2. remu:8000018c: 02c577b3 remu a5,a0,a2
    • INSTPAT("0000001 ????? ????? 111 ????? 01100 11", remu , R, R(rd) = (uint32_t)src1 % (uint32_t)src2);
    • remu,无符号数，求余数
  3. divu:80000198: 03695533 divu a0,s2,s6
    • INSTPAT("0000001 ????? ????? 101 ????? 01100 11", divu , R, R(rd) = (uint32_t)src1 / (uint32_t)src2);
  • HIT GOOD TRAP at pc = 0x80000144
13. min3.c+mov-c.c+movsx.c+mul-longlong.c
  • HIT GOOD TRAP at pc = 0x80000170
  • HIT GOOD TRAP at pc = 0x80000124
  • HIT GOOD TRAP at pc = 0x800001d0
  • HIT BAD TRAP at pc = 0x80000140!!
  • mul有问题，改： INSTPAT("0000001 ????? ????? 001 ????? 01100 11", mulh , R, int32_t a1 = src1; int32_t a2 = src2; int64_t tmp = (int64_t)a1 * (int64_t)a2; R(rd) = BITS(tmp, 63, 32));
  • 为什么原方法不对：
    1. 符号扩展问题：
      • src1 和 src2 被直接转换为 int64_t 类型。如果 src1 和 src2 是负数，符号扩展可能会导致错误的结果。
      • 通过将 src1 和 src2 显式转换为 int32_t 类型，然后再转换为 int64_t 类型，确保了符号扩展的正确性。
    2. 位移操作的行为：
      • 若乘积直接右移 32 位。如果乘积是负数，右移操作可能会保留符号位，导致错误的结果。
      • 而通过使用 BITS 宏提取特定位数，确保了结果的正确性。
14. pascal.c + prime.c + quick-sort.c + recursion.c + select-sort.c + shuixianhua.c
  • HIT GOOD TRAP at pc = 0x80000128
  • HIT GOOD TRAP at pc = 0x800000dc
  • HIT GOOD TRAP at pc = 0x800003cc
  • HIT GOOD TRAP at pc = 0x8000026c
  • HIT GOOD TRAP at pc = 0x8000015c
  • HIT GOOD TRAP at pc = 0x8000011c
15. shift.c
  1. sra:800000a8: 40855533 sra a0,a0,s0
    • INSTPAT("0100000 ????? ????? 101 ????? 01100 11", sra , R, R(rd) = (int32_t)src1 >> (src2 & 0x1F));
    • sra,算术右移，将src1的值右移src2位，空位用src1的符号位填充，结果存入rd
  2. srl:800000e0: 00855533 srl a0,a0,s0
    • INSTPAT("0000000 ????? ????? 101 ????? 01100 11", srl , R, R(rd) = (uint32_t)src1 >> (src2 & 0x1F));
    • srl,逻辑右移，将src1的值右移src2位，空位用0填充，结果存入rd
  • HIT GOOD TRAP at pc = 0x80000144
16. sub-longlong.c + sum.c + switch.c + to-lower-case.c + unalign.c + wanshu.c
  • HIT GOOD TRAP at pc = 0x80000138
  • HIT GOOD TRAP at pc = 0x8000009c
  1. bltu:80000070: 009a6463 bltu s4,s1,80000078 <main+0x50>
    • INSTPAT("??????? ????? ????? 110 ????? 11000 11", bltu , B, if ((uint32_t)src1 < (uint32_t)src2) s->dnpc = s->pc + imm);
    • bltu，无符号比较两个寄存器的值，如果第一个寄存器的值小于第二个，则跳转到目标地址
  • HIT GOOD TRAP at pc = 0x800000e8
  • HIT GOOD TRAP at pc = 0x800000d4
  • HIT GOOD TRAP at pc = 0x80000144
  • HIT GOOD TRAP at pc = 0x80000104
ps:hello-str.c和string.c
  • 还需要实现额外的内容才能运行(具体在后续小节介绍), 目前可以先使用其它测试用例进行测试.

mips32的分支延迟槽

  • 为了提升处理器的性能, mips使用了一种叫分支延迟槽的技术。
  • 程序的执行顺序发生一些改变:
    • 把紧跟在跳转指令(包括有条件和无条件)之后的静态指令称为延迟槽
    • 那么程序在执行完跳转指令后, 会先执行延迟槽中的指令, 再执行位于跳转目标的指令。
  • 延迟槽技术需要软硬件协同才能正确工作: mips手册中描述了这一约定, 处理器设计者按照这一约定设计处理器, 而编译器开发者则会让编译器负责在延迟槽中放置一条有意义的指令, 使得无论是否跳转, 按照这一约定的执行顺序都能得到正确的执行结果.
  • 如果你是编译器开发者, 你将会如何寻找合适的指令放到延迟槽中呢?
    1. 尽量选择不会影响程序逻辑的无副作用的指令
    2. 选择与跳转指令无关的独立的指令，即不依赖于跳转指令的结果，也不影响跳转目标的执行。
    3. 将原本在跳转目标处执行的指令提前到延迟槽中执行，可以减少跳转目标处的指令数量，提升性能

指令名对照

  • AT&T格式反汇编结果中的少量指令, 与手册中列出的指令名称不符, 如x86的cltd, mips32和riscv32则有不少伪指令(pseudo instruction). 除了STFW之外, 你有办法在手册中找到对应的指令吗? 如果有的话, 为什么这个办法是有效的呢?
  • 办法：
  1. 获取指令的机器码
    • 使用反汇编工具获取指令的机器码。
  2. 查找操作码和功能码
    • 从机器码中提取操作码和功能码。
    • 对于RISC-V指令，可以提取操作码（opcode）、功能码（funct3）和功能码（funct7）。
  3. 查阅手册
    • 然后在指令手册中查找对应的操作码和功能码。
  • 为什么有效：
    1. 唯一性：每条指令在机器码级别都有唯一的编码，通过操作码和功能码可以唯一确定一条指令。
    2. 标准化：指令手册中提供了详细的指令编码表和描述，通过这些表可以准确地找到指令的定义。
    3. 准确性：相比于直接搜索指令名称，通过操作码和功能码查找指令可以避免名称不一致的问题，确保查找结果的准确性。

PA2.1结束

程序, 运行时环境与AM

运行时环境

  • “并不是每一个程序都可以在NEMU中运行”背后的缘由：
    • 应用程序的运行都需要运行时环境的支持, 包括加载, 销毁程序, 以及提供程序运行时的各种动态链接库(你经常使用的库函数就是运行时环境提供的)等
  • 要提供相应的运行时环境的支持了！
  • 为了运行最简单的程序, 我们需要提供什么呢? 其实答案已经在PA1中了:
    • 只要把程序放在正确的内存位置, 然后让PC指向第一条指令, 计算机就会自动执行这个程序, 永不停止.
  • so：只要有内存, 有结束运行的方式, 加上实现正确的指令, 就可以支撑最简单程序的运行了

将运行时环境封装成库函数

  • 我们只需要定义一个结束程序的API, 比如void halt(), 它对不同架构上程序的不同结束方式进行了抽象: 程序只要调用halt()就可以结束运行, 而不需要关心自己运行在哪一个架构上.
  • 运行时环境的一种普遍的存在方式: 库
  • 通过库, 运行程序所需要的公共要素被抽象成API, 不同的架构只需要实现这些API, 也就相当于实现了支撑程序运行的运行时环境, 这提升了程序开发的效率: 需要的时候只要调用这些API, 就能使用运行时环境提供的相应功能.

思考：这又能怎么样呢

  • 思考一下, 这样的抽象还会带来哪些好处呢? 你很快就会体会到这些好处了.
  1. 代码复用
    • 通过定义统一的API，可以在不同的架构上复用相同的程序代码。只需要为每个架构实现对应的API，而不需要为每个程序和每个架构分别编写代码。
  2. 简化维护
    • 维护n个程序和m个架构相关的API实现，只需要维护n+m份代码，而不是n*m份代码。
  3. 提高开发效率
    • 只需要关注程序逻辑，而不需要关心底层架构的具体实现。
  4. 增强了程序的可移植性

AM - 裸机(bare-metal)运行时环境

  • 只进行纯粹计算任务的程序在TRM上就可以运行, 更复杂的应用程序对运行时环境必定还有其它的需求
    • eg：超级玛丽需要和用户进行交互
  • 如果我们把这些需求都收集起来, 将它们抽象成统一的API提供给程序, 这样我们就得到了一个可以支撑各种程序运行在各种架构上的库了!
    • 每个架构都按照它们的特性实现这组API
    • 应用程序只需要直接调用这组API即可, 无需关心自己将来运行在哪个架构上.
  • 这组API被称为抽象计算机，即AM(Abstract machine)
  • AM根据程序的需求把库划分成以下模块: 
    1
    AM = TRM + IOE + CTE + VME + MPE
    • TRM(Turing Machine) - 图灵机, 最简单的运行时环境, 为程序提供基本的计算能力
    • IOE(I/O Extension) - 输入输出扩展, 为程序提供输出输入的能力
    • CTE(Context Extension) - 上下文扩展, 为程序提供上下文管理的能力
    • VME(Virtual Memory Extension) - 虚存扩展, 为程序提供虚存管理的能力
    • MPE(Multi-Processor Extension) - 多处理器扩展, 为程序提供多处理器通信的能力 (MPE超出了ICS课程的范围, 在PA中不会涉及)
1
2
(在NEMU中)实现硬件功能 -> (在AM中)提供运行时环境 -> (在APP层)运行程序
(在NEMU中)实现更强大的硬件功能 -> (在AM中)提供更丰富的运行时环境 -> (在APP层)运行更复杂的程序

思考:为什么要有AM? (建议二周目思考)

  • 操作系统也有自己的运行时环境. AM和操作系统提供的运行时环境有什么不同呢? 为什么会有这些不同?
  • 不同：
    1. 抽象层次：
      • AM：主要关注于硬件抽象，提供基本的硬件功能抽象，如上下文管理、虚存管理、多处理器通信等。它直接运行在硬件之上，提供一个简化的、统一的硬件接口。
      • 操作系统：提供更高层次的抽象，包括进程管理、文件系统、网络通信、安全机制等。操作系统不仅抽象硬件，还管理系统资源，提供丰富的系统服务。
    2. 功能范围
      • AM：功能相对简单，主要提供硬件抽象和基本的运行时环境。
      • 操作系统：功能丰富，提供全面的系统服务和资源管理，包括内存管理、进程调度、文件系统、网络堆栈等。
    3. 目标和用途
      • AM：主要用于简化应用程序的开发和移植，使得应用程序可以在不同的硬件平台上运行。它通常用于嵌入式系统、模拟器和教学环境中。
      • 操作系统：主要用于管理计算机系统的资源，提供稳定和高效的运行环境。它用于通用计算平台，如桌面计算机、服务器和移动设备。
  • 为什么会有这些不同：
    1. 设计目标
      • AM：设计目标是提供一个统一的硬件抽象层，简化应用程序的开发和移植。因此，它的功能范围相对简单，主要关注于硬件抽象。
      • 操作系统：设计目标是管理系统资源，提供丰富的系统服务，确保系统的稳定性和高效性。因此，它的功能范围广泛，涉及资源管理和系统服务。
    2. 复杂性和性能要求
      • AM：由于功能简单，AM的实现相对简单，性能开销较小。它适用于对性能要求高、资源有限的环境。
      • 操作系统：由于功能丰富，操作系统的实现复杂，性能开销较大。它适用于通用计算平台，提供全面的系统服务。
    3. 应用场景不同
      • AM：适用于嵌入式系统、模拟器和教学环境，提供一个简化的硬件抽象层，方便应用程序的开发和移植。
      • 操作系统：适用于通用计算平台，提供全面的系统服务和资源管理，确保系统的稳定性和高效性。

RTFSC(3)

  • AM的子项目abstract-machine
  • 整个AM项目分为两大部分:
    • abstract-machine/am/ - 不同架构的AM API实现, 目前我们只需要关注NEMU相关的内容即可. 此外, abstract-machine/am/include/am.h列出了AM中的所有API, 我们会在后续逐一介绍它们.
    • abstract-machine/klib/ - 一些架构无关的库函数, 方便应用程序的开发
  • TRM的API：
    • Area heap结构用于指示堆区的起始和末尾
    • void putch(char ch)用于输出一个字符
    • void halt(int code)用于结束程序的运行
    • void _trm_init()用于进行TRM相关的初始化工作
  • 堆区是给程序自由使用的一段内存区间, 为程序提供动态分配内存的功能.
  • halt()里面调用了nemu_trap()宏 (在abstract-machine/am/src/platform/nemu/include/nemu.h中定义), 这个宏展开之后是一条内联汇编语句. 内联汇编语句允许我们在C代码中嵌入汇编语句, 以riscv32为例, 宏展开之后将会得到:asm volatile("mv a0, %0; ebreak" : :"r"(code));
    • 正是那条特殊的nemu_trap
  • am-kernels子项目用于收录一些可以在AM上运行的测试集和简单程序
  • 在让NEMU运行客户程序之前, 我们需要将客户程序的代码编译成可执行文件
    • 不能使用gcc的默认选项直接编译
      • 默认选项会根据GNU/Linux的运行时环境将代码编译成运行在GNU/Linux下的可执行文件,但此时的NEMU并不能为客户程序提供GNU/Linux的运行时环境
    • 使用交叉编译
      • 需要在GNU/Linux下根据AM的运行时环境编译出能够在$ISA-nemu这个新环境中运行的可执行文件
      • 为了不让链接器ld使用默认的方式链接, 我们还需要提供描述$ISA-nemu的运行时环境的链接脚本
  • 交叉编译生成一个可以在NEMU的运行时环境上运行的程序的过程大致如下:
    • gcc将$ISA-nemu的AM实现源文件编译成目标文件, 然后通过ar将这些目标文件作为一个库, 打包成一个归档文件abstract-machine/am/build/am-$ISA-nemu.a
    • gcc把应用程序源文件(如am-kernels/tests/cpu-tests/tests/dummy.c)编译成目标文件
    • 通过gcc和ar把程序依赖的运行库(如abstract-machine/klib/)也编译并打包成归档文件
    • 根据Makefile文件abstract-machine/scripts/$ISA-nemu.mk中的指示, 让ld根据链接脚本abstract-machine/scripts/linker.ld, 将上述目标文件和归档文件链接成可执行文件
  • 对编译得到的可执行文件的行为进行简单的梳理:
    1. 第一条指令从abstract-machine/am/src/$ISA/nemu/start.S开始, 设置好栈顶之后就跳转到abstract-machine/am/src/platform/nemu/trm.c的_trm_init()函数处执行.
    2. 在_trm_init()中调用main()函数执行程序的主体功能, main()函数还带一个参数, 目前我们暂时不会用到, 后面我们再介绍它.
    3. 从main()函数返回后, 调用halt()结束运行.

必做：阅读Makefile

  • abstract-machine项目的Makefile设计得非常巧妙, 你需要把它们看成一种代码来RTFSC, 从而理解它们是如何工作的. 这样一来, 你就知道怎么编写有一定质量的Makefile了; 同时, 如果哪天Makefile出现了非预期的行为, 你就可以尝试对Makefile进行调试了. 当然, 这少不了RTFM.
  1. 基本设置和检查
    • 默认目标：如果没有指定目标，默认构建image。
    • 环境变量检查：确保$AM_HOME和$ARCH环境变量设置正确。
    • 提取架构和平台：从$ARCH中提取指令集架构（ISA）和平台。
    • 检查源文件：确保有源文件可供构建。
  2. 通用编译目标
    • 创建目标目录：在build/$ARCH目录下创建构建输出目录。
    • 编译目标：定义生成的二进制镜像或归档文件的路径。
    • 收集链接文件：收集所有需要链接的对象文件和库文件。
  3. 通用编译标志
    • 编译器和工具链：定义交叉编译工具链的路径。
    • 编译标志：设置编译标志，包括包含路径、架构定义和优化选项。
  4. 架构特定配置
    • 包含架构特定配置：从scripts/$(ARCH).mk文件中包含架构特定的配置。
  5. 编译规则
    • 编译规则：定义如何从.c、.cc、.cpp和.S文件生成对象文件。
    • 递归构建库：递归调用 Makefile 构建依赖库。
    • 链接规则：定义如何从对象文件和库文件生成最终的 ELF 二进制文件。
    • 归档规则：定义如何从对象文件生成归档文件（.a）。
    • 依赖文件：包含由 gcc 生成的依赖文件（.d）。
  6. 杂项
    • 构建顺序控制：定义构建顺序，确保依赖关系正确。
    • 清理规则：定义清理单个项目和所有子项目的规则。

必做：通过批处理模式运行NEMU

1
2
3
4
5
我们知道, 大部分同学很可能会这么想: 反正我不阅读Makefile, 老师助教也不知道, 总觉得不看也无所谓.

所以在这里我们加一道必做题: 我们之前启动NEMU的时候, 每次都需要手动键入c才能运行客户程序. 但如果不是为了使用NEMU中的sdb, 我们其实可以节省c的键入. NEMU中实现了一个批处理模式, 可以在启动NEMU之后直接运行客户程序. 请你阅读NEMU的代码并合适地修改Makefile, 使得通过AM的Makefile可以默认启动批处理模式的NEMU.

你现在仍然可以跳过这道必做题, 但很快你就会感到不那么方便了.
  • 看nemu的代码: 
    1
    2
    3
    4
    5
    6
    7
    8
    void sdb_mainloop(){
        //检查是否处于批处理模式
        if(is_batch_mode){
            cmd_c(NULL);
            return;
        }
        ......//其它代码
    }
    • 进入sdb循环前要进行is_batch_mode的判断，为true，就会自动执行cmd_c函数，且不会进入sdb循环
  • 所以使is_batch_mode=true,而nemu提供了sdb_set_batch_mode()函数,应该调用它。
1
case 'b':sdb_set_batch_mode();break;
  • 所以：在运行NEMU时传入参数b即可。
  • 添加NEMUFLAGS += -b -l $(shell dirname $(IMAGE).elf)/nemu-log.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
### Compilation flags
INC_PATH += $(WORK_DIR)/include $(addsuffix /include/, $(addprefix $(AM_HOME)/, $(LIBS)))
INCFLAGS += $(addprefix -I, $(INC_PATH))

ARCH_H := arch/$(ARCH).h
CFLAGS   += -O2 -MMD -Wall -Werror $(INCFLAGS) \
            -D__ISA__=\"$(ISA)\" -D__ISA_$(shell echo $(ISA) | tr a-z A-Z)__ \
            -D__ARCH__=$(ARCH) -D__ARCH_$(shell echo $(ARCH) | tr a-z A-Z | tr - _) \
            -D__PLATFORM__=$(PLATFORM) -D__PLATFORM_$(shell echo $(PLATFORM) | tr a-z A-Z | tr - _) \
            -DARCH_H=\"$(ARCH_H)\" \
            -fno-asynchronous-unwind-tables -fno-builtin -fno-stack-protector \
            -Wno-main -U_FORTIFY_SOURCE -fvisibility=hidden
CXXFLAGS +=  $(CFLAGS) -ffreestanding -fno-rtti -fno-exceptions
ASFLAGS  += -MMD $(INCFLAGS)
LDFLAGS  += -z noexecstack $(addprefix -T, $(LDSCRIPTS))
NEMUFLAGS += -b -l $(shell dirname $(IMAGE).elf)/nemu-log.txt

实现常用的库函数

  • 把运行时环境分成两部分:
    1. 一部分是架构相关的运行时环境, 也就是我们之前介绍的AM
    2. 另一部分是架构无关的运行时环境, 类似memcpy()这种常用的函数应该归入这部分, abstract-machine/klib/用于收录这些架构无关的库函数.
      • klib是kernel library的意思, 用于提供一些兼容libc的基础功能.
  • 框架代码在abstract-machine/klib/src/string.c和abstract-machine/klib/src/stdio.c中列出了将来可能会用到的库函数, 但并没有提供相应的实现.

必做：实现字符串处理函数

  • 根据需要实现abstract-machine/klib/src/string.c中列出的字符串处理函数, 让cpu-tests中的测试用例string可以成功运行. 关于这些库函数的具体行为, 请务必RTFM.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#include <klib.h>
#include <klib-macros.h>
#include <stdint.h>

#if !defined(__ISA_NATIVE__) || defined(__NATIVE_USE_KLIB__)

//计算字符串长度
size_t strlen(const char *s) {
  if (s == NULL) {
    return 0;
  }
  size_t n = 0;
  while(s[n] != '\0') {
    n++;
  }
  return n;
}

//复制字符串
char *strcpy(char *dst, const char *src) {
  if (src == NULL) {
    return NULL;
  }
  char *ret = dst;
  while ((*dst++ = *src++) != '\0');
  return ret;
}

//复制一定长度的字符串
char *strncpy(char *dst, const char *src, size_t n) {
  char *ret = dst;
  while(n&&(*dst++ = *src++) != '\0') {
    n--;
  }
  while(n--) {
    *dst++ = '\0';
  }
  return ret;
}

//将源字符串连接到目标字符串的末尾
char *strcat(char *dst, const char *src) {
  char *ret = dst;
  while(*dst != '\0') {
    dst++;
  }
  while((*dst++ = *src++) != '\0');
  return ret;
}

//比较字符串,返回差值
int strcmp(const char *s1, const char *s2) {
  while(*s1&& *s1 == *s2) {
    s1++;
    s2++;
  }
  return *(unsigned char *)s1 - *(unsigned char *)s2;
}

//比较字符串的前n个字符,返回差值
int strncmp(const char *s1, const char *s2, size_t n) {
  while(n!=0 && *s1 && *s1 == *s2) {
    n--;
    s1++;
    s2++;
  }
  if(n == 0) {
    return 0;
  }else {
    return *(unsigned char *)s1 - *(unsigned char *)s2;
  }
}

//将内存块的前n个字节设置为指定的值
void *memset(void *s, int c, size_t n) {
  //使用unsigned char类型指针遍历内存块，并将每个字节设置为c
  unsigned char *p = (unsigned char *)s;
  while(n--) {
    *p++ = (unsigned char)c;
  }
  return s;
}

//安全地移动内存块，处理源和目标内存区域重叠的情况
void *memmove(void *dst, const void *src, size_t n) {
  unsigned char *d = (unsigned char *)dst;
  const unsigned char *s = (const unsigned char *)src;
  if(d < s) {//如果目标地址小于源地址，从前往后复制。
    while(n--) {
      *d++ = *s++;
    }
  }else {//如果目标地址大于源地址，从后往前复制
    const unsigned char *lasts = s + (n - 1);
    unsigned char *lastd = d + (n - 1);
    while(n--) {
      *lastd-- = *lasts--;
    }
  }
  return dst;
}

//将内存块的前n个字节从源复制到目标
void *memcpy(void *out, const void *in, size_t n) {
  unsigned char *dst = (unsigned char *)out;
  const unsigned char *src = (const unsigned char *)in;
  while(n--) {
    *dst++ = *src++;
  }
  return out;
}

//逐字节比较两个内存块的前n个字节，返回它们的差值
int memcmp(const void *s1, const void *s2, size_t n) {
  const unsigned char *p1 = (const unsigned char *)s1;
  const unsigned char *p2 = (const unsigned char *)s2;
  while(n--) {//使用unsigned char类型指针遍历两个内存块，并比较每个字节
    if(*p1 != *p2) {//如果发现不同的字节，返回差值
      return *p1 - *p2;
    }
    p1++;
    p2++;
  }//所有字节都相同，返回0
  return 0;
}

#endif

实现sprintf

  • 实现abstract-machine/klib/src/stdio.c中的sprintf(), 具体行为可以参考man 3 printf. 目前你只需要实现%s和%d就能通过hello-str的测试了, 其它功能(包括位宽, 精度等)可以在将来需要的时候再自行实现.
  • 和其它库函数相比, sprintf()比较特殊, 因为它的参数数目是可变的. 为了获得数目可变的参数, 你可以使用C库stdarg.h中提供的宏, 具体用法请查阅man stdarg.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
//（辅助）将整数转换为字符串
static void itoa(int num,char *str){
  char *p = str;
  if(num == 0){//为0
    *p++ = '0';
    *p = '\0';
    return;
  }
  if(num < 0){//负数
    *p++ = '-';
    num = -num;
  }
  //计算整数的长度，并将每一位转换为字符
  int len = 0;
  int temp = num;
  while(temp>0){
    temp /= 10;
    len++;
  }
  str[len] = '\0';
  while(num>0){
    str[--len] = num % 10 + '0';
    num /= 10;
  }
}

int sprintf(char *out, const char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  char *p = out;
  const char *f=fmt;

  while(*f){
    if(*f == '%'){//遇到%，检查下一个字符以确定格式类型
      f++;
      if(*f == 'd'){//如果是%d，将整数参数转换为字符串并复制到输出缓冲区
        int num = va_arg(ap, int);
        char num_str[20];//足够大
        itoa(num, num_str);
        char *num_p = num_str;
        while(*num_p){
          *p++ = *num_p++;
        }
      }else if(*f == 's'){//如果是%s，将字符串参数复制到输出缓冲区
        const char *str = va_arg(ap, const char *);
        while(*str){
          *p++ = *str++;
        }
    }else{//未知格式
      *p++ = '%';
      *p++ = *f;
    }
  }else{
    *p++ = *f;
  }
  f++;
  }
  *p = '\0';//末尾设置为'\0'
  va_end(ap);
  return p - out;//返回写入的字符数
}

重新认识计算机: 计算机是个抽象层

  • 讨论在TRM上运行的程序, 我们对这些程序的需求进行分类, 来看看我们的计算机系统是如何支撑这些需求的
    • 计算
    • 内存申请
    • 结束运行
    • 打印信息
  • 宏观视角：底层——>高层
    • 微观视角: 程序是个状态机
    • 宏观视角: 计算机是个抽象层
    • 理解计算机是如何把底层的功能经过层层抽象, 最终支撑程序的运行.

基础设施（2）

bug诊断的利器 - 踪迹

  • 为了提高效率, 我们可以通过printf()来输出我们关心的某些信息.
  • 在软件工程领域, 记录程序执行过程的信息称为踪迹(trace). 有了踪迹信息, 我们就可以判断程序的执行过程是否符合预期, 从而进行bug的诊断.

指令执行的踪迹 - itrace

  • NEMU已经实现– itrace (instruction trace), 它可以记录客户程序执行的每一条指令.
  • itrace会输出指令的PC, 二进制表示以及反汇编结果
  • 框架代码默认已经打开了这个功能, 客户程序执行的指令都会被记录到build/nemu-log.txt中
  • NEMU可以限制trace输出的时机, 你可以手动指定什么时候才输出它们, 甚至还可以自定义输出trace的条件. 具体如何指定, RTFSC.
  • 对于一些输出规整的trace, 我们还可以通过grep, awk, sed等文本处理工具来对它们进行筛选和处理.
  • nemu/src/cpu/cpu-exec.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
static void exec_once(Decode *s, vaddr_t pc) {
  s->pc = pc;///
  s->snpc = pc;
  isa_exec_once(s);
  cpu.pc = s->dnpc;
  printf("Executed instruction at pc = 0x%x, next pc = 0x%x\n", s->pc, s->dnpc);
#ifdef CONFIG_ITRACE
  char *p = s->logbuf;
  p += snprintf(p, sizeof(s->logbuf), FMT_WORD ":", s->pc);
  int ilen = s->snpc - s->pc;
  int i;
  uint8_t *inst = (uint8_t *)&s->isa.inst.val;
  for (i = ilen - 1; i >= 0; i --) {
    p += snprintf(p, 4, " %02x", inst[i]);
  }
  int ilen_max = MUXDEF(CONFIG_ISA_x86, 8, 4);
  int space_len = ilen_max - ilen;
  if (space_len < 0) space_len = 0;
  space_len = space_len * 3 + 1;
  memset(p, ' ', space_len);
  p += space_len;

  void disassemble(char *str, int size, uint64_t pc, uint8_t *code, int nbyte);
  disassemble(p, s->logbuf + sizeof(s->logbuf) - p,
      MUXDEF(CONFIG_ISA_x86, s->snpc, s->pc), (uint8_t *)&s->isa.inst.val, ilen);
#endif
}

指令环形缓冲区 - iringbuf

  • 我们能不能在客户程序出错(例如访问物理内存越界)的时候输出最近执行的若干条指令呢?
  • 环形缓冲区(ring buffer)
    • 在每执行一条指令的时候, 就把这条指令的信息写入到环形缓冲区中
    • 如果缓冲区满了, 就会覆盖旧的内容
    • 客户程序出错的时候, 就把环形缓冲区中的指令打印出来, 供调试进行参考.

必做：实现iringbuf

  • 根据上述内容, 在NEMU中实现iringbuf. 你可以按照自己的喜好来设计输出的格式, 如果你想输出指令的反汇编, 可以参考itrace的相关代码; 如果你不知道应该在什么地方添加什么样的代码, 你就需要RTFSC了.
  • 思考在哪添加代码：
    • nemu/src/memory/padder.c
    1
    2
    3
    4
    static void out_of_bound(paddr_t addr) {
    panic("address = " FMT_PADDR " is out of bound of pmem [" FMT_PADDR ", " FMT_PADDR "] at pc = " FMT_WORD,
        addr, PMEM_LEFT, PMEM_RIGHT, cpu.pc);
    }
    • panic定义在nemu/include/debug.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//nemu/include/debug.h
#ifndef __DEBUG_H__
#define __DEBUG_H__

#include <common.h>
#include <stdio.h>
#include <utils.h>

#define Log(format, ...) \
    _Log(ANSI_FMT("[%s:%d %s] " format, ANSI_FG_BLUE) "\n", \
        __FILE__, __LINE__, __func__, ## __VA_ARGS__)

#define Assert(cond, format, ...) \
  do { \
    if (!(cond)) { \
      MUXDEF(CONFIG_TARGET_AM, printf(ANSI_FMT(format, ANSI_FG_RED) "\n", ## __VA_ARGS__), \
        (fflush(stdout), fprintf(stderr, ANSI_FMT(format, ANSI_FG_RED) "\n", ##  __VA_ARGS__))); \
      IFNDEF(CONFIG_TARGET_AM, extern FILE* log_fp; fflush(log_fp)); \
      extern void assert_fail_msg(); \
      assert_fail_msg(); \
      assert(cond); \
    } \
  } while (0)

#define panic(format, ...) Assert(0, format, ## __VA_ARGS__)

#define TODO() panic("please implement me")

#endif
  • 由此可知panic通过Assert实现
  • 推出要在assert_fail_msg()实现
  1. 新建src/cpu/iringbuf.h定义环形缓冲区的数据结构和接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#ifndef IRINGBUF_H
#define IRINGBUF_H

#include <stdint.h>

#define IRINGBUF_SIZE 16

typedef struct {
  uint64_t pc;
  char asm_code[128];
} IRingBufEntry;

typedef struct {
  IRingBufEntry entries[IRINGBUF_SIZE];
  int head;
  int tail;
  int count;
} IRingBuf;

extern int iringbuf_nowidx;

void record_inst(uint64_t pc, const char *asm_code);
void display_iringbuf();

#endif // IRINGBUF_H
  1. 新建src/cpu/iringbuf.c，实现环形缓冲区的操作函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <string.h>
#include "../../include/common.h"
#include "../../include/debug.h"
#include "iringbuf.h"


static IRingBuf iringbuf = { .head = 0, .tail = 0, .count = 0 };
int iringbuf_nowidx=-1;

void record_inst(uint64_t pc, const char *asm_code) {
  IRingBufEntry *entry = &iringbuf.entries[iringbuf.head];
  entry->pc = pc;
  strncpy(entry->asm_code, asm_code, sizeof(entry->asm_code) - 1);
  entry->asm_code[sizeof(entry->asm_code) - 1] = '\0';

  iringbuf_nowidx = iringbuf.head;

  iringbuf.head = (iringbuf.head + 1) % IRINGBUF_SIZE;
  if (iringbuf.count < IRINGBUF_SIZE) {
    iringbuf.count++;
  } else {
    iringbuf.tail = (iringbuf.tail + 1) % IRINGBUF_SIZE;
  }
  // 调试输出
  printf("record_inst: pc = 0x%016lx, count = %d, head = %d, tail = %d\n", pc, iringbuf.count, iringbuf.head, iringbuf.tail);
}

void display_iringbuf() {
  printf("Recent instructions:\n");
  for (int i = 0; i < iringbuf.count; i++) {
    int index = (iringbuf.tail + i) % IRINGBUF_SIZE;
    IRingBufEntry *entry = &iringbuf.entries[index];
    if (index == iringbuf_nowidx) {
      printf("--> ");
    } else {
      printf("    ");
    }
    printf("0x%016lx: %s\n", entry->pc, entry->asm_code);
  }
}
  1. 在src/cpu/cpu-exec.c的trace_and_difftest函数中，将原本打印指令的位置更改为将指令记录到缓冲区：
1
2
3
4
5
6
7
8
9
10
11
12
static void trace_and_difftest(Decode *_this, vaddr_t dnpc) {
#ifdef CONFIG_ITRACE_COND
  if (ITRACE_COND) { log_write("%s\n", _this->logbuf); }
#endif
  if (g_print_step) { 
    IFDEF(CONFIG_ITRACE, puts(_this->logbuf)); 
  }
  // 记录指令到环形缓冲区
  record_inst(_this->pc, _this->logbuf);
  IFDEF(CONFIG_DIFFTEST, difftest_step(_this->pc, dnpc));
  IFDEF(CONFIG_WATCHPOINT, check_watchpoints());
}
  1. 在src/cpu/cpu-exec.c中,在assert_fail_msg函数中，调用display_iringbuf()来打印缓冲区中的指令信息。
1
2
3
4
5
void assert_fail_msg() {
  isa_reg_display();
  display_iringbuf();
  statistic();
}
  1. 在src/memory/paddr.c中添加引用
1
2
3
4
5
6
static void out_of_bound(paddr_t addr) {
  panic("address = " FMT_PADDR " is out of bound of pmem [" FMT_PADDR ", " FMT_PADDR "] at pc = " FMT_WORD,
      addr, PMEM_LEFT, PMEM_RIGHT, cpu.pc);
  assert_fail_msg();
  assert(0);
}
  • 效果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Recent instructions:
    0x0000000080000050: 0x80000050: 0d 00 00 ef jal	0xd0
    0x0000000080000120: 0x80000120: fd 01 01 13 addi	sp, sp, -0x30
    0x0000000080000124: 0x80000124: 00 81 24 23 sw	s0, 8(sp)
    0x0000000080000128: 0x80000128: 00 11 26 23 sw	ra, 0xc(sp)
    0x000000008000012c: 0x8000012c: 00 c1 2c 23 sw	a2, 0x18(sp)
    0x0000000080000130: 0x80000130: 00 d1 2e 23 sw	a3, 0x1c(sp)
    0x0000000080000134: 0x80000134: 02 e1 20 23 sw	a4, 0x20(sp)
    0x0000000080000138: 0x80000138: 02 f1 22 23 sw	a5, 0x24(sp)
    0x000000008000013c: 0x8000013c: 03 01 24 23 sw	a6, 0x28(sp)
    0x0000000080000140: 0x80000140: 03 11 26 23 sw	a7, 0x2c(sp)
    0x0000000080000144: 0x80000144: 00 00 04 17 auipc	s0, 0
    0x0000000080000148: 0x80000148: 12 04 04 13 addi	s0, s0, 0x120
    0x000000008000014c: 0x8000014c: 04 10 05 13 addi	a0, zero, 0x41
    0x0000000080000150: 0x80000150: 00 14 04 13 addi	s0, s0, 1
    0x0000000080000154: 0x80000154: f9 5f f0 ef jal	-0x6c
--> 0x00000000800000e8: 0x800000e8: a0 00 07 b7 lui	a5, 0xa0000

内存访问的踪迹 - mtrace

  • 可以很容易地对访存的结果进行追踪, 从而记录访存的踪迹(memory trace).

必做：实现mtrace

  • 这个功能非常简单, 你已经想好如何实现了: 只需要在paddr_read()和paddr_write()中进行记录即可. 你可以自行定义mtrace输出的格式.
  • 不过和最后只输出一次的iringbuf不同, 程序一般会执行很多访存指令, 这意味着开启mtrace将会产生大量的输出, 因此最好可以在不需要的时候关闭mtrace. 噢, 那就参考一下itrace的相关实现吧: 尝试在Kconfig和相关文件中添加相应的代码, 使得我们可以通过menuconfig来打开或者关闭mtrace. 另外也可以实现mtrace输出的条件, 例如你可能只会关心某一段内存区间的访问, 有了相关的条件控制功能, mtrace使用起来就更加灵活了.
  1. 更新Kconfig文件
1
2
3
4
5
config MTRACE
    bool "Enable memory trace"
    default n
    help
      Enable memory trace to record memory access behavior.
  1. 在include/common.h中添加 mtrace 宏定义
1
2
3
4
5
#ifdef CONFIG_MTRACE
#define MTRACE_COND (1)
#else
#define MTRACE_COND (0)
#endif
  1. 在paddr.c文件中实现mtrace
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "../../include/common.h"

word_t paddr_read(paddr_t addr, int len) {
  if (MTRACE_COND) {
    printf("MTRACE: Read from address 0x%08x, length %d\n", addr, len);
  }
  if (likely(in_pmem(addr))) return pmem_read(addr, len);
  IFDEF(CONFIG_DEVICE, return mmio_read(addr, len));
  out_of_bound(addr);
  return 0;
}

void paddr_write(paddr_t addr, int len, word_t data) {
  if (MTRACE_COND) {
    printf("MTRACE: Write to address 0x%08x, length %d, data 0x%08x\n", addr, len, data);
  }
  if (likely(in_pmem(addr))) { pmem_write(addr, len, data); return; }
  IFDEF(CONFIG_DEVICE, mmio_write(addr, len, data); return);
  out_of_bound(addr);
}
  1. make menuconfig,找到Enable memory trace选项,打开即启用
  • belike：
1
2
3
4
5
6
MTRACE: Read from address 0x80000000, length 4
Executed instruction at pc = 0x80000000, next pc = 0x80000004
MTRACE: Read from address 0x80000004, length 4
Executed instruction at pc = 0x80000004, next pc = 0x80000008
MTRACE: Read from address 0x80000008, length 4
Executed instruction at pc = 0x80000008, next pc = 0x8000000c
  1. 实现mtrace输出的条件, 例如你可能只会关心某一段内存区间的访问;在paddr.c文件中实现:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
static bool in_mtrace_range(paddr_t addr) {
  // 假设只关心某一段内存区间的访问，例如 [0x80000000, 0x8000ffff]
  return (addr >= 0x80000000 && addr <= 0x8000ffff);
}

word_t paddr_read(paddr_t addr, int len) {
  if (MTRACE_COND && in_mtrace_range(addr)) {
    printf("MTRACE: Read from address 0x%08x, length %d\n", addr, len);
  }
  if (likely(in_pmem(addr))) return pmem_read(addr, len);
  IFDEF(CONFIG_DEVICE, return mmio_read(addr, len));
  out_of_bound(addr);
  return 0;
}

void paddr_write(paddr_t addr, int len, word_t data) {
  if (MTRACE_COND && in_mtrace_range(addr)) {
    printf("MTRACE: Write to address 0x%08x, length %d, data 0x%08x\n", addr, len, data);
  }
  if (likely(in_pmem(addr))) { pmem_write(addr, len, data); return; }
  IFDEF(CONFIG_DEVICE, mmio_write(addr, len, data); return);
  out_of_bound(addr);
}

函数调用的踪迹 - ftrace

  • 要实现ftrace, 我们只需要关心函数调用和返回相关的指令就可以了.
    • 我们可以在函数调用指令中记录目标地址, 表示将要调用某个函数;
    • 然后在函数返回指令中记录当前PC, 表示将要从PC所在的函数返回.
    • 我们很容易在相关指令的实现中添加代码来实现这些功能. 但目标地址和PC值仍然缺少程序语义, 如果我们能把它们翻译成函数名, 就更容易理解了
  • 给定一个位于代码段的地址, 如何得知它位于哪一个函数
    • 这就需要ELF文件中符号表(symbol table)的帮助了.
    • 符号表是可执行文件的一个section, 它记录了程序编译时刻的一些信息, 其中就包括变量和函数的信息. 为了实现ftrace, 我们首先需要了解符号表中都记录了哪些信息.
  • 以cpu-tests中add这个用户程序为例, 使用readelf命令查看ELF可执行文件的信息:
1
riscv64-linux-gnu-readelf -a add-riscv32-nemu.elf
  • 符号表
    • Type属性为FUNC的表项
    • 仔细观察Name属性之后, 你会发现这些表项正好对应了程序中定义的函数
    • 相应的Value属性正好是它们的起始地址(你可以与反汇编结果进行对比)
    • 而相应的Size属性则给出了函数的大小.

思考：消失的符号

  • 我们在am-kernels/tests/cpu-tests/tests/add.c中定义了宏NR_DATA, 同时也在add()函数中定义了局部变量c和形参a, b, 但你会发现在符号表中找不到和它们对应的表项, 为什么会这样? 思考一下, 什么才算是一个符号(symbol)?
  1. 符号表中记录的是全局变量、函数和其他具有名称和地址的实体。局部变量和宏定义不会出现在符号表中，因为它们的作用域和生命周期局限于函数内部或预处理阶段。
  2. 一个符号（Symbol）通常是指在编译和链接过程中具有名称和地址的实体。以下是一些常见的符号类型：
    • 全局变量（Global Variables）
      • 在程序的全局作用域中定义的变量。
      • 这些变量在符号表中有对应的表项，记录了它们的名称、类型和地址。
    • 函数（Functions）
      • 在程序中定义的函数。
      • 符号表中记录了函数的名称、类型（FUNC）和起始地址。
    • 常量（Constants）
      • 在程序中定义的具有名称的常量。
      • 这些常量在符号表中有对应的表项。
    • 外部变量（External Variables）
      • 在一个文件中声明但在另一个文件中定义的变量。
      • 符号表中记录了这些变量的名称和类型。

思考：寻找”Hello World!”

  • 在Linux下编写一个Hello World程序, 编译后通过上述方法找到ELF文件的字符串表, 你发现”Hello World!”字符串在字符串表中的什么位置? 为什么会这样?
  1. 在编译后的ELF文件中，”Hello World!”字符串通常位于.rodata（只读数据段）或.data（数据段）中，而不是在字符串表（.strtab）中。字符串表主要用于存储符号名称和调试信息，而程序中的字符串常量则存储在数据段中。
  2. 原因：
    • 字符串表的用途：
      • 字符串表（.strtab）用于存储符号名称、调试信息等与程序执行无关的字符串。
      • 它主要用于链接和调试阶段，而不是程序运行时的数据存储。
    • 字符串常量的存储：
    • 程序中的字符串常量（如”Hello World!”）存储在数据段（如.rodata或.data）中。
    • 这些段用于存储程序运行时需要访问的常量和变量。

必做：实现ftrace

  • 根据上述内容, 在NEMU中实现ftrace. 你可以自行决定输出的格式. 你需要注意以下内容:
    • 你需要为NEMU传入一个ELF文件, 你可以通过在parse_args()中添加相关代码来实现这一功能
    • 你可能需要在初始化ftrace时从ELF文件中读出符号表和字符串表, 供你后续使用
    • 关于如何解析ELF文件, 可以参考man 5 elf
    • 如果你选择的是riscv32, 你还需要考虑如何从jal和jalr指令中正确识别出函数调用指令和函数返回指令
  • 注意, 你不应该通过readelf等工具直接解析ELF文件. 在真实的项目中, 这个方案确实可以解决问题; 但作为一道学习性质的题目, 其目标是让你了解ELF文件的组织结构, 使得将来你在必要的时候(例如在裸机环境中)可以自己从中解析出所需的信息. 如果你通过readelf等工具直接解析ELF文件, 相当于自动放弃训练的机会, 与我们设置这道题目的目的背道而驰.
  1. 为NEMU传入一个ELF文件, 在src/monitor/monitor.c的parse_args()中添加:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
static char *elf_file = NULL;

static int parse_args(int argc, char *argv[]) {
  const struct option table[] = {
    {"batch"    , no_argument      , NULL, 'b'},
    {"log"      , required_argument, NULL, 'l'},
    {"diff"     , required_argument, NULL, 'd'},
    {"port"     , required_argument, NULL, 'p'},
    {"help"     , no_argument      , NULL, 'h'},
    {"elf"      , required_argument, NULL, 'e'},
    {0          , 0                , NULL,  0 },
  };
  int o;
  while ( (o = getopt_long(argc, argv, "-bhl:d:p:e:", table, NULL)) != -1) {
    switch (o) {
      case 'b': sdb_set_batch_mode(); break;
      case 'p': sscanf(optarg, "%d", &difftest_port); break;
      case 'l': log_file = optarg; break;
      case 'e': elf_file = optarg; break;  // 解析ELF文件路径并解析ELF文件
      case 'd': diff_so_file = optarg; break;
      case 1: img_file = optarg; return 0;
      default:
        printf("Usage: %s [OPTION...] IMAGE [args]\n\n", argv[0]);
        printf("\t-b,--batch              run with batch mode\n");
        printf("\t-l,--log=FILE           output log to FILE\n");
        printf("\t-d,--diff=REF_SO        run DiffTest with reference REF_SO\n");
        printf("\t-p,--port=PORT          run DiffTest with port PORT\n");
        printf("\t-e,--elf=FILE           parse elf from FILE\n");
        printf("\n");
        exit(0);
    }
  }
  return 0;
}
void init_monitor(int argc, char *argv[]) {
 /* 函数调用踪迹,ftrace. */
	IFDEF(CONFIG_FTRACE, init_ftrace(elf_file));
}

  1. 新建nemu/src/cpu/elf_parser.c和nemu/src/cpu/elf_parser.h,
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//nemu/src/cpu/elf_parser.h
#ifndef __ELF_PARSER_H__
#define __ELF_PARSER_H__
#include "common.h"
#include <elf.h>

typedef struct {
    char name[64];
    paddr_t addr;      // the function head address
    Elf32_Xword size;
}FuncSymbol;

#define CALL_STACK_SIZE 1024

typedef struct {
  uint32_t pc;
  const char *func_name;
} CallStackEntry;

extern CallStackEntry call_stack[CALL_STACK_SIZE];
extern int call_stack_top ;

extern FuncSymbol *func_symbols;
extern int func_symbol_count;

void parse_elf(const char *elf_file);

#endif // __ELF_PARSER_H__
  1. 在初始化ftrace时从ELF文件中读出符号表和字符串表, 供后续使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
//nemu/src/cpu/elf_parser.c
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <elf.h>
#include "elf_parser.h"

FuncSymbol *func_symbols = NULL;
int func_symbol_count = 0;

void parse_elf(const char *elf_file) {
    if (elf_file == NULL) return;

    FILE *fp = fopen(elf_file, "rb");
    if (!fp) {
        perror("Failed to open ELF file");
        exit(EXIT_FAILURE);
    }

    // 读取 ELF 头
    Elf32_Ehdr ehdr;
    if (fread(&ehdr, sizeof(Elf32_Ehdr), 1, fp) != 1) {
        perror("Failed to read ELF header");
        exit(EXIT_FAILURE);
    }

    // 验证文件是否是 ELF 格式
    if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0) {
        fprintf(stderr, "Not a valid ELF file\n");
        exit(EXIT_FAILURE);
    }

    fseek(fp, ehdr.e_shoff, SEEK_SET);

    Elf32_Shdr shdr;
    char *string_table = NULL;

    // 寻找字符串表
    for (int i = 0; i < ehdr.e_shnum; i++) {
        if (fread(&shdr, sizeof(Elf32_Shdr), 1, fp) != 1) {
            perror("Failed to read section header");
            exit(EXIT_FAILURE);
        }

        if (shdr.sh_type == SHT_STRTAB) {
            // 获取字符串表
            string_table = malloc(shdr.sh_size);
            fseek(fp, shdr.sh_offset, SEEK_SET);
            if (fread(string_table, shdr.sh_size, 1, fp) != 1) {
                perror("Failed to read string table");
                exit(EXIT_FAILURE);
            }
        }
    }

    // 寻找符号表
    fseek(fp, ehdr.e_shoff, SEEK_SET);

    for (int i = 0; i < ehdr.e_shnum; i++) {
        if (fread(&shdr, sizeof(Elf32_Shdr), 1, fp) != 1) {
            perror("Failed to read section header");
            exit(EXIT_FAILURE);
        }

        if (shdr.sh_type == SHT_SYMTAB) {
            fseek(fp, shdr.sh_offset, SEEK_SET);

            Elf32_Sym sym;
            size_t sym_count = shdr.sh_size / shdr.sh_entsize;
            func_symbols = malloc(sizeof(FuncSymbol) * sym_count);

            for (size_t j = 0; j < sym_count; j++) {
                if (fread(&sym, sizeof(Elf32_Sym), 1, fp) != 1) {
                    perror("Failed to read symbol table");
                    exit(EXIT_FAILURE);
                }

                if (ELF32_ST_TYPE(sym.st_info) == STT_FUNC) {
                    const char *name = string_table + sym.st_name;
                    strncpy(func_symbols[func_symbol_count].name, name, sizeof(func_symbols[func_symbol_count].name) - 1);
                    func_symbols[func_symbol_count].name[sizeof(func_symbols[func_symbol_count].name) - 1] = '\0';  // 确保字符串以 null 结尾
                    func_symbols[func_symbol_count].addr = sym.st_value;
                    func_symbols[func_symbol_count].size = sym.st_size;
                    func_symbol_count++;
                }
            }
        }
    }

    fclose(fp);
    free(string_table);
}
  1. 在abstract-machine/scripts/platform/nemu.mk中添加
  • NEMUFLAGS += -e $(IMAGE).elf
  1. 在nemu/src/cpu/cpu-exec.c中：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
extern FuncSymbol *func_symbols;
extern int func_symbol_count;

CallStackEntry call_stack[CALL_STACK_SIZE];
int call_stack_top = 0;

static const char* find_func_name(paddr_t addr) {
  for (int i = 0; i < func_symbol_count; i++) {
    if (func_symbols[i].addr <= addr && addr < func_symbols[i].addr + func_symbols[i].size) {
      return func_symbols[i].name;
    }
  }
  return "???";
}

static void trace_and_difftest(Decode *_this, vaddr_t dnpc) {
//其它
#endif
  // 记录函数调用和返回
  const char *func_name = find_func_name(_this->pc);
  if (func_name) {
    printf("FTRACE: Call %s at 0x%08x\n", func_name, _this->pc);
  }
  func_name = find_func_name(dnpc);
  if (func_name) {
    printf("FTRACE: Return from %s to 0x%08x\n", func_name, dnpc);
  }
//其它
}

static void exec_once(Decode *s, vaddr_t pc) {
  s->pc = pc;
  s->snpc = pc;
  isa_exec_once(s);
  cpu.pc = s->dnpc;

  // 识别函数调用和返回指令
  uint32_t inst = s->isa.inst.val;
  if ((inst & 0x7f) == 0x6f) { // JAL
    const char *func_name = find_func_name(s->dnpc);
    if (strcmp(func_name, "???") != 0) {
      printf("FTRACE: Call %s at 0x%08x\n", func_name, s->dnpc);
      if (call_stack_top < CALL_STACK_SIZE) {
        call_stack[call_stack_top].pc = s->dnpc;
        call_stack[call_stack_top].func_name = func_name;
        call_stack_top++;
      }
    }
  } else if ((inst & 0x7f) == 0x67) { // JALR
    if (((inst >> 7) & 0x1f) == 1) { // rd == ra
      const char *func_name = find_func_name(s->dnpc);
      if (strcmp(func_name, "???") != 0) {
        printf("FTRACE: Return from %s to 0x%08x\n", func_name, s->dnpc);
        if (call_stack_top > 0) {
          call_stack_top--;
        }
      }
    }
  }

  printf("Executed instruction at pc = 0x%08x, next pc = 0x%08x\n", s->pc, s->dnpc);
//其它

void assert_fail_msg() {
  isa_reg_display();
  
  // 输出当前函数调用信息
  printf("Current function call information:\n");
  for (int i = 0; i < call_stack_top; i++) {
    printf("0x%08x: call [%s@0x%08x]\n", call_stack[i].pc, call_stack[i].func_name, call_stack[i].pc);
  }
  const char *func_name = find_func_name(cpu.pc);
  if (strcmp(func_name, "???") != 0) {
    printf("FTRACE: Current function %s at 0x%08x\n", func_name, cpu.pc);
  } else {
    printf("FTRACE: No function found at 0x%08x\n", cpu.pc);
  }


  display_iringbuf();
  statistic();
}
}
  1. 一直没有解析ELF，调试后发现:在当前的代码实现中，只有在命令行参数中提供 -e 选项时，才会解析 ELF 文件。要实现不提供 -e 选项时自动解析 ELF 文件，可以在nemu/src/monitor/monitor.c的init_monitor 函数中添加一个默认的 ELF 文件路径，并在没有提供 -e 选项时使用这个默认路径。
1
2
3
4
5
/* 函数调用踪迹,ftrace. */
  if (elf_file == NULL) {
    elf_file = "default.elf";  // 设置默认的ELF文件路径
  }
  init_ftrace(elf_file);
  • 删掉elf_file = "default.elf";，不自动启动，需要在命令行提供-e和elf文件
  1. 成功！类似：
1
2
3
4
5
6
7
8
9
10
11
12
13
Executed instruction at pc = 0x800002c4, next pc = 0x800000cc
FTRACE: Call strcmp at 0x800002c4
FTRACE: Return from main to 0x800000cc
Executed instruction at pc = 0x800000cc, next pc = 0x800000d0
FTRACE: Call main at 0x800000cc
FTRACE: Return from main to 0x800000d0
FTRACE: Call check at 0x80000010
Executed instruction at pc = 0x800000d0, next pc = 0x80000010
FTRACE: Call main at 0x800000d0
FTRACE: Return from check to 0x80000010
Executed instruction at pc = 0x80000010, next pc = 0x80000014
FTRACE: Call check at 0x80000010
FTRACE: Return from check to 0x80000014
  • 但是有点丑，
    • 把printf("Executed instruction at pc = 0x%08x, next pc = 0x%08x\n", s->pc, s->dnpc);注释后，片段如下：
1
2
3
4
5
6
7
8
9
10
FTRACE: Call main at 0x800000dc
FTRACE: Return from main to 0x800000e0
FTRACE: Call main at 0x800000e0
FTRACE: Return from main to 0x800000e4
FTRACE: Call main at 0x800000e4
FTRACE: Return from _trm_init to 0x80000108
FTRACE: Call _trm_init at 0x80000108
FTRACE: Return from _trm_init to 0x8000010c
FTRACE: Call _trm_init at 0x8000010c
FTRACE: Return from _trm_init to 0x80000110

思考：不匹配的函数调用和返回

  • 如果你仔细观察上文recursion的示例输出, 你会发现一些有趣的现象. 具体地, 注释(1)处的ret的函数是和对应的call匹配的, 也就是说, call调用了f2, 而与之对应的ret也是从f2返回; 但注释(2)所指示的一组call和ret的情况却有所不同, call调用了f1, 但却从f0返回; 注释(3)所指示的一组call和ret也出现了类似的现象, call调用了f1, 但却从f3返回.
  • 尝试结合反汇编结果, 分析为什么会出现这一现象.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
0x8000000c: call [_trm_init@0x80000260]
0x80000270:   call [main@0x800001d4]
0x800001f8:     call [f0@0x80000010]
0x8000016c:       call [f2@0x800000a4]
0x800000e8:         call [f1@0x8000005c]
0x8000016c:           call [f2@0x800000a4]
0x800000e8:             call [f1@0x8000005c]
0x8000016c:               call [f2@0x800000a4]
0x800000e8:                 call [f1@0x8000005c]
0x8000016c:                   call [f2@0x800000a4]
0x800000e8:                     call [f1@0x8000005c]
0x8000016c:                       call [f2@0x800000a4]
0x800000e8:                         call [f1@0x8000005c]
0x80000058:                         ret  [f0]              # 注释(2)
0x800000fc:                       ret  [f2]                # 注释(1)
0x80000180:                       call [f2@0x800000a4]
0x800000e8:                         call [f1@0x8000005c]
0x80000058:                         ret  [f0]
0x800000fc:                       ret  [f2]
0x800001b0:                     ret  [f3]                  # 注释(3)
0x800000fc:                   ret  [f2]
0x80000180:                   call [f2@0x800000a4]
0x800000e8:                     call [f1@0x8000005c]
0x8000016c:                       call [f2@0x800000a4]
0x800000e8:                         call [f1@0x8000005c]
0x80000058:                         ret  [f0]
  1. 现象描述
  2. 注释(1)
    - call [f2@0x800000a4]
    - ret [f2]
    - 这是正常的函数调用和返回，call调用了f2，并从f2返回。
  3. 注释(2)
    - call [f1@0x8000005c]
    - ret [f0]
    - 这里出现了不匹配的现象，call调用了f1，但却从f0返回。
  4. 注释(3)
    - call [f1@0x8000005c]
    - ret [f3]
    - 这里也出现了不匹配的现象，call调用了f1，但却从f3返回。
  5. 可能的原因
  • 这种不匹配的现象通常是由于函数调用过程中存在间接调用或尾调用优化（Tail Call Optimization, TCO）导致的。以下是两种可能的原因：
  1. 间接调用
    - 在函数f1内部，可能存在对其他函数（如f0或f3）的间接调用。
    - 这种情况下，f1在执行过程中调用了f0或f3，并直接从这些函数返回，而不是从f1返回。
  2. 尾调用优化
    - 尾调用优化是一种编译器优化技术，当一个函数的最后一个操作是调用另一个函数时，编译器可以优化为直接跳转到被调用函数，而不需要返回到调用者。
    - 这种优化可以减少栈帧的开销，提高程序的执行效率。
    - 在这种情况下，f1的最后一个操作是调用f0或f3，编译器优化为直接跳转到f0或f3，并从这些函数返回。

思考：冗余的符号表

  1. 在Linux下编写一个Hello World程序, 然后使用strip命令丢弃可执行文件中的符号表:
1
2
gcc -o hello hello.c
strip -s hello
  • 用readelf查看hello的信息, 你会发现符号表被丢弃了, 此时的hello程序能成功运行吗?
  1. 目标文件中也有符号表, 我们同样可以丢弃它:
1
2
gcc -c hello.c
strip -s hello.o
  • 用readelf查看hello.o的信息, 你会发现符号表被丢弃了. 尝试对hello.o进行链接:
1
gcc -o hello hello.o
  • 你发现了什么问题? 尝试对比上述两种情况, 并分析其中的原因.
  1. Hello World程序: 即使符号表被丢弃，hello程序仍然能够成功运行。
  • 因为可执行文件中的符号表主要用于调试和链接阶段，而不是程序运行时所需的内容。
  • 程序运行时所需的所有信息（如代码和数据）已经被嵌入到可执行文件中，因此丢弃符号表不会影响程序的运行。
  1. 目标文件中的符号表: 在尝试链接时，发现链接失败，出现错误信息：
1
2
3
/usr/bin/ld: hello.o: in function `main':
(.text+0x1b): undefined reference to `printf'
collect2: error: ld returned 1 exit status
  • 目标文件中的符号表用于链接阶段，记录了函数和变量的名称、类型和地址等信息。
  • 链接器需要这些符号信息来解析外部引用和生成最终的可执行文件。
  • 如果目标文件中的符号表被丢弃，链接器将无法解析外部引用（如printf函数），导致链接失败。

AM作为基础设施

  • AM的核心思想了: 通过一组抽象的API把程序和架构解耦
    • 保证了运行在AM之上的代码(包括klib)都是架构无关的, 这恰恰增加了代码的可移植性.
  1. abstract-machine中有一个特殊的架构叫native, 是用GNU/Linux默认的运行时环境来实现的AM API.
  2. 在abstract-machine中, 我们可以很容易地把程序编译到另一个架构上运行, 例如在am-kernels/tests/cpu-tests/目录下执行
1
make ALL=string ARCH=native run
  • 即可将string程序编译到native并运行. 由于我们会将程序编译到不同的架构中, 因此你需要注意make命令中的ARCH参数.
1
2
3
Exit code = 00h
test list [1 item(s)]: string
[        string] PASS
  • 如果string程序没有通过测试, 终端将会输出
1
make[1]: *** [run] Error 1
  • 当然也有可能输出段错误等信息.

思考：奇怪的错误码

  • 为什么错误码是1呢? 你知道make程序是如何得到这个错误码的吗?
  1. 错误码1的含义：
  • 在Unix和Linux系统中，程序的退出状态码（exit code）是一个整数值，用于表示程序的执行结果。
  • 通常，0表示成功，非0表示失败。
  • 错误码1通常表示一般性错误（general error），即程序执行过程中发生了某种错误，但没有具体的错误类型。
  1. make得到错误码的过程：
  • make程序通过执行命令并检查其退出状态码来确定命令是否成功。如果命令返回非0的退出状态码，make会认为该命令失败，并输出相应的错误信息
  • 框架代码编译到native的时候默认链接到glibc, 我们需要把这些库函数的调用链接到我们编写的klib来进行测试.
    • 我们可以通过在abstract-machine/klib/include/klib.h 中通过定义宏__NATIVE_USE_KLIB__来把库函数链接到klib.
    • 如果不定义这个宏, 库函数将会链接到glibc,** 可以作为正确的参考实现来进行对比**.

思考：这是如何实现的?

  • 为什么定义宏__NATIVE_USE_KLIB__之后就可以把native上的这些库函数链接到klib? 这具体是如何发生的? 尝试根据你在课堂上学习的链接相关的知识解释这一现象.
  • 当定义了宏__NATIVE_USE_KLIB__时，编译器会包含klib_impl.h，从而使用我们自己实现的klib库函数；否则，编译器会包含标准库的头文件，使用glibc的实现。
  • 具体过程：
    1. 定义宏：在编译时定义宏__NATIVE_USE_KLIB__。
    2. 条件编译：编译器根据宏__NATIVE_USE_KLIB__选择性地包含klib_impl.h，从而使用我们自己实现的klib库函数。
    3. 链接过程：链接器在链接过程中将printf函数链接到klib_impl.c中实现的printf函数，而不是标准库中的printf函数。

测试你的klib

  • 需要编写一些充分的测试用例来专门对klib的实现进行测试.
1
2
3
4
5
+----> 测试对象 ----> 实际输出
 |                        |
输入                      +----> 一致?
 |                        |
 +----> 某种方法 ----> 预期输出

选做：编写更多的测试

  • 尝试理解上述测试代码是如何进行测试的, 并在am-kernels/tests/目录下新增一个针对klib的测试集klib-tests, 测试集的文件结构可以参考am-kernels/tests/am-tests或am-kernels/kernels/hello.
  • 然后针对上文所述的第一类写入函数编写相应的测试代码. 编写测试的时候需要注意一些地方:
    • memcpy()的行为在区间重叠的时候是UB, 你可以在遍历的时候检查区间是否重叠, 若是, 则跳过此次检查; 或者使用另一个相同的数组来作为src, 这样就不会出现重叠的情况
    • 字符串处理函数需要额外注意\0和缓冲区溢出的问题
  • 编写后, 你可以先在native上用glibc的库函数来测试你编写的测试代码, 然后在native上用这些测试代码来测试你的klib实现, 最后再在NEMU上运行这些测试代码来测试你的NEMU实现.
  1. 创建目录
1
2
3
4
5
6
am-kernels/tests/klib-tests/
├── include/
│   └── klib.h
├── src/
│   └── test_memset.c
├── Makefile
  1. 在klib.h中包含需要测试的函数声明
1
2
3
4
5
6
7
8
9
10
11
#ifndef KLIB_H
#define KLIB_H

#include <stddef.h>
#include <stdint.h>

void *memset(void *s, int c, size_t n);
void *memcpy(void *dest, const void *src, size_t n);
char *strcpy(char *dest, const char *src);

#endif // KLIB_H
  1. 在src/test_type1.c中编写测试代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#include "klib.h"
#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

#define N 100
static uint8_t data[N];
static uint8_t src[N];
static char str_data[N];
static char src_str[N] = "Hello, world!";

// 重置数据数组
void reset() {
    for (int i = 0; i < N; i++) {
        data[i] = i + 1;
        src[i] = i + 101;
        str_data[i] = '\0';
    }
}

// 检查[l,r)区间中的值是否依次为val, val + 1, val + 2...
void check_seq(int l, int r, int val) {
    for (int i = l; i < r; i++) {
        assert(data[i] == val + i - l);
    }
}

// 检查[l,r)区间中的值是否均为val
void check_eq(int l, int r, int val) {
    for (int i = l; i < r; i++) {
        assert(data[i] == val);
    }
}

// 测试 memset 函数
void test_memset() {
    int l, r;
    for (l = 0; l < N; l++) {
        for (r = l + 1; r <= N; r++) {
            reset();
            uint8_t val = (l + r) / 2;
            memset(data + l, val, r - l);
            check_seq(0, l, 1);
            check_eq(l, r, val);
            check_seq(r, N, r + 1);
        }
    }
    printf("test_memset passed.\n");
}

// 测试 memcpy 函数
void test_memcpy() {
    int l, r;
    for (l = 0; l < N; l++) {
        for (r = l + 1; r <= N; r++) {
            reset();
            memcpy(data + l, src + l, r - l);
            check_seq(0, l, 1);
            check_seq(l, r, 101 + l);
            check_seq(r, N, r + 1);
        }
    }
    printf("test_memcpy passed.\n");
}

// 测试 strcpy 函数
void test_strcpy() {
    reset();
    strcpy(str_data, src_str);
    assert(strcmp(str_data, src_str) == 0);
    printf("test_strcpy passed.\n");
}

int main() {
    test_memset();
    test_memcpy();
    test_strcpy();
    return 0;
}
  1. 在Makefile中添加编译和运行测试的规则
1
2
3
4
5
6
7
8
9
10
11
12
13
ARCH ?= native
CFLAGS := -I$(PWD)/include

all: test_type1

test_type1: src/test_type1.c
  $(CC) $(CFLAGS) -o $@ $^

run: test_type1
	./test_type1

clean:
	rm -f test_type1
  1. 在am-kernels/tests/klib-tests下make,
  • 报错make Makefile:7: *** 缺失分隔符。 停止。
  • 改了设置的：使用Tab键时插入空格”为用缩进！
  • 编译成功得到
1
cc -I/home/xiaoyao/ics2024/am-kernels/tests/klib-tests/include -o test_type1 src/test_type1.c
  1. make run,成功则得到：
1
2
3
4
./test_type1
test_memset passed.
test_memcpy passed.
test_strcpy passed.

选做：编写更多的测试(2)

  • 尝试为klib-tests添加针对第二类只读函数的测试, 例如memcmp(), strlen()等. 思考一下, 应该如何得到函数的预期输出?
  1. tests/klib-tests/src/test_type2.c:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include "../include/klib.h"
#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

#define N 100
static uint8_t data[N];
static char str_data[N] = "Hello, world!";
static char str_data2[N] = "Hello, world!";
static char str_data3[N] = "Hello, Klib!";

// 重置数据数组
void reset() {
    for (int i = 0; i < N; i++) {
        data[i] = i + 1;
    }
}

// 测试 memcmp 函数
void test_memcmp() {
    reset();
    assert(memcmp(data, data, N) == 0);
    assert(memcmp(data, data + 1, N - 1) < 0);
    assert(memcmp(data + 1, data, N - 1) > 0);
    printf("test_memcmp passed.\n");
}

// 测试 strlen 函数
void test_strlen() {
    assert(strlen(str_data) == 13);
    assert(strlen(str_data2) == 13);
    assert(strlen(str_data3) == 12);//字符串"Hello, Klib!"的实际长度是 12，因为它包含了一个终止字符\0
    printf("test_strlen passed.\n");
}

int main() {
    test_memcmp();
    test_strlen();
    return 0;
}
  1. klib.h增加：
1
2
int memcmp(const void *s1, const void *s2, size_t n);
size_t strlen(const char *s);
  1. Makefile补充为:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
ARCH ?= native
CFLAGS := -I$(PWD)/include

all: test_type1 test_type2

test_type1: src/test_type1.c
    $(CC) $(CFLAGS) -o $@ $^

test_type2: src/test_type2.c
    $(CC) $(CFLAGS) -o $@ $^

run: test_type1 test_type2
    ./test_type1
    ./test_type2

clean:
    rm -f test_type1 test_type2
  1. make一下,然后make run：(成功！)
1
2
3
4
5
6
7
8
/test_type2.c
./test_type1
test_memset passed.
test_memcpy passed.
test_strcpy passed.
./test_type2
test_memcmp passed.
test_strlen passed.

选做：编写更多的测试(3)

  • 尝试为klib-tests添加针对格式化输出函数的测试. 你可以先通过sprintf()把实际输出打印到一个缓冲区中, 然后通过strcmp()来和预期输出进行对比.
  • 你也可以考虑实现位宽, 精度, 长度修饰符等功能, 然后生成相应的测试用例来进行测试.
  • 以%d为例, 我们需要构造一些输入. 但整数的范围太大了, 不能全部遍历它们, 因此我们需要挑选一些有代表性的整数.limits.h这个C标准头文件里面包含了一些最大数和最小数的定义, 你可以打开/usr/include/limits.h来阅读它们. 一些有代表性的整数可以是:
1
2
int data[] = {0, INT_MAX / 17, INT_MAX, INT_MIN, INT_MIN + 1,
              UINT_MAX / 17, INT_MAX / 17, UINT_MAX};
  • 为了得到相应的预期输出, 我们可以先编写一个native程序来用printf输出它们, 然后把输出结果整理到测试代码里面. cpu-tests中的预期输出也是这样生成的.
先编写一个native程序来用printf输出它们
  1. 在klib-tests目录下创建一个新的文件generate_expected_output.c：
1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
#include <limits.h>

int main() {
    int data[] = {0, INT_MAX / 17, INT_MAX, INT_MIN, INT_MIN + 1,
                  UINT_MAX / 17, INT_MAX / 17, UINT_MAX};
    for (int i = 0; i < sizeof(data) / sizeof(data[0]); i++) {
        printf("%d\n", data[i]);
    }
    return 0;
}
  1. 编译generate_expected_output.c:
1
2
cd /path/to/am-kernels/tests/klib-tests
gcc -o generate_expected_output generate_expected_output.c
  1. 运行生成的可执行文件`:
1
./generate_expected_output
  • 输出结果为：
1
2
3
4
5
6
7
8
0
126322567
2147483647
-2147483648
-2147483647
252645135
126322567
-1
把输出结果整理到测试代码里面，编写nemu的测试
  1. src/test_type3.c中编写测试代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include "../include/klib.h"
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>

#define BUFFER_SIZE 100

void test_sprintf() {
    char buffer[BUFFER_SIZE];
    int data[] = {0, INT_MAX / 17, INT_MAX, INT_MIN, INT_MIN + 1,
                  UINT_MAX / 17, INT_MAX / 17, UINT_MAX};
    const char *expected[] = {
        "0",
        "126322567",
        "2147483647",
        "-2147483648",
        "-2147483647",
        "252645135",
        "126322567",
        "-1"
    };

    for (int i = 0; i < sizeof(data) / sizeof(data[0]); i++) {
        sprintf(buffer, "%d", data[i]);
        assert(strcmp(buffer, expected[i]) == 0);
    }
    printf("test_sprintf passed.\n");
}

int main() {
    test_sprintf();
    return 0;
}
  1. klib.h补充函数声明：
1
int sprintf(char *str, const char *format, ...);
  1. Makefile中添加编译和运行test_type3.c的规则：
1
2
3
4
5
6
7
8
9
10
11
12
all: test_type1 test_type2 test_type3

test_type3: src/test_type3.c
	$(CC) $(CFLAGS) -o $@ $^

run: test_type1 test_type2
	./test_type1
	./test_type2
	./test_type3

clean:
	rm -f test_type1 test_type2 test_type3
  1. make和make run:(成功！！)
1
2
3
4
5
6
7
8
9
10
./test_type3
Expected: 0, Got: 0
Expected: 126322567, Got: 126322567
Expected: 2147483647, Got: 2147483647
Expected: -2147483648, Got: -2147483648
Expected: -2147483647, Got: -2147483647
Expected: 252645135, Got: 252645135
Expected: 126322567, Got: 126322567
Expected: -1, Got: -1
test_sprintf passed.

Differential Testing——强大的测试工具！

  • 如果有一种方法能够表达指令的正确行为, 我们就可以基于这种方法来进行类似assert()的检查了——ISA手册。
    • 如果有一个ISA手册的参考实现就好了——我们用的真机。
    • 我们让在NEMU中执行的每条指令也在真机中执行一次, 然后对比NEMU和真机的状态, 如果NEMU和真机的状态不一致, 我们就捕捉到error了
  • 这种方法在软件测试领域称为differential testing(后续简称DiffTest).
    • 进行DiffTest需要提供一个和DUT(Design Under Test, 测试对象) 功能相同但实现方式不同的REF(Reference, 参考实现)
    • 然后让它们接受相同的有定义的输入, 观测它们的行为是否相同.
  • 遗憾：真机上是运行了操作系统GNU/Linux的, 我们无法在native中运行编译到x86-nemu的AM程序, 对于mips32和riscv32的程序, 真机更是无法直接运行.
    • 所以, 我们需要的不仅是一个ISA手册的正确实现, 而且需要在上面能正确运行$ISA-nemu的AM程序.
  • 因此, 为了通过DiffTest的方法测试NEMU实现的正确性, 我们让NEMU和另一个模拟器逐条指令地执行同一个客户程序. 双方每执行完一条指令, 就检查各自的寄存器和内存的状态, 如果发现状态不一致, 就马上报告错误, 停止客户程序的执行.
  1. 为了方便实现DiffTest, 我们在DUT和REF之间定义了如下的一组API:
1
2
3
4
5
6
7
8
9
10
// 在DUT host memory的`buf`和REF guest memory的`addr`之间拷贝`n`字节,
// `direction`指定拷贝的方向, `DIFFTEST_TO_DUT`表示往DUT拷贝, `DIFFTEST_TO_REF`表示往REF拷贝
void difftest_memcpy(paddr_t addr, void *buf, size_t n, bool direction);
// `direction`为`DIFFTEST_TO_DUT`时, 获取REF的寄存器状态到`dut`;
// `direction`为`DIFFTEST_TO_REF`时, 设置REF的寄存器状态为`dut`;
void difftest_regcpy(void *dut, bool direction);
// 让REF执行`n`条指令
void difftest_exec(uint64_t n);
// 初始化REF的DiffTest功能
void difftest_init();
  • 其中寄存器状态dut要求寄存器的成员按照某种顺序排列, 若未按要求顺序排列, difftest_regcpy()的行为是未定义的.
    • REF需要实现这些API, DUT会使用这些API来进行DiffTest. 在这里, DUT和REF分别是NEMU和其它模拟器.
  1. NEMU的框架代码已经准备好DiffTest的功能了, 在menuconfig中打开相应的选项:
1
2
Testing and Debugging
  [*] Enable differential testing
  • 然后重新编译NEMU并运行即可
  • riscv32: Spike. Spike是RISC-V社区的一款全系统模拟器, 它的工作原理与NEMU非常类似. 我们在Spike中增加了少量接口来实现DiffTest的API. 由于Spike包含较多源文件, 编译过程可能需要花费数分钟. 为了运行Spike, 你还需要安装另一个工具:
  • apt-get install device-tree-compiler
  1. 由于不同ISA的寄存器有所不同, 框架代码把寄存器对比抽象成一个ISA相关的API, 即isa_difftest_checkregs()函数(在nemu/src/isa/$ISA/difftest/dut.c中定义). 你需要实现isa_difftest_checkregs()函数, 把通用寄存器和PC与从DUT中读出的寄存器的值进行比较. 若对比结果一致, 函数返回true; 如果发现值不一样, 函数返回false, 框架代码会自动停止客户程序的运行. 特别地, isa_difftest_checkregs()对比结果不一致时, 第二个参数pc应指向导致对比结果不一致的指令, 可用于打印提示信息.

选做：实现DiffTest

  • 上文在介绍API约定的时候, 提到了寄存器状态r需要把寄存器按照某种顺序排列. 你首先需要RTFSC, 从中找出这一顺序, 并检查你的NEMU实现是否已经满足约束.
  • 然后在isa_difftest_checkregs()中添加相应的代码, 实现DiffTest的核心功能. 实现正确后, 你将会得到一款无比强大的测试工具.
  • 体会到DiffTest的强大之后, 不妨思考一下: 作为一种基础设施, DiffTest能帮助你节省多少调试的时间呢?
  1. 寄存器状态r需要把寄存器按照某种顺序排列. 你首先需要RTFSC, 从中找出这一顺序, 并检查你的NEMU实现是否已经满足约束.
  • nemu/tools/spike-diff/difftest.cc
  1. 实现isa_difftest_checkregs:——将ref_c的寄存器与dut_cpu的寄存器逐一比较
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
bool isa_difftest_checkregs(CPU_state *ref_r, vaddr_t pc) {
  for (int i = 0; i < ARRLEN(cpu.gpr); i++) {
    if (cpu.gpr[i]._32 != ref_r->gpr[i]._32) {
      Log("Mismatch at gpr[%d]: DUT = 0x%08x, REF = 0x%08x", i, cpu.gpr[i]._32, ref_r->gpr[i]._32);
      return false;
    }
  }

  if (cpu.pc != ref_r->pc) {
    Log("Mismatch at pc: DUT = 0x%08x, REF = 0x%08x", cpu.pc, ref_r->pc);
    return false;
  }

  return true;
}
  1. make run一下，发现NEMU成功编译和运行，启用了 DiffTest 功能，并且使用了 spike-diff 作为参考动态库。

思考：匪夷所思的QEMU行为 (有点难度)

  • 在一些旧版的mips32-QEMU中, 仅在上述指令的PC值后12位为0xffc时, 才会进行指令打包. 这个打包条件看上去非常奇怪, 你知道可能的原因是什么吗?
  1. 缓存行对齐
  • 现代处理器通常使用缓存来提高内存访问速度。缓存行的大小通常是固定的，例如64字节或128字节。
  • 如果PC值的后12位为0xffc，这意味着指令的地址接近一个缓存行的末尾。为了避免跨缓存行访问，QEMU可能会选择在这种情况下进行指令打包，以提高缓存命中率和指令执行效率。
  1. 指令预取优化
  • 指令预取是处理器在执行指令之前，从内存中预先读取指令的一种技术。预取的指令通常存储在指令缓存中。
  • 当PC值的后12位为0xffc时，指令地址接近一个预取块的末尾。为了确保预取块中的指令能够连续执行，QEMU可能会选择在这种情况下进行指令打包，以优化指令预取的效果。
  1. 特定硬件行为的模拟
  • QEMU作为一个模拟器，可能需要模拟特定硬件的行为。在某些硬件平台上，指令打包可能会在特定的地址范围内触发。
  • QEMU可能在PC值的后12位为0xffc时进行指令打包，以模拟这些硬件平台的行为，确保模拟器的行为与实际硬件一致。
  1. 历史遗留问题

使用QEMU作为REF时, 不要同时运行两份NEMU

  • DiffTest会通过一个固定的端口连接到QEMU, 同时运行两份打开DiffTest的NEMU会出现以下信息:Failed to find an available port: Address already in use
  • 如果你确信没有同时运行两份NEMU, 但仍然遇到上述信息, 可以通过执行以下命令把残留在后台的QEMU杀掉:pkill -9 qemu

一键回归测试

  • 以后你还需要在NEMU中加入新的功能, 为了保证加入的新功能没有影响到已有功能的实现, 你还需要重新运行这些测试用例. 在软件测试中, 这个过程称为回归测试.
  • 为了提高效率, 我们为cpu-tests提供了一键回归测试的功能:
1
make ARCH=$ISA-nemu run
  • 即可自动批量运行cpu-tests中的所有测试, 并报告每个测试用例的运行结果.
  • PA2.2结束！

输入输出

设备与CPU

  • 除了纯粹的数据读写之外, 我们还需要对设备进行控制:
  • 比如需要获取键盘控制器的状态, 查看当前是否有按键被按下;
  • 或者是需要有方式可以查询或设置VGA控制器的分辨率.
  • 所以, 在程序看来, 访问设备 = 读出数据 + 写入数据 + 控制状态.
  • 既然设备也有寄存器, 一种最简单的方法就是把设备的寄存器作为接口, 让CPU来访问这些寄存器.
    1. 比如CPU可以从/往设备的数据寄存器中读出/写入数据, 进行数据的输入输出;
    2. 可以从设备的状态寄存器中读出设备的状态, 询问设备是否忙碌;
    3. 或者往设备的命令寄存器中写入命令字, 来修改设备的状态.
  • CPU如何访问设备寄存器：
  • 给设备中允许CPU访问的寄存器逐一编号, 然后通过指令来引用这些编号.
  • 设备中可能会有一些私有寄存器, 它们是由设备自己维护的, 它们没有这样的编号, CPU不能直接访问它们.
  • 这就是所谓的I/O编址方式, 因此这些编号也称为设备的地址.
  • 常用的编址方式有两种：

端口I/O

  • 一种I/O编址方式是端口映射I/O(port-mapped I/O), CPU使用专门的I/O指令对设备进行访问, 并把设备的地址称作端口号.
    • 有了端口号以后, 在I/O指令中给出端口号, 就知道要访问哪一个设备寄存器了.
  • 端口映射I/O把端口号作为I/O指令的一部分, 这种方法很简单, 但同时也是它最大的缺点
    • 指令集为了兼容已经开发的程序, 是只能添加但不能修改的. 这意味着, 端口映射I/O所能访问的I/O地址空间的大小, 在设计I/O指令的那一刻就已经决定下来了. 所谓I/O地址空间, 其实就是所有能访问的设备的地址的集合.
    • 随着设备越来越多, 功能也越来越复杂, I/O地址空间有限的端口映射I/O已经逐渐不能满足需求了.

內存映射I/O

  • 内存映射I/O(memory-mapped I/O, MMIO) ,是通过不同的物理内存地址给设备编址的
  • 这种编址方式将一部分物理内存的访问”重定向”到I/O地址空间中, CPU尝试访问这部分物理内存的时候, 实际上最终是访问了相应的I/O设备. 这样以后, CPU就可以通过普通的访存指令来访问设备
  • 好处: 物理内存的地址空间和CPU的位宽都会不断增长, 内存映射I/O从来不需要担心I/O地址空间耗尽的问题.

思考：理解volatile关键字

  • 也许你从来都没听说过C语言中有volatile这个关键字, 但它从C语言诞生开始就一直存在. volatile关键字的作用十分特别, 它的作用是避免编译器对相应代码进行优化. 你应该动手体会一下volatile的作用, 在GNU/Linux下编写以下代码:
1
2
3
4
5
6
7
8
9
void fun() {
  extern unsigned char _end;  // _end是什么?
  volatile unsigned char *p = &_end;
  *p = 0;
  while(*p != 0xff);
  *p = 0x33;
  *p = 0x34;
  *p = 0x86;
}
  • 然后使用-O2编译代码. 尝试去掉代码中的volatile关键字, 重新使用-O2编译, 并对比去掉volatile前后反汇编结果的不同.
1
2
gcc -O2 -c fun.c -o fun.o
objdump -d fun.o > fun_with_volatile.s
  • 你或许会感到疑惑, 代码优化不是一件好事情吗? 为什么会有volatile这种奇葩的存在? 思考一下, 如果代码中p指向的地址最终被映射到一个设备寄存器, 去掉volatile可能会带来什么问题?
  1. 使用volatile关键字的反汇编结果
1
2
3
4
5
6
7
00000000 <fun>:
   0:   c6 05 00 00 00 00 00    movb   $0x0,0x0(%rip)        # 0x6
   7:   80 3d 00 00 00 00 ff    cmpb   $0xff,0x0(%rip)       # 0xe
   e:   75 f7                   jne    7 <fun+0x7>
  10:   c6 05 00 00 00 00 33    movb   $0x33,0x0(%rip)       # 0x17
  17:   c6 05 00 00 00 00 34    movb   $0x34,0x0(%rip)       # 0x1e
  1e:   c6 05 00 00 00 00 86    movb   $0x86,0x0(%rip)       # 0x25
  • 编译器不会对变量p进行优化，每次访问*p时都会从内存中读取最新的值。
  • 反汇编结果中保留了所有对*p的写操作。
  1. 去掉volatile关键字的反汇编结果
1
2
3
4
5
00000000 <fun>:
   0:   c6 05 00 00 00 00 00    movb   $0x0,0x0(%rip)        # 0x6
   7:   80 3d 00 00 00 00 ff    cmpb   $0xff,0x0(%rip)       # 0xe
   e:   75 f7                   jne    7 <fun+0x7>
  10:   c6 05 00 00 00 00 86    movb   $0x86,0x0(%rip)       # 0x17
  • 编译器认为*p的值不会在循环中被改变，因此可能会对代码进行优化。
  • 反汇编结果中，编译器优化掉了中间的写操作，只保留了最后一次写操作。
  1. 为什么会有volatile关键字:
  • 代码优化通常是一件好事，可以提高程序的执行效率。然而，在某些情况下，优化可能会导致程序行为不符合预期。特别是当变量的值可能在程序的其他部分或外部环境中被改变时，编译器的优化可能会忽略这些变化，从而导致错误的行为。
  1. 如果代码中p指向的地址最终被映射到一个设备寄存器，去掉volatile可能会带来什么问题？
  2. 设备状态无法及时更新
    - 设备寄存器的值可能会在程序执行过程中被设备硬件改变。如果编译器对访问设备寄存器的代码进行了优化，可能会导致程序无法及时读取到设备的最新状态。
  3. 指令被优化掉
    - 编译器可能会优化掉一些关键的读写操作，导致设备无法正确接收命令或数据。例如，上述代码中的循环可能会被优化掉，导致程序无法正确等待设备状态的变化。
  4. 不可预测的行为
    - 由于设备寄存器的值可能在程序执行过程中被外部硬件改变，去掉volatile关键字可能会导致程序行为不可预测，难以调试和维护。

状态机视角下的输入输出

  • 设备是连接计算机和物理世界的桥梁.
1
2
3
4
5
状态机模型           |           状态机模型之外
S = <R, M>         |        D
计算机/程序  <----I/O指令----> 设备 <----模拟电路----> 物理世界
                   |
                   |
  • 对状态机模型的行为进行扩展——>对输入输出相关指令的行为进行建模:
    1. 执行普通指令时, 状态机按照TRM的模型进行状态转移
    2. 执行设备输出相关的指令(如x86的out指令或者RISC架构的MMIO写指令)时, 状态机除了更新PC之外, 其它状态均保持不变, 但设备的状态和物理世界则会发生相应的变化
    3. 执行设备输入相关的指令(如x86的in指令或者RISC架构的MMIO读指令)时, 状态机的转移将会”分叉”: 状态机不再像TRM那样有唯一的新状态了, 状态机具体会转移到哪一个新状态, 将取决于执行这条指令时设备的状态

NEMU中的输入输出

  • NEMU的框架代码已经在nemu/src/device/目录下提供了设备相关的代码,

映射和I/O方式

  • 可以通过对映射的管理来将端口映射I/O和内存映射I/O两种I/O编址方式统一起来
  1. 框架代码为映射定义了一个结构体类型IOMap(在nemu/include/device/map.h中定义), 包括
  • 名字
  • 映射的起始地址和结束地址
  • 映射的目标空间
  • 一个回调函数.
  1. 然后在nemu/src/device/io/map.c实现了映射的管理, 包括
  • I/O空间的分配及其映射
  • 映射的访问接口.
  • 其中map_read()和map_write()用于将地址addr映射到map所指示的目标空间, 并进行访问. 访问时, 可能会触发相应的回调函数, 对设备和目标空间的状态进行更新. 由于NEMU是单线程程序, 因此只能串行模拟整个计算机系统的工作, 每次进行I/O读写的时候, 才会调用设备提供的回调函数(callback).
    • 基于这两个API, 我们就可以很容易实现端口映射I/O和内存映射I/O的模拟了.
  1. nemu/src/device/io/port-io.c是对端口映射I/O的模拟.
  2. add_pio_map()函数用于为设备的初始化来注册一个端口映射I/O的映射关系.
  3. pio_read()和pio_write()是面向CPU的端口I/O读写接口, 它们最终会调用map_read()和map_write(), 对通过add_pio_map()注册的I/O空间进行访问.
  4. 内存映射I/O的模拟是类似的, paddr_read()和paddr_write()会判断地址addr落在物理内存空间还是设备空间,
  • 若落在物理内存空间, 就会通过pmem_read()和pmem_write()来访问真正的物理内存;
  • 若落在设备空间, 就通过map_read()和map_write()来访问相应的设备.
  • 从这个角度来看, 内存和外设在CPU来看并没有什么不同, 只不过都是一个字节编址的对象而已.

设备

  • 为了开启设备模拟的功能, 你需要在menuconfig选中相关选项:
1
[*] Devices  --->
  • 重新编译后, 你会看到运行NEMU时会弹出一个新窗口, 用于显示VGA的输出(见下文). 需要注意的是, 终端显示的提示符(nemu)仍然在等待用户输入, 此时窗口并未显示任何内容.
  • NEMU使用SDL库来实现设备的模拟, nemu/src/device/device.c含有和SDL库相关的代码.
    • init_device()函数主要进行以下工作:
      • 调用init_map()进行初始化.
      • 对上述设备进行初始化, 其中在初始化VGA时还会进行一些和SDL相关的初始化工作, 包括创建窗口, 设置显示模式等;
      • 然后会进行定时器(alarm)相关的初始化工作. 定时器的功能在PA4最后才会用到, 目前可以忽略它.
  • 另一方面, cpu_exec()在执行每条指令之后就会调用device_update()函数, 这个函数首先会检查距离上次设备更新是否已经超过一定时间, 若是, 则会尝试刷新屏幕, 并进一步检查是否有按键按下/释放, 以及是否点击了窗口的X按钮; 否则则直接返回, 避免检查过于频繁, 因为上述事件发生的频率是很低的.

将输入输出抽象成IOE

  • 与TRM不同, 设备访问是为计算机提供输入输出的功能, 因此我们把它们划入一类新的API, 名字叫IOE(I/O Extension).
  • 访问设备 = 读/写操作
  • IOE提供三个API:
1
2
3
bool ioe_init();
void ioe_read(int reg, void *buf);
void ioe_write(int reg, void *buf);
  • 第一个API用于进行IOE相关的初始化操作.
  • 后两个API分别用于从编号为reg的寄存器中读出内容到缓冲区buf中, 以及往编号为reg寄存器中写入缓冲区buf中的内容.
    • 需要注意的是, 这里的reg寄存器并不是上文讨论的设备寄存器, 因为设备寄存器的编号是架构相关的. 在IOE中, 我们希望采用一种架构无关的”抽象寄存器”, 这个reg其实是一个功能编号, 我们约定在不同的架构中, 同一个功能编号的含义也是相同的, 这样就实现了设备寄存器的抽象.
  • abstract-machine/am/include/amdev.h中定义了常见设备的”抽象寄存器”编号和相应的结构.
    • 这些定义是架构无关的, 每个架构在实现各自的IOE API时, 都需要遵循这些定义(约定).
    • 为了方便地对这些抽象寄存器进行访问, klib中提供了io_read()和io_write()这两个宏, 它们分别对ioe_read()和ioe_write()这两个API进行了进一步的封装.
  • 特别地, NEMU作为一个平台, 设备的行为是与ISA无关的, 因此我们只需要在abstract-machine/am/src/platform/nemu/ioe/目录下实现一份IOE, 来供NEMU平台的架构共享. 其中, abstract-machine/am/src/platform/nemu/ioe/ioe.c中实现了上述的三个IOE API, ioe_read()和ioe_write()都是通过抽象寄存器的编号索引到一个处理函数, 然后调用它.
  • 处理函数的具体功能和寄存器编号相关, 下面我们来逐一介绍NEMU中每个设备的功能.

串口

  • 串口是最简单的输出设备. nemu/src/device/serial.c模拟了串口的功能

必做：运行Hello World

  • 如果你选择的是mips32和riscv32, 你不需要实现额外的代码, 因为NEMU的框架代码已经支持MMIO了.
  • 实现后, 在am-kernels/kernels/hello/目录下键入
1
make ARCH=riscv32-nemu run
  • 如果你的实现正确, 你将会看到程序往终端输出一些信息(请注意不要让输出淹没在调试信息中).
  • 需要注意的是, 这个hello程序和我们在程序设计课上写的第一个hello程序所处的抽象层次是不一样的: 这个hello程序可以说是直接运行在裸机上, 可以在AM的抽象之上直接输出到设备(串口); 而我们在程序设计课上写的hello程序位于操作系统之上, 不能直接操作设备, 只能通过操作系统提供的服务进行输出, 输出的数据要经过很多层抽象才能到达设备层. 我们会在PA3中进一步体会操作系统的作用.
  1. am-kernels/kernels/hello/hello.c中代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <am.h>
#include <klib-macros.h>

int main(const char *args) {
  const char *fmt =
    "Hello, AbstractMachine!\n"
    "mainargs = '%'.\n";

  for (const char *p = fmt; *p; p++) {
    (*p == '%') ? putstr(args) : putch(*p);
  }
  return 0;
}
  1. HIT GOOD TRAP at pc = 0x800000b0
  • 输出Hello, AbstractMachine!/n和mainargs = ''.\n
  • 在AM中, main()函数允许带有一个字符串参数, 这一参数通过mainargs指定, 并由AM的运行时环境负责将它传给main()函数, 供AM程序使用. 具体的参数传递方式和架构相关.例如你可以在运行hello的时候给出一个字符串参数:make ARCH=riscv32-nemu run mainargs=I-love-PA
    • 输出Hello, AbstractMachine!/n和mainargs = 'I-love-PA'.\n

必做：实现printf

  • 有了putch(), 我们就可以在klib中实现printf()了.
  • 你之前已经实现了sprintf()了, 它和printf()的功能非常相似, 这意味着它们之间会有不少重复的代码. 你已经见识到Copy-Paste编程习惯的坏处了, 思考一下, 如何简洁地实现它们呢?
  • 实现了printf()之后, 你就可以在AM程序中使用输出调试法了.
  1. 在ics2024/abstract-machine/klib/src/stdio.c中：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
static char *number(char *str, unsigned int num, int base, int is_upper) {
  char buf[32];
  char *p = buf + 31;
  *p = '\0';

  do {
    int digit = num % base;
    *--p = (digit < 10) ? '0' + digit : (is_upper ? 'A' : 'a') + digit - 10;
    num /= base;
  } while (num > 0);

  while (*p) {
    *str++ = *p++;
  }

  return str;
}

int printf(const char *fmt, ...) {
  char buf[1024]; // 临时缓冲区
  va_list args;
  va_start(args, fmt);
  int len = vsprintf(buf, fmt, args);
  va_end(args);
  char *tmp = buf;
  while (*tmp != '\0') {
    putch(*tmp++);
  }
  return len;
}

int vsprintf(char *out, const char *fmt, va_list ap) {
  char *str = out;
  const char *s;
  int base;
  unsigned int num;

  for (; *fmt != '\0'; ++fmt) {
    if (*fmt != '%') {
      *str++ = *fmt;
      continue;
    }

    ++fmt;
    base = 10;

    switch (*fmt) {
      case 'c':
        *str++ = (unsigned char) va_arg(ap, int);
        continue;
      case 's':
        s = va_arg(ap, char *);
        while (*s) {
          *str++ = *s++;
        }
        continue;
      case 'd':
      case 'i':
        num = va_arg(ap, int);
        str = number(str, num, base, 0);
        continue;
      case 'x':
        base = 16;
        num = va_arg(ap, unsigned int);
        str = number(str, num, base, 0);
        continue;
      case 'X':
        base = 16;
        num = va_arg(ap, unsigned int);
        str = number(str, num, base, 1);
        continue;
      case 'o':
        base = 8;
        num = va_arg(ap, unsigned int);
        str = number(str, num, base, 0);
        continue;
      case 'u':
        num = va_arg(ap, unsigned int);
        str = number(str, num, base, 0);
        continue;
      case 'p':
        num = (unsigned long) va_arg(ap, void *);
        base = 16;
        *str++ = '0';
        *str++ = 'x';
        str = number(str, num, base, 0);
        continue;
      case '%':
        *str++ = '%';
        continue;
      default:
        *str++ = '%';
        if (*fmt) {
          *str++ = *fmt;
        } else {
          --fmt;
        }
        continue;
    }
  }

  *str = '\0';
  return str - out;
}

必做：运行alu-tests

  • 我们在am-kernels/tests/alu-tests/目录下移植了一个专门测试各种C语言运算的程序, 实现printf()后你就可以运行它了. 编译过程可能需要花费1分钟.
  • make ARCH=riscv32-nemu run
  • HIT GOOD TRAP at pc = 0x800ebb34
  • 但是没有printf输出，不知道为什么

时钟

必做：实现IOE

  • 在abstract-machine/am/src/platform/nemu/ioe/timer.c中实现AM_TIMER_UPTIME的功能. 在abstract-machine/am/src/platform/nemu/include/nemu.h和 abstract-machine/am/src/$ISA/$ISA.h中有一些输入输出相关的代码供你使用.
  • 实现后, 在$ISA-nemu中运行am-kernel/tests/am-tests中的real-time clock test测试. 如果你的实现正确, 你将会看到程序每隔1秒往终端输出一行信息. 由于我们没有实现AM_TIMER_RTC, 测试总是输出1900年0月0日0时0分0秒, 这属于正常行为, 可以忽略.
  1. 实现：
1
2
3
4
5
void __am_timer_uptime(AM_TIMER_UPTIME_T *uptime) {
  uint32_t low = inl(RTC_ADDR);
  uint32_t high = inl(RTC_ADDR + 4);
  uptime->us = ((uint64_t)high << 32) | low;
}
  • 不正确，之后有修改。修改后：
1
2
3
4
5
void __am_timer_uptime(AM_TIMER_UPTIME_T *uptime) {
  uint32_t high = inl(RTC_ADDR + 4);
  uint32_t low = inl(RTC_ADDR);
  uptime->us = ((uint64_t)high << 32) | low;
}
  1. 要如何运行real-time clock test这个测试, 就交给你来RTFSC吧:
  • 在am-kernels/tests/am-tests/src/main.c中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <amtest.h>

void (*entry)() = NULL; // mp entry

static const char *tests[256] = {
  ['h'] = "hello",
  ['H'] = "display this help message",
  ['i'] = "interrupt/yield test",
  ['d'] = "scan devices",
  ['m'] = "multiprocessor test",
  ['t'] = "real-time clock test",
  ['k'] = "readkey test",
  ['v'] = "display test",
  ['a'] = "audio test",
  ['p'] = "x86 virtual memory test",
};

int main(const char *args) {
  switch (args[0]) {
    CASE('h', hello);
    CASE('i', hello_intr, IOE, CTE(simple_trap));
    CASE('d', devscan, IOE);
    CASE('m', mp_print, MPE);
    CASE('t', rtc_test, IOE);
    CASE('k', keyboard_test, IOE);
    CASE('v', video_test, IOE);
    CASE('a', audio_test, IOE);
    CASE('p', vm_test, CTE(vm_handler), VME(simple_pgalloc, simple_pgfree));
    case 'H':
    default:
      printf("Usage: make run mainargs=*\n");
      for (int ch = 0; ch < 256; ch++) {
        if (tests[ch]) {
          printf("  %c: %s\n", ch, tests[ch]);
        }
      }
  }
  return 0;
}
  • 所以输入命令为make ARCH=riscv32-nemu run mainargs=t
  1. 成功,部分为：
1
2
3
4
5
6
7
8
9
1900-0-0 %02d:%02d:%02d GMT (1 second).
1900-0-0 %02d:%02d:%02d GMT (2 seconds).
1900-0-0 %02d:%02d:%02d GMT (3 seconds).
1900-0-0 %02d:%02d:%02d GMT (4 seconds).
1900-0-0 %02d:%02d:%02d GMT (5 seconds).
1900-0-0 %02d:%02d:%02d GMT (6 seconds).
1900-0-0 %02d:%02d:%02d GMT (7 seconds).
1900-0-0 %02d:%02d:%02d GMT (8 seconds).
1900-0-0 %02d:%02d:%02d GMT (9 seconds).

看看NEMU跑多快

  • 有了时钟之后, 我们就可以测试一个程序跑多快, 从而测试计算机的性能. 尝试在NEMU中依次运行以下benchmark(已经按照程序的复杂度排序, 均在am-kernel/benchmarks/目录下; 另外跑分时请关闭NEMU的监视点, trace以及DiffTest, 同时取消menuconfig中的 Enable debug information并重新编译NEMU, 以获得较为真实的跑分):
    • dhrystone
    • coremark
    • microbench
  • 成功运行后会输出跑分. 其中microbench跑分以i9-9900K @ 3.60GHz的处理器为参照, 100000分表示与参照机器性能相当, 100分表示性能为参照机器的千分之一. 除了和参照机器比较之外, 也可以和小伙伴进行比较. 如果把上述benchmark编译到native, 还可以比较native的性能.
  • 另外, microbench提供了四个不同规模的测试集, 包括test, train, ref和huge. 你可以先运行test规模, 它可以较快地运行结束, 来检查NEMU实现的正确性, 然后再运行ref规模来测量性能. 具体的运行方法请阅读README.
  • 此外, huge规模一般用于真机的测试, 在NEMU中需要运行很长时间, 我们不要求你运行它.
  1. 都报错
1
2
3
make[1]: *** [/home/xiaoyao/ics2024/nemu/scripts/native.mk:38: run] 浮点异常 (核心已转储)
make[1]: 离开目录“/home/xiaoyao/ics2024/nemu”
make: *** [/home/xiaoyao/ics2024/abstract-machine/scripts/platform/nemu.mk:32：run] 错误 2
  1. 关于AM_TIMER_UPTIME的实现, 我们在框架代码中埋了一些小坑, 如果你没有修复相关的问题, 你可能会在运行benchmark的时候出现跑分不正确的现象. 这是为了强迫大家认真RTFSC了解程序运行过程中的一切细节: benchmark读取时钟信息的时候, 整个计算机系统究竟发生了什么? 只有这样你才能把时钟相关的bug调试正确.
  • am-kernels/benchmarks/dhrystone/dry.c中944行有除0错误：
1
2
printf("Dhrystone %s         %d Marks\n", pass ? "PASS" : "FAIL",
      880900 / (int)User_Time * NUMBER_OF_RUNS/ 500000);
  1. 修改time.c
1
2
3
4
5
void __am_timer_uptime(AM_TIMER_UPTIME_T *uptime) {
  uint32_t high = inl(RTC_ADDR + 4);
  uint32_t low = inl(RTC_ADDR);
  uptime->us = ((uint64_t)high << 32) | low;
}
  1. Dhrystone:
1
2
3
4
5
6
7
Dhrystone Benchmark, Version C, Version 2.2
Trying 500000 runs through Dhrystone.
Finished in 16861 ms
==================================================
Dhrystone PASS         52 Marks
                   vs. 100000 Marks (i7-7700K @ 4.20GHz)
[src/cpu/cpu-exec.c:196 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000d24
  1. coremark:
  • 报错！
  • 查看benchmarks/coremark/build/coremark-riscv32-nemu.txt
  • 80000df4: 00178783 lb a5,1(a5)
  1. INSTPAT("??????? ????? ????? 000 ????? 00000 11", lb , I, R(rd) = SEXT(Mr(src1 + imm, 1), 8));//lb,将src1+imm地址的值的低8位存入rd
  • 80000968: 08046413 ori s0,s0,128
  1. INSTPAT("??????? ????? ????? 110 ????? 00100 11", ori , I, R(rd) = src1 | imm); //ori，或立即数，将src1的值与imm进行或运算，结果存入rd
1
2
3
CoreMark PASS       118 Marks
                vs. 100000 Marks (i7-7700K @ 4.20GHz)
[src/cpu/cpu-exec.c:196 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80002288
  1. microbench
  • 报错！
  • 查看：benchmarks/microbench/build/microbench-riscv32-nemu.txt
  • 80004a54: 02f535b3 mulhu a1,a0,a5
  1. INSTPAT("0000001 ????? ????? 011 ????? 01100 11", mulhu , R, R(rd) = ((uint64_t)src1 * (uint64_t)src2) >> 32);//mulhu
1
2
3
4
5
MicroBench PASS        153 Marks
                   vs. 100000 Marks (i9-9900K @ 3.60GHz)
Scored time: 122518.853 ms
Total  time: 141086.480 ms
[src/cpu/cpu-exec.c:196 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80004e1c
  • 正确实现时钟后, 你就可以在NEMU上运行一些具有展示性的程序了: 我们在am-kernels/kernels/demo/目录下移植了一些小型演示程序
  • 为了运行它们, 你还需要实现klib中的malloc()和free(), 目前你可以实现一个简单的版本:
    • 在malloc()中维护一个上次分配内存位置的变量addr, 每次调用malloc()时, 就返回[addr, addr + size)这段空间. addr的初值设为heap.start, 表示从堆区开始分配. 你也可以参考microbench中的相关代码. 注意malloc()对返回的地址有一定的要求, 具体情况请RTFM.
    • free()直接留空即可, 表示只分配不释放. 目前NEMU中的可用内存足够运行各种测试程序.

选做：

设备访问的踪迹 - dtrace

必做：实现dtrace

  • 这个功能非常简单, 你可以自行定义dtrace输出的格式. 注意你可以通过map->name来获取一段设备地址空间的名字, 这样可以帮助你输出可读性较好的信息. 同样地, 你也可以为dtrace实现条件控制功能, 提升dtrace使用的灵活性.
  1. 在Kconfig中定义DTRACE，nemu/Kconfig:
1
2
3
4
5
6
7
menu "Tracing Options"
config DTRACE
    bool "Enable device trace"
    default n
    help
      Enable device trace to record device access behavior.
endmenu
  1. 在 map_read 和 map_write 函数中添加 dtrace 功能:nemu/src/device/io/map.c:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
word_t map_read(paddr_t addr, int len, IOMap *map) {
  assert(len >= 1 && len <= 8);
  check_bound(map, addr);
  paddr_t offset = addr - map->low;
  invoke_callback(map->callback, offset, len, false); // prepare data to read
  word_t ret = host_read(map->space + offset, len);
  IFDEF(CONFIG_DTRACE, Log("address = " FMT_PADDR " read " FMT_PADDR " at device = %s", addr, ret, map->name));
  return ret;
}

void map_write(paddr_t addr, int len, word_t data, IOMap *map) {
  assert(len >= 1 && len <= 8);
  check_bound(map, addr);
  paddr_t offset = addr - map->low;
  host_write(map->space + offset, len, data);
  invoke_callback(map->callback, offset, len, true);
  IFDEF(CONFIG_DTRACE, Log("address = " FMT_PADDR " write " FMT_PADDR " at device = %s", addr, data, map->name));
}
  1. 成功，片段如下：
1
[src/device/io/map.c:61 map_read] address = 0xa0000060 read 0x00000000 at device = keyboard

键盘

  • 一般键盘的工作方式如下: 当按下一个键的时候, 键盘将会发送该键的通码(make code); 当释放一个键的时候, 键盘将会发送该键的断码(break code).
  • nemu/src/device/keyboard.c
  • 每当用户敲下/释放按键时, 将会把相应的键盘码放入数据寄存器, CPU可以访问数据寄存器, 获得键盘码; 当无按键可获取时, 将会返回AM_KEY_NONE.
  • abstract-machine/am/include/amdev.h中为键盘的功能定义了一个抽象寄存器:
    • AM_INPUT_KEYBRD, AM键盘控制器, 可读出按键信息. keydown为true时表示按下按键, 否则表示释放按键. keycode为按键的断码, 没有按键时, keycode为AM_KEY_NONE.

必做：实现IOE(2)

  • 在abstract-machine/am/src/platform/nemu/ioe/input.c中实现AM_INPUT_KEYBRD的功能. 实现后, 在$ISA-nemu中运行am-tests中的readkey test测试. 如果你的实现正确, 在程序运行时弹出的新窗口中按下按键, 你将会看到程序输出相应的按键信息, 包括按键名, 键盘码, 以及按键状态.
  1. am/src/platform/nemu/ioe/input.c:
1
2
3
4
5
6
7
8
9
10
void __am_input_keybrd(AM_INPUT_KEYBRD_T *kbd) {
  uint32_t keycode = inl(KBD_ADDR);
  if (keycode == AM_KEY_NONE) {
    kbd->keydown = false;
    kbd->keycode = AM_KEY_NONE;
  } else {
    kbd->keydown =(keycode & KEYDOWN_MASK ? true : false);
    kbd->keycode = keycode & ~KEYDOWN_MASK;
  }
}
  1. tests/am-tests/src/main.c中：['k'] = "readkey test"
  • make ARCH=riscv32-nemu run mainargs=k
  1. 成功：
1
2
3
4
5
6
Got  (kbd): Y (34) DOWN
Got  (kbd): Y (34) UP
Got  (kbd): O (37) DOWN
Got  (kbd): O (37) UP
Got  (kbd): U (35) DOWN
Got  (kbd): U (35) UP

思考：如何检测多个键同时被按下?

  • 在游戏中, 很多时候需要判断玩家是否同时按下了多个键, 例如RPG游戏中的八方向行走, 格斗游戏中的组合招式等等. 根据键盘码的特性, 你知道这些功能是如何实现的吗?
  • 思路：
    1. 使用数组或位图记录按键状态
    • 使用一个数组或位图来记录每个按键的状态（按下或释放）。
    • 当接收到按键事件时，更新相应的数组或位图。
    1. 检测多个键同时按下
    • 在游戏逻辑中，检查数组或位图中多个按键的状态，判断是否同时按下了这些按键。

VGA

  • VGA可以用于显示颜色像素, 是最常用的输出设备. nemu/src/device/vga.c模拟了VGA的功能

思考：神奇的调色板

  • 现代的显示器一般都支持24位的颜色(R, G, B各占8个bit, 共有2^82^82^8约1600万种颜色), 为了让屏幕显示不同的颜色成为可能, 在8位颜色深度时会使用调色板的概念. 调色板是一个颜色信息的数组, 每一个元素占4个字节, 分别代表R(red), G(green), B(blue), A(alpha)的值. 引入了调色板的概念之后, 一个像素存储的就不再是颜色的信息, 而是一个调色板的索引: 具体来说, 要得到一个像素的颜色信息, 就要把它的值当作下标, 在调色板这个数组中做下标运算, 取出相应的颜色信息. 因此, 只要使用不同的调色板, 就可以在不同的时刻使用不同的256种颜色了.
  • 在一些90年代的游戏中(比如仙剑奇侠传), 很多渐出渐入效果都是通过调色板实现的, 聪明的你知道其中的玄机吗?
  • 可以通过动态修改调色板中的颜色信息来实现渐变效果。例如，可以逐步调整调色板中的颜色值，使得屏幕上的图像逐渐变暗或变亮。
  • 在AM中, 显示相关的设备叫GPU, GPU是一个专门用来进行图形渲染的设备. 在NEMU中, 我们并不支持一个完整GPU的功能, 而仅仅保留绘制像素的基本功能.
  • abstract-machine/am/include/amdev.h中为GPU定义了五个抽象寄存器, 在NEMU中只会用到其中的两个:
    1. AM_GPU_CONFIG, AM显示控制器信息, 可读出屏幕大小信息width和height. 另外AM假设系统在运行过程中, 屏幕大小不会发生变化.
    2. AM_GPU_FBDRAW, AM帧缓冲控制器, 可写入绘图信息, 向屏幕(x, y)坐标处绘制w*h的矩形图像. 图像像素按行优先方式存储在pixels中, 每个像素用32位整数以00RRGGBB的方式描述颜色. 若sync为true, 则马上将帧缓冲中的内容同步到屏幕上.

必做：实现IOE(3)

  • 事实上, VGA设备还有两个寄存器: 屏幕大小寄存器和同步寄存器. 我们在讲义中并未介绍它们, 我们把它们作为相应的练习留给大家. 具体地, 屏幕大小寄存器的硬件(NEMU)功能已经实现, 但软件(AM)还没有去使用它; 而对于同步寄存器则相反, 软件(AM)已经实现了同步屏幕的功能, 但硬件(NEMU)尚未添加相应的支持.
  • 好了, 提示已经足够啦, 至于要在什么地方添加什么样的代码, 就由你来RTFSC吧. 这也是明白软硬件如何协同工作的很好的练习. 实现后, 向__am_gpu_init()中添加如下测试代码:
1
2
3
4
5
6
7
8
9
10
11
--- abstract-machine/am/src/platform/nemu/ioe/gpu.c
+++ abstract-machine/am/src/platform/nemu/ioe/gpu.c
@@ -6,2 +6,8 @@
 void __am_gpu_init() {
+  int i;
+  int w = 0;  // TODO: get the correct width
+  int h = 0;  // TODO: get the correct height
+  uint32_t *fb = (uint32_t *)(uintptr_t)FB_ADDR;
+  for (i = 0; i < w * h; i ++) fb[i] = i;
+  outl(SYNC_ADDR, 1);
 }
  • 其中上述代码中的w和h并未设置正确的值, 你需要阅读am-tests中的display test测试, 理解它如何获取正确的屏幕大小, 然后修改上述代码的w和h. 你可能还需要对gpu.c中的代码进行一些修改. 修改后, 在$ISA-nemu中运行am-tests中的display test测试, 如果你的实现正确, 你会看到新窗口中输出了全屏的颜色信息.
  1. nemu/src/device/vga.c中vga_update_screen(),调用update_screen函数并将同步寄存器清零：
1
2
3
4
5
6
7
8
void vga_update_screen() {
  // TODO: call `update_screen()` when the sync register is non-zero,
  // then zero out the sync register
  if (vgactl_port_base[1] != 0) {
    update_screen();
    vgactl_port_base[1] = 0;
  }
}
  1. abstract-machine/am/src/platform/nemu/ioe/gpu.c
1
2
3
4
5
6
7
8
9
10
11
12
void __am_gpu_config(AM_GPU_CONFIG_T *cfg) {
  uint32_t screen_data = inl(VGACTL_ADDR);
  int screen_width = (screen_data >> 16);
  int screen_height = screen_data & 0xffff;
  int screen_vmemsz = screen_width * screen_height * sizeof(uint32_t);
 
  *cfg = (AM_GPU_CONFIG_T) {
    .present = true, .has_accel = false,
    .width = screen_width, .height = screen_height,
    .vmemsz = screen_vmemsz
  };
}
  1. abstract-machine/am/src/platform/nemu/ioe/gpu.c
1
2
3
4
5
6
7
8
void __am_gpu_init() {
  int i;
  int w=inl(VGACTL_ADDR) >> 16;// TODO: get the correct width
  int h=inl(VGACTL_ADDR)& 0x0000ffff;// TODO: get the correct height
  uint32_t *fb = (uint32_t *)(uintptr_t)FB_ADDR;
  for (i = 0; i < w * h; i ++) fb[i] = i;
  outl(SYNC_ADDR, 1);
}
  1. 运行 ['v'] = "display test":make ARCH=riscv32-nemu run mainargs=v
    alt text

必做：实现IOE(4)

  • 事实上, 刚才输出的颜色信息并不是display test期望输出的画面, 这是因为AM_GPU_FBDRAW的功能并未正确实现. 你需要正确地实现AM_GPU_FBDRAW的功能. 实现后, 重新运行display test. 如果你的实现正确, 你将会看到新窗口中输出了相应的动画效果.
  • 实现正确后, 你就可以去掉上文添加的测试代码了.
  1. abstract-machine/am/src/platform/nemu/ioe/gpu.c:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void __am_gpu_fbdraw(AM_GPU_FBDRAW_T *ctl) {
  int x = ctl->x, y = ctl->y, w = ctl->w, h = ctl->h;
  uint32_t screen_data = inl(VGACTL_ADDR);
  int screen_width = (screen_data >> 16);
  int screen_height = screen_data & 0xffff;

  uint32_t *pixels = (uint32_t *)ctl->pixels;
  uint32_t *fb = (uint32_t *)(uintptr_t)FB_ADDR;

  for (int j = 0; j < h && j < screen_height - y; j++) {
    for (int i = 0; i < w && i < screen_width - x; i++) {
      fb[(j + y) * screen_width + i + x] = pixels[j * w + i];
    }
  }

  if (ctl->sync) {
    outl(SYNC_ADDR, 1);
  }
}
  1. 去掉测试代码
  2. 运行 ['v'] = "display test":make ARCH=riscv32-nemu run mainargs=v
    alt text
1
2
3
4
5
6
7
8
9
10
11
12
3264: FPS = 2
6388: FPS = 1
8857: FPS = 1
11971: FPS = 1
15062: FPS = 1
18262: FPS = 1
21386: FPS = 1
24425: FPS = 1
27507: FPS = 1
30531: FPS = 1
33067: FPS = 1
35720: FPS = 1

冯诺依曼计算机系统

展示你的计算机系统

  • 完整实现IOE后, 我们还可以运行一些酷炫的程序:
  1. 幻灯片播放(在am-kernels/kernels/slider/目录下). 程序将每隔5秒切换images/目录下的图片.
    alt text
  2. 打字小游戏(在am-kernels/kernels/typing-game/目录下).
  • Hit: 4; Miss: 172; Wrong: 25,好快哈哈哈
    alt text
  • (略)
  • 事实上, 游戏可以抽象成一个死循环:
1
2
3
4
5
6
while (1) {
  等待新的一帧();  // AM_TIMER_UPTIME
  处理用户按键();  // AM_INPUT_KEYBRD
  更新游戏逻辑();  // TRM
  绘制新的屏幕();  // AM_GPU_FBDRAW
}
  • 我们的计算机添加IOE之后, 完全可以通过AM的抽象支撑起循环体中的功能, 所以要在NEMU中运行这些酷炫的游戏, 并不是不可能的. 甚至我们也可以把刚才运行的am-tests测试中的死循环看成是一些简化的游戏. 你将要在PA3中运行的复杂游戏仙剑奇侠传, 背后也是这样的一个死循环.

必做：游戏是如何运行的

  • 请你以打字小游戏为例, 结合”程序在计算机上运行”的两个视角, 来剖析打字小游戏究竟是如何在计算机上运行的. 具体地, 当你按下一个字母并命中的时候, 整个计算机系统(NEMU, ISA, AM, 运行时环境, 程序) 是如何协同工作, 从而让打字小游戏实现出”命中”的游戏效果?
  • 打字小游戏只有不到200行的简单代码, 非常适合大家RTFSC. 如果你发现自己难以理解打字小游戏的具体行为, 你需要给自己敲响警钟了: 你在做PA的时候很有可能只关注怎么把必做内容的代码写对, 而不去思考这些代码和计算机系统的关系. 从ICS和PA的角度来说, 这种做法是不及格的, 而且很快你就会吃苦头了.
  1. RTFSC-程序视角：
  2. 初始化：
    - main() 函数首先调用 ioe_init() 和 video_init() 函数来初始化输入输出设备和视频显示。
    - ioe_init() 初始化输入输出环境。
    - video_init() 初始化屏幕宽度和高度，并设置字符纹理和背景颜色。
  3. 主循环：
    - main() 函数进入一个无限循环，持续更新游戏逻辑和渲染屏幕。
    - 在每一帧中，游戏逻辑通过 game_logic_update() 函数更新，处理字符的移动和状态。
    - render() 函数负责将字符绘制到屏幕上，并显示命中、错过和错误的统计信息。
  4. 输入处理：
    - 在每一帧中，游戏通过 io_read(AM_INPUT_KEYBRD) 函数读取键盘输入事件。
    - 如果按下的键是 ESC，游戏调用 halt(0) 函数退出。
    - 如果按下的键是字母键，游戏调用 check_hit() 函数检查是否命中字符。
  5. 命中处理：
  • check_hit() 函数遍历所有字符，检查按下的键是否与字符匹配，并且字符是否在屏幕上。
  • 如果命中，更新命中统计信息，并将字符的速度设置为负值，使其向上移动。
  • 如果未命中，更新错误统计信息。
  1. 系统视角
  2. NEMU：
    - NEMU用于模拟计算机硬件环境。它执行打字小游戏的二进制代码，并模拟 CPU、内存和外设。
    - 当游戏运行时，NEMU 负责解释和执行每一条指令，并处理硬件中断和设备 I/O。
  3. ISA：
    - ISA 定义了 CPU 支持的指令集和寄存器。打字小游戏的二进制代码是基于特定 ISA 编译的。
    - NEMU 根据 ISA 解释和执行指令，更新寄存器和内存状态。
  4. AM：
    - AM 提供了一组抽象的硬件接口，使得程序可以在不同的硬件平台上运行。
    - 打字小游戏通过 AM 提供的接口（如 io_read() 和 io_write()）与硬件交互，而不需要关心底层硬件的具体实现。
  5. 运行时环境：
    - 运行时环境包括操作系统和库函数，提供程序运行所需的基本服务。
    - 打字小游戏依赖于运行时环境提供的输入输出、内存管理和中断处理等功能。
  6. 按下一个字母并命中的过程：
  7. 按下字母键：
    - 用户按下一个字母键，键盘控制器生成一个键盘中断。
    - NEMU 捕获键盘中断，并调用相应的中断处理程序。
  8. 处理键盘中断：
    - 中断处理程序读取键盘输入，并将键码存储在输入缓冲区中。
    - 游戏主循环调用 io_read(AM_INPUT_KEYBRD) 函数读取键盘输入事件。
  9. 检查命中：
    - 游戏调用 check_hit() 函数，遍历所有字符，检查按下的键是否与字符匹配。
    - 如果命中，更新命中统计信息，并将字符的速度设置为负值，使其向上移动。
  10. 更新屏幕：
    - 游戏调用 render() 函数，将字符绘制到屏幕上，并显示命中、错过和错误的统计信息。
    - NEMU 模拟 GPU，将绘制的内容显示在屏幕上。

必答题：

程序是个状态机

  • 已完成，在“不停计算的机器”

RTFSC 请整理一条指令在NEMU中的执行过程

  • 已完成，在“RTFSC（2）”的“运行第一个C程序”中

程序如何运行 理解打字小游戏如何运行

  • 已完成，就在上面

编译与链接

  • 在nemu/include/cpu/ifetch.h中, 你会看到由static inline开头定义的inst_fetch()函数. 分别尝试去掉static, 去掉inline或去掉两者, 然后重新进行编译, 你可能会看到发生错误. 请分别解释为什么这些错误会发生/不发生? 你有办法证明你的想法吗?
  1. 去掉static：
  • 无错误
  • 原因：去掉static后，函数inst_fetch仍然是内联函数。内联函数在编译时会将函数体直接插入到调用点，因此不会产生多重定义的问题。
  1. 去掉inline：
  • 无错误
  • 原因：去掉inline后，函数inst_fetch仍然是静态函数。静态函数的作用域仅限于定义它的文件，因此不会产生多重定义的问题。
  1. 去掉两者：
  • 报错：
1
2
3
4
/usr/bin/ld: /home/xiaoyao/ics2024/nemu/build/obj-riscv32-nemu-interpreter/src/isa/riscv32/inst.o: in function `inst_fetch':
/home/xiaoyao/ics2024/nemu/include/cpu/ifetch.h:20: multiple definition of `inst_fetch'; /home/xiaoyao/ics2024/nemu/build/obj-riscv32-nemu-interpreter/src/engine/interpreter/hostcall.o:/home/xiaoyao/ics2024/nemu/include/cpu/ifetch.h:20: first defined here
collect2: error: ld returned 1 exit status
make: *** [/home/xiaoyao/ics2024/nemu/scripts/build.mk:54：/home/xiaoyao/ics2024/nemu/build/riscv32-nemu-interpreter] 错误 1
  • 原因：去掉static和inline后，函数inst_fetch变成了一个普通的全局函数。由于头文件ifetch.h会被多个源文件包含，因此会导致多个源文件中都定义了inst_fetch函数，从而在链接时产生多重定义错误。

编译与链接

  1. 在nemu/include/common.h中添加一行volatile static int dummy; 然后重新编译NEMU. 请问重新编译后的NEMU含有多少个dummy变量的实体? 你是如何得到这个结果的?
  2. 一共有：37个
  3. 方法：每个包含common.h的源文件都会打印dummy变量的地址，从而确认dummy变量的数量(数出37个)
1
2
3
4
5
#include <stdio.h>
volatile static int dummy;
__attribute__((constructor)) static void print_dummy_address() {
  printf("Address of dummy: %p\n", (void*)&dummy);
}
  1. 原因：
    - 重新编译后的 NEMU 含有多个 dummy 变量的实体。每个包含 common.h 的源文件都会有一个独立的 dummy 变量。
    - static 关键字使得 dummy 变量在每个源文件中都是局部的，因此每个包含 common.h 的源文件都会有一个独立的 dummy 变量。
  2. 添加上题中的代码后, 再在nemu/include/debug.h中添加一行volatile static int dummy; 然后重新编译NEMU. 请问此时的NEMU含有多少个dummy变量的实体? 与上题中dummy变量实体数目进行比较, 并解释本题的结果.
  3. 一共有：37个
  4. 方法：输出+数
1
2
3
4
5
6
7
8
9
10
11
12
//common.h
#include <stdio.h>
volatile static int dummy_common;
__attribute__((constructor)) static void print_dummy_address_common() {
  printf("Address of dummy in common.h: %p\n", (void*)&dummy_common);
}

//debug.h
volatile static int dummy;
__attribute__((constructor)) static void print_dummy_address_debug() {
  printf("Address of dummy in debug.h: %p\n", (void*)&dummy);
}
  1. 比较：结果相同。
  2. 原因：
    - static 关键字使得 dummy 变量在每个源文件中都是局部的，即每个包含 common.h 和 debug.h 的源文件都会有一个独立的 dummy 变量。
    - volatile 关键字告诉编译器该变量可能会被外部因素修改，因此编译器不会对该变量进行优化。
    - debug.h 包含了 common.h，因此每个包含 debug.h 的源文件中会有两个 dummy 变量，一个来自 common.h，一个来自 debug.h。
  3. 修改添加的代码, 为两处dummy变量进行初始化:volatile static int dummy = 0; 然后重新编译NEMU. 你发现了什么问题? 为什么之前没有出现这样的问题? (回答完本题后可以删除添加的代码.)
  • 报错，重复定义
  • 报错原因：
    • static 关键字：
      • static关键字使得变量在每个源文件中都是局部的，即每个包含 common.h 和 debug.h 的源文件都会有一个独立的 dummy 变量。
      • 但是，当在头文件中初始化 static 变量时，编译器会尝试在每个包含该头文件的源文件中定义并初始化该变量。这会导致多个定义冲突。
  • 之前没有出现这样的问题是因为：
    • 未初始化的 static 变量：
      • 当 static 变量未初始化时，编译器只会在每个包含该头文件的源文件中生成该变量的声明，而不会生成定义和初始化代码。
      • 因此，每个源文件都会有一个独立的 dummy 变量，而不会导致多个定义冲突。

了解Makefile

  • 请描述你在am-kernels/kernels/hello/目录下敲入make ARCH=$ISA-nemu 后, make程序如何组织.c和.h文件, 最终生成可执行文件am-kernels/kernels/hello/build/hello-$ISA-nemu.elf. (这个问题包括两个方面:Makefile的工作方式和编译链接的过程.) 关于Makefile工作方式的提示:
    • Makefile中使用了变量, 包含文件等特性
    • Makefile运用并重写了一些implicit rules
    • 在man make中搜索-n选项, 也许会对你有帮助
    • RTFM
  1. Makefile 工作方式
  2. 变量和包含文件
    - 在 am-kernels/kernels/hello/Makefile 中是以下内容：
    1
    2
    3
    NAME = hello
    SRCS = hello.c
    include $(AM_HOME)/Makefile

    - NAME 变量定义了目标文件的名称。
    - SRCS 变量定义了源文件。
    - include $(AM_HOME)/Makefile 包含了 $(AM_HOME)/Makefile 文件中的内容
  3. 隐式规则和重写
    - Makefile 使用了一些隐式规则和重写规则来简化编译和链接过程。隐式规则是 make 的默认规则，可以自动推断如何编译和链接文件。
  4. 编译链接过程
  5. 解析 Makefile
    - 当你在 am-kernels/kernels/hello/ 目录下敲入 make ARCH=$ISA-nemu 时，make 程序首先解析 Makefile。
  6. 包含 $(AM_HOME)/Makefile
    - make 程序解析 include $(AM_HOME)/Makefile，将 $(AM_HOME)/Makefile 文件的内容包含进来。假设 $(AM_HOME) 是 am-kernels/abstract-machine 目录。
  7. 解析 $(AM_HOME)/Makefile
    - 在 $(AM_HOME)/Makefile 中，定义了一些通用规则和变量，用于编译和链接不同的目标文件。
  8. 编译源文件
    - make 程序根据隐式规则和重写规则，首先编译源文件 hello.c
  9. 链接目标文件
    - 编译完成后，make 程序链接目标文件 hello.o，生成可执行文件 hello-$ISA-nemu.elf

If you like my blog, you can approve me by scanning the QR code below.

Other Articles
cover
计算机系统基础实验
PA1实验记录
  • 25/02/25
  • 22:49
  • 15k
  • 58
cover
计算机系统基础实验
PA3实验记录
  • 25/02/25
  • 22:46
  • 23.9k
  • 98
你走过的弯路，都是通向正轨的必经之路。
Article table of contents TOP
  1. 1. PA2 - 简单复杂的机器: 冯诺依曼计算机系统
  2. 2. 不停计算的机器
    1. 2.0.1. 1.取指(instruction fetch, IF)
    2. 2.0.2. 2.译码(instruction decode, ID)
    3. 2.0.3. 3.执行(execute, EX)
    4. 2.0.4. 4.更新PC
  3. 2.1. YEMU: 一个简单的CPU模拟器
  • 3. RTFSC(2)
    1. 3.1. RTFM
    2. 3.2. RTFSC(2)
      1. 3.2.1. 取指(instruction fetch, IF)
      2. 3.2.2. 译码(instruction decode, ID)
      3. 3.2.3. 执行(execute, EX)
      4. 3.2.4. 更新PC
      5. 3.2.5. 结构化程序设计
    3. 3.3. 运行第一个C程序
    4. 3.4. 运行更多的程序
      1. 3.4.1. PA2.1结束
  • 4. 程序, 运行时环境与AM
    1. 4.1. 运行时环境
    2. 4.2. 将运行时环境封装成库函数
    3. 4.3. AM - 裸机(bare-metal)运行时环境
    4. 4.4. RTFSC(3)
    5. 4.5. 实现常用的库函数
    6. 4.6. 重新认识计算机: 计算机是个抽象层
  • 5. 基础设施（2）
    1. 5.1. bug诊断的利器 - 踪迹
      1. 5.1.1. 指令执行的踪迹 - itrace
      2. 5.1.2. 指令环形缓冲区 - iringbuf
      3. 5.1.3. 内存访问的踪迹 - mtrace
      4. 5.1.4. 函数调用的踪迹 - ftrace
    2. 5.2. AM作为基础设施
    3. 5.3. 测试你的klib
    4. 5.4. Differential Testing——强大的测试工具！
    5. 5.5. 一键回归测试
  • 6. 输入输出
    1. 6.1. 设备与CPU
      1. 6.1.1. 端口I/O
      2. 6.1.2. 內存映射I/O
      3. 6.1.3. 状态机视角下的输入输出
    2. 6.2. NEMU中的输入输出
      1. 6.2.1. 映射和I/O方式
      2. 6.2.2. 设备
    3. 6.3. 将输入输出抽象成IOE
      1. 6.3.1. 串口
      2. 6.3.2. 时钟
      3. 6.3.3. 设备访问的踪迹 - dtrace
      4. 6.3.4. 键盘
      5. 6.3.5. VGA
    4. 6.4. 冯诺依曼计算机系统
      1. 6.4.1. 必答题：
    • Please enter keywords to search
    • to close