笔记 on Calendar's Blog

操作系统

Fri, 07 Nov 2025 00:00:00 +0000

操作系统概述

1940s 的计算机（ENIAC）：

逻辑门：真空电子管
延迟线内存通过 “抛球” 来扩大存储空间
没有操作系统！只需要执行程序即可

1950s：

磁芯内存
可以执行更复杂的任务，希望调用 API 而不是直接访问设备
在只有一个 CPU 的情况下，需要管理多个程序执行

1960s：

内存更大，意味着可以放多个程序到内存里
需要操作系统介入，实现多程序同时运行
还需要硬件变化，在多个地址隔离的程序间切换

1970s+：

基本现代化

程序和编译器

状态机：数字逻辑电路的模拟器

寄存器存储 + 运行逻辑 + 按照时间周期运行 –> 状态转换
程序就是状态机！

程序的状态有什么？

变量？全局 or 局部？
函数调用、函数返回是什么？ –> 栈帧的处理，调用是PUSH，返回是 POP

程序 = 计算 + syscall

加上了系统调用，将操作权交给系统。

编译器

优化可优化的部分，转义不可优化的部分

状态机的初始状态（lib-64-linux/…）等等都有定义，都建立在确定的基础上。

gdb、strace、binutils 追踪

并发

多处理器编程

原子性

并发的基础：多线程

线程共享内存、具有独立堆栈
如何验证？ –> strace……

带来的问题：

多线程共用变量时，发生冲突
基本假设不再成立：程序不再独占处理器执行

解决：实现原子性

将大人物切分为可以并行的小任务
用 worker thread 去锁保护的队列里取任务

顺序

编译器默认程序时顺序执行的，以进行优化；但是多线程时顺序不一定成立

可见性

处理器同时也是编译器，能够同时执行一个线程的指令

即便是汇编，也可能产生步骤乱序执行

需要放弃对旧的“程序”的理解

理解并发程序执行

Peterson 算法

举旗，两个共享变量实现并发？

用贴对方的标签来竞争

如何证明正确性？

画状态机？枚举所有可能性
PC 的含义 –> 指令的步骤++
用 python 来检测！选对语言

py 的特性，yield

只要能位系统建立模型，就能证明正确 / 找到错误

将问题转化为图论问题

在多处理器上实现线程隔离

虚拟化

把物理计算机 “抽象” 成 “虚拟计算机”
- 程序好像独占计算机运行

程序和进程

程序是状态机的静态描述
- 描述了所有可能的程序状态
- 程序 (动态) 运行起来，就成了进程 (进行中的程序)
- 可以使用文件 API (“everything is a file”) 访问当前进程的 ID、状态信息、命令行参数和工作目录等元数据。

进程（状态机）管理

操作系统 = 状态机的管理者

创建状态机：spawn(path, argv)
销毁状态机: _exit()
复制状态机: fork()
- 完整复制状态机；新创建的状态机返回值为 0，执行 fork() 的进程会返回子进程的进程号。
- pritf 的输出机制，输出到缓冲区
复位状态机: execve()
- 参数 path、argv、evnp

windows 与 Unix 管理进程的 API 不同

进程的地址空间

进程的初始状态

寄存器
- ABI 中规定了 initial state
- 只规定了部分寄存器和栈 (argv 和 envp 中的字符串保存在栈中)
内存
- Binary 中指定的 PT_LOAD 段
  - 内存是分成 “一段一段” 的
  - 每一段有访问权限 (rwx)
- 只有ELF 文件里声明的内存和一些操作系统分配的内存
  - 任何其他指针的访问都是非法的
  - 所以需要能够动态分配！

进程的地址空间管理

在状态机状态上增加/删除/修改一段可访问的内存
- MAP_ANONYMOUS: 匿名 (申请) 内存
- fd: 把文件 “搬到” 进程地址空间中 (例子：加载器)

// 映射
void *mmap(void *addr, size_t length, int prot, int flags,
           int fd, off_t offset);
int munmap(void *addr, size_t length);

// 修改映射权限
int mprotect(void *addr, size_t length, int prot);

可以用 pmap 命令查看进程的地址空间
瞬间完成内存分配
- mmap/munmap 为 malloc/free 提供了机制
- libc 的大 malloc 会直接调用一次 mmap 实现

pmap 命令通过读取 /proc/[pid]/maps 和 /proc/[pid]/smaps 文件来获取进程的内存映射信息。Linux 内核将这些信息以文本形式暴露在 /proc 文件系统中，pmap 通过解析这些文件实现功能，而无需直接调用特定的系统调用。

入侵地址空间

gdb 的实现原理，可以任意观测、修改程序状态

小时候用的游戏修改器，需要多次读取数据，筛选后修改。原理就是监控游戏的整块内存。

访问操作系统对象

先回顾一下操作系统创建的流程：一开始只有一个进程，然后通过 fork 产生出子进程，接着用 execve 来替换子进程为目标进程，再用 mmap 来分配空间

文件描述符

是指向操作系统对象的 “指针”——系统调用通过这个指针 (fd) 确定进程希望访问操作系统中的哪个对象。我们有 open, close, read/write, lseek, dup 管理文件描述符。
- 对象的访问都需要指针
  - open, close, read/write (解引用), lseek (指针内赋值/运算), dup (指针间赋值)
- 在 fork 的时候，文件描述符继承吗？
  - 继承（UNIX中），方便但是危险
“文件”：有名字的数据对象，Everything is a file

操作系统中的对象

真实的设备
- /dev/sda
虚拟的设备（文件）
- /dev/urandom，/dev/null，并没有实际文件，但是操作系统为它们实现了特别的read、write操作
管道：特殊的文件流
- 读口支持 read，写口支持 write

整合起来，就是所有的基础知识：

进程管理

fork, execve, waitpid, exit

内存管理

mmap, munmap, mprotect, msync

文件管理

open, close, read, write, lseek, dup

一切皆文件的利弊：

一套 API 可以访问所有对象,便捷
- 一切都可以 | grep
但是涉及多义性、复杂项目下不便、耦合度高、高速设备不友好…

终端和 UNIX shell

终端的历史，其实就是直接控制硬件（打字机、繁重而昂贵的操作系统）的输入 - 输出互动的窗口

今天则用伪终端（Pseudo Terminal）来模拟

用户登录的起点

系统启动 (内核 → init → getty)
远程登录 (sshd → fork → openpty)
- stdin, stdout, stderr 都会指向分配的终端
vscode (fork → openpty)

login 程序继承分配的终端

(是的，login 是一个程序)
fork() 会继承文件描述符 (指针)
- 因此，子进程也会指向同一个终端

终端的机制

怎么确定要控制的是那个终端/进程？（比如Ctrl + C）
只管传输字符 –> 由操作系统来决定如何对“当前”进程采取行动
历史遗留问题，局限性：无法预知软件的未来
- 要做的是进行抽象，不要在把高层“意图”翻译成低层“规程”上花费脑力和时间

Shell编程

基于文本替换的极简编程语言！
- 预处理: $(), <()
- 重定向: cmd > file < file 2> /dev/null
- 顺序结构: cmd1; cmd2, cmd1 && cmd2, cmd1 || cmd2
- 管道:cmd1 | cmd2
  - 这些命令被翻译成系统调用序列 (open, dup, pipe, fork, execve, waitpid, …)

C 标准库和实现

API 的设计有一个有趣的原则：“非必要不实现” (“机制与策略分离”、“最小完备性原则”)：但凡应用程序能自己搞定的功能，操作系统就不需要提供——在一定程度上，这样的设计能防止 “包揽一切” 导致代码膨胀，甚至在长期演化的过程中成为历史的包袱。

C 是一种 “高级汇编语言”
- 作为对比，C++ 更好用，但也更难移植
系统调用的一层 “浅封装”
libc
- 大部分可以用 C 语言本身实现
- 少部分需要一些 “底层支持”
  - 例子：体系结构相关的内联汇编
“最小完备性原则” 和 “机制策略分离” 的反面教材
- “每一个 malloc 在任何可能路径上都必有一次配对的 free，且之后不再使用”
- 在复杂系统里太难保证了

脱离 workload 做优化就是耍流氓

在开始考虑性能之前，理解你需要考虑什么样的性能

可执行文件

是什么

ELF 是 Executable and Linkable Format 的缩写，是 Linux 系统上的一种可执行文件格式。

一个操作系统中的对象 (文件)
一个字节序列 (我们可以把它当字符串编辑)
一个描述了状态机初始状态的数据结构

需要什么

一个头 (类似 7f 45 4c 46; 这是一个 jg 71)
一段 Trampoline Code (PIC)
- 操作系统会给一个文件描述符 (指向文件本身)
- 这段代码直接执行 hardcoded mmap
(就能实现 “加载” 的功能)

反思

ELF 不是一个人类友好的 “状态机数据结构描述”
- 为了性能，彻底违背了可读 (“信息局部性”) 原则
- Crash (SIGSEGV, SIGABRT, SIGILL, …) 时会做 core dump
  - ulimit -c unlimited：启用 Core Dump 的命令（或设一个合理的大小限制），确保程序崩溃时能生成 Core 文件
  - 适合于 production systems
  - 通过设置 core dump size，我们可以在程序发生 core dump 时保存到文件系统，并且在后续使用 gdb 调试它,但是 GDB 无法基于它继续执行
  - 用 CRIU （Checkpoint/Restore In Userspace）解决

自己设计可执行文件？

满足回归链接和加载中的核心概念：代码、符号、重定位，就可以了

生成可执行文件地过程

源代码 (.c) → 源代码 (.i)
- Ctrl-C & Ctrl-V (#include)
- 字符串替换
- 今天：我们有过程宏
源代码 (.i) → 汇编代码 (.s)
- “高级状态机” 到 “低级状态机” 的翻译
- 最终生成带标注的指令序列
- 汇编代码 (.s) → 目标文件 (.o)
  - 文件 = sections (.text, .data, .rodata.str.1, …)
    - 对于 ELF，每个 section 有它的权限、内存对齐等信息
  - section 中的三要素
    - 代码 (字节序列)
    - 符号：标记 “当前” 的位置
    - 重定位：暂时不能确定的数值 (链接时确定)
多个目标文件 (.o) → 可执行文件 (a.out)
- 合并所有的 sections
  - 分别合并 .text, .data, .bss 中的代码
  - 把 sections “平铺” 成字节序列
  - 确定所有符号的位置
  - 解析全部重定位
- 得到一个可执行文件
最后，把字节序列搬到内存，执行

操作系统和加载器

execve(path, argv, envp)

操作系统内核解析 path、完成加载
# 注释的作用 -> 指示解释器路径

操作系统

Fri, 07 Nov 2025 00:00:00 +0000

参考：https://jyywiki.cn/OS/

操作系统概述

1940s 的计算机（ENIAC）：

逻辑门：真空电子管
延迟线内存通过 “抛球” 来扩大存储空间
没有操作系统！只需要执行程序即可

1950s：

磁芯内存
可以执行更复杂的任务，希望调用 API 而不是直接访问设备
在只有一个 CPU 的情况下，需要管理多个程序执行

1960s：

内存更大，意味着可以放多个程序到内存里
需要操作系统介入，实现多程序同时运行
还需要硬件变化，在多个地址隔离的程序间切换

1970s+：

基本现代化

程序和编译器

状态机：数字逻辑电路的模拟器

寄存器存储 + 运行逻辑 + 按照时间周期运行 –> 状态转换
程序就是状态机！

程序的状态有什么？

变量？全局 or 局部？
函数调用、函数返回是什么？ –> 栈帧的处理，调用是PUSH，返回是 POP

程序 = 计算 + syscall

加上了系统调用，将操作权交给系统。

编译器

优化可优化的部分，转义不可优化的部分

状态机的初始状态（lib-64-linux/…）等等都有定义，都建立在确定的基础上。

gdb、strace、binutils 追踪

并发

多处理器编程

原子性

并发的基础：多线程

线程共享内存、具有独立堆栈
如何验证？ –> strace……

带来的问题：

多线程共用变量时，发生冲突
基本假设不再成立：程序不再独占处理器执行

解决：实现原子性

将大人物切分为可以并行的小任务
用 worker thread 去锁保护的队列里取任务

顺序

编译器默认程序时顺序执行的，以进行优化；但是多线程时顺序不一定成立

可见性

处理器同时也是编译器，能够同时执行一个线程的指令

即便是汇编，也可能产生步骤乱序执行

需要放弃对旧的“程序”的理解

理解并发程序执行

Peterson 算法

举旗，两个共享变量实现并发？

用贴对方的标签来竞争

如何证明正确性？

画状态机？枚举所有可能性
PC 的含义 –> 指令的步骤++
用 python 来检测！选对语言

py 的特性，yield

只要能位系统建立模型，就能证明正确 / 找到错误

将问题转化为图论问题

在多处理器上实现线程隔离

虚拟化

程序和进程

程序是状态机的静态描述
- 描述了所有可能的程序状态
- 程序 (动态) 运行起来，就成了进程 (进行中的程序)
- 可以使用文件 API (“everything is a file”) 访问当前进程的 ID、状态信息、命令行参数和工作目录等元数据。

进程（状态机）管理

操作系统 = 状态机的管理者

创建状态机：spawn(path, argv)
销毁状态机: _exit()
复制状态机: fork()
- 完整复制状态机；新创建的状态机返回值为 0，执行 fork() 的进程会返回子进程的进程号。
- pritf 的输出机制，输出到缓冲区
复位状态机: execve()
- 参数 path、argv、evnp

windows 与 Unix 管理进程的 API 不同

进程的地址空间

进程的初始状态

寄存器
- ABI 中规定了 initial state
- 只规定了部分寄存器和栈 (argv 和 envp 中的字符串保存在栈中)
内存
- Binary 中指定的 PT_LOAD 段
  - 内存是分成 “一段一段” 的
  - 每一段有访问权限 (rwx)
- 只有
  
  ELF 文件里声明的
  
  内存和一些操作系统分配的内存
  - 任何其他指针的访问都是非法的
  - 所以需要能够动态分配！

进程的地址空间管理

在状态机状态上增加/删除/修改一段可访问的内存
- MAP_ANONYMOUS: 匿名 (申请) 内存
- fd: 把文件 “搬到” 进程地址空间中 (例子：加载器)

// 映射
void *mmap(void *addr, size_t length, int prot, int flags,
           int fd, off_t offset);
int munmap(void *addr, size_t length);

// 修改映射权限
int mprotect(void *addr, size_t length, int prot);

可以用 pmap 命令查看进程的地址空间
瞬间完成内存分配
- mmap/munmap 为 malloc/free 提供了机制
- libc 的大 malloc 会直接调用一次 mmap 实现

pmap 命令通过读取 /proc/[pid]/maps 和 /proc/[pid]/smaps 文件来获取进程的内存映射信息。Linux 内核将这些信息以文本形式暴露在 /proc 文件系统中，pmap 通过解析这些文件实现功能，而无需直接调用特定的系统调用。

入侵地址空间

gdb 的实现原理，可以任意观测、修改程序状态

小时候用的游戏修改器，需要多次读取数据，筛选后修改。原理就是监控游戏的整块内存。

访问操作系统对象

先回顾一下操作系统创建的流程：一开始只有一个进程，然后通过 fork 产生出子进程，接着用 execve 来替换子进程为目标进程，再用 mmap 来分配空间

文件描述符

是指向操作系统对象的 “指针”——系统调用通过这个指针 (fd) 确定进程希望访问操作系统中的哪个对象。我们有 open, close, read/write, lseek, dup 管理文件描述符。
- 对象的访问都需要指针
  - open, close, read/write (解引用), lseek (指针内赋值/运算), dup (指针间赋值)
- 在 fork 的时候，文件描述符继承吗？
  - 继承（UNIX中），方便但是危险
“文件”：有名字的数据对象，Everything is a file

操作系统中的对象

真实的设备
- /dev/sda
虚拟的设备（文件）
- /dev/urandom，/dev/null，并没有实际文件，但是操作系统为它们实现了特别的read、write操作
管道：特殊的文件流
- 读口支持 read，写口支持 write

整合起来，就是所有的基础知识：

进程管理

fork, execve, waitpid, exit

内存管理

mmap, munmap, mprotect, msync

文件管理

open, close, read, write, lseek, dup

一切皆文件的利弊：

一套 API 可以访问所有对象,便捷
- 一切都可以 | grep
但是涉及多义性、复杂项目下不便、耦合度高、高速设备不友好…

终端和 UNIX shell

终端的历史，其实就是直接控制硬件（打字机、繁重而昂贵的操作系统）的输入 - 输出互动的窗口

今天则用伪终端（Pseudo Terminal）来模拟

用户登录的起点

系统启动 (内核 → init → getty)
远程登录 (sshd → fork → openpty)
- stdin, stdout, stderr 都会指向分配的终端
vscode (fork → openpty)

login 程序继承分配的终端

(是的，login 是一个程序)
fork() 会继承文件描述符 (指针)
- 因此，子进程也会指向同一个终端

终端的机制

怎么确定要控制的是那个终端/进程？（比如Ctrl + C）
只管传输字符 –> 由操作系统来决定如何对“当前”进程采取行动
历史遗留问题，局限性：无法预知软件的未来
- 要做的是进行抽象，不要在把高层“意图”翻译成低层“规程”上花费脑力和时间

Shell编程

基于文本替换的极简编程语言！
- 预处理: $(), <()
- 重定向: cmd > file < file 2> /dev/null
- 顺序结构: cmd1; cmd2, cmd1 && cmd2, cmd1 || cmd2
- 管道:
  1
  
  cmd1 | cmd2
  - 这些命令被翻译成系统调用序列 (open, dup, pipe, fork, execve, waitpid, …)

C 标准库和实现

API 的设计有一个有趣的原则：“非必要不实现” (“机制与策略分离”、“最小完备性原则”)：但凡应用程序能自己搞定的功能，操作系统就不需要提供——在一定程度上，这样的设计能防止 “包揽一切” 导致代码膨胀，甚至在长期演化的过程中成为历史的包袱。

C 是一种 “高级汇编语言”
- 作为对比，C++ 更好用，但也更难移植
系统调用的一层 “浅封装”
libc
- 大部分可以用 C 语言本身实现
- 少部分需要一些 “底层支持”
  - 例子：体系结构相关的内联汇编
“最小完备性原则” 和 “机制策略分离” 的反面教材
- “每一个 malloc 在任何可能路径上都必有一次配对的 free，且之后不再使用”
- 在复杂系统里太难保证了

脱离 workload 做优化就是耍流氓

在开始考虑性能之前，理解你需要考虑什么样的性能

可执行文件

是什么

ELF 是 Executable and Linkable Format 的缩写，是 Linux 系统上的一种可执行文件格式。

一个操作系统中的对象 (文件)
一个字节序列 (我们可以把它当字符串编辑)
一个描述了状态机初始状态的数据结构

需要什么

一个头 (类似 7f 45 4c 46; 这是一个 jg 71)
一段 Trampoline Code (PIC)
- 操作系统会给一个文件描述符 (指向文件本身)
- 这段代码直接执行 hardcoded mmap
(就能实现 “加载” 的功能)

反思

ELF 不是一个人类友好的 “状态机数据结构描述”
- 为了性能，彻底违背了可读 (“信息局部性”) 原则
- Crash (SIGSEGV, SIGABRT, SIGILL, …) 时会做 core dump
  - ulimit -c unlimited：启用 Core Dump 的命令（或设一个合理的大小限制），确保程序崩溃时能生成 Core 文件
  - 适合于 production systems
  - 通过设置 core dump size，我们可以在程序发生 core dump 时保存到文件系统，并且在后续使用 gdb 调试它,但是 GDB 无法基于它继续执行
  - 用 CRIU （Checkpoint/Restore In Userspace）解决

自己设计可执行文件？

满足回归链接和加载中的核心概念：代码、符号、重定位，就可以了

生成可执行文件地过程

源代码 (.c) → 源代码 (.i)
- Ctrl-C & Ctrl-V (#include)
- 字符串替换
- 今天：我们有过程宏
源代码 (.i) → 汇编代码 (.s)
- “高级状态机” 到 “低级状态机” 的翻译
- 最终生成带标注的指令序列
- 汇编代码 (.s) → 目标文件 (.o)
  - 文件 = sections (.text, .data, .rodata.str.1, …)
    - 对于 ELF，每个 section 有它的权限、内存对齐等信息
  - section 中的三要素
    - 代码 (字节序列)
    - 符号：标记 “当前” 的位置
    - 重定位：暂时不能确定的数值 (链接时确定)
多个目标文件 (.o) → 可执行文件 (a.out)
- 合并所有的 sections
  - 分别合并 .text, .data, .bss 中的代码
  - 把 sections “平铺” 成字节序列
  - 确定所有符号的位置
  - 解析全部重定位
- 得到一个可执行文件
最后，把字节序列搬到内存，执行

操作系统和加载器

execve(path, argv, envp)

操作系统内核解析 path、完成加载
# 注释的作用 -> 指示解释器路径

链接和加载

当开发者希望把库函数和应用程序 “分离” 开，但又希望库函数可以被调用，此时就需要动态链接

动态链接：机制

实现运行库和应用代码分离

应用之间的库共享
- 每个程序都需要 glibc
- 但系统里只需要
  
  一个副本
  
  就可以了
  - 是的，我们可以用 ldd 命令查看
  - 运行库和应用代码还可以分别独立升级
大型项目的分解
- 改一行代码不用重新链接 2GB 的文件
- libjvm.so, libart.so, …共享库文件
只读方式 mmap 同一个文件，物理内存中只有一个副本，分页的机制，使得内存的处理更灵活，无需多个物理副本

问题：怎么判断是否需要链接进来共享库？

动态链接的本质是 “运行时绑定地址”，PLT/GOT 是实现这一逻辑的底层表；环境变量 LD_PRELOAD 则是利用动态链接的加载顺序，实现库的 “运行时替换”（加入本地的库）。

密码学

Sat, 25 Oct 2025 00:00:00 +0000

引言与古典密码体制

基础知识

对称加密和公钥加密
- 根据消息发送方和接收方使用的加密和解密密钥是否相同，加密方案可分为对称加密和公钥加密。
  - ==公加私解==
消息认证码
- 消息发送方和接收方首先共享一个密钥，发送方为待发送的消息产生一个标识，并将消息和标识一同发送给接收方。
- 用于标志消息息在传递过程中没有被篡改
哈希函数
- 将任意长的消息映射为一个“较短的” “定长的” 抗碰撞的”消息摘要。
- 用于保护数据完整性，防篡改
数字签名
- 在数字世界中实现了“手写签名”的功能，保证了被签名消息的完整性和不可否认性。
- 案基于公钥密码体制：发送者使用自己的私钥对消息进行签名，接收者使用签名者的公钥验证数字签名的合法性。

现代密码学发展史

1940 ==香农==证明了一次一密的安全性

……

加密

语法
- K 密钥空间
- M 明文空间：现代密码学中，M是二进制字符串的集合
- C 密文空间
- 加密方案(Gen; Enc; Dec)
  - Gen ：K (概率性的) 密钥生成算法。
  - Enc : K x M→C 加密算法。
  - Dec : K x C →M 解密算法。
科尔霍夫原则
- 密码算法的安全性应该依赖于密钥k的保密性,而不应依赖于算法 Gen;Enc; Dec 的保密性。
- 理由：
  - 算法设计保密是不切实际的（逆向工程）。
  - 短密钥更容易保护、生成和替换。
  - 密码设计应该被公开讨论和分析。

古典密码

单表代换
- 移位密码：如凯撒密码、仿射密码
- 密文空间小时，直接爆破
- 密文空间大时，用字母频率猜测

多表代换
- 选择一串字符作为密钥，明文字符“加上”密钥字符得到密文字符
- 多表代换密码是安全的：密钥长度等于明文长度
- 当密钥长度小于明文长度时，多表代换密码易受到统计攻击。
  - 先确定密钥周期
  - 拆分部分，分别频率检测

对称加密

完善保密性

基本概念
- 高熵、均匀一致、随机
- 现代随机数生成步骤：收集高熵数据、产生几乎独立无偏的比特串
完善保密性
- 获取密文的行为不改变敌手对所发送的实际消息的知识
- 密文不应泄露有关底层明文的额外信息

知识 vs 信息

信息是公开可用的，可直观获取的。知识是困难计算的结果，任何人都能有效获得的都不能称为知识。应用于公开可用信息的简单计算的结果不被认为是知识。应用于公共可用信息的难以计算的函数的结果是知识。

流密码和分组密码

在实际中，PRG是使用流密码实例化的。
PRP是使用分组密码进行实例化的。实际上，PRP也被称为分组密码。
但是 Block cipher 不是一种加密方案

流密码

大致就是切分明文串来加密，密钥流是用单密钥随机产生的

两种操作模式

同步模式
- 有状态，消息按顺序接收、加密
异步模式
- 无状态，每个块密钥流独立
- 每个密钥流独立生成（有自己的生成器）

设计原则

混淆原则
- 使密钥和密文之间的依赖关系尽可能模糊。即使敌手获取了一些密文的统计特性,也无法推测密钥。常使用代替方法实现混淆。
扩散原则
- 使明文和密文的关系变得尽可能的复杂,即密文中的每一位受明文中的许多位的影响。常使用置换方法实现扩散
乘积密码
- 也叫迭代密码,通过轮函数的多次迭代,对数据重复迭代操作,实现扩散与混淆
分组密码的迭代方式
- 代换-置换SP网络(substitution-permutation)-Feistel网络

大学物理（下）

Wed, 22 Oct 2025 00:00:00 +0000

参考视频：《大学物理-电磁学》

电学

电场强度

库伦定律：

电场强度：

对于圆弧来说：dl = Rdθ

一些结论：

电通量、高斯定理

电通量

静电场中高斯定理

电势

电势

电势能

电场和电势的关系

导体

为什么内部场强为零？

导体上的电荷可以自由移动，移动后形成电场，与外部场强相抵消

内部包围有电荷 q 时，导体上电荷分布？

导体内层会感应出 -q，外层变为 Q+q。由高斯定理配合导体内场强为零，可知导体内部的 E * S = 0，故 q + -q = 0

传导电流

若将导体的两端接到电源上, 导体中便有持续的电流，这种存在导体中的电流称为传导电流。

电流密度

欧姆定律的微分形式

稳恒电流
- 可推导出基尔霍夫定律

电动势

电容器

串并联
- 串联时电荷相等
- 并联时电压相等 C = C1 + …… + Cn

特例：

电解质、电场能

电介质高斯定理

电场能

磁学

磁感应强度

判断方向

毕奥萨法尔定律

结论：

安培环路定理：

磁通量、高斯定理

分类：

安培力、磁矩、洛伦兹力

安培力

磁矩

洛伦兹力

磁介质、磁场能

磁介质

磁场能量

概率论

Wed, 22 Oct 2025 00:00:00 +0000

参考视频：概率论四小时速成

随机事件与概率

事件关系与运算率

事件关系：

运算律：

概率计算性质

注意：对于多项依然成立

集合并 == 概率 +

集合且 == 概率 ·

补充：容斥原理

条件概率

条件概率与乘法公式：

事件的独立性

独立不互斥，互斥不独立

多事件独立性：

全概率 - 贝叶斯公式：

随机变量分布

分布函数：

备注：

概率 - 分布函数关系：配凑出范围

分布函数的充要条件：

等号跟大于走，永远右连续

根据规范性、右连续性，可以用极限解方程求参数

常识结论：

离散型随机变量

分布律可以写成表格的形式

古典概型：

根据分布律写分布函数：

根据定义域划分范围，依次求和

二项分布

独立重复、事件 A 发生的次数

几何概型：

几何分布

事件首次发生的概率

二项 01 分布

泊松分布

注意一个代换：

连续型随机变量

概率密度：

概率为 0 的事件可能发生

概率密度的积分就成为概率 –> 在哪求概率，就在哪求积分

充要条件：

与分布函数：

分定义域求积分

均匀分布

指数分布

利用指数分布的无记忆性，转换区间

正态分布

标准化：

先变换为标准正态，再求概率（用标准正态的分布函数表示）

根据形式配凑

已知 X，求 f(X) 的分布函数

关键在于根据 Y <= y 转换出 X ~ y 关系，用 X 的分布函数代换出 Y 的

二维随机变量

离散型

联合分布律

独立性

有 p_ij = 0，一定不独立

独立 == 各行（列）成比例

连续型

分布密度、概率

找区域，二重积分即可

独立性

边缘密度

对另一个变量积分

条件概率密度

固定某个参数后，概率密度只域另一个参数有关

二位均匀

求面积之比即可

最大、最小值分布

二维连续型函数分布

分布函数法：

换元

做正概区域范围 D_z 和 g(x,y) 观察交集

根据 z 从负无穷到正无穷，对 x，y 积分（z 作为常数）

公式法：

需要可以反解出 y 才可使用，替换 x 或 y 以后，再乘上偏导

注意定义域的选定

数据结构与算法

Wed, 22 Oct 2025 00:00:00 +0000

绪论

数据结构

形式定义：
- 数据结构是一个四元组 Data_Structure=（D,L,S,O）
  - D是数据元素的有限集
  - L是D上客观存在的关系（逻辑结构）
  - S是关系L在计算机中的存储表示（存储结构）
  - O是D上规定的一组操作。
组成：
- 集合（set）—若干具有共同特征的事物的“聚合”。
- 数据（data) —所有能输入到计算机中的描述客观事物的符号
- 数据元素（data element）—数据的基本单位，也称节点（node）或记录（record）
- 数据项（data item）—有独立含义的数据最小单位，也称域(field)
- 关键码（key）—数据元素中能起标识作用的数据项。
- 关系 —集合中元素之间的某种相关性
逻辑结构
- 线性结构：一对一，线性表、栈、队列等
- 树形结构
- 图状结构
存储结构
- 顺序：借助相对位置表示元素间关系
- 链式：借助指针
- 散列：通过对关键字直接计算

算法

为了解决某类问题而规定的一个有限长的操作序列

特性：有穷、确定、可行、功能性
目标：正确、可读、健壮、高效率与低存储量需求
衡量方法
- 算法的时间特性用执行基本操作次数来度量
- 算法的空间特性用算法运行所需存储量的增长率

线性表、栈与队列

线性结构特点：在数据元素的非空有限集中
- 存在唯一一个称作“第一个”的数据元素
- 存在唯一一个称作“最后一个”的数据元素
- 除第一个外，集合中的每个数据元素均只有一个前驱
- 除最后一个外，集合中的每个数据元素均只有一个后继

线性表

定义：一个线性表是n个数据元素的有限序列
- 元素个数n = 表长度
- a_1 无直接前驱，a_n 无直接后继
- i 为 a_i 再线性表中的位序

顺序存储

逻辑上相邻 - 物理地址相邻

操作
- 插入：复杂度 n/2，算在 i 出的平均移动次数
- 删除：复杂度 (n-1)/2
优点：
- 逻辑相邻，物理相邻
- 可随机存取任一元素
- 存储空间使用紧凑
缺点：
- 插入、删除操作需要移动大量的元素
- 预先分配空间需按最大空间分配，利用不充分
- 表容量难以扩充

链式存储

特点：
- 用一组任意的存储单元存储线性表的数据元素，利用指针实现：用不相邻的存储单元存放逻辑上相邻的元素
- 每个数据元素ai，除存储本身信息外，还需存储其直接后继的信息

单链表

结构：

typedef struct ListNode {
 ElemType data;
 struct ListNode  *next;
 }ListNode,*ListNodePtr;

// 生成新节点
p=(ListNodePtr) malloc ( sizeof ( ListNode ));
// 回收节点
free(p)

操作
- 查找：O(n)
- 插入、删除：O(1)
特点：
- 动态结构，整个存储空间为多个链表共用
- 不需预先分配空间，指针额外存储空间
- 不能随机读取，查找慢

循环链表

表中最后一个结点的指针指向头结点，使链表构成环状

从表中任一结点出发均可找到表中其他结点，提高查找效率

操作与单链表基本一致,循环条件不同：
- 单链表 p 或 p->next=NULL
- 循环链表 p->next=h

双向链表

解决单链表单向性的问题，存储前、后指针

栈

顺序存储

定义：
- 限定仅在表尾进行插入或删除操作的线性表，进行操作的一端称栈顶，固定的一端称栈底，不含元素的空表称空栈。
- 先进后出
操作：
- 用指针 top 始终指向栈顶，初值为 -1 （栈空），终值为 M-1 （栈满）

// 初始化
#define MAXSTACK 100
 typedef struct{
 int top;
 StackEntry entry[MAXSTACK];
 }SqStack;

链式存储

top 始终指向下一个插入的位置，类似

队列

限定只能在表的一端进行插入，在表的另一端进行删除的线性表，先进先出

链式存储

设队首、队尾指针 front 和rear, front 指向头结点，rear 指向队尾

问题：

队列不满时假溢出、队列满时真溢出

解决：

队首固定：需要频繁移动 X
循环队列：将队列设计成环形，让 让sq[0] 接在 sq[M-1] 之后，若 rear == M，则令 rear = 0
- 问题：队空和队满标志一样
- 解决：另设标志位、少用一个元素空间、用一个计数变量

优先队列

不完全遵守先进先出，设有优先级

数组

顺序存储：

需要区分列主序、行主序
Loc (j1, j2, ... , jn )=Loc (0, 0, ... , 0)+(b2*b3*...*bn*j1 + b3*b4*...*bn*j2+ ...+bn*jn-1+ jn)*l

三角矩阵：

三对角矩阵：

稀疏矩阵：

链式存储

表示矩阵：

数组 + 链表

查找、排序、递归

递归

定义：

一个过程或函数出现调用本过程或本函数的成分,称之为递归。
若调用自身,称之为直接递归。若过程或函数p调用过程或函数q,而q又调用 p,称之为间接递归。
如果一个递归过程或递归函数中递归调用语句是最后一条执行语句,则称这种递归调用为尾递归。

查找

顺序表

顺序查找，改变 R[0] 以控制结束：

int seqsearch(DataType R[], KeyType key){
                  R[0].key=key, i=n;
                  while (R[i].key != key)  i=i-1;
                  return i;
}

折半查找，对于有序表

int BinarySearch(DataType SL[], KeyType key, int n){
   //在长度为n的有序表SL中折半查找其关键字等于key的数据元素
   //查找成功返回其在有序表中的位置，查找失败否返回0
	int low=1; 
	int high=n;
	while(low<=high){
	    mid=(low+high)/2;
	    if(key = = SL[mid].key) {return mid;}              
	    else if( key>SL[mid].key) low=mid+1;
	    else high=mid-1;
	}
	return 0;
}

索引表查找
- 基本思想：将原表分成若干块，各块内部不一定有序，但表中的块是“分块有序”的，抽取各块中的最大关键字及其起始位置建立索引表。
- 块间顺序：复杂度 1/2 * (n/s + s) + 1 (n 长度，分成 n/s 块)
- 块间二分：log_2(n/s + 1) + s/2

int IndexSequelSearch(IndexType ls[], DataType s[], int m, int l, KeyType key){
       //索引表中顺序查找关键字为key的记录。索引表为ls[0]-ls[m-1]
    //顺序表为s，块长为l
    //在索引表中顺序查找
         i=0;
         while(i<m && key>ls [i ].key)i++;  //块间查找
             if(i>=m)return -1;  //查找失败
             else{           //在块内顺序查找
                  j=ls[ i ].Link;
                  while(Key!=s[j].key && j-ls[ i ].Link<l)j++;
                   if(key = = s[j].key)return j;  //查找成功
                   else return -1;  //查找失败
           }
}

哈希表查找
- 以 h(key) 哈希函数 作为 key 的记录在表中的位置，常见构造方法有：
  - 直接哈希：适用于地址集合大小 == 关键字集合大小
  - 数字分析：取随机
  - 平方取中：取关键字平方后的中间几位
  - 折叠：关键字分割后求和
  - 除留取余：除某个不大于哈希表长度的数后取余
  - 随机数：取随机数
- 冲突处理方法：
  - 开放地址：线性探测、平方探测、随机探测再散列
  - 再哈希：将 n 个不同哈希函数排成序列，往下计算
  - 链地址：将关键字发生冲突的记录存储在一个线性链表中
  - 公共溢出：将发生冲突的放在冲突表中
- ALS 影响因素：
  - 选用的哈希函数
  - 冲突处理方法
  - 哈希表饱和度、装载因子 n/m 的大小

排序

基本概念

稳定性：对于任意的数据元素序列，以在排序前后相同关键字数据的相对位置是否改变为依据
内外部：
- 无需借助外存，称内部排序
- 数据量巨大，需要借助外村，称外部排序

插入

直接插入：

for ( i=2;  i<=n;  ++i )
   if (R[i].key<R[i-1].key) 
     {  在 R[1..i-1]中查找R[i]的插入位置;
         插入R[i] ;
     }

折半插入
- 因为 R[1..i-1] 是一个按关键字有序的有序序列，则可以利用折半查找实现
希尔排序
- 对于n较大而且无序时，直接插入排序效率就较低，这时，如果能将序列分成几个较小的序列，对这些较小的序列先排序，然后再对较长的序列进行排序，可一定程度地提高排序效率。
- 步骤：
  - 先选取一个小于n的整数di（步长），然后把待排序的序列分成di个组
  - 第一趟完成之后，减小步长，再进行分组，再排序，如此知道 d=1

交换

冒泡排序
- 基于两两比较及交换，直到某一趟没有发生数据的交换为止。
- 改进：记下上次交换的位置

void Bubble_Sort(DataType R[], int n){
//对长度为n的序列R按升序进行冒泡排序，降序排序类似
for(i=1; i<n; ++i){
swap=0;  //交换标志
for(j=1; j<=n-i; ++j){ // 可以改进成 j<i
		if(R[j].key>R[j+1].key){  不满足升序规则，交换
			R[0]=R[j+1];  R[j+1]=R[j];  R[j]=R[0];
			swap=1;
		}
		if(swap==0) break;  //此趟冒泡没有发生交换，排序结束
}
        }
}

图和贪心算法

贪心

顾名思义，贪心算法总是作出在当前看来最好的选择。也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。当然，希望贪心算法得到的最终结果也是整体最优的。

例：活动安排问题

将输入的活动按结束时间的非降序排列，只需 O(n) 即可

当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。问题的最优子结构性质是该问题可用贪心算法求解的关键特征。证明需用归纳证明。

例：0-1 背包问题

贪心不适用，应该比较选择 / 不选择该物品导致的最优方案

例：多机调度问题

图

图G是由两个集合 V(G) 和 E(G) 组成的,记为G=(V,E)其中：V(G)是顶点的非空有限集、E(G)是边的有限集合，边是顶点的无序对或有序对

还有一些基本概念，这里略过，参考离散数学

存储结构

顺序结构

邻接矩阵：表示顶点间关系的矩阵，即点*点的矩阵，若两点间有边相连，则标记为 1（或者有权值）

关联矩阵：表示顶点与边的关联关系，即点*边的矩阵，边的两顶点记为 1 或 -1

链式存储

邻接表：为图中每个顶点建立一个单链表，第 i 个单链表中的结点表示依附于顶点V的边（有向图中指以V为尾的弧）。即每条边对应一个非头节点，由头指向尾（反过来就是逆邻接表）

十字链表：节点间以弧尾相同连接，包含弧尾、弧头位置以及弧尾弧头相同的下一条弧。

定义：

注意一下弧头和弧尾的区分

无向图邻接多重表：节点间以顶点相同互相连接

定义：

图的遍历

深度优先（DFS）

方法：从图的某一顶点Vo出发，访问此顶点，然后依次从Vo的未被访问的邻接点出发，深度优先遍历图直至图中有和V0相通的顶点都被访问到；若此时图中尚有顶点未被访问，则另选图中一个未被访问的顶点作起点，重复上述过程，直至图中所有顶点都被访问为止

广度优先（BFS）

方法：从图的某一顶点Vo出发，访问此顶点后，依次访问V0的各个未曾访问过的邻接点：然后分别从这些邻接点出发，广度优先遍历图，直至图中所有已被访问的顶点的邻接点都被访问到；若此时图中尚有顶点未被访问，则另选图中一个未被访问的顶点作起点，重复上迷过程，直至图中所有顶点都被访问为止

计算机组成原理

Fri, 03 Oct 2025 00:00:00 +0000

第一章计算机系统概述

计算机系统的发展

计算机系统 = 硬件 + 软件

软件

系统软件：用来管理整个计算机系统

应用软件：按任务需要编制成的程序

硬件

第一台电子数字计算机：ENIAC

逻辑元件（用于处理电信号的最小单元）：电子管
十进制表示，手动编程
无冯 · 诺伊曼结构

第二代：晶体管

元器件：逻辑元件（晶体管），内存（磁芯），外存（磁鼓，磁带）
特点：变址，浮点运算，多路存储器，I/O 处理机，中央交换结构（非总线）。
软件：使用高级语言，提供系统软件。

第三代：中小规模集成电路

元器件：逻辑元件和主存储器均由集成电路实现。
特点：微程序控制，Cache，虚拟存储器，流水线。
代表机种：IBM 360（大型机），DEC PDP-8（小型机），巨型机。

IBM 360（兼容机）

相同/相似的指令集&操作系统。

好处：原来机器上的程序可以不改动而在新机器上运行，但性能不同。

保持兼容的关键：低端机指令集是高端机的一个子集，称为“向后兼容”。

DEC PDP-8（采用总线结构）

总线结构好处：可扩充性好（允许将新的符合标准的模块插入总线，形成各种配置），节省器件，体积小，价格便宜

第四代：大规模、超大规模集成电路

半导体存储器，微处理器发展迅速。
特点：共享存储器，分布式存储器以及大规模并行系统。

组成

冯诺依曼结构模型

冯诺依曼提出存储程序，取代手动接线。

冯诺依曼结构：

计算机由运算器，控制器，存储器，输入设备和输出设备五个基本部件组成。

各基本部件功能：

存储器不仅能存放数据，而且也能存放指令，形式上两者没有区别，但计算机应能区分数据还是指令；

控制器应能自动执行指令；

运算器应能进行加/减/乘/除四种基本算术运算，并且也能进行一些逻辑运算和附加运算；

操作人员可以通过输入设备和输出设备与主机进行通信。

内部以二进制数表述指令和数据

每条指令由操作码和地址码两部分组成。操作码指出操作的类型，地址码指出操作数的地址。

由一串指令组成程序。

采用存储程序工作方式

将事先编好的程序和原始数据送入主存中；启动执行后，在不需操作人员干预下，自动完成逐条取出指令和执行指令的任务。

基本部件及其功能

运算器（数据运算）：ALU、GPRs、标志寄存器等。
存储器（数据存储）：存储阵列、地址译码器、读写控制电路
总线（数据传送）：数据线（MDR）、地址线（MAR）和控制线
控制器（控制）：对指令译码生成控制信号

CPU = 运算器 + 控制器

主机 = CPU + 主存

各硬件工作原理

主存储器

主存储器 = 存储体 + MAR + MDR

Memory Address Register 存储地址寄存器：指示位置，位数反应存储单元的个数
Memory Data Register 存储数据寄存器：指示存入、取出的具体数据（包括指令）
存储体：数据、指令在存储体内按地址存储，每个存储单元对应一个地址

1B = 1 byte ; 1 b = 1 bit

MAR、MDR 逻辑上属于主存，但被集成到 CPU

运算器

实现算数运算、逻辑运算

运算器 = ACC + ALU + MQ + X

Accumulator：累加器，存放操作数或运算结果
Multiple-Quotient Register：乘商寄存器，乘除运算时，存放操作数或运算结果
Arithmetic and Logic Unit：算数逻辑单元，通过复杂电路实现算数运算、逻辑运算
X：通用的操作数寄存器，用于存放操作数

控制器

控制器 = CU + IR +PC

Control Unit:控制单元，分析指令，给出控制信号
Instruction Register:指令寄存器，存放当前执行的指令
Program Counter:程序计数器，存放下一条指令地址，有自动加1功能

配合

指令和数据

程序启动前，指令和数据都存储在存储器中，形式上没有区别，都是 0/1 序列。
采用存储程序的工作方式，程序由指令组成，启动后计算机自动取出一条条指令并执行，无需人的干预。
指令执行过程中，指令和数据从存储器取到 CPU，指令存在 IR 中，数据在 GPR 中。
指令需要给出的信息
- 操作码：指令的操作，加减法等
- 一个或多个源操作数：立即数、寄存器编号、存储地址
- 目的操作数地址：寄存器编号、存储地址

执行过程

程序执行前
- 数据和指令事先存放在存储器中，每条指令和每个数据都有地址，指令按序存放。指令由 OP、ADDR 字段组成，程序起始地址送入 PC。
开始执行程序
- 根据 PC 取指令送 IR：PC -> MAR ->存储器 -> MDR -> IR
- 指令译码：IR -> 控制器，控制器译码
- 取操作数：GPRs 或存储器 -> ALU
- 执行指令操作：ALU 运算
- 回写结果到 GPRs 或存储器
- 修改 PC 的值，使其指向下一条指令
- 重复上述步骤直到程序完成

软件

系统软件——简化编程，使硬件资源被有效利用
- 操作系统：硬件资源管理，用户接口
- 语言处理程序：翻译程序，Linker，Debug…
  - 翻译程序
    - 汇编器（Assembler）：汇编语言源程序->机器目标程序。或许叫汇编器更好理解？
    - 编译器（Complier）：高级语言程序->汇编/机器目标程序。或许叫编译器更好理解？
    - 解释器（Interpreter）：将高级语言程序语句逐条翻译成机器指令并执行，不生成目标文件。（跳过汇编阶段）
- 其他实用程序：磁盘碎片整理、备份程序…

机器语言：二进制代码

汇编语言：助记符

高级语言：C、C++、……

应用软件——解决具体的应用问题

层次结构

语言层次

微指令系统：直接控制硬件执行
机器语言：传统机器M1，执行二进制机器指令

操作系统机器
汇编语言：虚拟机器M2，用汇编语言翻译成机器语言
高级语言：虚拟机器M3，需要编译成汇编、机器语言

上两层视为硬件层

计算机体系结构：讨论如何设计硬件与软件之间的接口

计算机组成原理：讨论如何用硬件实现接口

ISA

指令集体系结构，其作为规约，规定了如何使用硬件。

可执行的指令集合，包括指令格式、操作种类以及对应操作数的规定。
可以接受的操作数类型。
操作数存放的寄存器组结构，例如寄存器名称、编号、长度和用途。
操作数存放的存储空间的大小和编址方式。
操作数在存储空间中按大/小端方式存放。
指令获得操作数的方式，即寻址方式。
指令执行过程的控制方式，例如程序计数器，条件码定义等。

ISA 是计算机系统中必不可少的抽象层。

性能指标

存储器

总容量 = 存储单元个数 * 存储字长(bit)

CPU

基本概念

主频：CPU内数字脉冲信号振荡的频率
- = 1 / 时钟周期
CPI：执行一条指令需要多少个时钟周期（不同指令，CPI不同）
CPU执行时间：执行整个程序的耗时 = (条数 * CPI) / 主频
IPS：每秒执行多少个命令 = 主频 / 平均CPI
FLOPS：每秒执行多少次浮点运算

K=Kilo=千=10^3

M=Million=百万=10^6

G=Giga=十亿=10^9

T=Tera=万亿=10^12

数据通路带宽：数据总线一次所能并行传送信息的位数（各硬件部件通过数据总线传输数据）
吞吐量：单位时间内处理请求的数量
相应时间：CPU时间 + 等待时间
基准程序：用于测量的程序

MIPS（Million Instructions Per Second）：每秒执行多少百万条指令，着重点在于单条指令。

MIPS 为平均值，其并没有考虑以上三个属性，并且由于：

不同机器指令集不同

程序由不同指令混合而成

指令的频率会动态变换

厂家给出峰值 MIPS

因此，MIPS 表示性能存在局限性。

MFLOPS：每秒执行浮点运算多少百万次，着重在于浮点操作本身。

计算

CPU 执行时间=CPI×程序总指令条数×时钟周期

第二章数据的机器级表示

信息二进制编码

计算机内部数据：二进制表示

机器级数据：

数值数据，无符号/带符号整数，浮点数，十进制数
非数值数据，逻辑数，汉字

二进制编码原因：

制造两个稳态的物理器件容易
二进制编码、计数、运算规则简单。
与逻辑命题对应，便于逻辑运算，方便地用逻辑电路实现算术运算。

机器数：0/1 编码的 0/1 内部 0/1 序列。

真值：机器数真正的值

数值数据表示方法

三要素：

进位计数制：十进制，二进制等转换。
定点浮点表示：定点整数/小数；浮点数（使用一个定点小数和一个定点整数表示）
编码：原码补码反码等。

若不知道三要素，那么便无法得知机器数的具体真值。

进制转换：

二进制 -> 其他：划分位数，对应

十六、八 -> 二：位数对应，补全

十进制 -> 任意位数：求商取余

定点数的表示

常规计数，小数点位置固定。整数、小数分开存储。

无符号数：没有符号位
原码：
- 有 +0、-0 两种表示形式
反码：
- 正数与原码相同
- 若符号位为1，则数值位全部取反
- 依然有 +0、-0
补码：
- 将减法抓换为等价的加法（加上补数）
- = 原码除符号位外，取反后加一（即反码 + 1）
移码： 将每一个数值加上一个偏置常数（ bias）
- 一般来说，当编码位数为 n **时，bias 取 2^n 标准移码
- 为什么要用移码来表示阶码？
- 便于浮点数加减运算时的对阶操作（比较大小）
- 与补码的关系：最高位相反，其余位相同

C语言的解析

无符号数变为有符号：不改变数据内容，改变解释方式

长变短：高位截断，保留地位

短变长：符号扩展

负数补1，正数补0

IEEE编码

规定了二进制浮点数算数标准，类似科学计数法简化计数

二进制浮点数

符号：决定数值的正负性
尾数：影响数值的精度。尾数的位数越多，精度越高
阶码：反映小数点的实际位置
基数：K进制通常默认基数为K
规格化：石确保尾数的最高位非0数位刚好在小数点之前

float型：32位单精度

符号 + 阶码 + 尾数：1 + 8 + 23

double型：64位双精度

符号 + 阶码 + 尾数：1 + 11 + 52

float单精度

默认存储规格化尾数，小数点前的1省略（隐含）
基数规定为 2
阶码用移码表示，规定偏置值为 127

如何将十进制真值转换为偏置值为M的移码？

将十进制真值+偏置值

按“无符号整数”规则转换为指定位数

double双精度

偏置值为1023

表示范围

特殊状态

阶码全 0，或阶码全 1

阶码真值的取值范围为 -126 ~ 127（单精度）

根据数轴，存在：

正上溢、正下溢、负上溢，负下移
上溢置为无穷，下溢置为0

数据表示

十进制数表示

ASCII 码：就是把数字当作字符存储，0-9用30H-39H表示
- 前分隔：正号用 2B 负号用 2D 放在最前面
- 后嵌入：将符号嵌入最低位数字的 ASCII 码高 4 位中。
  - 正数不变；负数高 4 位变为 0111。
BCD 码
- 每 1 位十进制数用 4 位二进制表示。而 4 位二进制数可组合成 16 种状态，只需要选 10 种状态来表示十进制数。

西文字符表示：

复习要点中未提到

十进制数字：0/1/2…/9 10 个
英文字母：A/B/…/Z/a/b/…/z 52 个
专用符号：+/-/%/*/&/…… 33 个
控制字符（不可打印或显示） 33 个

汉字表示

输入码：用于输入汉字。
内码：用于在系统中进行存储、查找、传送等处理
字模点阵或轮廓描述：用于显示/打印

数据的宽度

bit
字节：
- 现代计算机中，存储器按字节编址
- 字节是最小可寻址单位（addressable unit ）
- LSB 表示最低有效字节，MSB 表示最高有效字节
字
- 表示被处理信息的单位，用来度量数据类型的宽度
字长
- 指某特定机器定点运算时数据通路的宽度。
- 数据通路： CPU 内部进行数据运算、存储和传送的路径以及路径上的部件。
- 等于 CPU 内部总线的宽度，或运算器的位数，或通用寄存器的宽度。

数据的存储和排列顺序

大小端
- 小端（ Little Endian）:低字节放低地址
- 大端（ Big Endian）:高字节放低地址
- 指令中，操作码和寄存器号的存放顺序不变，只需要考虑立即数的顺序
对齐：要求数据存放的地址必须是相应的边界地址
- 每次访存只能读写一个字
- 浪费一定空间，换取存取时间

数据的检错与纠错

大多采用“冗余校验”思想，即除原数据信息外，还增加若干位编码，这些新增的代码被称为校验位。

奇偶校验码
海明校验码
循环冗余校验码

第三章运算方法和运算部件

加法器

串行进位

传递速度慢

并行进位

用先行进位优化，各进位之间无等待，相互独立并同时产生
但全先行电路复杂，成本高
局部先行进位加法器： 组内并行、组间串行
- 用多个位数较少的 n 位全先行进位加法器进行串联
多级先行进位加法器： 组内并行、组间并行

ALU的构成

ALU 如何控制实现加、减、与、或等等各种功能；
1. 无符号整数和带符号整数的加、减运算电路完全一样，这个运算电路称为整数加/减运算部件。
2. 在整数加/减运算部件基础上，加上寄存器、移位器以及控制逻辑，就可实现 ALU、乘/除运算以及浮点运算。
ALU 的 OF、SF、CF 和 ZF 标志信息如何产生。
1. 零标志 ZF、溢出标志 OF、进/借位标志 CF、符号标志 SF 称为条件标志。
2. 条件标志（Flag）在运算电路中产生，被记录到专门的寄存器中
3. 存放标志的寄存器通常称为程序/状态字寄存器或标志寄存器。

溢出条件：

无符号加、减溢出条件：CF=1
带符号加、减溢出条件：OF=1

定点数运算

移位

逻辑移位

针对无符号数
左移 n 位，即乘上位权的 n 次方。
高位溢出丢弃，低位补 0

算数移位

左移与逻辑移位类似，但移到符号位结果更改
右移：低位移出丢弃，但高位补符号位，若移出 1，则发生精度丢失

加减

原码

减法用减法器实现，1 变 0

补码

符号位可以一起参与运算
[A+B]补=[A]补+ [B]补
[A-B]补=[A]补+[-B]补

[-B] 补 = [B] 补的 “取反加 1”，符号位也参与取反

溢出判断：上溢正变负；只有可能同号运算出现；判断是否在合法表示范围内即可

乘法

无符号整数：

模拟手算乘法即可，计算机还需拆分部分积

具体实现：

带符号整数

给无符号整数乘法电路添加一辅助位，让符号位参与运算。

计算机底层判断溢出：

若 2n 位的高 n + 1 位不均相同，则溢出

实现方式

ALU + 移位器 + 寄存器 + 控制逻辑
阵列乘法器
逻辑运算模拟

浮点数运算

浮点数加减运算的对阶原则和方法；
- 原则：小阶向大阶看齐
- 方法：阶小的那个数的尾数右移，右移位数等于两个阶码差的绝对值
- IEEE 754 尾数右移时，要将隐含的“1”移到小数部分，高位补 0，移出的低位保留到特定的“附加位”上
如何计算移码表示的阶码的和与差（标准移码与 IEEE754 移码有什么差别）；
- 阶码加法公式为： Eb ← Ex + Ey + 129 （ mod 2^8）
- 阶码减法公式为： Eb ← Ex + [–Ey]补 + 127 （ mod 2^8）
如何计算一个移码数减 1
尾数规格化中的右规和左规方法；
1. 当尾数高位为 0，则需左规：尾数左移一次，阶码减 1，直到 MSB 为 1
  - 每次阶码减 1 后要判断阶码是否下溢
  - 先判断阶码是否为全 0，若是，则直接置阶码下溢；否则，阶码减 1 后判断阶码是否为全 0，若是，则阶码下溢。
2. 当尾数最高位有进位，需右规：尾数右移一位，阶码加 1，直到 MSB 为 1
  - 每次阶码加 1 后要判断阶码是否上溢
  - 先判断阶码是否为全 1，若是，则直接置阶码上溢；否则，阶码加 1 后判断阶码是否为全 1，若是，则阶码上溢。
3. 阶码溢出异常处理：
  - 阶码上溢，则结果溢出；
  - 阶码下溢，则结果为 0
4. 乘法运算结果不需左规！最多右规 1 次！
5. 除法最多左规 1 次！不需右规！
尾数的舍入处理常用方法；
1. 就近舍入：舍入为最近可表示的数
  - 若为非中间值：LSB 后 1 位 0 舍 1 入
  - 若为中间值：强迫结果为偶数， LSB=
    - 1.1101110 → 1.1110 (1.1101110 → 1.1110, 110>100, 1.1101+0.0001 = 1.1110)
    - 1.1101011 → 1.1101 (1.1101011 → 1.1101, 011<100, 1.1101+ 0 = 1.1101)
    - 1.1101101 → 1.1110
    - 1.1111100 → 10.0000 (1.1111100 → 10.0000, 100=100, 1.1111+0.0001 = 10.0000)
2. 朝+∞方向舍入：舍入为右边最近可表示数（正向舍入）
  - 例：-1.1101101 →-1.1101 ； 1.1101101 →1.1110
3. 朝-∞方向舍入：舍入为左边最近可表示数（负向舍入）
  - 例：-1.1101101 →-1.1110 ； 1.1101101 →1.1101
4. 朝 0 方向舍入：直接截取所需位，后面的位丢弃。这种方法最简单
如何判断结果溢出（上溢和下溢）。

第四章

指令格式

指令：是指示计算机执行某种操作的命令，是计算机运行的最小功能单位。

根据地址码数不同

零地址指令：
- 不需要操作数，如停机、关中断等
- 堆栈计算机，操作数隐藏在栈顶
一地址指令：
- 只需单操作数，如加一、取反
- 需两个操作数，但其中一个存储在某个寄存器内
二地址指令：
- 用于需要两个操作数的算术运算
三地址指令：
- 多一个地址存储结果
四地址指令：
- 再多一个地址存储下一个指令地址

指令位数不变时，地址码数越多，寻址能力越差

按指令长度分类

指令字长：一条指令的总长度(可能会变)

影响取指令所需时间

机器字长：CPU进行一次整数运算所能处理的二进制数据的位数(通常和ALU直接相关)

存储字长：一个存储单元中的二进制代码位数（通常和MDR位数相同)

按操作码长度分类

定长：译码电路设计简单，但复杂性低

按操作类型分类

数据传送
- LOAD：把存储器中的数据放到寄存器中
- STORE：把寄存器中的数据放到存储器中
算数逻辑操作
- 算数、逻辑（与或非、位操作）
移位操作
- 算数、逻辑、循环移位
转移操作（改变程序执行流，PC指针改变）
- 无条件转移 JMP
- 条件转移JZ：结果为0；JO：结果溢出；JC：结果有进位
- 调用和返回 CALL和RETURN
- 陷阱(Trap)与陷阱指令
输入输出操作
- CPU寄存器与IO端口之间的数据传送(端口即IO接口中的寄存器)

设计

指令格式的选择应遵循的几条基本原则
- 应尽量短
- 要有足够的操作码位数
- 指令编码必须有唯一的解释，否则是不合法的指令
- 指令字长应是字节的整数倍
- 合理地选择地址字段的个数
- 指令尽量规整
一条指令必须明显或隐含包含以下信息：
- 操作码：指定操作类型
- 源操作数或其地址：一个或多个源操作数所在的地址
- 结果的地址：产生的结果存放何处（目的操作数）
- 下一条指令地址：下条指令存放何处
指令的寻址方式—-简单
- 顺序执行：PC增值
- 跳转（ jump / branch / call / return ）：同操作数寻址
操作数的寻址方式—-复杂
- 操作数来源：寄存器 / 主（虚）存 /外设端口 / 栈顶
- 操作数结构：位 / 字节 / 半字 / 字 / 双字 / 一维表 / 二维表 /…
通常寻址方式特指“操作数的寻址”

扩展操作码

格式：定长指令字结构 + 可边长操作码

即不同地址数的指令使用不同的操作码，便于判断

通常情况下，对使用频率较高的指令，分配较短的操作码；对使用频率较低的指令，分配较长的操作码，从而尽可能减少指令译码和分析的时间。

设地址长度为n，上一层留出m种状态，下一层可扩展出mx2^n种状态

注意短的操作码不能是长操作码的前缀

寻址方式

PC：程序计数器，取址后会自动加一

指令寻址

确定下一条指令的存放地址，由 PC 指明

顺序寻址：

PC + ”1“
- 1 理解为一个指令字长，根据指令字长变化字节编码

跳跃寻址

执行转移指令导致 PC 值改变（直接修改）

数据寻址

确定本条指令的地址码指明的真实地址

程序存储位置是相对的，需要用偏移量解读

在地址码中划分出寻址特征，规定该地址需要用何种方式寻址

直接寻址：存储 = 真实，即 EA = A
间接寻址：存储的是真实值的地址，即 EA = （A）
寄存器寻址：指令字中直接给出操作数所在寄存器编号
寄存器间接寻址：寄存器存储的是操作数所在储存单元的地址，即 EA = （R）
隐含寻址：非显示给出的操作数
立即寻址：地址就是操作数本身，又称立即数
基址寻址：以程序的起始存放地址作为起点，EA = （BR）+ A

BR 为基址寄存器，由操作系统决定，不可更改

变址寻址：程序员自己决定从哪里作为起点，EA = （IX）+ A

IX 为变址寄存器，可由用户决定。类似一个指针，设置为数组首地址等

相对寻址：程序计数器PC所指地址作为起点，EA = （PC）+ A
堆栈寻址：操作数存放在堆栈中，隐含使用堆栈指针(SP)作为操作数地址。

堆栈可以用寄存器实现（硬堆栈）或主存实现，硬堆栈不妨存，速度快

优缺点

条件测试方式(?)

对于带符号数和无符号数运算，标志生成方式有没有不同？

答：没有，因为加法电路不知道是无符号数还是带符号整数！

指令系统设计风格

累加器型：（earliest machines）
- 特点：其中一个操作数（源操作数 1）和目的操作数总在累加器中
堆栈型：（e.g. HP calculator, Java virtual machines)
- 特点：总是将栈顶两个操作数进行运算，指令无需指定操作数地址
通用寄存器型：（e.g. IA-32, Motorola 68xxx)
- 特点：操作数可以是寄存器或存储器数据（即 A、B 和 C 可以是寄存器或存储单元）
装入/存储型：（e.g. SPARC, MIPS, PowerPC)
- 特点：运算指令的操作数只能是寄存器数据，只有 load/store 能访问存储器

指令集：CISC 和 RISC

CISC（Complex Instruction Set Computer）：

一条指令完成一个复杂的基本功能。
x86 架构

RISC（Reduced Instruction Set Computer）：

一条指令完成一个基本“动作”；多条指令组合完成一个复杂的基本功能。
电路简单，功耗小，寄存器多
只有 LOAD、STORE 指令可以访存
ARM 架构，主要用于手机、平板

在程序中各种指令出现的频率悬殊很大，最常使用的是一些简单指令，这些指令占程序的80%，但只占指令系统的20%。而且在微程序控制的计算机中，占指令总数20%的复杂指令占用了控制存储器容量的80%。

MIPS 的指令格式

所有指令都是32位宽（字长），按字地址对齐存储，字地址为4的倍数

分为 R、I、J 型

R 型

参与运算的操作数和结果都在寄存器，R 型指令的寻址方式只有寄存器寻址一种；
R 型指令的 op 全为 0，具体功能由 func 部分确定；
rs：第一个源操作数（source register）
rt：第 2 个源操作数（target register）
rd：目的寄存器（destination register）
shamt：对非移位指令为 00000。移位指令为移位次数。

I 型

指令中包含了一个立即数，所以称为 I 型指令。
op：确定指令的功能；
rs：可以是一个源操作数，寄存器寻址；或者在存取指令中用作基址寄存器，偏移寻址。
rt：目的寄存器
Immediate：长度为 16 位的立即数，指令执行时需扩展为 32 位。根据指令的不同，可以有以下三种用法：
- 运算类指令（ori）：以立即寻址方式提供的一个源操作数。
- 存取指令（lw/sw）：作为偏移量，与寄存器 rs 组成偏移寻址方式，提供一个存储器操作数。
- 条件转移指令（bne）：作为偏移量，与 PC 寄存器组成相对寻址方式，提供一个转移目的地址。

J 型

op：确定指令的功能
address：转移地址

整合

三种指令 汇编格式 a=b op c 把=和op变成逗号
- R型指令格式是op+rs+rt+rd+shamt+func 汇编格式是 xxx $rs, $rt, $rd
- I型指令格式是op+rs+rt+imm 汇编格式是 xxx $rt, $rs, imm
- J型指令格式是op+addr 汇编格式是 xxx addr

MIPS 的通用寄存器

0 号寄存器$zero 为固定值零，不能改变
MIPS还提供了32个32位的单精度浮点寄存器$f0∽$f31,用于浮点数指令。它们可配对成16个64位的双精度浮点寄存器。
在汇编语言中使用寄存器时可以用寄存器名，也可以用寄存器号，前面加上“$”,例如，$8或$t0。
寄存器
- 长度：32 位
- 个数：32 个

MIPS 的寻址方式

寄存器寻址
- 可以出现在 R 型和 I 型格式中

立即数寻址

偏移寻址

PC 相对寻址
PC<– PC+4+imm*4

伪直接寻址
- 为什么称伪直接？
- 最终地址：PC 高四位+addr+两个 0，+表示拼接
- 位数：4+26+2=32

机器语言的解码（反汇编）？

高级语言、汇编语言、机器语言之间的转换？

RISC-V 指令系统

具有模块化结构，稳定性和可扩展性好，在简洁性、实现成本、功耗、性能和程序代码量等各方面具有显著优势。

模块化结构：

核心：RV32I + 标准扩展集：RV32M、RV32F、RV32D、RV32A = RV32G
32位架构RV32G = RV32IMAFD，其压缩指令集RV32C（指令长度16位）
64位架构RV64G = RV64IMAFD，其压缩指令集RV64C（指令长度16位）
向量计算RV32V和RV64V；嵌入式RV32E（RV32I的子集，16个通用寄存器）

指令格式

32位

R-型为寄存器操作数指令

I-型为短立即数或装入（Load）指令

S-型为存储（Store）指令

B-型为条件跳转指令

U-型为长立即数操作指令

J-型为无条件跳转指令

16位压缩

第五章中央处理器

CPU 的功能和基本结构

CPU 基本功能：

指令控制。完成取指令、分析指令和执行指令的操作，即程序的顺序控制。
操作控制。一条指令的功能往往是由若干操作信号的组合来实现的。CPU 管理并产生由内存取出的每条指令的操作信号，把各种操作信号送往相应的部件从而控制这些部件按指令的要求进行动作。
时间控制。对各种操作加以时间上的控制。时间控制要为每条指令按时间顺序提供应有的控制信号。
数据加工。对数据进行算术和逻辑运算。
中断处理。对计算机运行过程中出现的异常情况和特殊请求进行处理。

基本结构

数据通路 + 控制器

控制器
- 对指令进行译码，生成指令对应的控制信号，控制数据通路的动作。它向执行部件发出控制信号，是指令的控制部件。

数据通路

由操作元件和存储元件通过总线方式或分散方式连接而成的进行数据传送、处理和存储的路径。

数据通路
- 指令执行过程中，数据所经过的路径，以及路径上的部件。
- 包括：ALU、通用寄存器、状态寄存器、MMU、cache、中断处理逻辑等
- 数据通路中专门进行数据运算的部件称为执行部件或功能部件
- 功能：进行数据传送、处理和存储
组成元件
- 组合逻辑元件（操作元件）：输出只取决于当前输入
- 时序逻辑元件（也称状态元件，或存储元件）：在时钟控制下输入被写到电路中，直到下个时钟到达。
  - 定时方式：规定信号何时写入状态元件（上升沿、下降沿、电平触发）
  - 存储元件：寄存器 –> 寄存器组
连接方式
- 总线、分散

时序控制（过去式）：

现代时钟周期
- …… + 状态元件 + 操作元件( 组合电路) + 状态元件 + ……
  - 只有状态元件能存储信息，所有操作元件都从状态元件接收输入，并将输出写入状态元件中。
- 时钟周期= Latch Prop + Longest Delay Path + Setup + Clock Skew(时钟偏移)
- 约束条件：操作元件输出有效信号最快出现必须在下一级状态元件的输入保持时间之后出现

单周期 MIPS 处理器的设计

复习：三种指令类型 R、I、J

设计处理器步骤
1. 分析每条指令功能，并用 RTL（Register Transfer Language）来表示
2. 根据指令的功能给出所需的元件，并考虑如何将他们互连
3. 确定每个元件所需控制信号的取值
4. 汇总所有指令所涉及到的控制信号，生成一张反映指令与控制信号之间关系的表
5. 根据表得到每个控制信号的逻辑表达式，据此设计控制器电路

设计数据通路

R-type：取指 –> 取寄存器 –> 运算 –> 输出、计算下地址
- M[PC] 从PC所指的内存单元中取指令
- R[rd] ← R[rs] + R[rt] 从rs、r所指的寄存器中取数后相加。若结果不溢出，则将结果送rd所指的寄存器中；若结果溢出，则不送结果，并转到“溢出处理程序”执行。
- PC ← PC + 4 PC加4，使PC指向下一条指令

I-type
- M[PC] 取指令（公共操作，取指部件完成）
- R[rt] ← R[rs] or ZeroExt(imm16) 立即数零扩展，并与rs内容做“或”运算
- PC ← PC + 4 计算下地址（公共操作，取指部件完成）

Lw 装入指令
- M[PC] 取指令（公共操作，取指部件完成）
- Addr ← R[rs] + SignExt(imm16) 计算存储单元地址 (立即数符号扩展！)
- R[rt] ← M [Addr]装入数据到寄存器rt中
- PC ← PC + 4计算下地址（公共操作，取指部件完成）

sw 指令
- M[PC] 取指令（公共操作，取指部件完成）
- Addr ← R[rs] + SignExt(imm16) 计算存储单元地址（符号扩展！）
- M[Addr] ← R[rt] 寄存器rt中的内容存到内存单元中
- PC ← PC + 4 计算下地址（公共操作，取指部件完成）

分支指令
- M[PC] 取指令（公共操作，取指部件完成）
- Cond ← R[rs] - R[rt] 做减法比较rs和rt中的内容
- if (Cond eq 0) 计算下地址（根据比较结果，修改PC）
  - PC ← PC + 4 + ( SignExt(imm16) x 4 )
- else
  - PC ← PC + 4

无条件跳转指令
- M[PC] 取指令（公共操作，取指部件完成）
- PC<31:2> ← PC<31:28> 串接 target<25:0> 计算目标地址

指令范围有多大？

不是相对寻址，是绝对寻址。转移范围只能在 j 指令所在的228=256MB页面内，页面号与j指令相同 PC<31:28>

完成

时间计算

设计控制器

方法：
1. 根据每条指令的功能，分析控制信号的取值，并列表表示。
2. 根据列出的指令和控制信号的关系，写出每个控制信号的逻辑表达式。

PPT 上看指令译码后条件码的产生、执行过程，内容较多

设计逻辑
- MIPS指令格式中指示操作性质有op 和 func两个字段，分别用来产生两类不同的控制信号
- func只用于R型指令，形成对应的ALU的功能控制信号
- op用来产生各种控制信号，包括了非R型指令的ALU功能控制信号
- 控制器 = 主控制单元 + ALU局部控制单元

单周期处理器的性能

CPI = 1；其他条件一定的情况下，CPI越小，则性能越好！

除CPI外，还取决于时钟周期的宽度，单周期处理器的时钟宽度为最复杂指令的执行时间

但是，对每类指令采用可变长时钟周期实现非常困难，而且所带来的额外开销会很大，不合算

单周期处理器的问题
- 时钟周期以最复杂指令所需时间为准，太长
解决思路
- 把指令的执行分成多个阶段，每个阶段用一个时钟周期完成
- 多周期处理器
  - 时钟周期短
  - 不同指令所用周期数可以不同
  - 允许功能部件在一条指令执行过程中被多次使用

微程序设计和异常处理

硬连线控制器的特点
- 优点：速度快，适合于简单或规整的指令系统，例如 MIPS 指令集
- 缺点：它是一个多输入/多输出的巨大逻辑网络。对于复杂指令系统来说，结构庞杂，不用大规模集成电路则实现困难；修改、维护不易；灵活性差。
- 简化方法：微程序设计
微程序控制器
- 仿照程序设计的方法，编制每条指令对应的微程序
- 所有指令对应的微程序放在只读存储器（控制存储器）中，执行某条指令就是取出对应微程序中的各条微指令，对微指令译码产生对应的微命令(即控制信号)
- 特点：具有规整性、可维护性和灵活性，但速度慢
基本结构

微指令格式
- 水平型：相容微命令尽量多地安排在一条微指令中
  - 优点：微程序短，并行性高，适合于较高速度的场合
  - 缺点：微指令长，编码空间利用率较低，并且编制困难
- 垂直型：一条微指令只控制一、二个微命令
- 包含：若干微命令、下条微指令地址（可选）、常数（可选）

异常和中断的处理

中断
- 内部异常：在CPU内部发生的意外事件或特殊事件
  - 故障（fault）：执行指令引起的异常事件，如溢出、缺页、堆栈溢出、访问超时等
  - 自陷（Trap）：预先安排的事件，如单步跟踪、系统调用(执行访管指令)等
  - 终止（Abort）：硬故障事件，此时机器将“终止”，调出中断服务程序来重启操作系统
- 外部中断：在CPU外部发生的特殊事件，通过向CPU发“中断请求”信号，请求CPU处理
处理机制
1. 关中断（“中断/异常允许”状态位清0）：使处理器处于“禁止中断”状态，以防止新异常(或中断)破坏断点、程序状态和现场（现场指通用寄存器的值）。
2. 保护断点和程序状态：将断点和程序状态保存到堆栈或特殊寄存器中。
3. 识别异常事件：有软件识别和硬件识别（向量中断方式）两种不同的方式。
  - 软件识别（MIPS采用）：设置一个异常状态寄存器（MIPS中为Cause寄存器），用于记录异常原因。操作系统中有一个统一的异常处理程序，该程序按优先级顺序查询异常状态寄存器的各位，识别出异常事件
  - 硬件识别（向量中断）：用专门的硬件查询电路按优先级顺序识别异常，得到“中断类型号”
MIPS 异常处理数据通路设计
- 增加以下两个寄存器
  - EPC：32位，用于存放断点（异常处理后返回到的指令的地址）
  - Cause：32位，记录异常原因
- 增加两个寄存器的“写使能”控制信号
  - EPCWr：在保存断点时该信号有效，使断点PC写入EPC
  - CauseWr：在处理器发现异常（如：非法指令、溢出）时，该信号有效，使异常类型被写到Cause寄存器
- 需要一个控制信号IntCause来选择正确的值写入到Cause中
- 需要将异常查询程序的入口地址（MIPS为0x8000 0180）写入PC，可以在原来PCSource控制的多路复用器中再增加一路，其输入为0x8000 0180

必须考虑：保存断点和异常原因，并将控制转到异常处理程序首地址处 =======

title: “计算机组成原理” subtitle: “王道课程笔记” summary: “计算机组成原理课程的笔记” description: “计算机组成原理课程的笔记” date: 2025-10-03 lastmod: 2025-11-06 image: "" draft: false toc: enable: true weight: false categories: [“笔记”] tags: [“笔记”]

第一章计算机系统概述

计算机系统的发展

计算机系统 = 硬件 + 软件

软件

系统软件：用来管理整个计算机系统

应用软件：按任务需要编制成的程序

硬件

第一台电子数字计算机：ENIAC

逻辑元件（用于处理电信号的最小单元）：电子管
十进制表示，手动编程
无冯 · 诺伊曼结构

第二代：晶体管

元器件：逻辑元件（晶体管），内存（磁芯），外存（磁鼓，磁带）
特点：变址，浮点运算，多路存储器，I/O 处理机，中央交换结构（非总线）。
软件：使用高级语言，提供系统软件。

第三代：中小规模集成电路

元器件：逻辑元件和主存储器均由集成电路实现。
特点：微程序控制，Cache，虚拟存储器，流水线。
代表机种：IBM 360（大型机），DEC PDP-8（小型机），巨型机。

IBM 360（兼容机）

相同/相似的指令集&操作系统。

好处：原来机器上的程序可以不改动而在新机器上运行，但性能不同。

保持兼容的关键：低端机指令集是高端机的一个子集，称为“向后兼容”。

DEC PDP-8（采用总线结构）

总线结构好处：可扩充性好（允许将新的符合标准的模块插入总线，形成各种配置），节省器件，体积小，价格便宜

第四代：大规模、超大规模集成电路

半导体存储器，微处理器发展迅速。
特点：共享存储器，分布式存储器以及大规模并行系统。

组成

冯诺依曼结构模型

冯诺依曼提出存储程序，取代手动接线。

冯诺依曼结构：

计算机由运算器，控制器，存储器，输入设备和输出设备五个基本部件组成。

各基本部件功能：

存储器不仅能存放数据，而且也能存放指令，形式上两者没有区别，但计算机应能区分数据还是指令；

控制器应能自动执行指令；

运算器应能进行加/减/乘/除四种基本算术运算，并且也能进行一些逻辑运算和附加运算；

操作人员可以通过输入设备和输出设备与主机进行通信。

内部以二进制数表述指令和数据

每条指令由操作码和地址码两部分组成。操作码指出操作的类型，地址码指出操作数的地址。

由一串指令组成程序。

采用存储程序工作方式

将事先编好的程序和原始数据送入主存中；启动执行后，在不需操作人员干预下，自动完成逐条取出指令和执行指令的任务。

基本部件及其功能

运算器（数据运算）：ALU、GPRs、标志寄存器等。
存储器（数据存储）：存储阵列、地址译码器、读写控制电路
总线（数据传送）：数据线（MDR）、地址线（MAR）和控制线
控制器（控制）：对指令译码生成控制信号

CPU = 运算器 + 控制器

主机 = CPU + 主存

各硬件工作原理

主存储器

主存储器 = 存储体 + MAR + MDR

Memory Address Register 存储地址寄存器：指示位置，位数反应存储单元的个数
Memory Data Register 存储数据寄存器：指示存入、取出的具体数据（包括指令）
存储体：数据、指令在存储体内按地址存储，每个存储单元对应一个地址

1B = 1 byte ; 1 b = 1 bit

MAR、MDR 逻辑上属于主存，但被集成到 CPU

运算器

实现算数运算、逻辑运算

运算器 = ACC + ALU + MQ + X

Accumulator：累加器，存放操作数或运算结果
Multiple-Quotient Register：乘商寄存器，乘除运算时，存放操作数或运算结果
Arithmetic and Logic Unit：算数逻辑单元，通过复杂电路实现算数运算、逻辑运算
X：通用的操作数寄存器，用于存放操作数

控制器

控制器 = CU + IR +PC

Control Unit:控制单元，分析指令，给出控制信号
Instruction Register:指令寄存器，存放当前执行的指令
Program Counter:程序计数器，存放下一条指令地址，有自动加1功能

配合

指令和数据

程序启动前，指令和数据都存储在存储器中，形式上没有区别，都是 0/1 序列。
采用存储程序的工作方式，程序由指令组成，启动后计算机自动取出一条条指令并执行，无需人的干预。
指令执行过程中，指令和数据从存储器取到 CPU，指令存在 IR 中，数据在 GPR 中。
指令需要给出的信息
- 操作码：指令的操作，加减法等
- 一个或多个源操作数：立即数、寄存器编号、存储地址
- 目的操作数地址：寄存器编号、存储地址

执行过程

程序执行前
- 数据和指令事先存放在存储器中，每条指令和每个数据都有地址，指令按序存放。指令由 OP、ADDR 字段组成，程序起始地址送入 PC。
开始执行程序
- 根据 PC 取指令送 IR：PC -> MAR ->存储器 -> MDR -> IR
- 指令译码：IR -> 控制器，控制器译码
- 取操作数：GPRs 或存储器 -> ALU
- 执行指令操作：ALU 运算
- 回写结果到 GPRs 或存储器
- 修改 PC 的值，使其指向下一条指令
- 重复上述步骤直到程序完成

软件

系统软件——简化编程，使硬件资源被有效利用
- 操作系统：硬件资源管理，用户接口
- 语言处理程序：翻译程序，Linker，Debug…
  - 翻译程序
    - 汇编器（Assembler）：汇编语言源程序->机器目标程序。或许叫汇编器更好理解？
    - 编译器（Complier）：高级语言程序->汇编/机器目标程序。或许叫编译器更好理解？
    - 解释器（Interpreter）：将高级语言程序语句逐条翻译成机器指令并执行，不生成目标文件。（跳过汇编阶段）
- 其他实用程序：磁盘碎片整理、备份程序…

机器语言：二进制代码

汇编语言：助记符

高级语言：C、C++、……

应用软件——解决具体的应用问题

层次结构

语言层次

微指令系统：直接控制硬件执行
机器语言：传统机器M1，执行二进制机器指令

操作系统机器
汇编语言：虚拟机器M2，用汇编语言翻译成机器语言
高级语言：虚拟机器M3，需要编译成汇编、机器语言

上两层视为硬件层

计算机体系结构：讨论如何设计硬件与软件之间的接口

计算机组成原理：讨论如何用硬件实现接口

ISA

指令集体系结构，其作为规约，规定了如何使用硬件。

可执行的指令集合，包括指令格式、操作种类以及对应操作数的规定。
可以接受的操作数类型。
操作数存放的寄存器组结构，例如寄存器名称、编号、长度和用途。
操作数存放的存储空间的大小和编址方式。
操作数在存储空间中按大/小端方式存放。
指令获得操作数的方式，即寻址方式。
指令执行过程的控制方式，例如程序计数器，条件码定义等。

ISA 是计算机系统中必不可少的抽象层。

性能指标

存储器

总容量 = 存储单元个数 * 存储字长(bit)

CPU

基本概念

主频：CPU内数字脉冲信号振荡的频率
- = 1 / 时钟周期
CPI：执行一条指令需要多少个时钟周期（不同指令，CPI不同）
CPU执行时间：执行整个程序的耗时 = (条数 * CPI) / 主频
IPS：每秒执行多少个命令 = 主频 / 平均CPI
FLOPS：每秒执行多少次浮点运算

K=Kilo=千=10^3

M=Million=百万=10^6

G=Giga=十亿=10^9

T=Tera=万亿=10^12

数据通路带宽：数据总线一次所能并行传送信息的位数（各硬件部件通过数据总线传输数据）
吞吐量：单位时间内处理请求的数量
相应时间：CPU时间 + 等待时间
基准程序：用于测量的程序

MIPS（Million Instructions Per Second）：每秒执行多少百万条指令，着重点在于单条指令。

MIPS 为平均值，其并没有考虑以上三个属性，并且由于：

不同机器指令集不同

程序由不同指令混合而成

指令的频率会动态变换

厂家给出峰值 MIPS

因此，MIPS 表示性能存在局限性。

MFLOPS：每秒执行浮点运算多少百万次，着重在于浮点操作本身。

计算

CPU 执行时间=CPI×程序总指令条数×时钟周期

第二章数据的机器级表示

信息二进制编码

计算机内部数据：二进制表示

机器级数据：

数值数据，无符号/带符号整数，浮点数，十进制数
非数值数据，逻辑数，汉字

二进制编码原因：

制造两个稳态的物理器件容易
二进制编码、计数、运算规则简单。
与逻辑命题对应，便于逻辑运算，方便地用逻辑电路实现算术运算。

机器数：0/1 编码的 0/1 内部 0/1 序列。

真值：机器数真正的值

数值数据表示方法

三要素：

进位计数制：十进制，二进制等转换。
定点浮点表示：定点整数/小数；浮点数（使用一个定点小数和一个定点整数表示）
编码：原码补码反码等。

若不知道三要素，那么便无法得知机器数的具体真值。

进制转换：

二进制 -> 其他：划分位数，对应

十六、八 -> 二：位数对应，补全

十进制 -> 任意位数：求商取余

定点数的表示

常规计数，小数点位置固定。整数、小数分开存储。

无符号数：没有符号位
原码：
- 有 +0、-0 两种表示形式
反码：
- 正数与原码相同
- 若符号位为1，则数值位全部取反
- 依然有 +0、-0
补码：
- 将减法抓换为等价的加法（加上补数）
- = 原码除符号位外，取反后加一（即反码 + 1）
移码： 将每一个数值加上一个偏置常数（ bias）
- 一般来说，当编码位数为 n **时，bias 取 2^n 标准移码
- 为什么要用移码来表示阶码？
- 便于浮点数加减运算时的对阶操作（比较大小）
- 与补码的关系：最高位相反，其余位相同

C语言的解析

无符号数变为有符号：不改变数据内容，改变解释方式

长变短：高位截断，保留地位

短变长：符号扩展

负数补1，正数补0

IEEE编码

规定了二进制浮点数算数标准，类似科学计数法简化计数

二进制浮点数

符号：决定数值的正负性
尾数：影响数值的精度。尾数的位数越多，精度越高
阶码：反映小数点的实际位置
基数：K进制通常默认基数为K
规格化：石确保尾数的最高位非0数位刚好在小数点之前

float型：32位单精度

符号 + 阶码 + 尾数：1 + 8 + 23

double型：64位双精度

符号 + 阶码 + 尾数：1 + 11 + 52

float单精度

默认存储规格化尾数，小数点前的1省略（隐含）
基数规定为 2
阶码用移码表示，规定偏置值为 127

如何将十进制真值转换为偏置值为M的移码？

将十进制真值+偏置值

按“无符号整数”规则转换为指定位数

double双精度

偏置值为1023

表示范围

特殊状态

阶码全 0，或阶码全 1

阶码真值的取值范围为 -126 ~ 127（单精度）

根据数轴，存在：

正上溢、正下溢、负上溢，负下移
上溢置为无穷，下溢置为0

数据表示

十进制数表示

ASCII 码：就是把数字当作字符存储，0-9用30H-39H表示
- 前分隔：正号用 2B 负号用 2D 放在最前面
- 后嵌入：将符号嵌入最低位数字的 ASCII 码高 4 位中。
  - 正数不变；负数高 4 位变为 0111。
BCD 码
- 每 1 位十进制数用 4 位二进制表示。而 4 位二进制数可组合成 16 种状态，只需要选 10 种状态来表示十进制数。

西文字符表示：

复习要点中未提到

十进制数字：0/1/2…/9 10 个
英文字母：A/B/…/Z/a/b/…/z 52 个
专用符号：+/-/%/*/&/…… 33 个
控制字符（不可打印或显示） 33 个

汉字表示

输入码：用于输入汉字。
内码：用于在系统中进行存储、查找、传送等处理
字模点阵或轮廓描述：用于显示/打印

数据的宽度

bit
字节：
- 现代计算机中，存储器按字节编址
- 字节是最小可寻址单位（addressable unit ）
- LSB 表示最低有效字节，MSB 表示最高有效字节
字
- 表示被处理信息的单位，用来度量数据类型的宽度
字长
- 指某特定机器定点运算时数据通路的宽度。
- 数据通路： CPU 内部进行数据运算、存储和传送的路径以及路径上的部件。
- 等于 CPU 内部总线的宽度，或运算器的位数，或通用寄存器的宽度。

数据的存储和排列顺序

大小端
- 小端（ Little Endian）:低字节放低地址
- 大端（ Big Endian）:高字节放低地址
- 指令中，操作码和寄存器号的存放顺序不变，只需要考虑立即数的顺序
对齐：要求数据存放的地址必须是相应的边界地址
- 每次访存只能读写一个字
- 浪费一定空间，换取存取时间

数据的检错与纠错

大多采用“冗余校验”思想，即除原数据信息外，还增加若干位编码，这些新增的代码被称为校验位。

奇偶校验码
海明校验码
循环冗余校验码

第三章运算方法和运算部件

加法器

串行进位

传递速度慢

并行进位

用先行进位优化，各进位之间无等待，相互独立并同时产生
但全先行电路复杂，成本高
局部先行进位加法器： 组内并行、组间串行
- 用多个位数较少的 n 位全先行进位加法器进行串联
多级先行进位加法器： 组内并行、组间并行

ALU的构成

ALU 如何控制实现加、减、与、或等等各种功能；
1. 无符号整数和带符号整数的加、减运算电路完全一样，这个运算电路称为整数加/减运算部件。
2. 在整数加/减运算部件基础上，加上寄存器、移位器以及控制逻辑，就可实现 ALU、乘/除运算以及浮点运算。
ALU 的 OF、SF、CF 和 ZF 标志信息如何产生。
1. 零标志 ZF、溢出标志 OF、进/借位标志 CF、符号标志 SF 称为条件标志。
2. 条件标志（Flag）在运算电路中产生，被记录到专门的寄存器中
3. 存放标志的寄存器通常称为程序/状态字寄存器或标志寄存器。

溢出条件：

无符号加、减溢出条件：CF=1
带符号加、减溢出条件：OF=1

定点数运算

移位

逻辑移位

针对无符号数
左移 n 位，即乘上位权的 n 次方。
高位溢出丢弃，低位补 0

算数移位

左移与逻辑移位类似，但移到符号位结果更改
右移：低位移出丢弃，但高位补符号位，若移出 1，则发生精度丢失

加减

原码

减法用减法器实现，1 变 0

补码

符号位可以一起参与运算
[A+B]补=[A]补+ [B]补
[A-B]补=[A]补+[-B]补

[-B] 补 = [B] 补的 “取反加 1”，符号位也参与取反

溢出判断：上溢正变负；只有可能同号运算出现；判断是否在合法表示范围内即可

乘法

无符号整数：

模拟手算乘法即可，计算机还需拆分部分积

具体实现：

带符号整数

给无符号整数乘法电路添加一辅助位，让符号位参与运算。

计算机底层判断溢出：

若 2n 位的高 n + 1 位不均相同，则溢出

实现方式

ALU + 移位器 + 寄存器 + 控制逻辑
阵列乘法器
逻辑运算模拟

浮点数运算

浮点数加减运算的对阶原则和方法；
- 原则：小阶向大阶看齐
- 方法：阶小的那个数的尾数右移，右移位数等于两个阶码差的绝对值
- IEEE 754 尾数右移时，要将隐含的“1”移到小数部分，高位补 0，移出的低位保留到特定的“附加位”上
如何计算移码表示的阶码的和与差（标准移码与 IEEE754 移码有什么差别）；
- 阶码加法公式为： Eb ← Ex + Ey + 129 （ mod 2^8）
- 阶码减法公式为： Eb ← Ex + [–Ey]补 + 127 （ mod 2^8）
如何计算一个移码数减 1
尾数规格化中的右规和左规方法；
1. 当尾数高位为 0，则需左规：尾数左移一次，阶码减 1，直到 MSB 为 1
  - 每次阶码减 1 后要判断阶码是否下溢
  - 先判断阶码是否为全 0，若是，则直接置阶码下溢；否则，阶码减 1 后判断阶码是否为全 0，若是，则阶码下溢。
2. 当尾数最高位有进位，需右规：尾数右移一位，阶码加 1，直到 MSB 为 1
  - 每次阶码加 1 后要判断阶码是否上溢
  - 先判断阶码是否为全 1，若是，则直接置阶码上溢；否则，阶码加 1 后判断阶码是否为全 1，若是，则阶码上溢。
3. 阶码溢出异常处理：
  - 阶码上溢，则结果溢出；
  - 阶码下溢，则结果为 0
4. 乘法运算结果不需左规！最多右规 1 次！
5. 除法最多左规 1 次！不需右规！
尾数的舍入处理常用方法；
1. 就近舍入：舍入为最近可表示的数
  - 若为非中间值：LSB 后 1 位 0 舍 1 入
  - 若为中间值：强迫结果为偶数， LSB=
    - 1.1101110 → 1.1110 (1.1101110 → 1.1110, 110>100, 1.1101+0.0001 = 1.1110)
    - 1.1101011 → 1.1101 (1.1101011 → 1.1101, 011<100, 1.1101+ 0 = 1.1101)
    - 1.1101101 → 1.1110
    - 1.1111100 → 10.0000 (1.1111100 → 10.0000, 100=100, 1.1111+0.0001 = 10.0000)
2. 朝+∞方向舍入：舍入为右边最近可表示数（正向舍入）
  - 例：-1.1101101 →-1.1101 ； 1.1101101 →1.1110
3. 朝-∞方向舍入：舍入为左边最近可表示数（负向舍入）
  - 例：-1.1101101 →-1.1110 ； 1.1101101 →1.1101
4. 朝 0 方向舍入：直接截取所需位，后面的位丢弃。这种方法最简单
如何判断结果溢出（上溢和下溢）。

第四章

指令格式

指令：是指示计算机执行某种操作的命令，是计算机运行的最小功能单位。

根据地址码数不同

零地址指令：
- 不需要操作数，如停机、关中断等
- 堆栈计算机，操作数隐藏在栈顶
一地址指令：
- 只需单操作数，如加一、取反
- 需两个操作数，但其中一个存储在某个寄存器内
二地址指令：
- 用于需要两个操作数的算术运算
三地址指令：
- 多一个地址存储结果
四地址指令：
- 再多一个地址存储下一个指令地址

指令位数不变时，地址码数越多，寻址能力越差

按指令长度分类

指令字长：一条指令的总长度(可能会变)

影响取指令所需时间

机器字长：CPU进行一次整数运算所能处理的二进制数据的位数(通常和ALU直接相关)

存储字长：一个存储单元中的二进制代码位数（通常和MDR位数相同)

按操作码长度分类

定长：译码电路设计简单，但复杂性低

按操作类型分类

数据传送
- LOAD：把存储器中的数据放到寄存器中
- STORE：把寄存器中的数据放到存储器中
算数逻辑操作
- 算数、逻辑（与或非、位操作）
移位操作
- 算数、逻辑、循环移位
转移操作（改变程序执行流，PC指针改变）
- 无条件转移 JMP
- 条件转移JZ：结果为0；JO：结果溢出；JC：结果有进位
- 调用和返回 CALL和RETURN
- 陷阱(Trap)与陷阱指令
输入输出操作
- CPU寄存器与IO端口之间的数据传送(端口即IO接口中的寄存器)

设计

指令格式的选择应遵循的几条基本原则
- 应尽量短
- 要有足够的操作码位数
- 指令编码必须有唯一的解释，否则是不合法的指令
- 指令字长应是字节的整数倍
- 合理地选择地址字段的个数
- 指令尽量规整
一条指令必须明显或隐含包含以下信息：
- 操作码：指定操作类型
- 源操作数或其地址：一个或多个源操作数所在的地址
- 结果的地址：产生的结果存放何处（目的操作数）
- 下一条指令地址：下条指令存放何处
指令的寻址方式—-简单
- 顺序执行：PC增值
- 跳转（ jump / branch / call / return ）：同操作数寻址
操作数的寻址方式—-复杂
- 操作数来源：寄存器 / 主（虚）存 /外设端口 / 栈顶
- 操作数结构：位 / 字节 / 半字 / 字 / 双字 / 一维表 / 二维表 /…
通常寻址方式特指“操作数的寻址”

扩展操作码

格式：定长指令字结构 + 可边长操作码

即不同地址数的指令使用不同的操作码，便于判断

通常情况下，对使用频率较高的指令，分配较短的操作码；对使用频率较低的指令，分配较长的操作码，从而尽可能减少指令译码和分析的时间。

设地址长度为n，上一层留出m种状态，下一层可扩展出mx2^n种状态

注意短的操作码不能是长操作码的前缀

寻址方式

PC：程序计数器，取址后会自动加一

指令寻址

确定下一条指令的存放地址，由 PC 指明

顺序寻址：

PC + ”1“
- 1 理解为一个指令字长，根据指令字长变化字节编码

跳跃寻址

执行转移指令导致 PC 值改变（直接修改）

数据寻址

确定本条指令的地址码指明的真实地址

程序存储位置是相对的，需要用偏移量解读

在地址码中划分出寻址特征，规定该地址需要用何种方式寻址

直接寻址：存储 = 真实，即 EA = A
间接寻址：存储的是真实值的地址，即 EA = （A）
寄存器寻址：指令字中直接给出操作数所在寄存器编号
寄存器间接寻址：寄存器存储的是操作数所在储存单元的地址，即 EA = （R）
隐含寻址：非显示给出的操作数
立即寻址：地址就是操作数本身，又称立即数
基址寻址：以程序的起始存放地址作为起点，EA = （BR）+ A

BR 为基址寄存器，由操作系统决定，不可更改

变址寻址：程序员自己决定从哪里作为起点，EA = （IX）+ A

IX 为变址寄存器，可由用户决定。类似一个指针，设置为数组首地址等

相对寻址：程序计数器PC所指地址作为起点，EA = （PC）+ A
堆栈寻址：操作数存放在堆栈中，隐含使用堆栈指针(SP)作为操作数地址。

堆栈可以用寄存器实现（硬堆栈）或主存实现，硬堆栈不妨存，速度快

优缺点

条件测试方式(?)

对于带符号数和无符号数运算，标志生成方式有没有不同？

答：没有，因为加法电路不知道是无符号数还是带符号整数！

指令系统设计风格

累加器型：（earliest machines）
- 特点：其中一个操作数（源操作数 1）和目的操作数总在累加器中
堆栈型：（e.g. HP calculator, Java virtual machines)
- 特点：总是将栈顶两个操作数进行运算，指令无需指定操作数地址
通用寄存器型：（e.g. IA-32, Motorola 68xxx)
- 特点：操作数可以是寄存器或存储器数据（即 A、B 和 C 可以是寄存器或存储单元）
装入/存储型：（e.g. SPARC, MIPS, PowerPC)
- 特点：运算指令的操作数只能是寄存器数据，只有 load/store 能访问存储器

指令集：CISC 和 RISC

CISC（Complex Instruction Set Computer）：

一条指令完成一个复杂的基本功能。
x86 架构

RISC（Reduced Instruction Set Computer）：

一条指令完成一个基本“动作”；多条指令组合完成一个复杂的基本功能。
电路简单，功耗小，寄存器多
只有 LOAD、STORE 指令可以访存
ARM 架构，主要用于手机、平板

在程序中各种指令出现的频率悬殊很大，最常使用的是一些简单指令，这些指令占程序的80%，但只占指令系统的20%。而且在微程序控制的计算机中，占指令总数20%的复杂指令占用了控制存储器容量的80%。

MIPS 的指令格式

所有指令都是32位宽（字长），按字地址对齐存储，字地址为4的倍数

分为 R、I、J 型

R 型

参与运算的操作数和结果都在寄存器，R 型指令的寻址方式只有寄存器寻址一种；
R 型指令的 op 全为 0，具体功能由 func 部分确定；
rs：第一个源操作数（source register）
rt：第 2 个源操作数（target register）
rd：目的寄存器（destination register）
shamt：对非移位指令为 00000。移位指令为移位次数。

I 型

指令中包含了一个立即数，所以称为 I 型指令。
op：确定指令的功能；
rs：可以是一个源操作数，寄存器寻址；或者在存取指令中用作基址寄存器，偏移寻址。
rt：目的寄存器
Immediate：长度为 16 位的立即数，指令执行时需扩展为 32 位。根据指令的不同，可以有以下三种用法：
- 运算类指令（ori）：以立即寻址方式提供的一个源操作数。
- 存取指令（lw/sw）：作为偏移量，与寄存器 rs 组成偏移寻址方式，提供一个存储器操作数。
- 条件转移指令（bne）：作为偏移量，与 PC 寄存器组成相对寻址方式，提供一个转移目的地址。

J 型

op：确定指令的功能
address：转移地址

整合

三种指令 汇编格式 a=b op c 把=和op变成逗号
- R型指令格式是op+rs+rt+rd+shamt+func 汇编格式是 xxx $rs, $rt, $rd
- I型指令格式是op+rs+rt+imm 汇编格式是 xxx $rt, $rs, imm
- J型指令格式是op+addr 汇编格式是 xxx addr

MIPS 的通用寄存器

0 号寄存器$zero 为固定值零，不能改变
MIPS还提供了32个32位的单精度浮点寄存器$f0∽$f31,用于浮点数指令。它们可配对成16个64位的双精度浮点寄存器。
在汇编语言中使用寄存器时可以用寄存器名，也可以用寄存器号，前面加上“$”,例如，$8或$t0。
寄存器
- 长度：32 位
- 个数：32 个

MIPS 的寻址方式

寄存器寻址
- 可以出现在 R 型和 I 型格式中

立即数寻址

偏移寻址

PC 相对寻址
PC<– PC+4+imm*4

伪直接寻址
- 为什么称伪直接？
- 最终地址：PC 高四位+addr+两个 0，+表示拼接
- 位数：4+26+2=32

机器语言的解码（反汇编）？

高级语言、汇编语言、机器语言之间的转换？

RISC-V 指令系统

具有模块化结构，稳定性和可扩展性好，在简洁性、实现成本、功耗、性能和程序代码量等各方面具有显著优势。

模块化结构：

核心：RV32I + 标准扩展集：RV32M、RV32F、RV32D、RV32A = RV32G
32位架构RV32G = RV32IMAFD，其压缩指令集RV32C（指令长度16位）
64位架构RV64G = RV64IMAFD，其压缩指令集RV64C（指令长度16位）
向量计算RV32V和RV64V；嵌入式RV32E（RV32I的子集，16个通用寄存器）

指令格式

32位

R-型为寄存器操作数指令

I-型为短立即数或装入（Load）指令

S-型为存储（Store）指令

B-型为条件跳转指令

U-型为长立即数操作指令

J-型为无条件跳转指令

16位压缩

第五章中央处理器

CPU 的功能和基本结构

CPU 基本功能：

指令控制。完成取指令、分析指令和执行指令的操作，即程序的顺序控制。
操作控制。一条指令的功能往往是由若干操作信号的组合来实现的。CPU 管理并产生由内存取出的每条指令的操作信号，把各种操作信号送往相应的部件从而控制这些部件按指令的要求进行动作。
时间控制。对各种操作加以时间上的控制。时间控制要为每条指令按时间顺序提供应有的控制信号。
数据加工。对数据进行算术和逻辑运算。
中断处理。对计算机运行过程中出现的异常情况和特殊请求进行处理。

基本结构

数据通路 + 控制器

控制器
- 对指令进行译码，生成指令对应的控制信号，控制数据通路的动作。它向执行部件发出控制信号，是指令的控制部件。

数据通路

由操作元件和存储元件通过总线方式或分散方式连接而成的进行数据传送、处理和存储的路径。

数据通路
- 指令执行过程中，数据所经过的路径，以及路径上的部件。
- 包括：ALU、通用寄存器、状态寄存器、MMU、cache、中断处理逻辑等
- 数据通路中专门进行数据运算的部件称为执行部件或功能部件
- 功能：进行数据传送、处理和存储
组成元件
- 组合逻辑元件（操作元件）：输出只取决于当前输入
- 时序逻辑元件（也称状态元件，或存储元件）：在时钟控制下输入被写到电路中，直到下个时钟到达。
  - 定时方式：规定信号何时写入状态元件（上升沿、下降沿、电平触发）
  - 存储元件：寄存器 –> 寄存器组
连接方式
- 总线、分散

时序控制（过去式）：

现代时钟周期
- …… + 状态元件 + 操作元件( 组合电路) + 状态元件 + ……
  - 只有状态元件能存储信息，所有操作元件都从状态元件接收输入，并将输出写入状态元件中。
- 时钟周期= Latch Prop + Longest Delay Path + Setup + Clock Skew(时钟偏移)
- 约束条件：操作元件输出有效信号最快出现必须在下一级状态元件的输入保持时间之后出现

单周期 MIPS 处理器的设计

复习：三种指令类型 R、I、J

设计处理器步骤
1. 分析每条指令功能，并用 RTL（Register Transfer Language）来表示
2. 根据指令的功能给出所需的元件，并考虑如何将他们互连
3. 确定每个元件所需控制信号的取值
4. 汇总所有指令所涉及到的控制信号，生成一张反映指令与控制信号之间关系的表
5. 根据表得到每个控制信号的逻辑表达式，据此设计控制器电路

设计数据通路

R-type：取指 –> 取寄存器 –> 运算 –> 输出、计算下地址
- M[PC] 从PC所指的内存单元中取指令
- R[rd] ← R[rs] + R[rt] 从rs、r所指的寄存器中取数后相加。若结果不溢出，则将结果送rd所指的寄存器中；若结果溢出，则不送结果，并转到“溢出处理程序”执行。
- PC ← PC + 4 PC加4，使PC指向下一条指令

I-type
- M[PC] 取指令（公共操作，取指部件完成）
- R[rt] ← R[rs] or ZeroExt(imm16) 立即数零扩展，并与rs内容做“或”运算
- PC ← PC + 4 计算下地址（公共操作，取指部件完成）

Lw 装入指令
- M[PC] 取指令（公共操作，取指部件完成）
- Addr ← R[rs] + SignExt(imm16) 计算存储单元地址 (立即数符号扩展！)
- R[rt] ← M [Addr]装入数据到寄存器rt中
- PC ← PC + 4计算下地址（公共操作，取指部件完成）

sw 指令
- M[PC] 取指令（公共操作，取指部件完成）
- Addr ← R[rs] + SignExt(imm16) 计算存储单元地址（符号扩展！）
- M[Addr] ← R[rt] 寄存器rt中的内容存到内存单元中
- PC ← PC + 4 计算下地址（公共操作，取指部件完成）

分支指令
- M[PC] 取指令（公共操作，取指部件完成）
- Cond ← R[rs] - R[rt] 做减法比较rs和rt中的内容
- if (Cond eq 0) 计算下地址（根据比较结果，修改PC）
  - PC ← PC + 4 + ( SignExt(imm16) x 4 )
- else
  - PC ← PC + 4

无条件跳转指令
- M[PC] 取指令（公共操作，取指部件完成）
- PC<31:2> ← PC<31:28> 串接 target<25:0> 计算目标地址

指令范围有多大？

不是相对寻址，是绝对寻址。转移范围只能在 j 指令所在的228=256MB页面内，页面号与j指令相同 PC<31:28>

完成

时间计算

设计控制器

方法：
1. 根据每条指令的功能，分析控制信号的取值，并列表表示。
2. 根据列出的指令和控制信号的关系，写出每个控制信号的逻辑表达式。