Yuukoの小屋

计算机网络架构

2026-06-14T16:00:00.000Z

计算机网络相关概念

计算机网络是由若干个计算机节点或者相关硬件节点与链接这些节点的链路组成的网状数据通路。

internet和Internet是两个需要区分的名词，前者是泛指的互联网结构，而后者是基于TCP/IP协议的现代 因特网。

以太网是一种使用有线连接实现局域网连接的技术形式，以太网主要通过“星型拓扑结构 + 交换机 + 网线/光纤 + 物理网卡”的方式来实现。

计算机网络的分类

按网络使用者划分可以分为:

公用网 -- 由电信运用商建设，由互联网服务提供商(ISP)，如中国移动，向普通用户提供互联网接入
专用网 -- 特定单位的需求下的专门内部网络，不对外使用。

按照空间拓扑结构可以分为

总线型 -- 单一互联网总线串联所有计算机。建网结构简单，但是重负载情况下的通信效率低。
星形网络 -- 中心化的网络架构，所有计算机通过独立线路与中心设备相联。实现成本高且中央设备对故障敏感，优点是便于管理与控制。
环形网络 -- 去中心化的网络架构，通过环形网络连接所有计算机。例子:令牌环局域网
网状网络 -- 去中心化的网络架构，广泛应用于广域网，可靠性较高，但是控制复杂，线路成本较高。

按照分布范围分类

广域网(WAN) -- 长距离通信，城市间的互联网结构，用于构成互联网的骨干部分，通过高速链路连接节点交换机。
城域网(MAN) -- 中距离通信，城市内或者城市群内的互联网结构。城域网通常使用以太网，因此有时也被纳入局域网。
局域网(LAN) -- 短距离通信，通过主机高速线路互联。
个人区域网(PAN) -- 使用无线网络在个人工作区域连接计算机与其他消费电子设备。
按传输技术分类
广播式网络 -- 联网计算机共享同一个公共通信的信道，所有计算机都能收听到报文信息，根据目的地址的检查决定是否
点对点网络 -- 每一条物理线路独立连接一对计算机，如果主机间没有直接连接，则分组通过中间件

计算机网络的功能

数据通信
资源共享 -- 硬件/软件/数据的共享，比如NAS实现云存储
分布式处理 -- 单一复杂任务的分布式计算
提高可靠性 -- 通过网络进行数据备份，比如git
负载均衡 -- 高并发任务的负载分配

网络的信息交换方式

节点间的信息交换方式分为

电路交换
报文交换
分组交换

电路交换

电路交换是通过电话线+电话交换机形式建立节点间的稳定通信线路资源，建立后通信线路由双方独占直到结束。因此电路交换通常只使用低频、连续且大量的

电路交换分为三个阶段 -- 建立连接(开启占用通信资源) -> 传输数据(持续占用通信资源) -> 释放连接(释放通信资源)

电路交换面临的问题有: 建立连接的时间长、线路利用率低与灵活性差、难以实现差错控制

报文交换

报文交换是用户节点将传输信息(比如源地址、目的地址等控制信息)封装为报文后传输。报文通过存储转发技术，在通信双方的节点中间的节点之间进行接收、存储、转发直到最终接收的节点。

假如节点A到节点B存在多个路径，每一个报文可以独立选择如何经过

交换节点能对报文进行差错检验，从而实现差错控制。报文交换方式不需要独占通信线路资源，线路利用率高。但是交换节点需要缓存报文后再转发，加大了缓存开销与转发的时间开销。如果报文过长，重传的成本也相应提高。

分组交换

分组交换则是将报文进一步拆分为等长的数据段，每一个细分的数据段的首部包含必要的控制信息(源地址、目的地址、分组号等)，组内的数据传输可能不通过相同的路径传输。网络中的分组交换器查询分组的首部后缓存并处理转发。

数据报服务 -- 数据报是分组的一种具体的实现形式，中转路由器将数据报作为独立的实体进行缓存、转发，同一报文的若干个数据报可能通过完全不同的路径传输。
虚电路服务 -- 仿照电路交换模式，在通信的结点间的所有交换设备建立逻辑通信连接，逻辑连接建立后会分配一个唯一的虚电路标志(VCID)，分组通过VCID进行传输与转发。

分组方式降低了报文的出错概率与重传的代价，遇到分组出错后只需要重传分组片段而不需要重传整个报文。但是每一个分组都需要额外的控制信息管理分组段。增加了控制复杂度同时降低了有效信息密度。

分组可能失序、丢失或者重复，通常需要控制信息的管理。数据报服务模式的分组可能通过不同路径到达目的主机，需要在目的主机重排序，也有可能在传输过程发生丢包。虚电路不会发生失序，但是和电路交换一样有连接的建立与占用的时间与通信资源的开销。

分组交换的时延通常是最小的，相比而言最灵活且最适合突发式通信。

网络的性能指标

速率 -- 数据传输的速度
带宽 -- 信道支持的最大速率
吞吐量 -- 单位时间内通过某个位置的实际数据量
时延 -- 从当前结点传输到目的结点的总耗时，包括发送时延、传播时延、处理时延、排队时延

发送时延指发送结点分组信息全部推入传输链路的耗时。满足

$\text{发送时延} \tau_s = \frac{\text{分组长度} l}{\text{发送速度} v}$

传播耗时为数据在信道中的传输时间

$\text{传输时延} \tau_t = \frac{\text{信道长度} s}{\text{电磁波的信道传输速度}c}$

处理时延为交换结点内的处理耗时

排队时延为数据在路由器等设备等输入输出队列中的排队耗时

关于传输信道的其他性能指标有:

时延带宽积 -- 第一个比特到达接收端时，已发送的比特量。
往返时延
信道利用率 -- 有数据通过的时间占整个统计时间窗口的比例

滑模控制

2026-06-12T16:00:00.000Z

滑模控制

滑模控制是通过将相空间分块的方式实现分段非线性控制的控制方法。

相图

对于微分方程

$\frac{\mathrm{d} \mathbf{x}}{\mathrm{d} t} = f(\mathbf{x})$

且 $f(\mathbf{x})$ 只通过 $\mathbf{x}$ 与 $t$ 相关而不直接相关，这样的微分方程称为自洽微分方程, 同时保证，在一个初值下，自洽微分方程的解是存在且唯一的

微分方程的解为 $x = \phi(t,x_0) $, 即从初值 $x_0$ 出发的解。

我们可以证明: 对于方程的解 $\phi(t,x_0)$ , $\phi(t+c,x_0)$ 仍然是方程的解，即解是 $t$ 无关的

方程的解集

$D = \left\{\mathbf{x}\in D\big| \mathbf{x} = \phi(t,\mathbf{x}_0), t\in J\right\}$

称为方程的相空间，解曲线 $\mathbf{x}_i = \phi(t,\mathbf{x}_0)$ 实际是 $t\in J\subset \mathbb{R} \to \mathbf{x} \in D\subset \mathbb{R}^n$ 的一条曲线，曲线在相空间 $D$ 上的投影称为相轨迹

二阶系统滑模控制

考虑二阶系统，其闭环传递函数为

$\Phi(s) = \frac{\alpha}{s^2+\beta s+\alpha}$

对应的微分方程为

$\ddot{c} + \beta \dot{c} + \alpha c = \alpha r$

$e$ 为误差函数，定义为 $e = r-c$

考虑常值输入，此时有

$\begin{aligned} \alpha e & = \alpha (r-c) = -\ddot{e} - \beta\dot{e} \end{aligned}$

因此原系统可以化为关于误差的零输入二阶系统

$\ddot{e} + \beta\dot{e} +\alpha e = 0$

特征方程根

$\lambda_1 = \frac{-\beta + \sqrt{\beta^2-4\alpha}}{2}, \lambda_2 = \frac{-\beta - \sqrt{\beta^2-4\alpha}}{2}$

对于方程

$\ddot{e} -(\lambda_1+\lambda_2)\dot{e} + \lambda_1\lambda_2 e = 0$

写为

$\begin{bmatrix} \dot e\\ e \end{bmatrix}' = \begin{bmatrix} \lambda_1+\lambda_2 & \lambda_1\lambda_2\\ 1&0 \end{bmatrix} \begin{bmatrix} \dot e\\ e \end{bmatrix}$

因此对于 $\displaystyle X = \begin{bmatrix}\dot e\\ e\end{bmatrix}$ , 有

$\frac{\mathrm{d} X}{\mathrm{d} t} = A X$

特征值为 $\lambda_1,\lambda_2$

这个方程的相曲线即为当前零输入误差二阶系统的相曲线。

由于

$\mathrm{d} e^{2} = 2e\dot e$

因此当 $\dot{e}, e$ 图的相曲线收敛到0时，表示 $\|e\| \to 0$ 且不在变化，说明此时系统稳定。同时，当 $e\dot{e} <0$ 时，系统的误差在下降。

去掉中间的负反馈通路 $\beta$ ,将二阶系统改为前向通路中存在一个-1的开关

当开关处于1的时候，闭环传递函数为

$\Phi(s) = \frac{\alpha}{s^2+\alpha}$

当开关处于2当时候，闭环传递函数为

$\Phi(s) = -\frac{\alpha}{s^2-\alpha}$

这两种状态单独存在的时候，两个系统都无法渐进稳定，但是通过某种切换策略，在两个系统之间有限次转换，就可以实现相轨迹趋向于原点。

其中发散模量

$A = \frac{\dot e_0 +\sqrt{\alpha} e_0}{2\lambda} = \frac{s_0}{2\sqrt \alpha}$

Switch 2的稳定特征线为 $ \dot e+ \sqrt{\alpha} e = 0$, 此时方程通解的发散模项为0

当 $s>0$ 是向正向发散，当 $s<0$ 的时候会将幅值先向0调整后再负向发散。因此，当 $e> 0,s<0$ 或者 $e<0, s>0 $ 时，发散项的贡献都是将误差向靠近0的收敛。

当 $es>0$ 时，切换为Switch 1, 此时特征根为两个共轭纯虚根，因此对于轨迹的贡献为旋转贡献。

因此以 $e(\dot e +\sqrt \alpha e ) = 0$ 作为滑模面进行滑模控制

通常使用开关函数进行开关的切换

$\mathrm{sgn}(s) =\begin{dcases} 1& s\geq 0\\ -1 & s<0 \end{dcases}$

实际使用时，会设计一个饱和边界层 $\gamma$ , 使用连续的函数替换开关函数，比如

$\mathrm{Sat}\left(x\right) = \begin{dcases} 1 & x\geq 1\\ x & x\in (-1,1)\\ -1 & x\leq -1 \end{dcases}$

或者

$\tanh (x) = \frac{e^{x}-e^{-x}}{e^{x}+e^{-x}}$

用于实现跳变的连续化与光滑化。使用 $\mathrm{Sat}\left(\dfrac{s}{\gamma}\right)$ 或者 $\tanh\left(\dfrac{s}{\gamma}\right)$ 进行跳变，能将变化区域大致限制在饱和区 $[-\gamma,\gamma]$ 中

对于 $n$ 阶高阶系统，滑模面是子空间内的超曲面

$s = s(x_1,\cdots, x_m)$

需要更加复杂的切换逻辑

BPE-tokenizer

2026-06-11T16:00:00.000Z

BPE - Tokenizer

BPE的基本观念

BPE Tokenizer 是将单个单词拆分为若干个子块进行tokenizer的方式，会训练一个Tokenizer Merge 表用于规定如何进行单个字母合并为子块，并训练一个token string子块与token id空间的映射表vocab以实现将字符转换为int类型的token id

BPE 需要考虑一些Special token，它们是不可分token string单元，每一个作为整体映射到token id. 比如 "<|endoftext|>"

BPE Merge 表的训练

BPE 基于字符合并而贪心算法进行vocab和 Merge表

假设Tokenizer 训练集为

We</w> *20
are</w> *12
the</w> *3
world</w> *9

拆分为字频

W e </W> *22
a r e </w> *12
t h e </w> *3
w o r l d </w> *9

</w> *44
e    *35
w    *29
r    *21
a    *12
o    * 9
l    * 9
d    * 9
t    * 3
h    * 3

Top-2 字频的字为 w 和 e，将这两个字进行有序的合并

we </w> *22
a r e </w> *12
t h e </w> *3
w o r l d </w> *9

更新字频表

</w>  *44
we   *22
r    *21
a    *12
o    * 9
l    * 9
d    * 9
e    * 6
t    * 3
h    * 3

此时可合并的Top-2 字频为r 与 a

we </w> *22
ar e </w> *12
t h e </w> *3
w o r l d </w> *9

更新词频表

</w>  *44
we   *22
ar   *12
r    * 9
o    * 9
l    * 9
d    * 9
e    * 6
t    * 3
h    * 3

以此方式迭代直到达到设定的合并上限

正则表达式库`re`的使用

遇到的问题

磁盘与SSD

2026-06-10T16:00:00.000Z

磁盘存储器

磁盘存储器由磁盘驱动器、磁盘控制器与盘片三个部分构成

磁盘的存储单元，自上而下分为

盘面 -- 磁盘的记录面，一个磁盘由多个盘面构成，每一个盘面有配套的读写磁头，盘面间共轴转动
扇区 -- 盘面的扇形区域，盘面根据角度均分为若干个扇形区域，扇区中间有一定的间隙，称为扇区间隙
磁道 -- 根据半径区分的，磁头能访问的存储区域。由于磁道的存储密度相同，磁道间的编址空间与存储空间随着半径递增。或者降低外层磁道信息线密度以保证磁道间一致性。

存储区域内存在相关信息

记录面数 -- 磁头数 = 盘面数
柱面数 -- 单个记录面上的磁道数，即盘面沿着半径方向被分割成多少个部分
扇区数 -- 单个记录面上的扇区数，即盘面沿着旋转方向被分割成多少个部分

最早的磁盘是IBM推出的温彻斯特磁盘(温盘)

磁记录原理

磁头和磁性记录相对移动时，电磁转换以实现数据的读写操作

磁盘的管理

磁盘的初始化

磁盘的初始化分为低级格式化与高级格式化

低级格式化将磁盘分为若干个扇区，扇区分为头部、尾部和数据部分，并使用CRC字段校验。低级格式化只是物理片段的划分，所以也叫物理格式化。

高级格式化则是在分区上建立文件系统，初始化根目录等操作。因此也称为逻辑格式化。

磁盘的容量也分为非格式化容量与格式化容量。非格式化容量是磁盘的理论存储上限，磁盘的磁记录表面可用的磁化单元总量；格式化容量是格式化后的实际可用存储容量。因此非格式化容量 > 格式化容量

磁盘的地址编码方式

|柱面(磁道)号|盘面(磁头)号|扇区号|

磁盘阵列

RAID是将多个物理磁盘统一组合为一个逻辑磁盘的方式，数据在多个物理盘间交叉分割存储并并行访问，以获得更好的存储性能与安全性。

磁盘的文件系统

文件管理

将磁盘进行分区，每一个分区的起始位置和大小记录在MBR中，而后是引导块进行OS的文件块加载进行自举。

BIOS存储在ROM中，进行在硬件自检后加载引导块以启动操作系统。

磁盘的调度算法

磁盘读写时间由三个部分构成

寻道时间
旋转延迟时间
数据传输时间

寻道时间由跨越磁道时间 $m$ 和磁头臂启动时间 $s$ 构成

$T_s = mn+s$

平均寻道时间是最大寻道时间的一半

旋转延迟时间为目标扇区旋转到磁头下的耗时，假设盘面转速为 $r$ ,平均旋转延迟时间为

$T_r = \frac{1}{2r}$

数据传输时间为读写 $b$ 字节所需的时间。如果每条磁道存储 $N$ 字节，则平均数据传输时间为

$T_t= \frac{b}{rN}$

总平均存取时间为

$T_a = T_s+ T_r+T_t$

磁盘的存取时间中，寻道时间是最主要的时间开销部分，因此主要目标是降低寻道时间的开销。

响应时间还需要考虑排队延迟和控制器时间的开销

磁盘调度算法

FCFS算法

最简单且最公平的算法，但是大量进程竞争磁盘时，磁头会频繁长距离移动导致效率低下

最短寻道时间优先(SSTF)

基于贪心算法，每一次都寻找最短时间开销的磁道请求。

SSTF可能在一个磁道区域来回移动导致较远的磁道出现"饥饿"现象

SCAN算法

根据当前的移动方向向最远处磁道移动，到达最远处后反向到达最内侧磁道。

SCAN算法也称为电梯算法。它对最新扫描过的扇区不公平，需要更大的耗时才会返回该区域，因此局部性不如FCFS和SSTF。

C-SCAN算法

C-SCAN算法在到达磁盘最外侧边缘时，直接返回最内侧，返回过程不执行服务。当磁头从最内侧移动到最外侧时才进行服务。

LOOK/C-LOOK 调度

基于SCAN/C-SCAN改良，不到达磁道物理边缘，而只到达当前方向上的最远请求位置后就反向。

NStepSCAN & FSCAN 算法

由于SSTF/SCAN/C-SCAN 算法会出现磁道黏着现象。假设有进程始终在访问某个磁道，那么磁头就只会在当前磁道工作，导致其他磁道进程饥饿

NStepSCAN将任务队列划分为若干长度为N的子队列，队列间FCFS，队列内SCAN。新请求放入新的队列当中，不放入正在执行的队列中。

FSCAN将NStepSCAN简化为 $N=2$ 的形式，即维护当前服务队列和新请求的队列两个部分，将当前扫描过程中新增的请求全放入新请求队列中，降低了实现开销。

减少延迟时间的算法

交替编号 -- 盘面内奇偶分离编号，减少执行时间导致错过扇区的长延迟
错位命名 -- 盘面间错位编号，减少旋转延迟

提高磁盘IO速度的方法

改进文件目录结构与目录以降低目录查找时间
选择号的文件存储结构
提高磁盘IO速度，如高速缓存、提前写、延迟读、虚拟盘、RAID等方式

SSD

SSD 是基于Flash技术的存储设备，是E^2PROM的变体。

SSD的读写操作以页为单位进行，擦除操作以块单位进行。

SSD 的随机写速度较慢且擦写寿命较低，擦除的用时也比较长。因此提出了磨损均衡算法：

动态磨损均衡 -- 写入数据时优先擦写访问少的块，将负载分散在不同块中
静态磨损均衡 -- 控制器定期定期进行高磨损块的数据迁移，高磨损块以只读为主，低磨损块更多承担擦写任务，以提升平均寿命

静态磨损均衡的实际性能好于动态磨损均衡

IO管理

2026-06-08T16:00:00.000Z

IO管理

IO 设备

根据信息交换可以分为

块设备 -- 传输速率高、支持随机读取的设备以块单位进行数据交换，如磁盘
字符设备 -- 以字符为单位进行信息交换，通常使用中断方式实现异步通信，比如打印机

打印机需要逐字符对照进行打印

根据传输速率可以分为

低速设备 -- 键盘鼠标等，传输速率低，大致为几字节每秒到几百字节每秒
中速设备 -- 打印机等，大约数百至数千字节每秒
高速设备 -- 磁盘，显卡等

按共享属性分类为

独占设备 -- 同一时刻只允许单一进程使用，直到释放，比如打印机
共享设备 -- 同一时刻单独访问，但是允许进程逻辑上并发，通过调度实现多进程访问，分时交替使用，比如磁盘
虚拟设备 -- 通过SPOOLing 设备将独占设备改造为多个逻辑设备并发，使用高速共享设备作为缓冲区，实现独占设备的逻辑共享。

IO接口

IO 接口(设备控制器)是CPU与IO 设备之间的桥梁。设备管理器与CPU通过三根逻辑区分的总线相连，分别为数据总线、地址总线、控制总线。

总线端维护了数据寄存器与控制/状态寄存器用于解决总线与IO速度不同步的信息缓冲问题

在现代总线结构，比如显卡的PCIe结构中，都是使用高速串行总线结构，实际为单根高速总线的串行结构，在物理结构上串行，在逻辑结构上分段。

IO接口可以有一个或者多个面向设备的接口，每一个接口可以传输数据、控制、状态信号。

IO接口中存在IO逻辑电路，用于实现对于设备的控制.CPU启动设备后，向设备控制器发送相应命令与地址，但是传输给设备的信息需要经过IO逻辑进行解析并控制发送。

控制设备器的主要作用

接收并识别命令
完成数据交换
标识并报告设备状态
地址识别与数据缓冲 (对应)
差错控制 -- 通过奇偶校验等方式进行差错识别；通过Hamming码等方式进行校验，或者报告给CPU进行信息的重传。

IO 接口的类型

传统意义下IO接口并不是一个大型控制器的集成，而是若干个IO接口功能模块的实现，IO接口根据不同的类型有不同的分类。

根据数据传输的方式分类为并行接口与串行接口

根据主机访问方式分为 程序查询接口、中断接口与DMA接口

根据可编程性分为 可编程接口与不可编程接口，在可编程接口中需要一套执行指令的PC/相关寄存器，甚至单个IO接口就是一个SoC，具有独立指令执行的功能的设备。

根据设备类型不同分为 块设备接口、字符设备接口与网络设备接口

IO 接口的编址

可以分为独立编址方式与统一编址方式。

独立编址方式中的IO接口的地址空间与主存相对独立，二者不属于相同的地址空间，因此主存的地址值能和主存的某个地址相同。

统一编址方式则是将部分主存地址分配给IO设备，IO设备可以获得较大的编址空间，且可以使用统一的虚拟内存管理方式管理。缺点是减少了内存物理地址可用量。

IO控制方式

分为程序直接控制(程序查询方式)、中断驱动方式与DMA方式。

程序直接控制

程序直接控制方式中，IO设备与主机的数据交换完全由CPU控制，通过程序的执行实现。

实现流程

CPU初始化程序并预设相应参数(比如UART传输的波特率、起始地址等)
向IO接口发送命令字并启动外设
循环读取外设状态寄存器值
如果设备就绪就进行数据传送
修改地址与计数器参数
直到计数器归零停止传送

读取外设状态寄存器的查询方式可以分为

独占查询 -- 进程占据CPU进行忙等待查询
定时查询 -- CPU周期性查询，周期间释放CPU资源

程序中断方式

通过中断技术让IO独占总线与CPU一段时间以实现信息与至指令的传输；当IO工作的时候将IO进程中断并实现IO设备和CPU中其他进程的并行工作，以节省CPU的资源。

中断源是能够向CPU发送中断请求的设备或者事件，中断系统为每个中断源设置了中断请求标记触发器，置1时表示中断源请求中断。

通过INTR的信号线发出的是可屏蔽中断。通过NMI的信号线发送的是不可屏蔽中断。不可屏蔽中断优先级高于可屏蔽中断，且可屏蔽中断在关中断状态不能中断。

中断响应的过程可分为

关中断
保存断点 -- 程序计数器PC与程序状态字PSW保存入栈或者专用寄存器
中断服务程序寻址 -- 通过中断类型找到对应的中断服务程序入口，并送入PC等待执行
开中断
执行中断服务程序
关中断
恢复现场和PSW
开中断与中断返回

中断隐指令(关中断-保存断点-中断服务寻址)是中断前的准备指令，将前一进程状态保存，并加载中断服务程序以便实现中断。

中断服务程序的实现过程分为中断过程和恢复过程，中断过程(开中断-执行中断服务程序-关中断)进行中断，恢复过程(恢复现场和PSW-开中断与中断返回)将中断现场恢复并开中断

多重中断与中断屏蔽

当系统存在多中断源竞争的时候需要使用优先级机制匹配中断，只有在开中断阶段的时候可屏蔽中断才能参与多重中断的竞争。

多重中断是指多个中断源发生时，低优先级中断过程被高等级中断抢占并优先中断的过程。通过栈结构管理相应多重中断的断点，因为优先级执行机制是FILO的。

中断处理优先级是多重中断的实际处理顺序，可以通过动态屏蔽技术动态调整。分为处理优先级与响应优先级，当中断系统不使用动态屏蔽技术的时候处理优先级等于响应优先级。

中断请求寄存器维护每一个中断源的中断请求，中断屏蔽字寄存器维护进程的处理优先级。中断请求经由请求寄存器发送，在屏蔽字寄存器和处理优先级电路的运算下输出在当前中断请求状态下的处理优先级，再通过中断判优电路处理后输出真正的执行中断的响应优先级。

逻辑上的中断实现需要维护一个 $n\times n$ 的中断屏蔽字表，比如

$\begin{bmatrix} 1&1&1&1\\ 0&1&0&0\\ 0&1&1&0\\ 0&1&1&1 \end{bmatrix}$

表示 $A>D>C>B$ ，这是静态的中断响应优先级表

但是基于当前中断请求状态的动态执行是通过vector+ 中断请求寄存器更新实现的。

比如在初始请求寄存器为 $[A,B,C,D] = [0,1,1,1]$ 时

第一轮 -- 中断D，请求寄存器更新为 $[0,1,1,0]$
第二轮 -- 中断C, 请求寄存器更新为 $[0,1,0,0]$
第三轮 -- 中断B, 请求寄存器更新为 $[0,0,0,0]$ , 中断结束

DMA 方式

DMA 在IO接口和内存之间建立轮直接的数据通路，以提高CPU资源利用率，实现数据准准备阶段传输过程中的CPU任务与IO设备的并行。

DMA控制器组成

主存地址计数器 -- 用于存放待传输数据的主存地址，传输一个字就自加确认下一个地址
传送长度计数器 -- 用于标记待传送数据的总长，传送一个字就自减，计数器归零说明传输结束
数据缓冲寄存器 -- 暂存每次传输的数据
DMA请求触发器
控制状态逻辑
中断机构 -- DMA中断源

DMA控制器需要竞争总线的能力，且对于总线/CPU的优先级满足

DMA > 不可屏蔽中断 > 可屏蔽中断

DMA 传送方式

DMA 与 CPU 共享主存的方式可分为

停止CPU访问主存 -- DMA直接竞争主存，CPU停止主存相关的访问，直到DMA结束数据传送
周期挪用 -- 在单个访存周期内，DMA优先级高于CPU，但是周期内DMA无法中断CPU访存
DMA与CPU交替访存 -- 交替分配主存访存周期

DMA传送过程

DMA传送需要CPU进行预处理，数据传送与后处理三个过程。

预处理 -- 完成DMA的初始化并启动IO设备，当IO设备准备好输入/输出请求时，向DMA发送DMA请求
数据传输 -- DMA直接通过总线访问主存，CPU执行其他进程
后处理 -- CPU响应后执行中断服务程序，并进行数据校验等后处理工作。

IO 软件

IO软件是运行在CPU侧进行IO设备与IO接口管理的软件系统，向上与文件系统、用户进程、虚拟存储器等系统交互，向下与底层IO设备系统交互。

比如NVIDIA的驱动程序，面向下层显卡的实际计算管理，面向上层操作系统与用户暴露API，使用户能通过这些API进行显卡计算能力的使用，比如CUDA/OpenGL等计算

IO 软件根据用户侧 -- 硬件侧的自下而上的软件分类可分为

用户 - 用户层软件 - 设备独立性软件 - 设备驱动软件 - 中断处理软件 - 硬件

中断处理软件

用于管理IO设备结束等情况下的中断管理，实现最基本的CPU/总线与IO设备的通信层任务

操作系统对于中断处理软件本身也存在一层管理，包括三个环节

注册中断 -- 向内核注册中断号，建立当前设备中断状态与内核记录的服务状态的记录映射，建立CPU和设备间中断状态的握手，确保内核能进行中断处理
处理中断
注销中断 -- 驱动/设备停用的时候恢复中断现场，注销中断处理程序并释放相应资源。

设备驱动程序

面向不同种类设备的专用管理软件，比如打印机的打印机驱动，鼠标设备的驱动，NVIDIA显卡的显卡驱动等。不同设备向主机暴露的API不同，访问方式不同，设备驱动程序正是提供这些API的软件层。

类比VFS的统一管理多协议磁盘的形式，设备驱动程序类似于磁盘文件系统NTFS/ext4。

设备独立层软件

操作系统将设备驱动程序进行统一管理，比如网络的统一化接口Socket层，进行用户层网络调用的编程不需要考虑通过有线还是通过无线进行网络访问，而直接通过操作系统暴露的Socket获得网络资源。

设备独立层软件引入物理设备与逻辑设备的概念，将实际用户层的访问与物理设备相解耦。比如在Unix中访问网卡信息，通常获得的不是真实的网卡名，而是映射后的网卡号以及相关信息

asuna@AsunadeMacBook-Air ~ % ifconfig
lo0: ...
gif0: ...
stf0: ...
anpi0: ...
anpi1: ...
en3: ...
en4: ...
en1: ...
en2: ...
ap1: ...
en0: ...
utun0: ...
awdl0: ...
llw0: ...
utun1:...
utun2: ...
utun3: ...

其中en*是映射真实物理网卡的逻辑网卡接口
lo0是本地回环的网络接口，纯粹软件虚拟实现且指向127.0.0.1
anpi*是Apple Silicon 的内部协议与通信接口，用于支撑内部系统服务的部分通信，并将这样的总线通信权限通过anpi*暴露给用户。

用户层软件

用户层软件就是整体实现与用户交互的软件接口，通过调用用户层的IO库函数与硬件进行交互。

应用程序IO接口

应用程序IO接口是OS面向用户侧提供的管理与访问IO设备的架构与编程规范。

OS将物理设备抽象为块设备、字符设备、网络设备，网络设备虽然速度匹配，但是网络通信使用的是不可随机访问的数据包而不是数据块，因此不算块设备的范畴。

字符设备接口 -- get/put操作用于向缓冲区读写；in-control 用于实现具体设备的控制; open/close用于打开关闭与互斥访问
块设备接口 -- 块设备通常为存储设备，因此块设备接口通常暴露的就是存储相关能力的接口。read/write/seek用于执行基本功能，seek用于指定下一个传输块。

阻塞IO与非阻塞IO

IO接口面向不同的设备有两种执行模式: 阻塞与非阻塞，

阻塞IO能在进程发起IO请求但是资源未满足时发生阻塞，并移动到相应等待队列。

非阻塞IO发生时，进程会轮询资源就绪情况，且进程能同时执行其他的任务而不受IO请求的影响。

设备独立性软件

设备独立性软件和VFS相似，在设备驱动程序层之上，实现不同设备等公共操作，并暴露统一且抽象化的API。具体功能有

统一的驱动程序接口
缓冲管理 -- 缓冲CPU和IO设备的速度差异，建立统一的缓冲区对应硬件层的软件实现。
差错控制
独占设备的分配与回收
统一的逻辑数据块

高速缓存与缓冲区

磁盘高速缓存(Disk cache)基于内存实现，利用内存的存储空间暂存磁盘读取的盘块信息以实现加快磁盘IO速度的效果。在内存实现方式有两种

在内存中开辟固定大小的专用缓冲区
将内存中空闲的空间作为动态缓冲池，供分页系统与磁盘IO子系统使用。

缓冲区

IO设备大部分情况下IO速度远远慢于CPU的速度(如打印机)，也可能远快于CPU(显卡)

缓冲区的实现方式有

硬件缓冲区 -- 实现成本较高，关键部位才使用
内存缓冲区 -- 常见实现方式

缓冲区总是单个时刻可读/可写的，所以其能实现的作用是在CPU处理时间内作为数据蓄水池

单缓冲

在缓冲区结构中，单次IO时间分为三个部分

IO设备写入缓冲区的时间 $T$
缓冲区传送给CPU的时间 $M$
CPU处理时间 $C$

在单个周期内，当 $M_i$ 结束，就能执行 $T_{i+1}$ .如果 $C_{i}> T_{i+1}$ ，即CPU处理时间长于IO写时间，则缓存区写等待CPU执行；反之CPU写等缓存区写。通常情况下都是 $C_{i}<T_{i+1}$ , 因此单轮耗时为

$\mathcal{T}_s = \max(C,T)+M$

对于 $N$ 轮IO写入的作业，总耗时为

$\mathcal{T}_{total} = (N-1)(\max(C,T)+M)+(T+C+M)$

最后一轮没有 $C$ 与 $T$ 在时间轴上的cover，因此都需要计算

双缓冲

双缓冲是可切换的两个缓冲区的结构。在缓存区1写的时候，缓存区2也能向CPU传输信息

如果IO写时间 $T$ > 从缓冲区传入CPU的总时间 $M+C$ , 则缓冲区2空闲等待缓冲区1写，反之需要缓冲区1满等待缓冲区2执行。因此单轮执行时间为

$\mathcal{T}_s = \max(T,M+C)$

N轮的总执行时间为

$\mathcal{T}_{total} = (N-1)\max(T,M+C) +(T+M+C)$

双缓冲能实现全双工通信，双向传输信息，每一台设备设置发送缓冲区与接收缓冲区

循环缓冲

循环缓冲区的实现逻辑与循环链表类似，通过环形空间和in/out两个指针指向当前写入的缓冲区与传入CPU的缓冲区。

如果in指针追上out指针则为CPU速度慢于IO写速度；反之则为IO写速度慢于CPU速度

缓冲池

缓冲池是一套包括管理数据结构和操作函数的，能管理多个缓冲区的软件机制，能支持多进程共享。

缓冲池按四种方式进行工作

收容输入 -- 将输入数据存入输入缓冲区
提取输入 -- 将输入缓冲区信息传入CPU并清空输入缓冲区
收容输出 -- 从CPU将输出数据输入输出缓冲区
提取输出 -- 将输出缓冲区的数据输出到IO并清空输出缓冲区

设备分配与回收

设备独立性软件维护了一张系统设备表(SDT)，包含所有物理设备与相应的全局索引。每一个表项对应一个设备，包含设备类型、标识符等用于检索设备的信息。

每一个物理设备私有一个设备控制表(DCT), 管理设备的各项具体属性，比如设备类型、设备标识符、设备状态、指向设备器控制表的指针、重复执行次数与时间和设备的队首指针等。

**设备器控制表(COCT)用于标记设备器的状态信息，存在指向通道控制表(CHCT)**的指针

通道控制表(CHCT) 标记每一个通道的状态信息，以及通道相关的所有的控制器的信息。

通道是内存和IO设备的通信通道，是一个协处理器级别的IO管理设备，用于实现更加复杂化，可编程的，类似于DMA的IO设备管理。

根据访问顺序自上而下的排列为

SDT -> DCT -> COCT -> CHCT

设备的分配的顺序为

设备分配 -- 查询SDT并找出对应设备的DCT,分配设备
控制器分配 -- 根据COCT找到对应设备的控制器
通道分配 -- 控制器分配后根据COCT找到对应CHCT, 分配内存和IO设备间的通道。

设备的分配算法会考虑是否死锁，

安全分配方式 -- 死锁避免，进程IO请求后进入阻塞态
不安全分配方式 -- 只有当请求设备被其他进程占用时才进入阻塞态。但是可能由于资源竞争造成死锁

死锁竞争的讨论见进程的同步与互斥与死锁

逻辑设备与物理设备的映射

设备的逻辑化需要建立逻辑设备和物理设备之间的映射，对应的映射表为逻辑设备表(LUT)

逻辑设备表可以为整个系统维护一个LUT表或者为单个用户维护LUT表，前者适用于单用户系统，后者适用于多用户系统

SPOOLing技术

SPOOLing技术用于缓和高速CPU和低速IO之间的速度矛盾。其核心是将高速磁盘作为缓冲进行相应信息的临时存储，通过软件模拟脱机IO的过程。

脱机IO的本质是将不同的作业拿到外围机进行并行IO作业，一方面解放主计算机的CPU，一方面可以保证IO作业的连续性。

通过SPOOLing技术能通过多道程序和磁盘缓冲空间代替IO的外围机，从而将一台物理独占设备仿真为多个逻辑设备。具体场景为多用户共享的打印中心。

SPOOLing技术的构成结构有

输入井和输出井 -- 位于磁盘中的缓冲区，用于暂存输入/输出设备的文件(称为井文件)
输入/输出缓冲区 -- 在内存中用于暂存输入/输出设备的数据，这是磁盘写速度慢于内存的平衡buffer
输入输出进程
井管理系统 -- 控制作业和磁盘井的信息交换

磁盘

磁盘与SSD

Position Encoding

2026-06-06T16:00:00.000Z

Position Encoding

Attention Is All You Need 中提出了 Sinusoidal Position Encoding

$\begin{aligned} \mathrm{PE}(pos,2i) &= \sin \left(\frac{pos}{f^{2i/d_{mod}}}\right)\\ \mathrm{PE}(pos,2i+1)& = \cos \left(\frac{pos}{f^{2i/d_{mod}}}\right) \end{aligned}$

对于token vector

$pos =$

Assignment1 -- Building a Transformer LM

2026-06-06T16:00:00.000Z

Assignment1 -- Building a Transformer LM

本作业从最基本的全连接层出发，进行一个简单的Transformer LM 的搭建

`torch`的一些API的用法

矩阵转置与对换

使用<Tensor>.T可以实现矩阵的转置，同样可以使用更加泛用的<Tensor>.transpose(-2,-1)进行维度对换

<Tensor>.transpose(i,j)相当于第 $i$ 维与第 $j $维进行对换

核心函数的实现

Linear

简单的线性层的实现，相当于实现了一个张量乘法。

在torch中实现乘法的方式:torch.matmul或者直接@。在考虑张量的乘法的时候需要考虑乘法的维度对应问题

def run_linear(
    d_in: int,
    d_out: int,
    weights: Float[Tensor, " d_out d_in"],
    in_features: Float[Tensor, " ... d_in"],
) -> Float[Tensor, " ... d_out"]:
    return in_features @ weights.T

Embedding

嵌入映射的函数的实现。输入的Token经过Tokenizer转换为token_ids后，通过embedding形成token的特征向量。具体的实现为查表

def run_embedding(
    vocab_size: int,
    d_model: int,
    weights: Float[Tensor, " vocab_size d_model"],
    token_ids: Int[Tensor, " ..."],
) -> Float[Tensor, " ... d_model"]:
    return weights[token_ids]

torch.Tensor支持python数组的操作方式，因此可以直接通过数组读token_ids的方式输出Tensor

SwiGLU

实现SwiGLU激活函数。同样是注意张量乘法维度的问题。SwiGLU的数学定义满足

$\mathrm{SwiGLU}(x,W_1,W_2,W_3) = W_3(\mathrm{SiLU}(W_1x)\odot W_2x)$

其中SiLU和Sigmoid函数为

$\mathrm{SiLU} = x\sigma(x) = \frac{x}{1+e^{-x}}$

def run_swiglu(
    d_model: int,
    d_ff: int,
    w1_weight: Float[Tensor, " d_ff d_model"],
    w2_weight: Float[Tensor, " d_model d_ff"],
    w3_weight: Float[Tensor, " d_ff d_model"],
    in_features: Float[Tensor, " ... d_model"],
) -> Float[Tensor, " ... d_model"]:
    def run_silu(in_features):
        return in_features / (1+ torch.exp( - in_features))
    tensor_1 = in_features @ w1_weight.T   
    tensor_2 = in_features @ w3_weight.T   
    return (run_silu(tensor_1)* tensor_2) @ w2_weight.T

计算中实现 $\odot$ ，即Hadamard积，直接使用A*B

Softmax

Softmax需要根据dim进行Tensor的切分，作为vector进行计算后再合并

为防止最大值过大导致计算指数爆炸，通常在计算时将最大值减去

$\begin{aligned} \mathrm{Softmax}(x)& = \left(\frac{e^{x_i}}{\sum e^{x_j}}\right)_i\\ &=\left(\frac{e^{x_i-x_{max}}}{\sum e^{x_j - x_{max}}}\right)_i\\ &=\mathrm{Softmax}(x-x_{max}) \end{aligned}$

def run_softmax(in_features: Float[Tensor, " ..."], dim: int) -> Float[Tensor, " ..."]:
    max_val = torch.max(in_features,dim,keepdim=True).values
    sum_val = torch.sum(torch.exp(in_feature - torch.max),dim,keepdim=True)
    return torch.exp(in_feature - max_val) / sum_val

keepdim 保证对应维度为1的axis不被压缩，仍然保留该维度。
torch.exp实现了Tensor逐元素的指数运算

Dot Self-Attention with Scaling

$\mathrm{Attention}(Q,K,V) = \mathrm{Softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)\cdot V$

在Attention的基础上，需要考虑Q,K 的masking

def run_scaled_dot_product_attention(
    Q: Float[Tensor, " ... queries d_k"],
    K: Float[Tensor, " ... keys d_k"],
    V: Float[Tensor, " ... keys d_v"],
    mask: Bool[Tensor, " ... queries keys"] | None = None,
) -> Float[Tensor, " ... queries d_v"]:
    mul = Q @ K.transpose(-2,-1) / torch.sqrt(torch.tensor(K.shape[-1]), device = K.device, dtype = K.dtype)
    if (mask is None):
        mask_mul = mul
    else:
        mask_mul = torch.mask_fill(mask,-torch.inf)
    return torch.softmax(mask_mul, dim = -1) @ V

需要注意的是，torch.sqrt只能面向Tensor进行计算，所以需要将python int 的 d_k转换为Tensor后再进行开根

mask 是一个Bool类型的Tensor，用于控制能输入Attention被“注意”的部分

$\text{mask}(i,j) = \begin{dcases} -\infty &a_{i,j}\,\text{is masked}\\ 0 &a_{i,j}\,\text{isn't masked} \end{dcases}$

mask矩阵和scaling QK product 输出的矩阵相加

某一个项Masked后，经过Softmax就会变成 $e^{-\infty} = 0$ , 反之保留原本的结果

MultiHead-Attention

多头注意力需要将输入的QKV矩阵的隐藏层平均分割为num_heads个，每一个Head分为d_k = d_model / num_heads

在初始设置通道数的时候，总保证通道数是整除隐藏层维度的，因此单个输出头的隐藏层维度总是整数

将不同输出头的Attention结果Concat，并最后经过output tensor

def run_multihead_self_attention(
    d_model: int,
    num_heads: int,
    q_proj_weight: Float[Tensor, " d_model d_model"],
    k_proj_weight: Float[Tensor, " d_model d_model"],
    v_proj_weight: Float[Tensor, " d_model d_model"],
    o_proj_weight: Float[Tensor, " d_model d_model"],
    in_features: Float[Tensor, " ... sequence_length d_model"],
) -> Float[Tensor, " ... sequence_length d_model"]:
    d_k = d_model // num_heads
    Q = (in_features @ q_proj_weight).reshape(...,num_heads,d_k).transpose(-2, -3) 
    K = (in_features @ k_proj_weight).reshape(...,num_heads,d_k).transpose(-2, -3)
    V = (in_features @ v_proj_weight).reshape(...,num_heads,d_k).transpose(-2, -3)

    attn_output = run_scaled_dot_product_attention(Q, K, V)
    attn_output = attn_output.transpose(-2, -3).reshape(*in_features.shape[:-1], d_model)
    return attn_output @ o_proj_weight.T

Cross-Entropy

对于输入为logits ，Target 为One-Hot 的标记Tensor, Cross-Entropy 的实现为

def run_cross_entropy(
    inputs: Float[Tensor, " batch_size vocab_size"], targets: Int[Tensor, " batch_size"]
) -> Float[Tensor, ""]:
    inputs_ = run_softmax(inputs,dim=-1)
    target_tensor = inputs_[torch.arange(inputs.shape[0]),targets]
    return -torch.mean(torch.log(target_tensor))

即表示为

$\mathrm{CE}(x) = -\frac{1}{\mathcal{B}}\sum \log \mathrm{Softmax}(x_i)$

RoPE

RoPE旋转编码器 Position Encoding

def run_rope(
    d_k: int,
    theta: float,
    max_seq_len: int,
    in_query_or_key: Float[Tensor, " ... sequence_length d_k"],
    token_positions: Int[Tensor, " ... sequence_length"],
) -> Float[Tensor, " ... sequence_length d_k"]:
    x = in_query_or_key
    dim_idx = torch.arange(0, d_k, 2, device = x.device, dtype = x.dtype)
    feq = 1.0 / (theta ** (dim_idx / d_k))
    angle = token_positions.to(x.dtype).unsqueeze(-1) * feq

    cos_ = torch.cos(angle)
    sin_ = torch.sin(angle)
    x_even = x[...,0::2]
    x_odd = x[...,1::2]
    out_even = x_even * cos_ - x_odd * sin_
    out_odd = x_even * sin_ + x_odd * cos_
    out = torch.empty_like(x)
    out[...,0::2] = out_even
    out[...,1::2] = out_odd
    return out

Batch

将Dataset 分割为若干个batch进行训练。输出为两个torch.Tensor x,y

Q: 为什么输出x,y，且y tensor是x tensor 后移1位

A: 因为自回归语言模型的训练目标是 Next Token Prediction，也就是根据当前位置之前的 token 来预测下一个 token。

def run_get_batch(
    dataset: npt.NDArray, batch_size: int, context_length: int, device: str
) -> tuple[torch.Tensor, torch.Tensor]:
    max = len(dataset) - context_length
    sample = torch.randint(0,max,(batch_size,))
    x = torch.stack([torch.tensor(dataset[s : s + context_length]) for s in sample])
    y = torch.stack([torch.tensor(dataset[s + 1 : s + 1 + context_length]) for s in sample])
    return x.to(device), y.to(device)

torch.randint 本身就能直接生成Tensor int的随机张量，不需要单个随机整数生成再载入Tensor中

Gradient Clippiing

对于给定梯度模阈值Scaling 梯度

$\mathrm{Scal\_ factor} = \begin{dcases} 1 & g<M\\ \frac{M}{\|g\|+\varepsilon} & g\geq M \end{dcases}$

def run_gradient_clipping(parameters: Iterable[torch.nn.Parameter], max_l2_norm: float) -> None:
    norm = torch.tensor(0.0)
    for p in parameters:
        norm += torch.norm(p.grad) ** 2
    total_norm = torch.sqrt(norm)
    if total_norm > max_l2_norm:
        for p in parameters:
            p.grad *= max_l2_norm / (total_norm + 10**(-6))

Checkpoint Save & Load

实现模型状态的断点保存与加载,通过torch.save一个dict对象实现

def run_save_checkpoint(
    model: torch.nn.Module,
    optimizer: torch.optim.Optimizer,
    iteration: int,
    out: str | os.PathLike | BinaryIO | IO[bytes],
):
    torch.save(
        {
            "model": model.state_dict(),
            "optimizer": optimizer.state_dict(),
            "iteration": iteration
        },
        out
    )

加载就是从dict中load出来


def run_load_checkpoint(
    src: str | os.PathLike | BinaryIO | IO[bytes],
    model: torch.nn.Module,
    optimizer: torch.optim.Optimizer,
) -> int:
    checkpoint = torch.load(src)
    model.load_state_dict(checkpoint["model"])
    optimizer.load_state_dict(checkpoint["optimizer"])
    return checkpoint["iteration"]

文件管理

2026-06-04T16:00:00.000Z

文件管理

Everything is a file

文件是存储在计算机持久性存储设备的信息集合。用户进行IO操作时，文件是逻辑操作的基本对象，而文件系统是操作系统面向用户的文件管理系统。

文件的定义与属性

文件是具有文件名的一组相关元素的集合，分为有结构文件与无结构文件。

有结构文件由若干个格式相似的记录组成。而记录是一组相关数据项的组合，用于描述一个对象某一方面的完整属性。
无结构文件则是连续的字节流，比如二进制文件或者普通文本文件。因此也称为流式文件。例如.lib、.dll、.o文件这样的已编译后的二进制文件，需要通过读/写指针的方式定位下一个操作的字节。进行特定区域的检索只能通过顺序查找，效率较低。

对于有结构文件，其由多个记录组成，因此称为记录式文件。根据记录的长度是否一致可以分为

定长记录 -- 所有记录的长度相同，且各数据项在记录中的位置相对固定，系统可以直接通过偏移量定位记录。
变长记录 -- 记录长度不一或者数据长度不一，只能通过顺序查找相应记录，速度较慢

有结构文件根据记录组织方式分为

顺序文件
索引文件
索引顺序文件
直接文件(散列文件)

顺序文件的记录按线性排列，可分为串结构与顺序结构。串结构的记录是时间先后顺序排列的，因此只能顺序扫描，效率低；而顺序结构的记录按键字排列，能通过偏移量直接定位记录。

类似于磁带这样物理限制的硬件，只能存储与使用顺序文件。

索引文件通常用于进行数据随机查询等任务。索引文件维护了一个索引表，索引表中包含了：索引号、文件长度于指针，指针指向相应的逻辑文件，但是逻辑文件对象是什么层度地址取决于程序员的逻辑。

|索引号idx|长度m|指针ptr|

对于定长记录，第 $i$ 条记录的首址是简单的 $A_i = iL$ , 对于变长记录，第 $i$ 条记录的首址是前序记录的后继

$A_i = \sum_{k=1}^i A_k +1$

索引顺序文件

将索引文件与顺序文件相结合。分组的组间通过索引建立，可以无序；但是组内通过顺序文件构成，需要键字有序才能进行偏移量定位。

索引顺序文件的查找逻辑和查找中的分块查找相同。

对于 $N$ 条记录的普通顺序文件的普通顺序文件的查找需要 $\frac{N}{2}$ 次。分块最优查找下，假设分为 $M$ 块，则需要在块间和块内进行顺序查找，总共需要

$\frac{M}{2}+\frac{N}{2M}\geq 2\sqrt{\frac{M}{2}\cdot\frac{N}{2M}} = \sqrt{N}$

当 $M = \sqrt{N}$ 时，查找效率最优

散列文件 通过Hash函数进行文件索引

文件的属性

文件的属性包括

名称
类型
创建者
所有者
位置
大小
保护
创建时间

文件系统结构

根据与硬件系统交互的自下至上的结构可分为

IO控制 -- 负责磁盘与内存交互，将磁盘文件写入写出内存，并实现IO与操作系统的交互
基本文件系统 -- 负责读写磁盘中的物理块
文件组织模块 -- 负责文件逻辑与物理块直接的映射
逻辑文件系统 -- 负责管理文件系统的元数据，维护目录结构，不含有实际数据的内容。

文件目录

文件目录管理的目的是实现:

按名存取
提高检索速度
支持文件共享 -- 允许多用户访问同一目录下的文件
允许文件重名 -- 不同子目录下的文件可重名

文件控制块FCB

和PCB刻画进程信息类似，FCB用于确定文件的相关信息。FCB包含的信息有

文件的基本信息 -- 文件名，物理地址、逻辑结构等
存储控制信息 -- 访问权限等
使用信息 -- 创建时间与最后修改时间等

为了避免在检索文件时将整个FCB全部调入内存，UNIX系统中将文件名和描述信息解耦，将文件描述信息组织位索引结点(inode)。通常inode就是FCB，在文件目录的目录项中，对应索引结点编号指向对应的inode，文件目录表建立的是文件名和索引节点编号的映射

|文件名|索引节点编号|

目录项大小相比FCB减小，每个盘块可以容纳更多的目录项，因此单次搜索可以降低平均磁盘启动的次数。

索引节点由两个部分构成，分别为磁盘索引节点与内存索引节点

磁盘索引节点是文件的相关信息，包括文件标识符、文件类型、权限、地址、长度等信息。文件加载进内存后，相应的内存索引节点则相比磁盘索引节点多了运行时信息，包括索引节点号、状态、访问计数器、链接指针等。

文件目录的结构

文件目录分为

单级目录将FCB线性排列，满足了基本的按名存取的需求，但是其无法实现文件重名存储且查找效率低，文件无法共享。

两级目录分为主文件目录(MFD)和用户文件目录(UFD)，满足了多用户的需求，主文件目录下放置多个文件名和用户目录的存储位置, 用户目录下放置用户私有文件。

用户文件目录内是单级目录排列的，因此灵活性与查找效率仍然较差。

树状目录是现代的文件目录结构，从根结点/出发，到若干个子目录。用户的专有目录在/usr/*

树状目录的路径分为绝对路径与相对路径。绝对路径就是从根结点出发的完整路径，比如/var/root. 相对路径则是从进程当前路径为基准，其他文件的路径。比如这篇文章的相对路径为./source/_posts/OS/文件管理.md

有向无环图的目录结构的形成逻辑和图中的m叉树和DAG的转换相同，即将目录间共享的文件作为共同结点商去，就构成了有向无环图。但是有向无环图的目录结构带来了更复杂的文件用户权限管理和文件增删的逻辑，增加了管理的开销。

文件目录的实现

文件目录基于线性列表/哈希表实现

线性列表通过线性表管理文件名与数据块指针，但是查找效率较低，时间复杂度为 $\mathcal{O}(n)$
哈希表查找效率高但是存在Hash冲突，且目录查询依赖磁盘IO，需要动态加载活跃的目录进内存以提高响应速度。

文件目录的操作

和日常使用计算机相同，文件目录的操作包含

搜索文件
创建/删除文件
创建/删除目录
移动/显示/改变目录

文件的物理结构

文件的物理结构是指操作系统中抽象的文件对象与磁盘中的存储块之间的对应方式。

文件的物理结构分为两个互补的核心部分

文件分配方式 -- 管理已使用的磁盘非空闲块
文件存储空间管理方式 -- 管理未使用的磁盘空闲块

连续分配方式

根据磁盘连续的存储块进行分配。比如文件长度为 $n$ 块，从第 $b$ 块开始存放，则分配给该文件的块就是 $b,b+1,\cdots , b+n-1$

连续分配方式可以在 $\mathcal{O}(1)$ 时间内读取指定块，但是它和内存连续分配类似，可能产生大量的外部碎片。文件长度也需要预先知道，难以支持文件大小的动态拓展。

和线性表插入的问题相同，对于连续分配方式的文件，需要增删新的文件需要整体移动文件，性能开销大。

链接分配方式

隐式链接

磁盘块内存储指向下一个磁盘块的指针，用户无法管理内部指针。当磁盘块链断开时，后续磁盘块内的数据都无法访问。

磁盘块能合并为簇对象，减少了指针存储的开销。簇内的块是连续分配的块，而簇间的指针序仍然存在。

显式链接

显式链接会维护一张文件分配表(FAT), 其在整个文件系统只有一张。FAT记录盘块的盘块号与其指向的下一个块的盘块号。这其实就是盘块的静态链表结构。

FAT需要始终加载在内存中，内存开销较大，但是支持顺序访问也支持随机访问，性能效率高。

索引分配

索引表相当于将单个文件分配的硬盘块使用一个表进行维护，访问文件时只需要根据索引表的内容加载硬盘块。

如果文件过大可以使用多级索引表进行硬盘块的索引。类似于内存管理中关于多级页表的形式，多级索引表也是将块号进行离散分表映射以节省存储开销。但是相应会增加磁盘IO的开销。

混合索引方式

混合索引方式则是对于大文件与小文件使用不同的文件索引方式。inode结构中可以存入多个直接块以及若干层索引间址，对应多级索引的管理方式。这样对于不同大小的文件使用不同的索引方式可以降低整体的性能开销。

文件的操作

文件的基本操作包括创建文件、删除文件、读/写文件

创建文件的过程包括

文件名合法检验和权限检验
分配inode并创建inode中的信息
分配磁盘块
建立目录项
更新文件系统的元数据

删除文件的过程包括

定位删除文件，按路径名检索文件目录找到目录项并获得inode
检查使用状态、硬链接计数，如果文件被打开，则延迟删除(Windows 系统会直接终止删除，Linux/Macos会等待文件关闭后完全删除)；如果硬链接计数大于1则不回收inode和磁盘块
移除目录项
释放inode、磁盘块与内存资源 -- 内存临时资源的释放要晚于磁盘信息的释放
更新文件系统元数据

读文件与写文件前都需要将文件从磁盘加载入内存中，这个过程称为打开文件，对应open()系统调用(这个操作会切换用户态至内核态，因为设计磁盘IO操作)

打开文件的实现为：通过目录找到inode, 并根据inode维护一个打开文件表，用于记录当前活跃的文件信息。

打开文件表有两层

系统打开文件表 -- 全局活跃的文件属性，每一个项中有一个打开计数器，用于记录多少进程打开了这个文件
进程打开文件表 -- 进程独有的打开文件表，用于记录私有文件的打开状态

读文件的过程: 打开文件，如果文件不在内存中就将文件磁盘块加载进内存并更新读指针

写文件的过程: 打开文件，如果文件不在内存中就将文件磁盘块加载进内存并更新写指针

文件关闭时，通过系统调用close()关闭文件。对应的打开计数器减1，当计数器减到0，就释放打开文件表中关于这个文件的项并释放相关资源。

文件加载入内存后，包含额外的信息有

文件指针 -- 在打开文件表中，多个进程对文件多开的时候需要在打开文件表中维护多个文件指针，这是在文件在内存中的指针
文件打开计数 -- 内存inode会管理多少个打开文件项使用了这个inode；打开文件表会管理多少个进程打开了这个inode
文件磁盘位置 -- 在内存inode中
访问权限 -- 在内存inode中

总结: 内存inode的信息是对于磁盘文件在内存的对象的信息管理；打开文件表是进程面/文件多开场景下的信息管理

文件的共享

文件的共享分为两个视角:

用户对文件的共享
进程对文件的共享

进程对于文件共享管理的方式就是打开文件表以及相应的打开计数器与指针的管理

用户侧的共享分为硬链接与软链接

硬链接是基于索引结点的共享方式。文件加载进内存后，文件的物理地址与属性信息加载在内存inode中，用户目录项只维护文件名与指向inode的指针。

文件内存inode维护了一个链接计数count，用于标记指向该文件的用户文件表个数。当用户A不再使用该文件时，将count减1，并删除A私有文件表中的目录项，只有当count等于0才真正从内存中释放该文件与inode。

软链接是Namespace层面的链接，对于形成软链接的文件，分配一个Link类型的文件，里面只存储文件实际目录的字符串，直接存储在inode中。

当原始文件被删除时，不会影响另外一个用户访问Link文件本身，但是会出现访问失败的错误。同时，软链接建立的只是文件目录的映射而不是指针的映射，所以并不会改变原始文件内存inode的链接计数器

文件保护

文件保护机制包括

口令保护
加密保护
访问控制

口令与加密防止其他用户的非法获取文件内容，访问控制用于管理用户对文件的权限。

Linux/Macos中的chmod实现了对于三种用户类型的文件访问权限控制的方式。这是一种访问控制列表(Access-Control List,ACL)控制方式

u -- file owner
g -- group users
o -- other users

对于三种权限进行赋权:

r -- read
w -- write
x -- execute

使用三位十进制数转二进制权限，每一个十进制位代表user类型，比如chmod 712 <file> 表示file user 具有rwx(111)， group users具有x(001), other users具有w(010)

文件系统

文件系统是整体文件管理逻辑在硬盘与IO侧的实现。

FS -- 文件系统

File System 是在硬盘中真实管理硬盘的系统。硬盘通常被划分为若干个分区，每一个分区包括一个FS用于管理分区内的块信息。

FS的构成可以分为

主引导部分(MBR) -- 位于磁盘的0号分区，经由BIOS加载进内存并执行用于识别活动分区并读取分区的第一个扇区 -- 引导块
引导块 -- 分区的引导部分，也是分区的，用于加载当前分区的操作系统的文件部分。
超级块(Super Block) -- 包含分区的全局信息，比如分区的总分块、块大小、空闲块数量和指针、空闲i节点数量和指针
空闲块信息

对于不同品牌/设别类型的外存，文件系统不尽相同，存在如ext4/NTFS/FAT等类型。

操作系统在内存中维护与VS相关的信息：

内存中的挂载表 -- 挂载文件系统分区的信息，包括设备标识、挂载点与文件系统类型等
内存中的目录表缓存 -- 根据局部性原理缓存最近访问的目录内容，减少磁盘的读取
系统级打开文件表
进程级打开文件表

这些内存中信息在文件系统挂载时加载，在文件打开且运行时更新，卸载时释放。

文件存储空间管理

文件存储空间管理是面向磁盘空闲块的管理方式。

空闲表法 和磁盘块分配中的连续分配方式类似，都是基于磁盘的连续磁盘空间进行分配。FS维护了一张空闲表用于记录空闲块的序号、起始盘块号、空闲盘块数等。

空闲链表法 使用一个链表链接所有空闲盘区组织

空闲链表法的基本单位可以是盘块/盘区，和簇结构类似，空闲盘区链就是将一块块连续空闲盘块区域使用链表链接，满足区内连续，区间链表序的关系。

成组链接法
通过分组方法进一步拓展了空闲链表法的指示空间。通过每一组的第一个盘块作为索引块记录下一组的空闲表块的块号与数目。

这是经典的离散映射拓展指示空间的方式，第一级空闲表块信息被加载到专门的内存栈中，称为空闲盘块号栈，通过盘块栈弹出表示顺序分配空闲盘块。

位示图法

通过一个二维二进制表维护磁盘盘块的使用情况。

$\begin{dcases} a_{i,j} = 0 & \text{(i,j)盘块空闲}\\ a_{i,j} = 1 & \text{(i,j)盘块正在使用} \end{dcases}$

盘块的序号是横向顺序数下去的，因此对于一个 $m\times n$ 的位示图表，坐标为 $(i,j)$ 的磁盘块的盘块号为

$b = m(i - 1)+j$

盘块的回收则是根据盘块值反解二维坐标的过程。即

$\begin{dcases} i = \left\lceil\frac{b}{m}\right\rceil \\ j = (b-1) \% m ++1 \end{dcases}$

VFS -- 虚拟文件系统

VFS 是操作系统层与FS的中间层。由于现代操作系统会面对多种不同的FS，VFS统一化了面向操作系统的API，以保证系统能更加统一化的IO。

VFS存在四种基础对象

超级块 -- 与FS中的超级块对象相对应。当文件系统挂载时，将超级块加载入内存
Vnode -- vnode与每一个FS下的inode相对应，本质是对各个FS的元数据进行封装，通过指针索引FS中的私有元数据并向上暴露给OS。这体现了封装的同一性理念
目录表对象与文件对象

文件系统的挂载

Windows 的单个盘，比如C:\表示分区/卷，比如可以在一个机械硬盘中进行多个分区

每一个卷作为独立的根目录，OS根据相应的驱动器定位对应的文件系统，再从其目录中查找

Unix以单一根目录为挂载点进行挂载，挂载点只能挂载单一设备，但是同一个设备可以使用多个挂载点。

WSL中的挂载

(base) asuna@Asuna:~$ df -h
Filesystem      Size  Used Avail Use% Mounted on
none            3.9G     0  3.9G   0% /usr/lib/modules/6.6.114.1-microsoft-standard-WSL2
none            3.9G  4.0K  3.9G   1% /mnt/wsl
drivers         201G  198G  3.0G  99% /usr/lib/wsl/drivers
/dev/sdd       1007G   71G  885G   8% /
none            3.9G   84K  3.9G   1% /mnt/wslg
none            3.9G     0  3.9G   0% /usr/lib/wsl/lib
rootfs          3.9G  2.7M  3.9G   1% /init
none            3.9G  604K  3.9G   1% /run
none            3.9G     0  3.9G   0% /run/lock
none            3.9G     0  3.9G   0% /run/shm
none            3.9G   76K  3.9G   1% /mnt/wslg/versions.txt
none            3.9G   76K  3.9G   1% /mnt/wslg/doc
C:\             201G  198G  3.0G  99% /mnt/c
D:\             753G  626G  128G  84% /mnt/d
E:\             954G  837G  118G  88% /mnt/e
tmpfs           781M   20K  781M   1% /run/user/1000

WSL 可以访问宿主Windows机器的卷，挂载在/mnt/*上，因此也可以查看宿主机的硬盘挂载情况

Macos的挂载方式与Linux类似

optimizer

2026-06-03T16:00:00.000Z

内存管理

2026-06-01T16:00:00.000Z

内存管理

内存管理是操作系统对内存空间的分配、组织、管理、回收，以及物理/虚拟内存地址映射的一整套庞大的管理系统。

内存的分配

内存的分配包括连续分配方式与离散分配方式，其中连续分配方式是将

连续内存分配方式

连续分配管理方式直接向用户进程分配物理内存的连续内存空间。因为其物理空间是完整连续的，它的地址转换通常只需通过硬件的基址寄存器进行简单的加法计算即可完成，而不需要像非连续分配（分页/分段机制）那样，依赖页表或段表来进行复杂的离散内存寻址与映射。

连续分配方式分为单一连续分配、固定分区分配与动态分区分配

单一分区分配

将内存分为系统区与用户区，用户区单次只允许一条进程访问。单一分区分配不会产生外部碎片，但是其对于内存的利用率过低，在现代操作系统中被淘汰。

固定分区分配

单一分区分配只支持单进程访问内存，多进程并发的场景受限。固定分区将物理内存空间分为固定大小的分区，每一个分块只能容纳一道进程作业。

固定分区可以分为相同内存大小的分区与不同内存大小的分区。

分区大小相等 -- 缺乏灵活性，分区过小限制大，分区过大会产生内部碎片，造成空间浪费。
分区大小不等 -- 需要维护一个内存分配的分区使用表，按照分区大小排列，包括内存大小、初始地址与是否被分配。

动态分区分配

按照进程的动态需求分配连续内存空间。动态分区分配方式在进程释放后会出现内存碎片，这样的内存碎片存在于给进程分配的内存块外，因此称为外部碎片，即一小段的连续内存空间。假如之后的进程需求内存小于内存碎片，则可以直接从内存碎片分配内存空间，但是代价是再次释放进程后会将内存碎片分为更小的内存碎片，直到内存碎片无法支持任何进程。

对于外部碎片，可以通过紧凑技术合并外部碎片。操作系统周期性地移动进程内存地址，将进程的首址与进程的终址拼接，从而将碎片合并。

紧凑技术需要进行动态重定位以实现，性能开销较大。

通常通过链表维护空闲分区，以起址排序。内存块回收时，内存空闲区的合并大致可以分为四类

内存块回收时，与前一空闲区相邻 -- 合并并更新前一空闲区的大小，空闲区的个数不改变
内存块回收时，与后一空闲区相邻 -- 合并并更新后一空闲区的大小，空闲区的个数不改变
内存块回收时，不与任何空闲区相邻 -- 创建新的空闲表项并插入空闲区链表，空闲区个数+1
内存块回收时，前后均与空闲区相邻 -- 合并并更新前一空闲区大小(前+当前块+后)，删除后一空闲块的链表项

空闲内存块分配方式

动态分区中有很多的内存块，如何将空闲的、具有足够大小的内存块分配给进程作业呢？

根据分区索引方式分为顺序分配与索引分配。

空闲内存块的顺序分配

由于空闲分区内存块的链表是根据空闲地址升序排列的，**首次分配算法(First Fit)**使用最简单的顺序查找，找到第一个满足内存条件的空闲分区就分配给进程。

首次分配算法下，通常高地址的内存块是没有被使用过的完整分块，因此有利于大内存开销的进程使用。但是低地址区域容易积累小的外部碎片。每次查找需要从表头开始，查找的开销也较大。

基于首次分配算法的查找逻辑，**邻近适应算法(Next Fit)**的每一轮搜索起点为上次搜索的结束位置。但是首次分配算法的大内存块保留的优势因为搜索起点变化而被破坏，整体性能不如首次分配算法

最佳适应算法(Best Fit) 将空闲内存块根据容量的升序排列，根据内存大小进行最优分配。最佳适应算法目的是追求单次分配的最大内存利用率，但是会产生相当多的微小外部碎片，实际内存利用率与性能不佳。

最坏适应算法(Worth Fit) 将空闲分区按容量递减排列，主动将最大的内存块分割为小块，每次分块总是内存利用率最小的，从而避免生成小碎片。但是难以有足够的大内存块满足大作业的内存需求。

空闲内存块的索引搜索分配

通过索引表查找的方式分配空闲内存块。常见的方式有三种: 快速适应算法(Quick Fit)、伙伴系统(Buddy System)、哈希算法

快速适应算法是根据常用进程占据的空间进行预分块，分为固定大小的内存块。但是回收时进行合并操作的逻辑较为复杂，因为合并后的块大小不一定是常用进程的分块大小，不可避免产生内部碎片。

伙伴系统是将内存空间进行空间二分，形成一个内存块二叉树。如果内存块不足以分配给进程，就向上合并为更大的块以匹配需求。通常不会适应类似于红黑树/B树等更加复杂的数据结构进行内存的管理，更加复杂的数据结构意味着更加复杂的硬件逻辑与性能问题。

哈希算法通过哈希函数得到空闲块的头指针以快速获取空闲分块链。

离散内存分配方式

即分页方式和分段方式，通过页表和段表的映射方式管理内存块

基本分页存储管理

分页管理模式将物理内存分为若干大小相等的物理内存单元，称为页框(物理块/页帧)；将逻辑空间分为与物理空间相等大小的区域称为页。系统以页框为单位分配进程的内存资源。

页与页框的映射方式

逻辑地址中的页有一个唯一的编号称为页号，同时物理地址的页框也有唯一编号称为页框号。

页号到页框号的映射通过页表记录。页表包含每一个页的对应物理页框号、以及相应的状态信息(有效位、访问位等)

逻辑地址的构成由页号+页内偏移量构成。页号用于确定逻辑地址所在的页面，页内偏移量用于确定相对于页面首址的偏移量。这两个地址共同刻画了单一逻辑地址对象。

逻辑地址与物理地址的转换需要地址变换机构，通过页表将逻辑地址映射到物理空间。通过**页表寄存器(PTR)**加快地址变换的速度, 用以存放页表始址与长度。

设逻辑侧的页大小/物理侧的页框大小为 $L$ , 逻辑地址为 $A$ , 物理地址 $E$ , 页表长度 $M$

地址变换的逻辑为:

根据逻辑地址进行页号与偏移量的计算: 页号 $P = \lfloor \frac{A}{L} \rfloor$ (填满了多少块), 页内偏移 $W = A\% L$ (偏移)
越界判断: $P\geq M$ 说明当前逻辑地址所在页超过页表范围，触发越界中断
根据页号 $P$ 在页表中查找页框号 $T$ , 并计算该页框的始址 $b$
逻辑地址对应的物理地址为对应页框相等页内偏移的地址

A = PL+W // 逻辑侧
T = σ(P) // 页表映射
E = TL+W // 物理侧

如果地址转换速度慢或者页表过大，可能导致内存系统的性能下降。诸如快表、多级页表等技术解决了这样的问题

基于快表的地址变换机构

虚拟存储器中提到 快表(TLB) 是基于Cache实现的、能快速并行查找的存储器。

快表中的存储形式和内存页表一致，都是页号+页内偏移量的形式。但是遵循局部性原理存入更高频使用的页表项，能提高地址变换的整体性能。

在有快表的地址变换机构中，CP优先向快表中的页号进行比较，如果快表页号命中就直接读取快表中存储的物理块号；否则就访问内存页表。

两级页表结构

两级页表结构将底层页表也做了一层页表离散映射，相当于将页表作为一个地址
。同时，系统只将活跃的页表调入内存，其余页表置于内存当中。

假设单个页框内能容纳的页表项数量为 $K$

P_1 = ⌊P_0/K⌋ // 一级页表索引
P_2 = P_0 % k // 二级页表索引
A = P_0L+W    // 逻辑侧 -- P_0 为总逻辑页号
T = σ(P)      // 页表映射
E = TL+W      // 物理侧

两级页表结构本质是对页进行分组，满足

$P_0 = P_1K+P_2$

因此逻辑地址由三个部分组成

|一级页表索引|二级页表索引|页内偏移量|

硬件系统通常设置一个外层页表寄存器用于存放一级页表的起始地址

基本分段存储管理

分页管理方式是硬件上的内存管理方式，分段管理方式是面向用户的内存管理方式。

分段系统将用户进程的逻辑空间分为不同大小的段，包含如主程序段、子程序段、栈段与数据段等不同内存段，每一个段从0地址开始兵分配连续的段内空间。通过段号+段内偏移量确定逻辑地址

分段结构中的逻辑地址结构

|段号 S|段内偏移量 W|

段表结构

|段表|段长|本段在主存中的初始地址|

用于确定段在物理地址中的区域，段地址变换机构也能通过段表进行逻辑地址与物理地址的映射

段与共享

系统能维护一个共享段表以支持多个共享段访问共享段表。不可修改的代码支持多个进程的并发执行，系统会将这样的纯代码放入只读段中。同时每一个进程都有私有的局部数据区，避免共享访问私有数据。

段的保护

越界保护段号不能超过段表长度
存取控制保护通过访问权限位防止非法访问

段页式存储管理

先根据用户逻辑讲进程地址分段，再将每一个段内存块根据页逻辑存储。进程的逻辑地址由三个部分构成

|段号 S|页号 P|页内偏移量 W|

段页寻址中段寻址部分需要通过段表实现，这和单段表的逻辑是一样的。

MoE -- Mixture of experts

2026-05-31T16:00:00.000Z

Mixture of Experts

死锁

2026-05-31T16:00:00.000Z

死锁

死锁，即进程间的资源竞争陷入了一个循环等待的链，等待其他进程的资源但是自身占用了一定的资源。当进程链形成有向环且进程都等待时，系统处于死锁。

死锁产生的原因

系统资源的竞争 -- 系统资源分配不足但不可剥夺时才会出现死锁
进程推进顺序非法 -- 系统资源充足但是进程的资源申请与释放的顺序不合法，为此我们需要通过安全性检测与银行家算法得到合法的执行顺序。

死锁产生的必要条件

互斥访问 -- 资源只能一个进程访问，否则不会产生资源竞争。
不可剥夺条件
请求并保持条件 -- 如果进程申请资源不足，并不会释放当前拥有的资源而是保持占用。
循环等待

死锁的预防

死锁的预防即通过硬件手段扼杀死锁的产生，针对死锁产生的四个必要条件破坏。

破坏互斥条件 -- 基本不可行，对于类似于打印机的设备无法实现并行访问
破坏不可剥夺条件 -- 资源可抢夺，可能导致任务执行混乱，通常也不可行
破坏请求并保持条件 -- 进程不能在拥有不可剥夺资源时申请新资源。
- 静态资源分配：进程运行前一次性分配所有资源，资源不足则不执行。静态资源分配可能造成系统资源浪费与饥饿现象
- 动态申请并释放：进程可以申请资源，但是使用完拥有的资源释放后才能申请新资源
破坏循环等待条件 -- 基于编号分配资源，从而避免自然产生死锁环。

死锁避免

死锁避免是通过软件方式对当前执行状态下的进程序列进行安全性检验。

安全性检查

系统安全性检查是对于某个进程组，进程序列 $(P_1,\cdots ,P_n)$ 的执行是否不会发生死锁。如果在某个初始分配条件下的任何进程序列都是安全序列，则系统是安全的；反之，如果系统不安全，其不一定会陷入死锁，因为系统不一定会选择不安全序列执行。

#include <vector>
#include <stdexcept>

int num = 3;  // 3个进程
int resource = 2; // 2个互斥资源

std::vector<std::vector<int>> max(num,std::vector<int>(resource));
std::vector<std::vector<int>> allocate(num,std::vector<int>(resource));

std::vector<bool> finish(num,false);
std::vector<int> work(resource);   // 当前可用资源

for (int i = 0; i < num; i++){     // 顺序执行example， 检测P0-P1-P2序列
    std::vector<int> need(resource);
    int sign = 0;
    for (int j = 0; j < resource; j++){
        need[j] = max[i][j] - allocate[i][j];
        if (need[j] <= work[j]){
            sign ++;
        }
    }    
    if (sign == resource){
        finish[i] = true;
        for (int k = 0; k < resource; k++){
            work[k] += allocate[i][k];
        }
    }
    else{
        throw std::runtime_error("Unsafe process seq");
    }
}

银行家算法

银行家算法不需要遍历所有的安全序列。对于当前资源足够执行的进程，将试探性分配资源再通过安全性检查检测系统是否为安全状态，安全则正式分配，否则撤销分配。

死锁检测

死锁检测是在进程执行中，判断当前是否处于死锁状态，只根据当前的资源分配情况判断，而不进行进程的安全性检验与未来运行的预测。

通常通过资源分配图进行简化与判断。有向边从进程指向资源表示进程申请资源；从资源指向进程表示进程已经分配的资源。

简化：如果资源类中存在数量足够的资源，则将请求有向边反向；入股进程结点只有入度，则该进程资源分配足够，执行完成就可以删除相应入边并释放资源。

如果简化进程资源分配图仍然存在有向边，则系统处于死锁状态。基于此，可以归纳出

死锁定理：系统死锁当且仅当资源分配图不可完全简化

死锁解除

通过操作系统进行死锁状态的解除

资源剥夺 -- 挂起死锁进程并释放资源，分配给其他进程。可能存在进程长时间挂起而饥饿的现象
撤销进程 -- 终止死锁进程并回收资源。
进程回退 -- 回到未死锁状态并进行安全序列的执行。

进程的同步与互斥

2026-05-28T16:00:00.000Z

进程的同步与互斥

进程会对临界资源的访问权限竞争。通常临界区只支持一个进程进行读/写，因为如果两条进程对临界区的相同数据进行写操作，有可能导致两个进程的发生先后不同，导致产生不同的执行结果。

临界资源

临界资源是能被多个进程访问，但是被多个进程同时访问会产生冲突的资源。临界区是访问这一块共享资源的代码。

进程对临界资源的访问分为四个部分

进入区 -- 进入临界区前的检查部分
临界区 -- 实际访问临界资源的代码段
退出区 -- 离开临界区的释放资源的段
剩余区 -- 其他部分

进程的同步

进程的同步指的是多个异步进程，需要彼此协调运行次序，而在执行流程上产生等待或者进程信息传递等制约关系。比如进程B需要进程A提供的相关数据，A在缓冲区写入信息、B在缓冲区读信息，那么进程A就是进程B的严格前序进程，这两个进程是同步的。

进程的互斥

进程的互斥指的是，对于一个缓冲区有多个进程能进行读、写操作。当一个进程进入缓冲区后，其他需要访问缓冲区的进程只能等待当前进程结束才能进入缓冲区。

避免多进程进入缓冲区的设计策略:

空闲让进 -- 缓冲区空则放行
忙则等待 -- 缓冲区有进程，其他进程就挂起等待
有限等待 -- 挂起进程不能一直被挂起等待，应保证在有限时间内得到缓冲区资源
让权等待 -- 等待期应当放弃CPU使用权，变为阻塞态，避免忙等待。具体体现在不应反复执行判断语句占用CPU资源。

实现临界区互斥的方法

实现临界区互斥的方法通常都需要基于上面四个设计策略构建，其中让权等待是节省CPU性能开销的可选择策略。

实现方法分为软件实现方法与硬件实现方法。

软件实现方法

单标志法

单标志法通过一个一个公共变量turn指示当前允许进入临界区的进程编号

#include <thread>
#include <iostream>
#include <atomic>
std::atomic<int> turn = 0;

void critical_section(int id) {
    std::cout << "thread " << id << " in critical section\n";
}

void remainder_section(int id) {
    std::cout << "thread " << id << " in remainder section\n";
}

void thread0() {
    while (true) {
        while (turn != 0) {
            // busy waiting
        }

        critical_section(0);

        turn = 1;

        remainder_section(0);
    }
}
void thread1() {
    while (true) {
        while (turn != 1) {

        }

        critical_section(1);
        turn = 0;
        remainder_section(1);
    }
}
int main() {
    std::thread t0(thread0);
    std::thread t1(thread1);

    t0.join();
    t1.join();

    return 0;
}

两个进程必须按照turn的标记交替进入临界区访问，是互锁的，假如thread0不再申请临界区, 则turn始终为0，thread1也无法再申临界区，违背空闲让进原则

双标志法

在turn的基础上，添加了布尔数组flag[]，用于表示进程访问临界区的意愿，flag[i]=true表示进程i需要访问临界区。

双标志先检查法

#include<iostream>
#include<thread>
#include<atomic>

std::atomic<int> turn = 0;
std::atomic<bool> flag[2] = (false,false);

void critical_section(int id) {
    std::cout << "thread " << id << " in critical section\n";
}

void remainder_section(int id) {
    std::cout << "thread " << id << " in remainder section\n";
}
void thread0(){
    while(flag[1]) ;   // 先进行其他进程的意愿检查
    flag[0] = true;    // 再设置本进程的进入意愿
    critical_section(0);
    flag[0] = false;    // 访问完临界区后降低访问意愿
    remainder_section(0);
}

void thread1(){
    while(flag[0]) ;
    flag[1] = true;
    critical_section(1);
    flag[1] = false;
    remainder_section{1};
}
int main(){
    int main() {
        std::thread t0(thread0);
        std::thread t1(thread1);

        t0.join();
        t1.join();

        return 0;
    }
}

双标志先检查法的问题在于，如果两个进程都通过了意愿检查，可能出现两个进程同时使用临界区的问题，违背了忙则等待原则

双标志后检查法

/* 其他的设置与 双标志先检查法 相同*/
void thread0(){
    flag[0] = true;      // 先设置本进程访问意愿
    while(flag[1]);      // 再检查其他进程的访问优先级
    critical_section(0);
    flag[0] = false;    // 访问完临界区后降低访问意愿
    remainder_section(0);
}


void thread1(){
    flag[1] = true;
    while(flag[0]) ;
    critical_section(1);
    flag[1] = false;
    remainder_section{1};
}
int main(){
    int main() {
        std::thread t0(thread0);
        std::thread t1(thread1);

        t0.join();
        t1.join();

        return 0;
    }
}

双标志后检查法解决了双标志先检查法的忙则等待问题，但是双标记后检查法可能遇到两个进程都想访问临界区，都进行等待，导致临界区空闲，违背了空闲让进与有限等待准则。

Peterson 算法

Peterson算法融合了turn与flag的优点，通过turn管理互斥访问，通过flag管理饥饿问题

#include <array>
#include <atomic>
#include <chrono>
#include <iostream>
#include <mutex>
#include <string>
#include <thread>

using namespace std::chrono_literals;

std::array<std::atomic<bool>, 2> flag = {false, false};
std::atomic<int> turn{0};

std::atomic<int> shared_counter{0};
std::atomic<int> active_in_critical{0};
std::mutex output_mutex;

void log(int process_id, const std::string& message) {
    std::lock_guard<std::mutex> lock(output_mutex);
    std::cout << "P" << process_id << " | " << message << '\n';
}

void peterson_lock(int process_id) {
    const int other = 1 - process_id;

    flag[process_id].store(true);
    turn.store(other);

    log(process_id, "wants to enter: flag[" + std::to_string(process_id) +
                        "]=true, turn=" + std::to_string(other));

    bool printed_wait_message = false;
    while (flag[other].load() && turn.load() == other) {
        if (!printed_wait_message) {
            log(process_id, "waits because flag[" + std::to_string(other) +
                                "]=true and turn=" + std::to_string(other));
            printed_wait_message = true;
        }
        std::this_thread::sleep_for(20ms);
    }

    if (printed_wait_message) {
        log(process_id, "can enter now");
    }
}

void peterson_unlock(int process_id) {
    flag[process_id].store(false);
    log(process_id, "leaves: flag[" + std::to_string(process_id) + "]=false");
}

void critical_section(int process_id, int round) {
    const int already_inside = active_in_critical.fetch_add(1);
    if (already_inside != 0) {
        log(process_id, "ERROR: mutual exclusion was broken");
    }

    log(process_id, "enters critical section, round " + std::to_string(round));

    const int before = shared_counter.load();
    std::this_thread::sleep_for(80ms);
    shared_counter.store(before + 1);

    log(process_id, "updates shared_counter: " + std::to_string(before) +
                        " -> " + std::to_string(before + 1));
    log(process_id, "exits critical section, round " + std::to_string(round));

    active_in_critical.fetch_sub(1);
}

void process(int process_id, int rounds) {
    for (int round = 1; round <= rounds; ++round) {
        peterson_lock(process_id);
        critical_section(process_id, round);
        peterson_unlock(process_id);

        std::this_thread::sleep_for(process_id == 0 ? 35ms : 55ms);
    }
}

int main() {
    constexpr int rounds = 2;

    std::cout << "Peterson algorithm demo: two threads, one critical section\n";
    std::cout << "----------------------------------------------------------\n";

    std::thread p0(process, 0, rounds);
    std::thread p1(process, 1, rounds);

    p0.join();
    p1.join();

    std::cout << "----------------------------------------------------------\n";
    std::cout << "Final shared_counter = " << shared_counter.load()
              << " (expected " << rounds * 2 << ")\n";
    return 0;
}

Peterson算法的while循环会持续检测是否具有进入临界区的权限(对于进程0，当对方进程进入的时候挂起,flag[1]=true+ turn =1), 因此没有遵循让权等待原则，但是这已经是纯软件互斥算法中最完善的方案。

硬件实现算法

硬件实现算法相当于给临界区资源添加锁

中断屏蔽

对于单处理器系统，一次只能执行单进程任务。因此能够通过关中断方式，保证进程在临界区执行时不进行进程的切换，保证进程访问临界区不受干扰。

硬件指令 -- `TestAndSet`与 `Swap`

TestAndSet原语实现了加锁功能

以CPP伪代码实现

#include <atomic>
using namespace std;

atomic<bool> TestAndSet(atomic<bool>& lock) {
    return lock.exchange(true, memory_order_acquire);
}

void Unlock(atomic<bool>& lock) {
    lock.store(false, memory_order_release);
}
int main(){
    ...
    while (TestAndSet(lock)) {
        // 忙等待
    }
    fun_();       // 上锁的临界区代码段
    Unlock(lock); // 开锁 
    fun_other();
}

Swap实现的是交换两个原子变量的值

#include<atomic>
using namespace std;

void Swap(atomic<bool> a, atomic b){
    atomic<bool> tmp = a;
    a = b;
    b = tmp;
}
int main(){
    atomic<bool> key = true;
    atomic<bool> lock = false;
    while(key != false){
        swap(lock, key);
    }
    fun_();
    lock = false;
    fun_other();
}

Swap实现的是，进程维护的Key值与临界区的Lock的原子布尔值的交换，进程持有Key = True访问临界区时，临界区的Lock变为True，此时相当于上锁。其他进程便无法访问临界区。但是通过TS与Swap实现的互斥锁，在临界区外的进程需要持续检查Key的值，形成忙等待。

互斥锁

互斥锁(自旋锁)和TS/Swap指令逻辑相同，基于这两个指令实现开/关锁管理进程与临界区

atomic<bool> available = true;
void acquire(){
    while (!available);
    available = false;
}
void release(){
    available = true;
}

实际场景下的同步算法

信号量机制

信号量将互斥锁的二元占用状态推广为整数计数状态，可用于表示可用资源数量或限制并发访问数量；其 acquire/release 操作本质上是原子的计数检查、递减、递增与等待唤醒机制，而不只是普通整数比较。

信号量只能通过两个标准原语访问wait()/ signal(), 也称为P/V操作

整型信号量
通过整数S记录信号量

伪代码实现:

wait(S){
    while(S<=0){
         // 忙等待
    }
    S--;
    
}
signal(S){
    S++;
}

记录型信号量

通过整数S与进程链表L的整个结构体共同实现信号量。

struct semaphore{
    int val;
    llist<process> *L;
};

void wait(semaphore S){
    S.val -- ;
    if (S.val < 0){
        // L 中插入进程
        block(S.L);
    }
}
void signal(semaphroe S){
    S.val ++;
    if (S.val < 0){
        // L 中 移除进程
        wakeup(S.L);
    }
}

信号量与互斥

semaphore S = n; // 初始化信号量
thread P1(){
    P(S);    // 加锁
    fun();   // 执行
    V(S)     // 开锁
}

信号量与同步

semaphore S = 0; // 初始化信号量

thread P1(){
    fun1();
    V(S);
}

thread P2(){
    while(S<=0);
    P(S);
    fun2();
}

进程P1执行完后，信号量才能增加到1，进程P2才能通过忙等待执行。因此通过信号量的序关系确定了进程的前驱关系

信号量与计算图

信号量可以描述程序段间的前后前驱关系，它能实现一个有向图的任务执行流程，每一个有向边对应一个同步问题。通过维护不同的信号量值，管理不同的前驱关系，从而构建一个进程前驱图。

神经网络中的计算图是张量信息流作为有向边与算子计算结点构成顶点的DAG。由于数据依赖天然诱导执行依赖，因此它可以被视为一种前驱图。若从并行调度角度实现，每条依赖边都可以抽象为一个同步约束，信号量是表达这种约束的一种机制。

生产者-消费者问题

系统中存在多个生产者与消费者，其中生产者、消费者只能在缓冲区互斥读/写

这个场景下，只需要判断缓冲区是否有“产品”与是否能访问。通过互斥信号量mutex实现互斥访问的限制，通过计数信号量empty的值表示当前缓冲区含有的产品量。

CPP伪代码为


semaphore mutex = 1;  // 互斥缓冲区 -- 占用进程缓冲区P后不允许进程访问
semaphore empty = n;  // 空缓冲区值 -- 产品缓冲区的存量上限
semaphore full = 0;

void producer(){
    while(true){
        produce();        // 生产产品
        P(empty);         // 申请空缓冲区 -- 容量 -1
        P(mutex);         // 申请进程互斥缓冲区 -- 禁止其他进程访问
        put_product();    // 产品放入缓冲区 
        V(mutex);         // 释放进程互斥缓冲区 
        V(full);          // 满缓冲区 有效产品 +1
    }
}

void consumer(){
    while(true){
        P(full);          // 申请满缓冲区 有效产品 -1
        P(mutex);         // 申请进程互斥缓冲区
        use_product();    // 消耗产品
        V(mutex);         // 释放进程互斥缓冲区
        V(empty);         // 释放空缓冲区 -- 容量 +1
    }
}

读者-写者问题

读者-写者问题是生产者-消费者问题的变式。写者互斥写、读者并行读，但是读者读和写者写不能同时发生。

读者-写者问题分为两种权限优先

读者优先 -- 读者可抢占行夺取缓冲区资源
写者优先 -- 写者非抢占性优先，读者读取时写者需等待

读者优先

写者的信号量权限为 rw = 1, 读者侧维护信号量account 表示当前在读的人数，如果读者归零，则写者能进入缓冲区写

CPP伪代码实现

int count = 0;
semaphore mutex = 1; 
semaphore rw = 1;

void reader(){
    while(true){
        P(mutex);   // 申请进程缓冲区
        if (count == 0){
            P(rw);  // 关闭 写者访问
        }
        count ++;
        V(mutex);   // 释放进程缓冲区
        read();
        P(mutex);
        count -- ;
        if(count == 0){
            V(rw);
        }
        V(mutex);
    }
}


void writer(){
    while(true){
        P(rw);      // 申请rw锁，如果存在读者，则无法访问
        write();
        V(rw);
    }
}

写者优先

写者优逻辑中，还需要维护一个新的信号量w, 用于限制写者的唯一访问

CPP伪代码

int count = 0;       // 读者数
semaphore mutex = 1; // count锁
semaphore rw = 1;    // 写者优先权
semaphore w = 1;     // 文件的独占写信号量


void writer(){
    while(true){
        P(rw);      // 阻止读者读
        P(w);       // 写者单独写
        write();
        V(w);
        P(rw);
    }
}


void reader(){
    while(true){
        P(rw);      // 申请读权限，如果有写者则无法读
        P(mutex);   // 申请进程缓冲区访问
        if (count == 0){
            P(w);   // 阻止写者访问，非抢占性优先
        }
        count ++;
        V(mutex);
        V(rw);
        read();
        P(mutex);
        count -- ;
        if(count == 0){
            V(w);
        }
        V(mutex);
    }
}

哲学家进餐问题

圆形餐桌的每一个哲学家左右手各有一根筷子，进餐时哲学家需要拿起两根筷子进食，如果没有足够的筷子就进行等待。

选定一个哲学家为 $0$ 号哲学家，且逆时针编号，则第 $i$ 个哲学家的左手边的筷子与右手边的筷子的编号分别为

$\begin{dcases} \quad i & \text{左手边筷子}\\ (i+1)\% 5 &\text{右手边筷子} \end{dcases}$

对于 $n$ 个哲学家与 $n$ 根筷子，会出现一个人有一只筷子的死锁情况: 每一个人都只有左手边筷子或者右手边筷子，此时会发生死锁。

如果限制每一次只能有 $n-1$ 个哲学家能吃饭，那么根据容斥原理，总有一个哲学家有两只筷子，此时这个哲学家吃完饭释放筷子资源后，其余哲学家也能继续进餐。因此基于这个想法，进餐人数的信号量初始为 $n-1$ 时能避免死锁。

《伊豆的舞女》 -- 川端康诚

2026-05-28T16:00:00.000Z

《伊豆的舞女》并不是我看过的第一本川端康诚的书，相比《雪国》、《千纸鹤》等刻作品刻画的日本压抑严肃社会背景下的扭曲的爱情，《伊豆的舞女》中的萍水相逢间平淡而朴素的好感与爱恋，却如山间的野花纯真，也如野花般易逝。

在黑暗中，少年的体温温暖着我。我任凭泪泉涌流，我的头脑恍如变成一池清水，一滴滴溢了出来，后来什么也没有留下，顿时觉得舒畅了。

进程与线程

2026-05-24T16:00:00.000Z

进程与线程

进程是操作系统进行资源分配与调度的基本单位。

进程的特征

动态性 -- 进程有明确的生命周期，执行状态存在变化
并发性 -- 多个进程可以在内存中存在于内存并在CPU中并发
独立性 -- 作为申请系统资源的独立单元存在
异步性 -- 进程间相互制约，申请CPU资源是先后进行的。这导致了实际执行的结果可能不可复现

并行的效率

Amdahl’s Law与 Gustafson’s Law 讨论了并行计算能提升多大的计算效率

Amdahl's Law

Amdahl's Law 讨论在等量任务的条件下，并行计算带来的计算效率优化上线。

假设一个程序中可并行部分的比例为 $p$ , 可以 $N$ 路并行，那么整体加速比为

$S_N = \frac{1}{(1-p)+\frac{p}{N}}$

Amdahl's law 指出了并行优化的效率上限 -- 串行部分的比例。当 $N\to \infty$ 时，加速比最大值为

$S_\infty = \frac{1}{1-p}$

Gustafson’s Law

Gustafson’s Law讨论在相等时间的情况下，并行计算得带来的计算任务量的效率优化上限。

假设一个程序的可并行部分为 $p$ . 则相同时间下并行的任务量（加速比）为

$S_N = 1-p + Np = (N-1)p+1$

这说明通过增加并行资源，能通过扩大并行任务规模并使并行部分占主导。

进程的构成

进程实体由三部分构成：

进程控制块(PCB)
程序段
相关数据段

进程控制块 (PCB)

PCB是进程存在的唯一标志，在进程的整个生命周期内，OS均依赖PCB进行进程管理。

PCB包含四类信息:

进程标志信息: 包含用户ID(UID)、进程ID(PID)与父进程ID(PPID), 作为进程标志编号；用户ID能标注进程所属用户，以提供资源与安全的保护
进程调度信息: 包含进程当前状态，进程优先级，CPU占用时间等进度相关调度信息
资源与内存信息: 包含进程内所使用的内存信息，包含代码指针、数据指针、堆栈指针、IO清单与文件描述符
处理机状态信息: 也称为CPU上下文，包含物理寄存器状态参数，如通用寄存器值(PC)、程序计数器值、程序状态字(PSW)、栈指针(SP)

进程的PCB是用户不透明的，我们能通过shell访问相应进程的PCB。

# Linux
cat /proc/[pid]         # 进程 PCB
cat /proc/[pid]/status  # 进程 PCB中的状态特征

# MacOS

ps -l -p [pid]          # 与 cat /proc/[pid]/status 一致

对于不同OS，父进程中断对子进程的影响都不同。Linux系统对父进程中断并不会中断子进程的执行，而是由init(PID=1)进程收养并正常运行。

PCB中的处理机状态信息与指令的相应状态信息相对应。当进程指令进入CPU时间片处理时，对应寄存器从内存中读取PCB处理机信息。

程序段

程序段是CPU可执行的代码部分，是代码的纯二进制指令部分。静态的二进制指令可以被多个进程共享。

程序段包含

.init -- 主程序启动前的隐代码准备
.text -- 程序的可执行部分
.rodata -- 只读数据存储

数据段

数据段包含进程运行所需的数据，包含.data、.bss与堆、栈

.data用于放置已初始化的静态变量、.bss用于放置未初始化的静态变量

Tip: 关于变量存储的空间

int a = 1; // 在.data 数据段中
int b[10]; // 在.bss 数据段中

void main(){
    static int List[10]; // 函数中静态变量声明在.data数据段中
    int c = 1; // 在被调用的函数中声明的变量直接在栈中生成
    int *p_arr = (int*)malloc(10*sizeof(int)) // 被调用函数中声明动态申请空间时，变量生成在堆中

}

共享库的存储映射区

依赖库的加载，比如一些动态库.so/.dll

静态库通常加载到.text中

进程的生命周期

进程的生命周期分为

创建态
就绪态
运行态
阻塞态
终止态

满足图


创建态 -> 就绪态  <-> 运行态 -> 终止态
            |          |
            <------  阻塞态

进程的创建

在创建态下，OS通过创建原语建立新进程。

分配唯一标识并创建空白PCB
分配新进程所需的资源，如内存、文件、IO等，存入PCB
初始化PCB
插入就绪队列中

终端登录、作业调度系统启动任务、用户程序请求、系统提供服务等事件都会创建新的进程。

进程的终止

分为正常结束、异常结束与外界干预

正常结束 -- 进程完成任务后退出
异常结束 -- 异常或者中断导致退出
外界干预 -- 人工退出、系统资源不足或者安全原因导致退出

终止进程的流程

检索PCB并读取当前状态
剥夺CPU并调度下一个进程
释放相关的系统资源，归还给OS
根据系统设计中断相关子进程
清除并释放PCB

进程的阻塞与唤醒

进程因为外部事件无法进行时会主动调用阻塞原语(Block), 将进程从运行态转变为阻塞态。

阻塞原语与中断实现的逻辑相似。阻塞原语的实现过程

保存CPU现场(PC/状态寄存器)到PCB
修改PCB状态字段为阻塞态并放入等待队列
调度就绪队列的进程运行

阻塞进程的事件结束后，需要内核的中断处理程序或者合作进程调用**唤醒原语(Wakeup)**进行进程的唤醒

在等待队列找到对应PCB
移除队列并修改PCB中的状态字，此时从阻塞态转变为就绪态
将PCB插入就绪队列，并等待CPU资源执行

进程的通信

进程是独立的单元，进程间的通信通常需要申请内存区域搭建通信的介质进行信息交换。

根据通信效率与量的不同可以分为:

低级通信 -- 控制信息的传输
高级通信 -- 高效传输大量信息

高级通信面对大量的数据与地址的传递

共享传递 -- 划出独立的内存空间，使多个进程都能读写这个共享的空间以实现通信。引入同步互斥机制规避同时读写共享空间的导致的数据不一致的问题
消息传递 -- 封装格式化的信息进行传递，格式化信息由内核实现，面向用户透明。分为直接通信方式与间接通信方式。直接通信方式是将格式化信息通过发送原语与接收原语到指定进程；间接通信方式通过维护一个信箱实体进行间接通信
管道通信
维护一个固定大小的内存缓存区进行通信，管道是单向的。管道满足:
- 互斥性: 同一时刻只有写端或者读端一个进程访问管道，以避免并发造成数据混乱
- 同步性: 管道慢自动阻塞，读端释放后继续写入
- 写端关闭检测后读端自动返回空
信号用于通知进程事件发生的情况，通过一个向量维护待处理的信号，一个向量维护被阻塞的信号。信号的来源分为:
- 内核: 如SIGKILL(kill -9)
- 进程：其他进程或者自身发送信号

仅当OS从内核态回到用户态的时候才会处理待处理的信号。处理信号的方式

执行系统默认的信号处理 -- 比如遇到SIGKILL杀死进程
执行用户自定义的信号处理程序 -- 相关定义函数的执行

线程

线程是程序执行流的最小单位，也是处理器调度的基本单位。

在单个进程中有多个执行线程。一个线程不拥有独立的系统资源，比如地址空间，但是运行基本的线程私有数据，比如线程ID、PC、寄存器组和栈寄存器(这些是指令执行的基本单位，线程独立执行一些指令组，因此拥有这些物理元件的数据独立性)。线程的控制块TCB用于记录线程的执行上下文(即对应物理元件的备份值，如PC值，栈指针等)

统一进程中的多个线程也能并发执行相同的程序代码。常见的，比如uWSGI创建的多线程后端服务，能访问同一个后端代码库。也能同时共享进程的资源与内存信息。

线程间的CPU调用与生命周期是独立的。多CPU系统的线程可以在不同的CPU核心上运行

线程间的调度的开销小于进程间的调度。

线程控制块(TCB)

TCB 包含

线程标志符(ID)
寄存器集合
线程状态
调度优先级
线程私有数据的局部存储区
线程的私有堆栈的指针

线程的实现

线程分为用户级线程(ULT)与内核态线程(KLT)，基于这两种线程存在多种进程实现方式。

用户级线程模式 -- 只由用户级线程执行线程，任务只需要库函数进行。这样的OS称为纯微内核系统，用户态线程只通过系统调用的方式执行一些内核操作(比如IO)
内核级线程模式 -- 指系统内核支持用户级与内核级线程。但是线程的用户态/内核态转换面临系统开销

组合方式分为多对一模式、一对一模式与多对多模式

一对一模式与内核级线程模式是一个模式的两个名字

多对一模式是指始终只有一个线程能从用户态切换至内核态，实现并发的内核态运行。多对一模式并不能完成多内核/多CPU多线程并行

多对多模式是能将实现多对多的内核态切换，同时避免一对一模型的全切换开销过大的问题。

线程库是用户态线程的管理方式，程序员通过线程库的库函数(API)进行线程的创建与生命周期的管理。同时，高级语言能通过线程池进行多用户线程的管理，例如SQLite的ThreadPoolExecutor

CPU调度

CPU调度是指当进程数远大于CPU核心数时，如何分配CPU资源以实现进程的高效、公平的运行，从而实现进程的高并发。

调度的层次

调度自外向内分为三个层次

高级调度(作业调度) -- 高级调度负责将作业从外存中提取进内存，分配内存/IO等资源，并创建相应的PCB。整个作业调度周期内高级调度只发生一次。
中级调度(内存调度) -- 中级调度是为了提高内存利用率，当内存紧张时，将阻塞态或者就绪态持续较长的进程挂起并放入外存；当系统资源支持对应进程继续运行时，中级调度将进程移回内存。
低级调度(进程调度) -- 低级调度按照规则给进程分配CPU资源。

进程调度的任务包括

保存CPU现场信息(如PC,PSM), 以确保上一个进程能断点运行
选取就绪的待运行进程，将进程PCB从就绪态改为运行态
移交CPU控制权，恢复断点，分配CPU

调度的实现

进程调度通过调度器实现，调度器分为排队器、分派器与上下文切换器。

排队器 -- 进程就绪态的排队序列
分派器 -- 根据调度算法选定进程进行CPU资源分配，并触发上下文的切换
上下文切换器 -- 进行当前CPU运行的进程的上下文切换写入PCB，再将分派进程的上下文写入CPU的相应寄存器中

上下文切换

上下文切换是进程调度的核心占用步骤，因为PCB就是进程的信息载体本身。上下文切换分为上一个进程PCB的保存与下一个进程PCB的恢复与写入CPU寄存器，完整流程为

挂起当前进程，将CPU上下文写入PCB
将当前进程的PCB放入就绪队列或者阻塞队列中
选择另外一个进程，更新相关PCB信息(从就绪态改为运行态)
将PCB的运行信息恢复进CPU
分配CPU资源，跳转到PC地址并执行

上下文切换涉及复杂的访存与指令的执行，时间与资源的开销都较大。

上下文切换是发生在进程间的，而模式切换是发生在进程或者线程内的状态变化。上下文切换只能由内核执行，因此当前进程切换必须为内核态。

调度的时机

进行进程调度的时刻有

创建新进程时，父进程与子进程都进入就绪态，调度器选择父进程/子进程分配CPU资源
进程正常结束或者终止的时候。如果没有就绪进程就挂起一个闲逛进程(PID=0,优先度最低)、
进程进入阻塞态时，为了提高CPU利用率，会进行进程调度
IO就绪时，将阻塞态进程切换为就绪态进程

不能进行进程切换的场景(关中断状态)

处理中断的过程。
执行原子操作的情况，此时系统会进行屏蔽中断操作。

调度的方式

非抢占调度方式: 面对更加紧迫的或者优先级更高的进程，只有当前进程执行后才会进行调度
抢占调度方式: 出现优先级更高的进程进入就绪态，当前进程的CPU资源直接被剥夺，给新进程分配CPU资源

调度的目标

调度的目标是提高CPU的利用率，进程的调度目的是尽可能提高CPU的利用率。CPU利用率的计算公式为

$\text{CPU利用率} = \frac{\text{CPU有效工作时间}}{\text{CPU有效工作时间}+\text{CPU空闲等待时间}}$

系统吞吐量用于衡量系统的执行单个作业的平均速度。长作业通常占用CPU的时间，降低系统的吞吐量。

周转时间指作业从提交到完成的整个生命周期所消耗的时间，包括等待、就绪态排队、阻塞态等待IO以及实际CPU的执行时间。对于 $n$ 个作业的平均周转时间为均值

调度算法

先来先服务(FCFS)算法

FCFS算法中的进程队列满足FIFO，即先来先执行，晚到晚执行的策略，属于非抢占式的算法。FCFS是公平算法但是对短进程不友好，效率较低；同时FCFS遇到高频IO的进程无法快速释放CPU资源，效率更低。

短作业优先(SJF)算法 / 短进程优先(SPF)算法

短作业优先算法会进行队列中的作业用时预测，将最短用时的作业分配CPU资源。

预测算法是简单的预测时间加权。对于上一次实际用时 $t_n$ 与预测用时 $\tau_n$ , 以及预测因子 $\alpha$ , 本轮的预测用时为

$\tau_{n+1} = \alpha t_n + (1-\alpha)\tau_n$

SJF对于长作业不利，如果短作业频繁创建，长作业会始终得不到CPU资源而产生饥饿现象(调度策略使某一进程出现无限期等待)；同时SJF只考虑了作业长度作为优先级而没考虑进程的优先级，无法保证紧迫作业及时处理。

高响应比优先调度算法

基于响应比评估作业的整体优先级，综合考虑了作业的时效性与等候时间

$\text{响应比} = \frac{\text{等待时间}+\text{估计运行时间}}{\text{估计运行时间}}$

优先级调度算法

根据系统优先级进行作业的调度

优先级调度算法根据是否能在进程期间抢占CPU资源分为

抢占式优先调度算法
非抢占式优先调度算法

通常系统进程 > 用户进程，交互性进程 > 非交互性进程， IO进程 > 计算进程(IO设备的传输与处理优先级高，相关的数据信息无法暂存，处理速度也慢于CPU)

根据进程优先级是否可变可以分为静态优先级与动态优先级。其中静态优先级指进程优先级在创建时就固定不可变，调度简单但是有可能出现饥饿现象；动态优先级可以根据等待时间或者进程属性进行动态的改变。

时间片轮转(RR)算法

时间片一个执行窗口，如果进程执行时间长于时间片，就将进程CPU资源释放给下一个进程，并放入就绪队列。时间片轮转能保证进程的公平性，不会遇到饥饿现象，但是面临性能开销较大的问题。

当进程结束但是时间片未结束，此时也触发时间片的轮转，为下一个几次呢分配CPU资源

多级队列调度算法

将就绪进程分为多个不同优先级、不同或相同调度算法的进程队列，进行进程的调度与执行。潜在的问题为高级队列进程频繁创建的场景下，低等级队列的进程饥饿

多级反馈队列调度算法

相比多级队列调度算法，多级反馈队列调度算法打通了不同优先级队列的通道。多级反馈队列的通常基于递增时间片的进程队列实现，通常越低级、越底层的队列的时间片越长，越接近FCFS。

新到达的进程通常先进入最高优先级队列。若进程在当前队列的时间片内未执行完，则被剥夺 CPU，并被移动到下一较低优先级队列的队尾继续等待；若进程已经处于最低优先级队列，则被剥夺 CPU 后通常回到该最低级队列队尾等待。、、

多处理机调度

多处理器系统分为非对称多处理器(AMP)和对称多处理器(SMP)。AMP有一个独立主CPU进行全部调度与决策，从CPU只执行任务；SMP的CPU是平等执行与调度进程的，调度程序可以将任意就绪进程分配给不同的CPU

在多核CPU/多CPU系统中，某个进程在CPU1运行，调度到CPU2时，相应的寄存器与Cache都要进行移动。因此系统应尽量使进程在单个CPU中调度，称为处理器亲和性

CPU多核性能平均化称为 性能均衡，因此需要进行CPU间的进程调度实现多核平均化。从这个角度看，处理器亲和性与性能均衡是相对矛盾的，性能均衡会抵消处理器亲和性的性能优化。

面向多处理机的调度方式可以分为公有队列调度与私有队列调度

公共就绪队列调度 -- 所有CPU共享一个进程队列，CPU的性能均衡但是处理器亲和性较差
私有就绪队列调度 -- 调度器控制私有队列进程，当CPU空闲时调用私有队列进程执行。CPU的处理器亲和性高但是性能不均衡

处理器的亲和性的提升方法分为软亲和与硬亲和。软亲和指调度器进行进程软绑定在某个CPU上，尽量向这个CPU调度；硬亲和指用户进程通过系统调度主动请求系统绑定在某个CPU上。

协程

协程是语言实现的，可以在线程内部执行、中断并恢复的程序控制结构，通过yield()自主管理CPU的调用，其性能开销小于线程的切换

DeepNet

2026-05-23T16:00:00.000Z

DeepNet

本篇文章作为Transformer 中的 Layer Normalization与梯度稳定性的后继文章，进一步进行Layer Normalization的相关学习

Warm-up 与初始化方式对于梯度下降稳定性的影响

在本节设置了三个实验组进行对比

对照组1: Post-LN + 标准Xavier初始化 + No Warm-up
对照组2: Post-LN + 标准Xavier初始化 + Warm-up
对照组3: Post-LN + Xavier缩放初始化 + Warm-up

Xavier的缩放初始化是对于第 $l$ 层， $l\in[1,N]$ , 有随着深度递减的缩放因子 $k_l = N+1-l$ , 使得

$W_o^l\sim \mathcal{N}(0,\frac{1}{k_l^2d'})$

其采用的评估指标为整个模型各轮训练的输出更新的模, $\theta_i$ 表示第 $i$ 轮训练后的参数, $\theta_0$ 表示初始化参数

$\|\Delta F_i\| = \|F(x,\theta_i)-F(x,\theta_0)\|$

在图4.a中，对照组1 的Model Update在初始步就出现了爆炸。这一结论和 Transformer 中的 Layer Normalization与梯度稳定性中的结论是一致的。

通过图3的子图对比，作者将Model Update 而非梯度模作为评估梯度下降稳定性的评估指标，因为在对照组2、3的对比中，对照组3的梯度模更大，但是具有更好的收敛效果。

DeepNet 的结构

本文的主体创新点，即DeepNorm 架构。相对于Pre-LN,就是在主输入信号处增加了一个可学习参数 $\alpha>1$ , 对输入tensor进行了放大。

Lemma 1.: 对于 $X=(\mathbf{x}_1,\cdots,\mathbf{x}_n)\in \mathbb{R}^{n\times d}$ , $\mathrm{Var}(\mathbf{x}_i) = 1, \mathbf{E}(\mathbf{x}_i) = 0$ , $q_i\in [0,1]$ , 则有

$\mathrm{Softmax}(q_1,\cdots, q_n)\cdot X \asymp \mathbf{x}_i$

这里的 $\asymp$ 表示 equal bound of magnitude，即只比较数量级上的上下界，而不要求两个向量在方向或逐元素取值上相同。
Proof:

$\begin{aligned} \mathrm{Softmax}(q_1,\cdots, q_n) \cdot X &= \left(\frac{\exp{q_i}}{\sum \exp{q_j}}\right)_{i}\cdot \left(\mathbf{x}_1,\cdots ,\mathbf{x}_n \right)^T\\ &=\sum \frac{\mathbf{x}_i\exp q_i}{\sum\exp q_j} \end{aligned}$

由于

$n\leq\sum \exp q_j\leq ne$

有

$\frac{1}{\sum \exp q_j} = \Theta\left(\frac{1}{n}\right)$

因此可以写成凸集的形式

$\mathrm{Softmax}(q_1,\cdots,q_n)X = \sum_{i=1}^n w_i\mathbf{x}_i, \quad w_i=\frac{\exp{q_i}}{\sum \exp q_j}=\Theta\left(\frac1n\right).$

因此，由 $w_i=\Theta\left(\frac1n\right)$ 可得

$\sum_{i=1}^n w_i\mathbf{x}_i \asymp \sum_{i=1}^n \frac1n\mathbf{x}_i .$

又因为每个 $\mathbf{x}_i$ 都满足 $\mathbf{E}(\mathbf{x}_i)=0$ 且 $\mathrm{Var}(\mathbf{x}_i)=1$ ，所以所有 $\mathbf{x}_i$ 具有相同的 magnitude bound。于是 $n$ 个同阶向量经过 $\frac1n$ 量级的权重加权求和后，其输出仍然具有与单个 $\mathbf{x}_i$ 相同的 magnitude bound，即

$\sum_{i=1}^n \frac1n\mathbf{x}_i \asymp \mathbf{x}_i .$

因此

$\mathrm{Softmax}(q_1,\cdots,q_n)X = \sum_{i=1}^n w_i\mathbf{x}_i \asymp \mathbf{x}_i .$

Lemma 1对Attention输出头的阶进行了估计，保证了输入和输出的阶是相等的，Attention不会导致Model Update发生爆炸

Lemma 2 方差的阶的可加性

$\mathrm{Var}(X+Y)\asymp \mathrm{Var}(X) + \mathrm{Var}(Y)$

Proof:
展开得

$\begin{aligned} \mathrm{Var}(X+Y) &= \mathbb{E}[(X+Y)^2] - [\mathbb{E}(X+Y)]^2\\ & = \mathbb{E}(X^2) - \mathbb{E}^2(X) +\mathbb{E}(Y^2) - \mathbb{E}^2(Y) +2\mathbb{E}(XY) - \mathbb{E}(X)\mathbb{E}(Y)\\ & = \mathrm{Var}(X) +\mathrm{Var}(Y)+2\mathrm{cov}(X,Y) \end{aligned}$

Theorem 1 对于 $N$ 层DeepNet结构 $F(x,\theta)$ , 每一层的DeepNet可表示为 $x_{l+1} = f(x_l,\theta_l) = \mathrm{LN}(\alpha x_l+G_{\theta_l}(x_l))$ , $\theta_i\in \left\{\theta_1,\cdots,\theta_{2N}\right\}$

其中奇数参数是Selt-Attention的参数权重，偶数参数是FFN的参数权重。则有

$\|\Delta F\|\leq \sum_{i=1}^n \frac{\sqrt{v_i^2+w_i^2}}{\alpha}\|\theta^*_i-\theta_i\|$

基于最简化的情况，Self-Attention Layer 与 FFN layer 都视为 $G_\theta(x_l) \asymp v_lw_lx_l$ , 则每一个Layer的递推输出为

$\begin{aligned} x_{l+1} = f(x_l,\theta_l) &= \frac{\alpha x_l+G_{\theta_l}(x_l)}{\sqrt{\mathrm{Var}(\alpha x_l+G_{\theta_l}(x_l))}}\\ & \asymp \frac{(\alpha+v_lw_l)x_l}{\sqrt{(\alpha^2+v_l^2w_l^2)\mathrm{Var}(x_l)}}\\ \end{aligned}$

根据Lemma 1, $\mathrm{Var}(x_l) \asymp \mathrm{Var}(x_0) = 1$ , 故

$x_{l+1} = f(x_l,\theta_l) \asymp \frac{\alpha+v_lw_l}{\sqrt{\alpha^2+v_l^2w_l^2}}x_l$

因此

$\frac{\partial f_l}{\partial x_l} \asymp \frac{\alpha+v_lw_l}{\sqrt{\alpha^2+v_l^2w_l^2}}$

视 $\theta_l = (v_l,w_l)$

$\frac{\partial f_l}{\partial \theta_l} \asymp \frac{\alpha x_l(\alpha -v_lw_l)}{(\alpha^2+v_l^2w_l^2)^{\frac{3}{2}}} \left(w_l,v_l\right)$

因此可展开Layer Model Update

$\begin{aligned} \|\Delta F\| &= \|f(x_{2N}^*,\theta_{2N}^*)-f(x_{2N},\theta_{2N})\|\\ & = \|\frac{\partial f}{\partial x_l}(x_{2N},\theta_{2N})(x^*_{2N}-x_{2N}) +\frac{\partial f}{\partial \theta_l}(x_{2N},\theta_{2N})(\theta_{2N}^*-\theta_{2N})\|\\ &\leq \|\frac{\partial f}{\partial x_l}(x_{2N},\theta_{2N}) \| \|x^*_{2N}-x_{2N}\| +\|\frac{\partial f}{\partial \theta_l}(x_{2N},\theta_{2N})\|\|\theta_{2N}^*-\theta_{2N}\|\\ &\asymp \frac{\alpha+v_{2N}w_{2N}}{\sqrt{\alpha^2+v_{2N}^2w_{2N}^2}}\|x^*_{2N}-x_{2N}\|+ \frac{\alpha x_{2N}(\alpha -v_{2N}w_{2N})}{(\alpha^2+v_{2N}^2w_{2N}^2)^{\frac{3}{2}}} \|\left(w_{2N},v_{2N}\right)\|\|\theta_{2N}^*-\theta_{2N}\||\\ &\leq \|x^*_{2N}-x_{2N}\|+\frac{\alpha x_{2N}(\alpha -v_{2N}w_{2N})}{(\alpha^2+v_{2N}^2w_{2N}^2)^{\frac{3}{2}}} \sqrt{w_{2N}^2+v_{2N}^2}\|\theta_{2N}^*-\theta_{2N}\|\\ &\asymp \|x^*_{2N}-x_{2N}\|+\frac{\sqrt{w_{2N}^2+v_{2N}^2}}{\alpha}\|\theta_{2N}^*-\theta_{2N}\|\ \end{aligned}$

递推得

$\|\Delta F\|\leq\sum_{i=1}^{2N}\frac{\sqrt{w_{i}^2+v_{i}^2}}{\alpha}\|\theta_{i}^*-\theta_{i}\|$

由于每一个 $w_i,v_i$ 的初始化都与scaling factor $\beta$ 相关，因此整个Model Update 的 Bound 能通过 $\alpha, \beta$ 控制，我们能通过设计这两个值的大小实现稳定训练Deeper的Network且保证收敛

Transformer 中的 Layer Normalization与梯度稳定性

2026-05-22T16:00:00.000Z

On Layer Normalization in the Transformer Architecture

本文介绍了Pre-LN, 将归一化层放置在残差分支，以降低训练初始状态的训练梯度爆炸的现象。通过Post-LN架构进行训练刚需Warm-up(即通过初始降低学习率的方式进行训练)，本文提出的Pre-LN通过迁移LN层位置的方式降低了整体梯度的稳定性与相对大小。将模型从Warm-up 中解脱出来。

Layer Normalization的作用

$\mathrm{LN}(x) = \gamma \odot \frac{x-\mu}{\sqrt{\sigma^2+\varepsilon}}+\beta$

其中 $\gamma, \beta$ 是可学习的参数。

整个 $\mathrm{LN}$ 层的作用可视为一个归一化与一个仿射变换作用，内层归一化可表示为

$\mathrm{Normal}: x\to \frac{x-\mu}{\sqrt{\sigma^2+\varepsilon}}$

归一化的 $\mathrm{Normal}(x)$ 变为期望 $0$ , 方差 $1$ 的标准向量

$\begin{aligned} \mathrm{Var}(\mathrm{Normal}(x)) &= \frac{\sigma^2}{\sigma^2+\varepsilon}\to 1 \\ \mathrm{E}(\mathrm{Normal}(x)) &= 0 \end{aligned}$

可学习的参数 $\gamma, \beta$ 能改变向量的整体期望与均值以增强 $\mathrm{LN}$ 层的调节能力。

Post-Layer Normalization 的梯度爆炸与 Warm-up

本文对于Multi Head Attention 的梯度阶估计过程提出了一个简化计算的模型，再通过实验论证假设对于完整的MHA Residue Flow 也成立。

初始权重使用Xavier初始化，每个权重 $w$ 满足

$\mathrm{Var}(w) = \frac{2}{n_{in}+n_{out}}$

Post-LN 层的一次前向传播的公式

$\begin{dcases} \tilde{x}^{post}_t = \mathrm{LN}(x^{post}_t+\mathrm{MHA}(x^{post}_t))\\ x^{post}_{t+1} = \mathrm{LN}(\tilde{x}^{post}_t+ \mathrm{FFN}(\tilde{x}^{post}_t)) \end{dcases}$

Pre-LN 层的一次前向传播的公式

$\begin{dcases} \tilde{x}^{pre}_t = x^{pre}_t + \mathrm{MHA}(\mathrm{LN}(x^{pre}_t))\\ x^{pre}_{t+1} = \tilde{x}^{pre}_t+\mathrm{FFN}(\mathrm{LN}(\tilde{x}^{pre}_t)) \end{dcases}$

记

$J_{\mathrm{LN}}(x) = \frac{\partial \mathrm{LN}(x)}{\partial x}$

为 $\mathrm{LN}$ 层的Jacobian 矩阵

则Post-LN满足

$\begin{aligned} \mathrm{d}\tilde{x}^{post}_t &= J_{\mathrm{LN}}(x^{post}_t+\mathrm{MHA}(x^{post}_t))\cdot (\mathrm{d} x^{post}_t+ \mathrm{d} \mathrm{MHA}(x^{post}_t))\\ &=J_{\mathrm{LN}}(x^{post}_t+\mathrm{MHA}(x^{post}_t))\cdot(I+J_{\mathrm{MHA}}(x^{post}_t)) \cdot \mathrm{d}x^{post}_t \end{aligned}$

$\begin{aligned} \mathrm{d} x^{post}_{t+1} = J_\mathrm{LN}(\tilde{x}^{post}_t+\mathrm{FFN}(\tilde{x}^{post}_t))\cdot (I+J_\mathrm{FFN}(\tilde{x}^{post}_t))\mathrm{d}\tilde{x}^{post}_t \end{aligned}$

$\frac{\partial x^{post}_{t+1}}{\partial x^{post}_{t}} = J_\mathrm{LN}(\tilde{x}^{post}_t+\mathrm{FFN}(\tilde{x}^{post}_t))\cdot (I+J_\mathrm{FFN}(\tilde{x}^{post}_t))\cdot J_{\mathrm{LN}}(x^{post}_t+\mathrm{MHA}(x^{post}_t))\cdot(I+J_{\mathrm{MHA}}(x^{post}_t))$

Pre-LN满足

$\begin{aligned} \mathrm{d} \tilde{x}^{pre}_{t} &= (I + J_{\mathrm{MHA}}(\mathrm{LN}(x^{pre}_t))\cdot J_{\mathrm{LN}}(x^{pre}_t))\mathrm{d}x^{pre}_t\\ \mathrm{d} x^{pre}_{t+1}&=(I + J_{\mathrm{FFN}}(\mathrm{LN}(\tilde{x}^{pre}_t))\cdot J_{\mathrm{LN}}(\tilde{x}^{pre}_t))\mathrm{d}\tilde{x}^{pre}_t \end{aligned}$

$\frac{\partial x^{pre}_{t+1}}{\partial x^{pre}_t} = (I + J_{\mathrm{FFN}}(\mathrm{LN}(\tilde{x}^{pre}_t))\cdot J_{\mathrm{LN}}(\tilde{x}^{pre}_t))\cdot(I + J_{\mathrm{MHA}}(\mathrm{LN}(x^{pre}_t))\cdot J_{\mathrm{LN}}(x^{pre}_t))$

MHA贡献的梯度流动

基于本文关于MHA的假定，有 $W_Q = W_K = 0$ , 因此单一Attention头的输出为

$\begin{aligned} h &= \mathrm{Softmax}(\frac{QK^T}{\sqrt{d}})\cdot V\\ & = \mathrm{Softmax}(\bold{0}) \cdot X\cdot W_V\\ & = \frac{1}{n}X\cdot W_V\\ & = \frac{1}{n} \sum_{j=1}^n x^j w_{V}^j \end{aligned}$

$\mathrm{MHA}(X) = \mathrm{Concat}(h_1,\cdots, h_n)\cdot W_O$

计算MHA的微分

$\begin{aligned} \mathrm{d\,MHA}(X)&= \mathrm{d\,Concat}(h_1,\cdots, h_n)\cdot W_O+ \mathrm{Concat}(h_1,\cdots, h_n)\cdot \mathrm{d}W_O \\ & = \mathrm{Concat}(\mathrm{d}h_1,\cdots,\mathrm{d}h_n)\cdot W_O + \mathrm{Concat}(h_1,\cdots, h_n)\cdot \mathrm{d}W_O\\ & = \mathrm{Concat}(\mathrm{d}X \cdot W_V^i)\cdot W_O\\ & = \mathrm{d}X\cdot \mathrm{Concat}(W_V^i)\cdot W_O\\ & = \frac{1}{n}\sum_{j=i}^n\left(\mathrm{d}x^j\right)\cdot \mathrm{Concat}(W_V^i)\cdot W_O\\ & :=\frac{1}{n}\sum_{j=i}^n\left(\mathrm{d}x^j\right) W_{V,l} \end{aligned}$

其中 $W_{V,l}$ 是等效的随机矩阵

$W_{V,l} = \mathrm{Concat}(W_V^i)\cdot W_O$

对应Jacobian矩阵为

$J_{\mathrm{MHA}} = \frac{1}{n}\bold{1}\bold{1}^T\otimes W_{V,l}$

残差梯度流为

$I+J_\mathrm{MHA} = I+\frac{1}{n}\bold{1}\bold{1}^T\otimes W_{V,l}$

LN层Jacobian矩阵谱范数的阶估计

根据上文推导，需要计算LN层的Jacobian矩阵的大小。在此我们只考虑未仿射变换的归一化映射的梯度，因为仿射变换后只需要进行梯度的线性缩放。

$\mathrm{LN}(x) = \frac{x-\mu}{\sigma}$

取无偏向量

$y = x(I-\frac{1}{n}\bold{1}^T\bold{1}) = \begin{pmatrix} x_1 - \frac{1}{n}\sum x_i\\[1em] x_2 - \frac{1}{n}\sum x_i\\[1em] \vdots\\[1em] x_n - \frac{1}{n}\sum x_i \end{pmatrix}$

其中

$\begin{aligned} \|y\| &= \sqrt{\frac{1}{n}\sum_i (x_i-\mu)^2}\\ &=\sqrt{\frac{1}{n} \sum_i (x_i^2-2\mu x_i+\mu^2)}\\ &=\sqrt{\frac{1}{n}\sum_i x_i^2-\mu^2} \end{aligned}$

有 $\mathcal{O}(\|y\|) = \mathcal{O}(\|x\|)$

因此

$\mathrm{LN}(x) = \frac{y}{\sqrt{\frac{1}{n}\sum y_j^2}}$

$\begin{aligned} \frac{\partial \mathrm{LN}(x)_i}{\partial y_j} & = \sqrt{n} \frac{\delta_{i,j} \sqrt{\sum y_j^2} - y_i\frac{y_j}{\sqrt{\sum y_j^2}}}{\sum y_j^2}\\ & = \frac{\sqrt{n}}{\|y\|}\left(\delta_{i,j} -\frac{y_iy_j}{\|y\|^2} \right) \end{aligned}$

因此

$\begin{aligned} J_{\mathrm{LN}}(x) &= \frac{\partial \mathrm{LN}(x)}{\partial y}\frac{\partial y}{\partial x}\\ &=\frac{\sqrt{n}}{\|y\|}\left(I-\frac{y_iy_j}{\|y\|^2}\right)(I- \bold{1}^T\bold{1}) \end{aligned}$

$\|J_\mathrm{LN}(x)\| = \mathcal{O}(\frac{\sqrt{n}}{\|y\|}) = \mathcal{O}(\frac{\sqrt{n}}{\|x\|})$

基于以上结果进行主定理的叙述

Definition 1.1: 随机变量的 $(\varepsilon,\delta)$ -Bounded

对于实随机变量 $Z\geq 0$ , 如果 $Z$ 满足

$\mathbb{P}\left(\frac{Z-\mu}{\mu}\leq \varepsilon\right) \geq 1-\delta$

也即

$\mathbb{P}\left(\frac{Z-\mu}{\mu}\geq \varepsilon\right) \leq \delta$

其中 $\varepsilon > 0, 0<\delta <1$ , 则称随机变量 $Z$ 是 $(\varepsilon-\delta)$ -Bounded

这个结论和Chebyshev不等式的结构相似, Chebyshev不等式能说明对方差有界随机变量都是 $(\varepsilon, \frac{\sigma^2}{\varepsilon^2})$ -Bounded的

整体损失函数梯度谱范数

Post-LN架构的损失函数定义为顶部第 $L$ 层的交叉熵

$\mathcal{L}(x^{post}_{L+1,i}) = -\log \mathrm{softmax}_{y_i} (W^{emb}x^{post}_{L+1,i}) = -\log(\mathbb{P}(\mathrm{Softmax}(W^{emb}x^{post}_{L+1,i})|\, y_i))$

Pre-LN架构尾部多一个LN块，损失函数为

$\mathcal{L}(x^{pre}_{final,i}) = -\log\mathrm{softmax}_{y_i}(W^{emb}x^{pre}_{final,i}) = -\log(\mathbb{P}(\mathrm{Softmax}(W^{emb}x^{pre}_{final,i})|\, y_i))$

其中

$x^{pre}_{final,i} = \mathrm{LN}(x^{pre}_{L+1,i})$

Theorem 1. 假设 $\|W^{post}_{L+1,i}\|$ , $\|W^{pre}_{L+1,i}\|$ 均为 $(\varepsilon,\delta)$ -Bounded的。则Post-LN与Pre-LN结构的梯度谱范数满足

$\begin{dcases} \left\|\frac{\partial\tilde{\mathcal{L}} (x^{post}_{L+1})}{\partial W^{2,L}}\right\|_F= \mathcal{O}(d\sqrt{\ln d})\\[2em] \left\|\frac{\partial\tilde{\mathcal{L}}(x^{pre}_{final})}{\partial W^{2,L}}\right\|_F=\mathcal{O}(d\sqrt{\frac{\ln d}{L}}) \end{dcases}$

其中 $W^{2,L}$ 是FFN中的参数矩阵

Proof:
由链式法则

$\begin{aligned} \frac{\partial\tilde{\mathcal{L}} (x^{post}_{L+1})}{\partial W^{2,L}}&= \frac{\partial \tilde{\mathcal{L}}(x^{post}_{L+1})}{\partial x^{post}_{L+1}}\left(\prod_{k=l}^L\frac{\partial x^{post}_{k+1}}{\partial x^{post}_{k}}\right)\frac{\partial x^{post}_l}{W^{2,L}} \end{aligned}$

$\dfrac{\partial\tilde{L}}{\partial x^{post}_{L+1}}$ 是有界的，因为 $x^{post}_{L+1}$ 是 $(\varepsilon,\delta)$ -Bounded的

$\left|\dfrac{\partial\tilde{L}}{\partial x^{post}_{L+1}}\right| = \left|\frac{\partial \mathbb{P}(\mathrm{Softmax}(W^{emb}x^{post}_{L+1}|y_i))}{\mathbb{P}(\mathrm{Softmax}(W^{emb}x^{post}_{L+1}|y_i))\cdot\partial x^{post}_{L+1}}\right|= \mathcal{O}(1)$

(此处略相关递推的阶估计，上文有相关Jacobian矩阵，只需进行估阶即可)关键在于

$\begin{dcases} \text{Post-LN:}&\left\|J_{\mathrm{LN}}(x^{post}_{L+1})\right\|^2 = \mathcal{O}(\frac{n}{\|x^{post}_{L+1}\|^2}) = \mathcal{O}(1)\\[2em] \text{Pre-LN:}&\left|J_{\mathrm{LN}}(x^{pre}_{final})\right\|^2 = \mathcal{O}(\frac{n}{\|x^{pre}_{final}\|^2}) = \mathcal{O}(\frac{1}{L}) \end{dcases}$

Theorem 1 的结论证明了：在初始化时刻，Post-LN 的梯度规模是常数阶，这意味着它与模型深度 $L$ 无关，无法感知并抑制深层带来的不稳定因素；而 Pre-LN 的梯度规模具有 $O(\frac{1}{\sqrt{L}})$ 的衰减性，能随着模型深度的增加降低初始梯度强度，减弱了对 warmup 的依赖。

From ResNet to mHC

2026-05-22T16:00:00.000Z

Tensor Flow 的演化历程

整体的发展脉络分为四类

跨层深度连接 Depth Connection
同层广度连接 Width Connection
把层看成动力系统 Continuous-Implicit Flow
不同样本/token 走不同路径 Routing Connection

Plain Chain

最原始的信息流就是层的复合，满足 $x_{l+1} = \mathcal{F}_{l}(x_l,\theta_l)$ , 这样的深层网络的微分就是

$\frac{\partial x_{l+1}}{\partial x_0} = \prod_{i = 1}^l \frac{\partial \mathcal{F}_i}{\partial x_i}$

Gradient of Loss Function

$\frac{\partial \mathcal{L}}{\partial x_l} = \frac{\partial \mathcal{L}}{\partial x_L}\prod_{i=l}^{L-1}J_{\mathcal{F}_i}(x_i)$

Plain Chain 容易出现梯度消失或者梯度爆炸的现象。随着梯度的模大于0或者小于0，指数发散(爆炸)或者收敛到0(消失)

ResNet

$x_{l+1} = x_{l} + \mathcal{F}_{l}(x_l,\theta_l)$

将模型的更新量作为线性可加的残差，将整体的复合非线性映射变为了一个恒等映射+微小扰动量的形式。

DenseNet

DenseNet在ResNet的Skip Connections的基础上,将加性结构换为高维嵌入, 每一层的输入都是前面所有层输出的Concat, 即

$x_{l+1} = \mathcal{F}_l(\mathrm{Concat}[x_0,\cdots,x_l])$

DenseNet的性能开销和维度爆炸无疑是相当恐怖的。在CV领域DenseNet取得了不错的效果，但是在LLM中，其结构无法合适的Scaling-Up

Post-LN、Pre-LN及相关的衍生架构 -- 深度Transformer 中的 residual stream与稳定化

Transformer 中的 Layer Normalization与梯度稳定性与 DeepNet 对相关的架构进行了讨论。在ResNet的基础结构上，研究LayerNorm的位置对于整体训练的效果、收敛的速度与稳定性的优化

Neural ODE

Deep Equilibrium Model

MoE

MoE 是 Tenor Flow go wider 的结构范式

MoE -- Mixture of experts

Hyper-Connections

本文认为类似于梯度消失/梯度爆炸在深层网络的训练中的问题已经被Post-LN / Pre-LN (Transformer 中的 Layer Normalization与梯度稳定性)解决了，但是二者之间存在对抗性博弈。

Pre-LN：确实有效解决了梯度消失问题，使得训练极深的网络成为可能。但它带来了表示崩溃（Representation Collapse）——即深层特征变得高度相似，每一层都在做重复工作。
Post-LN：能缓解表示崩溃，但代价是重新引入了梯度消失，导致训练极不稳定。

实验结果展示了HC在深层网络中余弦相似度较低的结果，表明HC相比Pre-LN解决了表示崩溃的问题

Hyper-Connection 由两个部分拼接而成

Width-Connections
Depth-Connections

作为残差链接的横向的和纵向的线性拓展。相当于将n路ResNet 之间嵌入了线性层(如果是SHC则为静态参数线性层，如果是DHC则为可学习的线性层)

Hidden Matrix的不同hidden vector 在初始化时状态是相同的，即满足

$\mathrm{H}_0 = (h_0,h_0,\cdots ,h_0) \in \mathbb{R}^{n\times d }$

其中hidden vector 的个数 $n$ 称为拓展率, 表示 Width-Connections 在横向拓展的维度，这个维度对hidden vector本身的信息量没有影响。

在后续的非线性变换后，不同的hidden vector才变为具有不同意义的vector构成 hidden matrix

由图可以写出层间的残差递推公式, 对于第 $i$ 层的残差，有

$h_{i,t+1} = \sum \alpha_{j,i} h_{j,t} + \beta_i \mathrm{Layer}(\sum \alpha_{k,0} h_k)$

用矩阵形式编码相应的参数:

$\mathcal{HC} = \begin{pmatrix} 0 & B\\ A_m & A_r \end{pmatrix} = \begin{pmatrix} 0 & \beta_1 & \beta_2 & \cdots & \beta_n\\ \alpha_{1,0} & \alpha_{1,1} & \alpha_{1,2} & \cdots & \alpha_{1,n}\\ \alpha_{2,0} & \alpha_{2,1} & \alpha_{2,2} & \cdots & \alpha_{2,n}\\ \vdots & &&\ddots\\ a_{n,0} & \alpha_{n,1} & \alpha_{n,2} & \cdots & \alpha_{n,n}\\ \end{pmatrix}$

记第 $t$ 层的残差通道的Layer为 $\tau$ ，单层的递推写为矩阵方程的形式

$\mathrm{H}_{t+1} = B^{\mathsf{T}}\tau (A_m^\mathsf{T} \mathrm{H_t}) + A_r^{\mathsf{T}} \mathrm{H}_t$

Stastic Hyper-Connections

SHC 中的权重矩阵是固定学习的权重矩阵 $\mathcal{HC}$ 。训练完后，在实际的推理阶段并不会改变相应的参数。

Dynamic Hyper-Connections

DHC 中的权重矩阵依赖于输入的Hidden matrix, 但是并不是类似于在线学习的方式，而是作为Hidden matrix 的函数进行动态输出。

DHC 中在每一个 Hidden Matrix 的输入时都会先进行相应的处理后再输出参数。相应的处理为

$\begin{dcases} \overline{\mathrm{H}}_t = \mathrm{LayerNorm} (\mathrm{H}_t) \\ \mathcal{B}(\mathrm{H}_t) = s_\beta\circ \tanh (\overline{\mathrm{H}}_tW_\beta)^\mathsf{T}+B\\ \mathcal{A}_m(\mathrm{H_t}) = s_m\circ \tanh (\overline{\mathrm{H}}_t W_m) + A_m\\ \mathcal{A}_r(\mathrm{H}_t) = s_r\circ \tanh (\overline{\mathrm{H}}_t W_r)+A_r \end{dcases}$

相比SHC，每一个"输出头" 都是一个局部的线性层+ $\tanh$ 激活函数的结构

在单次训练中，DHC相比 SHC多训练了线性层，但是换取了更高的信息密度，且这几个线性层的参数量约为 $\mathcal{O}(dn)$ , 在模型训练的开销较小的情况下，通过实时生成的非线性权重打破了传统残差连接的表达瓶颈，从而实现了极高的信息利用率和收敛稳定性。

实验证明SHC在小任务的条件下性能与DHC相近，但是在更深的网络、更复杂任务(比如图像生成/大参数LLM预训练)的情况下DHC性能远高于SHC

Manifold-Constrained Hyper-Connections

操作系统的基本概念

2026-05-20T16:00:00.000Z

操作系统

操作系统是计算机将硬件系统和用户的连接，是计算机的Harness。计算机系统自下而上分为: 硬件、操作系统、应用与用户。操作系统负责管理硬件资源、为应用程序提供运行环境并充当硬件和用户之间的桥梁。

操作系统的发展过程与分类

原始模式:手动操作阶段，人工通过穿孔纸带输入计算机。分别分为人工操作模式与脱机IO模式。脱机IO通过外围机读取数据到磁带再供CPU调入内存。外围机和高速磁带的读取速度远远高于手动输入，大幅提高CPU IO速度

批处理方式: 基于脱机IO实现的自动连续处理，以提高CPU和系统资源的利用率。可分为

单道批处理 --
多道批处理

总线

2026-05-20T16:00:00.000Z

总线

总线分为CPU内的总线(片内总线)与CPU和其他功能部件之间的总线(系统总线)，I/O总线与通信总线。

多总线硬件系统的系统总线通常可分为

数据总线
地址总线
控制总线

I/O 总线是CPU与内部I/O设备的总线结构，如显卡、网卡等，通常使用标准化的内部总线协议

通信总线是CPU与外部I/O设备或者其他计算机通信的总线结构，常见协议有USB、RS-232、RS-485等

总线结构

总线结构发展历程经历三种结构

早期共享总线结构 -- 通过单一系统总线串联所有设备，传输冲突严重
三总线结构 -- 将总线在物理结构上增加到为三条总线，系统总线、IO总线与DMA总线。传统总线仍然需要承载所有设备通信，具有共享式、广播式的特点，仍然限制了并发和拓展能力
南北桥结构 -- 通过南桥/北桥芯片分离内部和外部的控制功能，北桥负责高速内部通信，如显卡、内存通信；南桥负责外部通信，如USB设备、磁盘与其他外设。南北桥之间通过桥间总线进行通信，北桥与CPU之间通过 前端总线(FSB) 进行通信。南北桥结构仍然因为FSB的吞吐影响了系统的并发能力。
现代集成通信结构 -- 传统北桥被集成在CPU内作为片上集成，CPU与其他外部设备进行点对点互联。多核CPU核间、多CPU结构的CPU之间使用QPI高速串行链路通信。高速IO设备直接通过PCIe与CPU相联，低速设备采用集成度更高的南桥芯片PCH管理

总线的性能指标

总线传输周期 -- 完成一次完整总线事务的总时间，简称总线周期
总线时钟频率 -- 总线周期的倒数表示总线事务信号的频率。现代总线事务的时钟独立于CPU时钟
总线工作频率 -- 总线有效数据传输的频率
总线宽度 -- 总线中数据线条数，标志总线并行数量
总线带宽 -- 总线总传递速度，总线带宽 = 总线宽度 $\times$ 总线频率
总线复用 -- 地址总线/数据总线复用以减小引脚总数
总线寻址能力 -- $n$ 位地址线能寻址 $2^n$ 个存储单元

总线事务

总线事务是主设备到从设备到一次信息交换的过程。分为三个基本段

地址传送阶段 -- 目标地址与操作类型，主设备 -> 从设备
从设备响应阶段(数据准备阶段) -- 从设备准备数据
数据传输阶段 -- 数据在总线上的传输

总线的连续传输模式可分为:

非突发传输模式 -- 单次传输一个总线宽度的数据单元，每一次传输都完整执行三个传输基本段
突发传输模式 -- 连续地址传输，地址线仅传输首地址，后续地址由硬件执行地址自增生成，省去了地址传输的时间开销

总线的物理传输方式可分为串行通信与并行通信。其中并行通信能通过多条数据线同步传输数据，但是会出现信号串扰和时序偏移等问题，实际传输效率低于串行通信。

串行通信可分为

同步串行 -- 发送方时钟控制接收方时钟，二者时钟严格一致，只在数据块首位进行标记。硬件实现复杂，成本较高
异步串行 -- 收发方使用独立的时钟，单数据块以起始位0开启，以终止位1结束，存在奇偶校验。

总线定时

总线定时方式可分为

同步定时方式 -- 主从设备使用同一个时钟，每个操作都在固定的周期内进行
异步定时方式 -- 通过主从设备间的握手信号实现定时控制，分为不互锁(主-从)、半互锁(主-从-主)、全互锁(主-从-主-从). 异步定时方式能改变总线周期长度，并可靠连接工作速度差异较大的设备
半同步定时方式 -- 通过Wait 信号线控制。主设备在信号上升沿检测Wait, 当Wait 置高电平时表示数据未准备就绪，同步无效，直到Wait置低电平时才能读取数据
分离式定时方式 -- 将总线事务拆为请求阶段与应答阶段，请求阶段主设备申请总线使用权，发送地址与命令后释放；应答阶段由从设备申请总线使用权并应答。分离式定时方案能处理多主设备竞争的场景，但是总线仲裁的逻辑较为复杂，协议管理开销较大。

Yuukoの小屋

计算机网络架构

计算机网络相关概念

计算机网络的分类

计算机网络的功能

网络的信息交换方式

电路交换

报文交换

分组交换

网络的性能指标

滑模控制

滑模控制

相图

二阶系统滑模控制

BPE-tokenizer

BPE - Tokenizer

BPE的基本观念

BPE Merge 表的训练

正则表达式库re的使用

遇到的问题

磁盘与SSD

磁盘存储器

磁记录原理

磁盘的管理

磁盘的初始化

磁盘的地址编码方式

磁盘阵列

磁盘的文件系统

磁盘的调度算法

磁盘调度算法

FCFS算法

最短寻道时间优先(SSTF)

SCAN算法

C-SCAN算法

LOOK/C-LOOK 调度

NStepSCAN & FSCAN 算法

减少延迟时间的算法

提高磁盘IO速度的方法

SSD

IO管理

IO管理

IO 设备

IO接口

IO 接口的类型

IO 接口的编址

IO控制方式

程序直接控制

程序中断方式

多重中断与中断屏蔽

DMA 方式

DMA控制器组成

DMA 传送方式

DMA传送过程

IO 软件

中断处理软件

设备驱动程序

设备独立层软件

用户层软件

应用程序IO接口

阻塞IO与非阻塞IO

设备独立性软件

高速缓存与缓冲区

缓冲区

单缓冲

双缓冲

循环缓冲

缓冲池

设备分配与回收

逻辑设备与物理设备的映射

SPOOLing技术

磁盘

Position Encoding

Position Encoding

Assignment1 -- Building a Transformer LM

Assignment1 -- Building a Transformer LM

torch的一些API的用法

矩阵转置与对换

核心函数的实现

Linear

Embedding

正则表达式库`re`的使用

`torch`的一些API的用法