wsmの随记

算法笔记

Fri, 09 Jan 2026 00:00:00 +0800

此文尚未完工，可能还会有重大改动或者被废弃

基础

定义：算法是良定义的有输入输出的计算过程 (procedure)
正确性：liveness （有限时间），safety （答案正确）
- 分析：伪代码，正确性，复杂度
- loop invariant, maintenance
串行 (sequential) 算法
- 技巧：分治，动态规划，贪心
- 分治：“分”即分解为同构的、小规模的问题；“治”即递归解决。治后还需合并小问题结果。例如归并排序
- 图算法：最小生成树，单源最短路
- NP: 旅行商
分布式 (distributed) 算法：多节点 (core, processor, machine, cluster) 互相通信
- examples: C/S, 区块链
- 基础抽象：时序 (timing) 假设，故障 (fault) 检测，广播（可靠，因果），Leader 选举，共识

算法复杂度

执行时间即指令数：假定所有指令（算术，访存，控制）都会耗等时，串行。

朴素计算方式：逐指令计数；考虑最佳/最坏/平均

增长量级 Order of growth：Θ (tight) 𝑂 (upper) Ω (lower) ；$f(n)=\Theta(g(n))$ 定义： $$ \exists n_0 \in \mathbb{N}, c_1,c_2>0, \forall n>n_0, 0\le c_1g(n)\le f(n) \le c_2g(n) $$

我们需要计算一些递归算法的复杂度，其具有 $T(n) =aT\left(\frac{n}{b}\right) + f(n)$ 的形式。有三种算法：代入法，递归树，主定理。

计算机网络

Wed, 07 Jan 2026 17:00:00 +0800

快速自查

物理层
- 调制：曼彻斯特编码/差分曼彻斯特编码；QAM
- 奈奎斯特准则，信噪比，香农公式
- 媒体：TP (U,S,F)，光纤波段 (0.85, 1.3, 1.55) 带宽 (25THz)，无线电 (2-40GHz)
- 信道复用：FDM, TDM, WDM, CDM
- SONET / SDH (51.84, 155.52 Mbps)
- ASDL, HFC, FTTx, ODN (PON)
数据链路层
- LLC, MAC; MTU, SOH, EOT, ESC; BER, FCS, ARQ
- CRC, Hamming; ARQ, SW, GBN, SR
- PPP: LCP, NCP, CHAP, PAP
- CSMA/CD: 0.1us, 96b IFG, 512b CW, 16, 48b jam
- MAC: addr (I/G, G/L, broadcast), 18B, 1500B, VLAN (802.1Q, 4B)
- Switch: CAM, STP; 交换结构
- 802.3u/z/ab; 10ns, 512B; bursting
网络层
- IP (20B+4*n, pld*8, trie) ARP (0806 8+10*2), ICMP (8+n), IGMP (8)
- IPv6(40B) ICMPv6 (ND, MLD)
- ip range, private addr, NAT (NAPT)
- AS, IGP, RIP (hop, udp+4+20*n), OSPF (proto89, 24+); EGP, BGP-4 (iBGP. eBGP, select algo, 19+)
- multicast: mbone, 01-00-5e-0b1, 路由选择 (DVMRP, PIM)，RPB
- MPLS: 4B, label, LDP, LSP, LSR, FEC; SR
- SDN: OpenFlow, 南北
- libc socket
传输层
- UDP: 8B hdr, checksum (2B, 12B phead, pad4B)
- TCP: TPDU, port (49512); hdr 20+4*n, Options (2B TL+nV, MSS 2, Window Scale 1, TS 8, SACK 8/16)
- swnd, cwnd, rwnd; ARQ; SACK, D-SACK; RTO (Karn), 快速重传, ZWP （持续计时器）, Nagle, Reno 四阶段; AQM
- TCP state machine; MSL; keepalive timer
应用层
- TCP: FTP (20/21), TELNET (23), SMTP (25/587), POP3 (110/005), IMAP (143/993)
- UDP: DNS (53), NFS (2049), TFTP (69), DHCP (68/67), SNMP (161/162, SMI, MIB)
- DNS: 四种 DNS, 递归迭代
- WWW: URLm HTTP (1.0, 1.1, 2), HTML, Email (SMTP, POP3, IMAP, pld), MIME, Proxy, Payload (v1), CGI, 搜索引擎, Blog, SNS
- P2P: Time, DHT, Chore ring (KID, NID, finger table)
无线网络
- 802.11: AP, Service set (BSS, ESS, SSID, B/ESSID), Association; AD Hoc (MANET, WSN); version (bagncx); WPAN
- CSMA/CA: CW, 预约 (RTS,CTS), NAV, IFS (slot time, SIFS, DIFS); backoff time; MAC (4+3*6+2+6+body+4)
- WPAN: Bluetooth (IEEE802.15.1, BLE, Piconet), ZigBee (IEEE 802.15.4, FFD, RFD), 802.15.3
- 蜂窝: 1G (FDMA), 2G (T/FDMA, GSM, GPRS), 3G (T/CDMA, UTRAN), 4G (SC/OFDMA+MIMO, LTE, E-UTRAN, EPC)

概述

Internet / 互联网：
- 基本特点：连通性，资源共享
- 组成/要素：计算机，信道，通信协议
- 发展阶段：ARPANET (1969/1983)，三级结构 NSFNET (1985) （主干+地区+企业），多层 ISP （主干，地区，本地多 tier）
  - Internet Service Provider (ISP)
  - Internet eXchange Point (IXP) 互联网交换点
  - Content Provider
  - Request For Comments (RFC) (Proposed, Drafted, STD)
- 标准化：RFC
- 边缘网 edge/end system
  - 端通信方式：C/S, P2P
  - 接入网 Access Network：从用户到 ISP 边缘路由器之间的网络
- 核心网
  - router + packet switch
  - 交换技术：电路交换（点对点），分组交换，报文交换
    - 分组交换优点：高效灵活迅速可靠；逐段占用独立选择无需连接协议可靠
    - 缺点：排队延迟带宽无保证增加开销
    - 报文交换：电报
- 我国发展：铁道部 (1980)，CNPAC (1989)，CHINANET (1994)
  - 最大主干网：CHINANET, UNINET, CMNET, CERNET, CSTNET
网络：节点 node + 链路 link
- internet 互连网：网络 + router；internet ≠ Internet
- 计算机通信网：计算机+通道+通信协议
计算机网络
- 计算机网络主要是由一些通用的、可编程的硬件互连而成的，而这些硬件并非专门用来实现某一特定目的（例如，传送数据或视频信号）。这些可编程的硬件能够用来传送多种不同类型的数据，并能支持广泛的和日益增长的应用。
- 分类：
  - 作用范围：WAN (wide) MAN (metropolitan) LAN (local) PAN (personal)
  - 使用者：public/private
  - Access Network 边缘路由器
性能参数
- （额定）速率/带宽
- （实际）吞吐 throughput
- 时延：发送/传输时延 (end)，传播 (link)，处理 (node)，排队 (node)
  - 提高速率 = 提高发送速率 = 减小发送时延
  - 网络实际时延 = 空闲时延 / (1-利用率)
- 时延带宽积：链路可容纳的数据量
- RTT：2传播+remote 处理排队发送
- 有效数据率 = 数据长度 / (发送时间+RTT) = 带宽 * 发送时间/(发送时间+RTT)
- 信道利用率：利用时间比
- 其他：标准化，可靠性，可扩展性
计算机网络体系结构
- 开放系统互连参考模型 Open Systems Interconnection Reference Model (OSI/RM)
- 网络协议：语法 (payload) +语义+同步（顺序）
- entity 实体：可收发信息的软硬件
- 分层
  - 五层/七层 (ISO 7498)：物理，数据链路，网络，传输，应用（会话，表示，应用）
  - TCP/IP：网络接口，IP，TCP/UDP，应用
- Protocol Data Unit (PDU): (OSI) 对等层次之间传送的数据单位
- Service Access Point (SAP): 相邻两层的实体交互点
- 服务数据单元 SDU 层与层之间交换的数据的单位（与 PDU many2many）

物理层

物理层传输比特流

系统安全

Mon, 24 Nov 2025 21:00:00 +0800

系统安全概述

计算机系统组成：硬件，软件（内核，系统软件，应用）
- 系统安全：在系统生命周期内应用系统安全工程和系统安全管理方法，辨识系统中的隐患，并采取有效的控制措施使其危险性最小，从而使系统在规定的性能、时间和成本范围内达到最佳的安全程度
- 操作系统的安全是整个计算机系统安全的基础
系统的重要性
- 系统无处不在，系统日益广泛
- 2018 年 11 月 30 日，万豪国际集团数据库被黑客入侵
- 2024 年 12 月 17 日，Facebook 涉嫌泄露 2900 万用户个人数据，被爱尔兰数据保护委员会罚款
- 2021 年 Apache Log4j 中发现了一个被称为“Log4Shell”的零日漏洞（CVE-2021-44228）
- 系统安全是数字时代企业生存与发展的根基，是保障核心业务数据与连续性的生命线；一次系统漏洞可能导致毁灭性损失，安全防护是唯一的底线
系统安全问题存在的原因
- 技术层面：软件漏洞与缺陷 (0day)，系统复杂性，防御机制滞后
- 管理层面：安全策略缺失或执行不力，安全意识不足，第三方与供应链风险
- 人为层面：内部人员威胁，外部攻击者
- 外部环境：法律法规与合规挑战，网络攻击产业化
系统安全的错误认识
- 应对安全威胁的主要手段是密码技术，是添置边界防护等安全设备 —— 黑客成功实施攻击的途径是发现、挖掘和利用信息系统的漏洞
- 不值得在关注系统安全，降低糟糕的系统开发、集成和部署带来的风险上花费成本

概念

系统安全核心定义：系统安全是为保护系统（如信息系统、操作系统、网络系统）免受未经授权的访问、使用、披露、破坏、修改而采取的措施和流程的集合
基本属性：CIA
机密性（Confidentiality）
- 对谁保：仅被合法的实体（如用户、进程等）访问，而不被泄漏给未授权实体的特性
- 保什么：不但包括国家秘密，而且包括各种社会团体、企业组织的工作秘密及商业秘密，个人的秘密和个人隐私（如浏览习惯、购物习惯等）
- 机密性还包括保护数据的存在性，有时候存在性比数据本身更能暴露信息
- 对计算机的进程、中央处理器、存储、打印设备的使用也必须实施严格的保密措施，以避免产生电磁泄露等安全问题
- GB/T 16260.1：软件产品保护信息和数据的能力，以使未授权人员或系统不能阅读或修改这些信息和数据，而不拒绝授权人员或系统对它们的访问。
- GB/T 18492：对系统各项的保护，使其免于受到偶然的或恶意的访问、使用、更改、破坏及泄露。
- 实现机密性的方法一般是通过物理隔离，信息加密，或是访问控制（对信息划分密级并为用户分配访问权限，系统根据用户的身份权限控制对不同密级信息的访问）等
完整性（Integrity）
- 信息在存储、传输或处理等过程中不被未授权、未预期或无意地篡改、销毁等破坏的特性
- 系统完整性：系统能够按照预期的功能运行，不受任何有意的或者无意的非法错误所破坏的系统安全属性
- 实现完整性的方法一般分为预防和检测两种机制。预防机制通过阻止任何未经授权的方法来改写数据的企图，如加密、访问控制，以确保数据的完整性；检测机制并不试图阻止完整性的破坏，而是通过分析数据本身或是用户、系统的行为来发现数据的完整性是否遭受破坏，如**数字签名、哈希（Hash）**值计算等
可用性（Availability）
- 信息、信息系统资源和系统服务可被合法实体访问并按要求使用的特性
- ISO13335-1：可用性被定义为保证授权实体在需要时可以正常地访问和使用系统信息的属性
- 为了实现可用性可以采取备份与灾难恢复、应急响应、系统容侵等许多安全措施
其他属性：可认证性，授权，可审计性，抗抵赖性，可控性，可存活性

网络空间安全：还关注构成网络空间的基础设施的安全和可信，以及网络对现实社会安全的影响

维度	系统安全	网络空间安全
核心焦点	单个计算系统的保密性、完整性、可用性	整个互联数字领域的保密性、完整性、可用性
保护对象	独立的操作系统、应用程序、硬件、数据文件	网络、网络中的系统、传输和存储中的数据、云环境、物联网生态
范围	微观、内向（聚焦于系统自身）	宏观、外向（聚焦于互联互通的整体环境）
核心威胁	本地权限提升、软件漏洞、系统配置错误、恶意软件在本地的执行	网络攻击、网络钓鱼、DDoS 攻击、跨站脚本（XSS）、APT 攻击、通过网络入侵
主要手段	安装防病毒软件、系统加固、打补丁、访问控制、加密本地文件	部署防火墙、入侵检测/防御系统(IDS/IPS)、VPN、安全网关、网络监控、态势感知
专业角色	系统管理员、系统安全工程师	网络安全工程师、渗透测试员
类比	汽车安全：确保一辆车的刹车、引擎、车身结构可靠	道路交通安全：确保所有车辆、行人、道路标志、交通规则的整体安全
依赖关系	是网络空间安全的基础	是涵盖系统安全的宏观框架
目标	保证单个系统的可靠运行和数据安全	保障整个数字生态系统的稳定和安全

系统安全是基础，网络安全是屏障

系统面临的安全威胁
- 恶意软件攻击、网络攻击与入侵、人为因素与社会工程学、数据安全与内部威胁、系统与软件漏洞、物理安全与供应链威胁
- 恶意软件攻击：勒索软件 (Ransomware)，木马病毒 (Trojan)，蠕虫病毒 (Worm)，间谍软件 (Spyware)
- 网络攻击与入侵：分布式拒绝服务攻击 (DDoS)，中间人攻击 (MitM)，SQL 注入 (SQL Injection)，跨站脚本攻击 (XSS)
- 人为因素：网络钓鱼 (Phishing)，钓鱼 (Pretexting)，内部人员疏忽，权限滥用
- 数据安全与内部威胁：数据泄露，内部恶意人员，云数据配置错误
- 系统与软件漏洞：零日漏洞 (Zero-Day)，未及时打补丁 (Patching)，默认配置与弱口令；信息源：CNVD，Microsoft，暗网（嘉豪兄拜托了）
- 物理安全与供应链威胁：物理安全威胁，供应链攻击，物联网设备威胁
系统安全之路
- 系统安全开发的最佳实践是采用从系统开发之初就不允许漏洞发生的方式，在系统开发的各个环节尽可能消除漏洞，这不仅使得系统及其用户更安全，关键基础设施更具弹性，还将节省软件企业的开发成本。
- 100%安全的系统和软件是不存在的，系统和软件产品存在漏洞是当前信息安全领域而临的最大困境。
- 由于漏洞的产生、利用以及相互作用的机理复杂，因此，如何有效减少系统漏洞数量，提高信息系统整体安全性成为当前亟待解决的挑战性问题。
系统安全防护
- 将机密性、完整性、可用性、认证性、授权、可审计性作为系统安全的核心属性
- 系统自身的实现质量，即系统和软件产品包含的漏洞情况也应该是系统安全性的主要内容，因为这些漏洞会直接导致安全性问题，这也是传统的系统安全关注的问题
- 站在不同的管理者视角，抗抵赖性、可信性、可控性、可靠性、软件弹性等也成为系统被关注的其他安全属性
系统安全开发方法
- 抛弃了传统的先构建系统，然后再将安全手段应用于系统的构建模式
- 留了采用风险管理、身份认证、访问控制、数据加密保护、入侵检测等传统安全方法，将安全作为功能需求的必要组成部分，在系统开发的需求阶段就引入安全要素，同时对系统开发全过程的每一个阶段实施风险管理，以期减少每一个开发步骤中可能出现的安全问题，最终提高系统的本质安全性。
- 系统安全错误原因分析：
  - 分析系统安全错误发生的原因，将安全错误的修正嵌入到系统开发生命周期的整个阶段。通过对需求分析、设计、实现、测试、发布，以及运维等各阶段相关的系统安全错误的分析与控制，以期大大减少系统的漏洞数量，使系统的安全性得到有效提高。
  - 该方法是将安全保障的实施开始于系统发布之前，尤其强调从系统生命周期的早期阶段开始安全考虑，从而减少系统生命周期的后期系统运行过程中安全运维的工作量，提高安全保障效果。
- 系统安全工程
  - 运用系统工程的思想和方法，系统地分析信息系统存在的安全漏洞、风险、事件、损失、控制方法以及效果之间复杂的对应关系，对信息系统的安全性进行分析与评价，以期建立一个有效的安全防御体系，而不是简单的安全产品堆砌。
  - 系统安全工程可以在系统生命周期的不同阶段对安全问题提供指导
信息保障
- 系统安全的核心目标就是保障信息安全，包括对信息的保护、检测、反应和恢复能力。
- 信息保障与之前的信息保密、网络信息安全等阶段的概念相比，它的层次更高、涉及面更广、解决问题更多、提供的安全保障更全面，它通常是一个战略级的信息防护概念。
- 核心思想是纵深防护战略（Defense-in-Depth），它采用层次化的、多样性的安全措施来保障用户信息及信息系统的安全
- 人、技术和操作是 3 个核心因素，包括了主机、网络、系统边界和支撑性基础设施等多个网络环节之中，如何实现保护（Protection）、检测（Detection）、响应（Reaction）和恢复（Restore）有机结合的动态技术体系，这就是所谓的PDRR（或称 PDR2）模型。
- 信息安全保障围绕漏洞消除展开；要将安全保障措施置于系统发布运行之时
- 降低系统脆弱性的最有效方法就是漏洞分析，因此，漏洞分析是信息安全保障的基础，在信息安全保障中占据核心地位。

操作系统安全机制

安全威胁的种类
- 形成途径：不合理的授权机制，不恰当的代码执行，不恰当的主体控制，不安全的进程间通信，网络协议的安全漏洞，服务的不当配置
- 行为方式：切断，截取，篡改，伪造
- 漏洞分类：获取系统控制权，获取隐私信息，受到拒绝服务攻击
- 表现形式：
  - 逻辑炸弹：在被感染应用程序的起始处，不能复制自身
  - 计算机病毒：能自我复制的一组计算机指令或程序代码
    - 蠕虫：无须计算机使用者干预即可运行的独立程序
  - 特洛伊木马：表面上执行合法功能，实际上却完成用户不曾料到的非法功能，不具备自我复制能力
  - 后门：嵌在操作系统里的一段非法代码
  - 隐蔽信道：为系统中不受安全策略控制的、违反安全策略的信息泄露路径
    - 存储隐蔽信道：利用不受安全策略控制的存储单元
    - 时间隐蔽信道：利用不受安全策略控制的系统在当前时间段内某方面的状态
操作系统的安全需求：CIA+可靠性

操作系统的安全机制：访问控制，认证机制，加密机制，最小特权管理，安全审计机制，存储保护、运行保护和 I/O 保护

访问控制

系统对用户身份及其所属的预先定义的策略组限制其使用数据资源能力的手段
三要素：主体 S（发起者/进程），客体 O（资源），控制策略 A
对文件/目录的访问控制
自主访问控制 (DAC)
- 每个客体有一个所有者，可按照各自意愿将客体访问控制权限授予其他主体
- 强制访问控制 (MAC)：
  - 将系统中的信息分密级和范畴进行管理，保证每个用户只能访问那些被标明能够由他访问的信息；
  - 每个主客体都自动被赋予相应的安全属性；
  - 访问时比较进程的安全属性和客体的安全属性
- 基于角色的访问控制 (RBAC)：
  - 用户-角色-权限多对多
  - 安全原则：最小权限原则，责任分离原则，数据抽象原则

访问控制机制	优点	缺点
自主访问控制（DAC）	• 控制是自主的，为用户提供了很大的灵活性	• 权限管理比较分散 • 安全性差，不能抵御特洛伊木马的攻击 • 缺乏高安全等级所需的高安全性
强制访问控制（MAC）	• 保障了信息的机密性	• 忽视了信息的完整性 • 对授权管理比较僵硬，缺乏灵活性 • 应用领域狭窄，通常只应用于对安全性需求非常高的领域，如军方信息系统
基于角色的访问控制（RBAC）	• 便于授权管理 • 便于角色的划分 • 便于赋予最小权限的原则 • 便于职责的分离 • 便于客体分类	• 需要了解组织结构知识 • 导致角色爆炸 • 没有提供操作顺序的控制机制，这一缺陷使 RBAC 模型很难适应那些对操作顺序有严格要求的系统

认证机制
- 标识：操作系统能够通过内部识别码或标识符正确识别用户的身份，即用户向系统表明的身份
- 鉴别：对用户所宣称的身份标识的有效性进行校验和测试的过程，用户声明自己身份的几种方法包括
  - 证实自己所知道的：证实自己所知道的：密码、身份证号、最喜欢的人名字等
  - 出示自己所拥有的：智能卡、USBkey 等
  - 证明自己是谁：指纹、掌纹、声纹、视网膜、面部特征扫描等
  - 表现自己的动作：签名、按键的速度与力量、语速等
- 授权：确定给予哪些主体存取哪些客体的权限，并实施这些存取权限
加密机制
- 数据传输加密技术：链加密，端加密
- 数据存储加密技术：文件级，驱动器级
最小特权管理原则
- 为使系统能够正常运行，系统中的某些进程需要具有一些可违反系统安全策略的操作能力
- 最小特权原则：必不可少的特权（充分必要性）
- 在系统中定义：系统安全管理员、审计员、操作员、安全操作员、网络管理员
- 任何一个用户都不能获取足够的权利破坏系统的安全策略；不应赋予某人一个以上的职责
- 例：惠普 Presidum/Virtual Vault，红旗安全操作系统 RFSOS，SElinux
安全审计机制：对系统中有关安全的活动进行记录、检查及审核
- 作用：能详细记录与系统安全有关的行为；能够对违反安全规则的行为或企图提供证据；可以提供信息帮助进行损失评估和系统恢复
- 审计事件：是系统审计用户动作的基本单位，如注册事件、使用系统的事件、利用隐蔽通道的事件
- 实现：日志记录器，分析器，通告器
- 日志：系统日志，应用程序日志，安全日志
存储保护、运行保护和 I/O 保护
- 存储器管理和存储保护之间的关系：存储保护与存储器管理是紧密相关的，存储保护负责保证系统各个任务之间互不干扰；存储器管理则是为了更有效地利用存储空间
- 基于内存管理的访问控制：由系统软件精确地说明对该进程而言: 系统空间的哪一页是可读的，哪一页是可写的
- 安全操作系统很重要的一点是进行分层设计，而运行域正是这样一种基于保护环的等级式结构
- I/O 操作一般是仅由操作系统完成的一个特权操作；操作系统对 I/O 操作进行封装，提供对应的系统调用

Microsoft Windows 安全

Windows NT
- 第一个真正意义上的网络操作系统
- 特点：支持多种网络协议，内置 Internet 功能，支持 NTFS 文件系统
架构：Windows 系统由内核、系统服务、用户界面等组件构成，提供多任务、多线程处理能力。
- 用户模式：用户进程，服务进程，系统支持进程，环境子系统服务进程
- 内核模式：执行体（包含操作系统的基础服务），Windows 内核，设备驱动程序；硬件抽象层，窗口和图形系统
- 虚拟机监控程序层
Windows 系统安全组件 (Also see Access Control Model | Microsoft Learn)
- Windows 系统内置支持用户认证、访问控制、管理、审计、管理等安全功能
- 标识 (SAM)
  - 安全账户管理器 SAM：负责管理本机定义的用户名和组等信息
  - SAM 数据库：HKEY_LOCAL_MACHINE\SAM / %systemroot%\system32\config\sam
  - 在系统启动后就处于锁定状态，用户无法擅自更改其内容；只由 LSASS 控制
- 鉴别授权/审计 (LSA)
  - 交互式登录管理器 Winlogon / 登录用户界面 LogonUI
  - 凭据提供程序 CP：在 LogonUI 进程中运行的进程内 COM（Component Object Model）对象，用于获取用户的用户名、密码、智能卡 PIN 码、生物验证数据（如指纹、面部识别数据）等
  - 身份验证包 AP：检查特定用户名与密码是否匹配，进而对用户进行身份验证
  - 本地安全机构子系统服务 LSASS：负责本地系统安全策略，负责用户身份验证。负责将安全审核信息发送给事件日志
  - LSASS 数据库 HKLM\SECURITY
  - 内核安全设备驱动程序 KSecDD；实现了高级本地过程调用接口，其它内核模式安全组件，包括加密文件系统，可以用来在用户模式下与 LSASS 通信
- 访问控制 (SRM)
  - 安全引用监视器 SRM：定义代表安全上下文的访问令牌数据结构
  - APPLocker：该机制供管理员决定用户和组允许使用哪些可执行文件、DLL 和脚本
  - APPContainer：提供一个限制性的进程执行环境
Windows 系统安全模型
- 访问令牌 Access Token：包含有关已登录用户的信息
  - 代表此用户执行的每一个进程都将具有此访问令牌的副本
  - 包含安全标识符，用于标识用户的帐户以及该用户所属的任何组帐户；包含用户或用户组拥有的权限列表
  - 产生过程：凭据认证，创建当前登录会话，LSA 创建 token；依据 token 创建进程、线程
- 安全描述符 Security Descriptor
  - 与被访问对象相关联，包含与安全对象关联的安全信息
  - 安全对象：是可以具有安全描述符的对象，如文件、管道、进程、注册表等
  - 组成：
    - 对象所有者的 SID，属组 SID
    - DACL (Discretionary Access Control List)：描述允许或拒绝特定用户或组的某些访问权限，它包含零个或多个ACE
      - 访问控制项 ACE：SID，访问掩码 (rwx…)，allow/deny，继承
    - SACL（System Access Control List）：主要是用于系统审计，指定了当特定账户对这个对象执行特定操作时，将其记录到系统日志中
Windows 系统安全管理
- 加强 Windows 用户账户认证：密码策略，账户锁定策略
- 进行 Windows 系统备份
- 使用 Windows BitLocker 进行驱动器加密
- 开启 Windows Defender 防火墙

Linux 操作系统安全

Linux 系统概述
- 类 Unix 操作系统，GPL 许可证
- 特点：免费，兼容 POSIX 1.0，多用户多任务，良好的界面，丰富的网络功能，可靠的安全，稳定性能，支持多种平台
- Unix 操作系统：由美国 Bell 实验室开发的一种多任务通用操作系统
Linux 用户管理
- 相关文件：/etc/{passwd,group,shadow}
- 用户类型：超级用户 (uid0) 和普通用户
- 特权：进程控制，设备控制，网络控制，文件系统控制，用户控制
- /etc/passwd：共 7 个字段
  - 帐号名称，密码（x 占位）
  - UID: 0 root, 1-499 sys, 500+ user
  - GID, description, home, shell
- /etc/shadow: 8+ 字段
  - name, passwd, last update, min pwd age, max pwd age, pwd warn period, pwd inactivity period, expire, reserved (ref)
  - password: $id$salt$hashed
- 设置密码复杂度：edit /etc/security/pwquality.conf or authconfig --passminlen=12 --passminclass=4 --passmaxrepeat=2 --update
- 特权管理：/etc/pam.d/su，/etc/sudoers
Linux 系统访问控制
- 文件系统挂载：mount [选项] 设备名挂载点, umount 设备路径|挂载点
- procfs 虚拟文件系统（/proc/{cpuinfo,stat}）
- ls flags：
  - 类型：d,-,l,b,c,…
  - 3x(rwx)
- ls, chown, chgrp, chmod
- open: DAC 检查 (rwx, cap) - MAC 检查 (selinux, AppArmor)

移动操作系统安全

本章三个操作系统：鸿蒙，安卓，Darwin

数据库笔记

Wed, 19 Nov 2025 21:00:00 +0800

本笔记中 key 翻译为 ”码“，熟悉”键“说法的同志可以自行转译

教材：数据库系统概论（第六版）王珊
CMU15445

系统概论

数据 - 数据库 - 数据库管理系统 - 数据库系统
概念：
- 实体 Entity
- 属性 Attribute
- 码 Key
- 域 Domain
- 实体类型 Entity Type
- 实体集 Entity Set
- 联系 Relationship
ER 图
- Entity: 矩形
- Attribute: 椭圆
- Join/Relationship: 菱形，标注类型 (1:1, 1:n, m:n)；联系也有属性
- Edge: 直线（无向！）
- 三关联：仅“两两之间存在联系”且描述用一句话完成
数据模型
- 组成
  - 数据结构：联系的意义；常用于命名数据模型（层次，关系）
  - 数据操作：CURD，and more…
  - 完整性约束
- 层次模型：树状
  - 特点：parent 唯一，仅一对多，需要完整路径，约束需要 parent 存在 (on delete cascade)
- 网状：层次的扩展
- 关系模型：
  - Relation, Tuple (Row), Attribute (Column)
  - 关系：元组的集合
  - Key, Domain, Component,
  - 数据结构
    - 实体：用关系表示
    - 一对一/一对多：隐含在 Attribute
    - 多对多：新关系
  - 完整性：实体完整，参照完整，属性完整，用户定义的完整性
数据库系统模式

密码学笔记

Fri, 14 Nov 2025 00:00:00 +0800

misc

密码：
- （密码法）采用特定变换的方法对信息等进行加密保护、安全认证的技术、产品和服务
- 是研究密码技术（Cryptography）和密码分析（Cryptanalysis）的技术科学
- 密码体制是满足条件的五元组 $\mathcal{P,C,K,E,D}$
Kerckhoffs原则：密码体制的安全性仅依赖于密钥，其他一切（包括算法本身）都是公开的。
香农的保密系统理论
- 无条件安全：m 明文，c 密文，有 $I(m;c)=0$, $H(m|c,k)=0$, $H(c|k=k_0)=H(m)$ （第三条仅对于一一映射代换成立）
- 计算安全：各种攻击方法的复杂度均超出了分析者的计算资源可达到的合理边界
攻击模型：唯密文攻击，选择明文，已知明文，选择密文
法律法规：电子签名法 (2004)，网络安全法 (2016)，密码法 (2019)，数据安全法 (2021)，个人信息保护法 (2021)

古典密码

古典代换
- Caesar cipher: +3
- Vigenere: 多单字母P
- 密码机
- 中国古代反切码：诗为密钥，声母-韵母-声调
古典置换
- Scytale：棍子
- 平面轨迹
  - 轨道栅栏 Rail Fence
  - 几何图形
- 行变换：
  - 以密钥（循环）给出的顺序按行读出密文
  - 英文密钥：按字母大小顺序
  - 密码分析：猜测密钥周期, 再对可能的行列变换进行猜测
- 中国古代：藏头诗

序列密码

冷战时期受政治影响大，大部分研究保密
原理：密钥流 xor 明文
结构：
- 同步流密码：独立于明文，但不可抗缺码
- 自同步：密钥唯一，$g_n$ 仅依赖于上 n 个 c； $c_{i-k..i-1} \to g_n \to m_i \to c_i$
LFSR:
- $f=\sum^\oplus c_ia_i$ 作为下一个 $a_{n}$，联接多项式为 $1 + \sum_1^n c_{n+1-i}x^i$
- 左 an c1 右 a1 cn；左进右出
- 最长：
  - m序列：$n$ 级 LFSR 产生周期为 $2^n-1$ 的序列
  - 条件：联接多项式不可约（必要）；$F_2$ 上本原多项式（充要）；$2^n-1$ 素且不可约（充分）
  - 随机性：
    - $0,1$ 分别出现 $2^{n-1}-1, 2^{n-1}$ 次
    - 长 $k$ 游程有 $2^{n-2-k}\ (1\le k\le n-2)$ , 长 $n-1$: 0, 长 $n$: 1
    - $C(\tau)=-1$
- 对 $n$ 级，$2n$ 明密文对可破解，计算量 $n^3$ （矩阵逆）
Golomb 随机假设：
- 周期内 0,1 个数相等
- 长 i 游程（bit 连续相同）占 $2^{-i}$
- （注意到 $\sum_1^{\infty}k\cdot 2^{-k}=2$ 游程总数应接近周期一半，考虑 0,1 概率相等，应有长 $k$ 的0/1游程个数为 $\frac{T}{2}\cdot 2^{-i}/2 = T\cdot 2^{-i-2}$）
- $C(\tau)=\sum_i^n (-1)^{a_i+a_{i+\tau}}=常数$ $(\tau \ne 0 \mod n)$ （对于不同 $\tau$ 有 $(a_i,a_{i+\tau})$ 分布相同）
线性复杂度：能够生成该序列的最短 LFSR 的长度；决定了破译复杂度
好密码：周期长，随机性好，线性复杂度大（周期一半）
生成器：
- 滤波：由 LFSR 单输出非线性滤波
- 组合：多个 LFSR 加非线性组合
- 钟控/停走：LFSR 控钟+LFSR 被控
其他生成器：
- 勒让德序列：$p$ 为奇素数，$a_i=(\exists x\in \mathbb{N}\ s.t.\ x^2\equiv i \mod p)$
- 椭圆曲线（TODO）
实用流密码：
- 钟控+停走 (A5)
- RC4：
  - 初始化：(sbox, key) -> sbox 赋值 0-255 + 利用 key 随机打乱 (j+=s[i]+k[i])
  - 加密：每 byte 同步打乱 sbox 生成密钥流 j += s[i]

分组密码

设计原理：充分利用简单轮函数和非线性变换进行若干轮迭代
- 乘积组合：多种简单运算组合，包括置换、替换，e.g. 异或、线性变换、模乘
- 混淆：密文统计特征与密钥关系复杂化
- 扩散：明文/密钥任何一位都影响密文多位；雪崩/完备特性
Feistel 结构：(↙方向传递)
- $L_i, R_i = R_{i-1}, L_{i-1}\oplus f(R_{i-1}, k_i)$
- $L_{i-1}, R_{i-1} = R_{i}\oplus f(L_i, k_i), L_i$
DES 64b block, 56b key
- 初始置换/逆置换 $P_I$；64->64；output[i]=input[PI[i]]
- 轮函数（16）：
  - 扩展 E；32->48；output[i]=input[E[i]]
  - 异或 k_i；48->48
  - S盒；6x8->4x8；output_k[i]=S_k[input_k[1,6],input_k[2-5]]
  - P 盒；32->32；output[i]=input[P[i]]
- 子密钥
  - 长为 64 但每 7bit 有奇偶校验位（和为奇）
  - 置换 PC-1；64->56；output[i]=input[PC1[i]]
  - 每轮前 LS；28x2->28x2；output_k[i] = rol(input_k[i], LS[k])
  - 每轮密钥通过置换 PC-2 产生；56->48；output[i] = input[PC2[i]]
- 弱性质
  - 互补：$\bar c = \text{DES}_{\bar k}(\bar m)$
  - 弱密钥 DES(DES(m))=m：01, 1F 以及补
IDEA 64b block, 128b key
- 基本运算：异或 $\oplus$，模 $2^{16}$ 加 $\boxplus$，模 $2^{16}+1$ 乘 $\odot$
- MA 单元 (32, 16, 16)->32
```
def ma(a1, a2, k1, k2): # all uint16, override with mod plus / mul
	s = a1 * k1
	t = (s + a2) * k2
	return s + t, t
```
- 轮函数（8.5）
  - 初始运算 output[i]=[mmul,mplus,mplus,mmul][i](input[i], k[i])
  - MA t1, t2 = ma(input[1]^input[3],input[2]^input[4], k5, k6)
  - output[1,3] ^= t2, output[2,4] ^= t1
  - swap(output[2],output[3])
- 输出变换即轮函数的初始变换
- 密钥生成：一次生成 8 个 (16x8)，不够 rol25 再生成；不与轮同步 8x6+4
- 解密密钥：解密循环 I 的头4个子密钥从加密循环 10－I 的头4个子密钥中导出；解密密钥第1、4个子密钥对应于1、4加密子密钥的乘法逆元；2、3对应2、3的加法逆元（TODO）
- 注：和 Feistel 一样构造了使用非可逆变换（ma），但有可轮间传递数据的结构（使用异或 ma 结果使 output[1]xor output[3]=input[1] xor input[3] 抵消了 ma）；密钥生成有些简陋了。
AES / Rijindael: 128bit block, 128-256bit key (10,12,14 cycles)
- State: 8bit 为字，4 行，4 列, 128bit
- 子密钥生成：
  - 轮密钥不与轮同步，由密钥扩展随取随用
  - 10/12/14 轮
- 轮函数列长为 r
  - 字节替换/S 盒； 4rx8 -> 4rx8
  - 行移位；4xrx8 -> 4xrx8；rol i (by byte)
  - 列混合；每列视为多项式 $\sum_0^{r-1} a_i x^{r-i-1}$，做 $x^4+1$ 模乘
    - 可视为系数 ror 的矩阵乘（$GF(2^8)$ 上，模 0x1B；可查表 (02, 03, 0e, 0b, 0d, 09 共 6*256 空间 / embed 算 *2 然后霍纳法则)，可逆；
  - 轮密钥加
工作模式：
- ECB：逐块
- CBC：有 IV，$C_{i+1}=f(M_{i+1}\oplus C_i)$；错误传播本块+后一块对应 bit
- CFB-n：有 IV，$C_i=M_i\oplus f(IV_{i-1}[:n])$, $IV_i=IV_{i-1}«n | C_i$；寄存器长度与算法一致；错误传播 L/n 块，错误的那块只改对应 bit
- OFB-n：同 CFB 但把加密算法输出直接反馈；错误仅影响对应 bit
- CTR：可并行，$C_i=M_i\oplus f(IV+i)$
- GCM：CTR + GHASH；先 CTR 完，用 K 派生的 H，预定文本 A，密文 C 计算 GHASH $X_{m+n+1}$ where $X_{i}=(X_{i-1}+ S_i)\cdot H$ （$GF(2^{128})$ 内运算，mod 0x87），$S$ 为 $(A||pad||C||pad||len(A)||len(C))$
算法分析
- 强力攻击（分类：唯密文，已知明文，选择明/密文，自适应选择明/密文）
- 差分攻击：依赖 S 盒的差分熵低（概率分布不平均），寻找概率最高/0路径

公钥密码

对称缺陷：密钥管理分配麻烦，认证（抗抵赖）
分类：
- 公钥分发 Public-Key Distribution Schemes
- 公钥加密 Public Key Encryption
- 数字签名 Signature Schemes
特点：
- 加密公开，解密保密
- 公钥+密文 -x> 明文（=> 公钥 -x>私钥）
- 攻击：强力，选择消息，私钥破解
陷门单向函数
- $f$ 容易 $f^{-1}$ 难
- （最重要！）$F_p$ 上离散对数问题 $y=x^b$
- （非循环交换群）离散对数问题 $y=x^b$ （认为等价于大素数乘积分解）
- （非循环交换群）二次剩余问题 $y=x^2$
Diffie-Hellman 密钥交换
- 单向性：$F_p^*$ 上离散对数
- 生成元 $g$，生成随机 $x_A, x_B$, 交换 $y_A=g^{x_A}, y_B=g^{x_B}$，则共享密钥为 $y_A^{x_B}=y_B^{x_A}$
El Gamal 公钥密码
- 单向性：$F_p^*$ 上离散对数
- 密钥生成：大素数 $p$，$g$ 是 $F_p^*$ 生成元，任意 $x<p-1$ 为私钥，$g, y=g^x\mod p$ 为公钥
- 明文空间 $F_p^*$，密文空间 $F_p^*\times F_p^*$
- 加密：任取 $k$（保密），$c=(g^k, my^k) \mod (p,p)$
- 解密：$m=c_2c_1^{-x}$
  - 算法：由费马小定理，$c^{-x}=c^{-x \mod p-1}$ / 扩展欧几里得算法
- 签名：
  - 选 $k\text{ s.t. } GCD(k,p-1)=1$
  - $K=a^k$, $S=k^{-1}(h-xK)\pmod{p-1}$，$(K,S)$ 为 $h$ 签名
  - 验签：$y^{K}K^{S}\equiv a^h \pmod{p}$
  - 注：$k$ 的选择并非任意，这很重要！因此才有了 DSA 改进
DSA 签名算法
- 密钥生成：N bit $p$, L bit $q$ 使得 $q|p-1$；$g=h^{\frac{p-1}{q}}\pmod{p}$；选择私钥 $x<q$ 计算公钥 $y=g^x\pmod{p}$
  - 注：ECDSA 没有这么多要求，随便选 g,p,q；主要是 $\mathbb{Z}^*_p$ 的阶是 $p-1$ 为和数，就很难受
- 签名：
  - 选 $k<q$
  - 签名：$K=(g^k\text{ mod }p) \pmod{q}$，$S=k^{-1}(h+xK)\pmod{q}$
  - 验签：$K$ 等于 $((y^{K}g^{h})^{S^{-1}}\text{ mod }p) \pmod{q}$ （注：指数上可以 $\text{mod }q$ 优化）
  - 注：这里的 K 由于 mod q 了，从 $\langle g\rangle$ 群降维到了 $F_q$，之后不涉及 $\langle g\rangle$ 相关性质。
Rivest-Shamir-Adleman 公钥密码
- 单向性：风味离散对数
- 密钥生成：生成大质数x2: $pq=n$，生成随机数 $e\le\phi(n)$ 计算 $d=e^{-1} \mod \phi(n)$；则 $(e,n), (d,p,q)$ 为公钥、私钥
- 加解密：$c=m^e, m=c^d \mod n$
- 签名：$S=h^d, S’=S^e$
- 工程上：
  - 私钥文件会存储所有参数
  - $e=65535$
- 中国剩余定理优化解密
  - 原解密计算复杂度：$\log{d}$ 次乘法，每次乘法 $\log^2 n$ FLOP （忽略加法）；共 $\log d\log^2n$ FLOP
  - 由费马小定理 $c^{p-1}=1 (\text{mod}\ p)$，$c^d=c^{d\mod (p-1)} \mod p=m_p$；由此可在 $\log p \times \log^2 p$ FLOP 计算 $m_p$；$m_q$ 同理；共 $2\log^3p$ FLOP
  - 此时 $m=m_p\mod p = m_q \mod q$；由中国剩余定理，令 $t_p=(q^{-1}\mod p)$, $t_q=(p^{-1}\mod q)$（都可以提前计算），有 $m=m_pq^{-1}_p q + m_q p^{-1}_q p \mod n$；计算量可忽略
  - 可见考虑 $d\sim n\sim p^2$ 的情况下，能快 4 倍左右；代价是要知道完整的 $p,q,p^{-1}_q, q^{-1}_p$
- 攻击：共模攻击，弱指数攻击
- EC 可用性：$pq$ 阶 $\langle G\rangle$ 不够安全且难以找到符合条件参数
SM2
- 单向性：离散对数
- 密钥生成：大素数 $p$，$g$ 是生成元，任意 $k<p-1$ 为私钥，$q=kg$ 为公钥（同 ElGamal）
- 加解密：
  - DH：加密者任意生成 $r$，则 $rq$ 为共享密钥 $S$，且只需传输 $rg$
  - KDF：通过 $S$、消息长度派生出密钥
  - Hash：SM3 $(S_x||M||S_y)$ 得哈希，拼接在最后
  - 加密：M 通过 xor 派生密钥加密
  - 解密：xor 得 M 后验签
  - 密文数据：$(rg || C || Hash)$
- 注：SM2 启示我们，只要有好的密钥交换算法、密钥派生和对称加密就可以实现公钥加密：可以把预生成 a,A 中 A 公开，这样对方只要随机生成 b B, 用 KDF(A,b) 加密，把 B 绑到密文中，A 可以用 KDF(a,B) 解密。但签名就不行了，因为是单向的。
Rabin
- 单向性：二次剩余问题
- 密钥生成：$p\equiv q \equiv 3\mod 4$，$n=pq$ 为公钥，$p,q$ 为私钥
- 加解密：$c = m^2 \mod n$, $m=$ $\pm(c^{\frac{p+1}{4}} \mod p)q q^{-1}_{p}$ $\pm (c^{\frac{q+1}{4}} \mod q) p p^{-1}_{q} \mod n$；
  - 注：有四种可能明文，需要可识别
  - 又是中国剩余定理
  - 是 $e=2$, 不满足 $\exists d, de\equiv 1 \mod \phi(n)$ 的 RSA。
- 选择密文攻击不安全
Elliptic Curve (over Finite Fields) (ref)
- 是一系列 $F_p\times F_p$ 子集上的质阶交换群（因此适用离散对数问题对应算法）
- 通常选用曲线 $y^2=x^3+ax+b, 4a^3+27b^2\ne 0\mod p$；参数包括 $p, a, b, G$；以及导出参数 $n=|\langle G\rangle|, h=\frac{\# E(F_p)}{n}$
- 质数阶循环群二次剩余问题有 $O(\log^2 p)$ 快速算法，可以由 $x$ 推算出 $y$。
- 任意选择参数和基点 $G$，使满足：$\#E(F_p)$ 是一个素数或近乎素数，$|G|$ 是大素数（最好等于 $\# E(F_p)$，最好 $h=1$；由此构成的 $\langle G\rangle$ 作为群集合；当 $h=1$ 时有 $\# E(F_p)=\langle G\rangle \cong Z_{n}$。
- 法则（全部 $\text{mod}\ p$）
  - 单位元/无穷远点 $\mathcal{O}$
  - 逆元 $-P = (x_1, -y_1)$
  - 加法 $\lambda = \begin{cases}\frac{y_2 - y_1}{x_2 - x_1} & \text{if } P \neq Q \\ \frac{3x_1^2 + a}{2y_1} & \text{if } P = Q\end{cases}$，$\begin{pmatrix} x_3 \\ y_3 \end{pmatrix} = \begin{pmatrix} \lambda^2 - x_1 - x_2 \\ \lambda(x_1 - x_3) - y_1 \end{pmatrix}$
- Elliptic Curve Cryptography：
  - EC+El Gamal：课上讲了，但工程上没人用
  - 签名 ECDSA；密钥交换 ECDH(E)…
  - ECMQV （TODO）
其他：
- $GF(2^n)$ 上的，NTRU…
- McEliece 公钥密码：线性译码问题（TODO）
- 背包问题（TODO）
攻击：
- 共模攻击
- …

认证和哈希

目的：身份确认，防篡改重放延迟（完整性）
安全要求
- 单向性/抗原像：无法计算 $y$，$H(y)=h$
- 弱抗碰撞性/第二抗原像：无法计算找到 $y$， $H(y) =H(x)$
- 强抗碰撞：无法计算找到任何 $x,y$，$H(x)=H(y)$
认证方法：加密/MAC/哈希
- MAC 需要 sk 可以认证消息合法；hash 搭配非对称加密可以提供不可否认性（签名）
- MAC：基于哈希，基于分组密码，加密认证模式
  - HMAC：$Hash((K\oplus opad)$ || $Hash(K\oplus ipad)||M)$
  - DES Based: CBC 模式最后输出
两种结构
- Merkle–Damgård construction: $CV_{i}=f(M_i, CV_{i-1})$
- 海绵结构：位宽(b)大于比特率(r)，$CV_i=f(CV_{i-1}\oplus M_i)$ 吸收，挤压 $CV_i=f(CV_{i-1})$ 每次 r bit 直到预定长度；安全性等于容量 c/2 (c+r=b)
MD5：
- 512bit 分组，128bit state；4 轮 x 16 步
- 结构：
  - pad and length: 填充一个 1 和若干 0 到 -64 mod 512 再填 64bit LE 长度
  - $IV$ 用LE常数
  - $F$ 为 HMD5(M,CV)+CV
- HMD5 (see rfc1321)
  - M(k,i)=M[[k, 1+5k,5+3k, 7k][i]&0xf] （考虑 M 为 32 bitx16，注意这里 i, k 从 0开始，不同于书）
  - T(k,i)=2^32 abs(sin(16i+k+1)) （打表64）
  - g_i=[xy|!xz, xz|y!z, x^y^z, y^(x|!z)][i]
  - for i in 0..4, for k in 0..16:
    - A = (A + gi(B,C,D)+M(k,i)+T(k,i)) << s(k,i) + B
    - A,B,C,D = D,A,B,C
SHA1：
- 512bit 分组，160bit state；4 轮 x 20 步
- 结构：同 MD5
- HSHA：
  - M(k,i)=M[[k, 1+5k,5+3k, 7k][i]&0xf] （考虑 M 为 32 bitx16，注意这里 i, k 从 0开始，不同于书）
  - M(j)= j<16 ? M[j] : rol(M(j-16)^M(j-14)^M(j-8)^M(j-3), 1)
  - g_i=[xy|!xz, x^y^z, xy|yz|xz, x^y^z][i]
  - for i in 0..4, for k in 0..20:
    - E = E + g_i(B,C,D)+rol(A,5)+M(20*i+16)+T(i)
    - A,B,C,D,E = E, A, rol(B, 30), C, D
- SHA2 / SM3：都是 MD5 改版（TODO）
```
algorithm  SHA-1  SHA2-256  SHA2-384  SHA2-512 SM3
digest     160    256       384       512      256
maxm(2^?)  64     64        128       128      64
block      512    512       1024      1024     512
word       32     32        64        64       32
steps      80     64        80        80       64
security   80     128       192       256      128
```

SHA3：

结构：
- 填充 10*1 （正则表达式）
- f 是S盒

实例 (b=1600)

name  S224  S256  S384  S512  SHAKE128  SHAKE256
d     224   256   384   512   /         /
r     1152  1052  832   576   1344      1088
c     448   512   768   1024  256       512

Keccak-f[1600]
- 24轮迭代，每轮 5 步 ι ◦ χ ◦ π ◦ ρ ◦ θ

后量子密码

量子算法
- Shor 算法离散在多项式时间对数问题/大质因数分解问题：现有公钥算法不能用了
- Grover 算法能把所有 $O(2^n)$ 遍历比较问题加速到 $O(2^{n/2})$：对称加密/哈希算法长度加倍
后量子密码
- 可以抵御已知量子计算攻击的公钥密码
格 (lattice) 密码
- 可以密钥交换、签名、加密
- 运算空间：$n$ 维线性空间
- 难题：SVP 最短向量问题，给定基，找出格中的最短非零向量；变体：
  - ASVP 近似最短向量问题
  - SIVP 最短线性无关向量问题
  - uSVP 唯一最短向量问题
  - CVP 最近向量问题
- 实用算法：NTRU （TODO）
基于编解码的密码（TODO）
- GPT 公钥加密：基于线性最大秩距离码
- McElice 公钥密码：基于 Goppa 纠错码
基于二次多变量多项式
- 公开 $L_2\circ F \circ L_1$ 用于加密，私钥是可逆的 $L_1,L_2$ 和$F$ （TODO）
基于哈希和对称性：（TODO）
- 可以签名
- 通过哈系树构造；安全性基于抗碰撞性
- Merkle 哈希树…
基于安全多方计算：可以签名（TODO）

考点

题型：
- 填空题：非常简单，送分题！
- 选择题：也非常简单！两分钟做完！
- 问答题/简答题
古典密码：代换置换
对称密码
- 现代分组：雪崩/混淆 (S)，完备/扩散 (P)
  - 乘积密码：SPN
  - Feistel 结构
  - 参数选择，安全效率兼顾——密钥长度，分组长度，迭代轮数，密钥编排，F 复杂度
  - IDEA, DES, 重点：AES 参数 (10-12-14)
  - 加密模式 EBC CBC OFB CFB CTR; 错误传播，仅加密/也要解密
- 序列：
  - 安全性好的密钥流：周期，伪随机性（Golomb：01 等量，游程指数下降，自相关函数恒定），线性复杂度高
  - LFSR 原理，周期 ($2^n-1$)；提高线性复杂度（滤波，钟控/走停）
  - 知道有 RC4
公钥
- 数学困难问题：大整数分解，二次剩余，离散对数，椭圆曲线
- 算法：RSA Rabin ElGamal ECDH；安全性（什么时候不安全）、正确性分析
  - RSA: 安全性基于计算 ø(N) 的困难性
    - 共模攻击：同消息、不同 e、同模计算的密文可 (Euclidean) 解出明文（用 $re_1+se_2=1\pmod{n}$ 绕开 $d$）
    - 低加密指数广播攻击：同消息，同小 e，e 个不同互素 n，可由三密文+CRT+开 e 次方解明文
    - 低加密指数暴力攻击：算 $\sqrt[e]{c+kN}$ 直到为整
  - Rabin: 安全性基于（非素模）二次剩余问题 / n 因数分解；
    - 选择密文攻击 1/2 概率直接解私钥
  - El Gamal: 安全性基于离散对数
  - DSA: 共享 k 两条消息直接解私钥
- ECDH 的主动攻击（mimt）
- RSA 的中国剩余定理优化
哈希函数
- 认证的需求、目的：身份确认，防篡改重放延迟
- 设计不同场景要怎么设计实现；场景设计
- 安全要求：抗原像，强弱碰撞
- 两大类：MD（要掌握），海绵
- 算法分组长度、输出长度、迭代轮数

信号与系统系统速成

Sat, 14 Jun 2025 22:00:59 +0800

奇怪事项

对周期信号不要强行傅里叶变换，要利用一般周期信号性质
积分时注意处理奇点（最好通过性质绕开）；1 的傅里叶变换是 $2\pi\delta(\omega)$
对偶 $\frac 1 {2\pi}$
区分全三角函数和因果三角函数
“稳态”关键词
不重要
- $\delta$ 积分注意限

信号与系统基础

信号：传递信息的函数有输入 $x(t)$ 输出 $y(t)$
系统：实现规定功能而构成的相互关联的集合体
求解系统
- 时域：卷积 / 微分方程 | 卷积和 / 差分方程
- 变换域：傅里叶/拉普拉斯 | 离散傅里叶/Z变换
信号分类：确定性，周期，功率/能量有限，连续/离散时间
系统分类：记忆，因果，稳定（求和），时不变（尺度变换，分段），（增量）线性
- 时不变：$y(t)=f(x(g(t)))$ 有 $f(x(g(t-t_0)))=f(x(g(t)-t_0))$；充分条件：$g(t-t_0)=g(t)-t_0$
脉冲/模拟/数字/离散
信号
- $Sa(t)=\frac{\sin t}{t}$, $\text{sinc}(t)=\frac{\sin \pi t}{\pi t}$, 积分 $\frac\pi\omega$
- $u(t)$, $\delta(at)=\frac{1}{|a|}\delta(t)$
- 离散三角：$\omega=\frac{2\pi}{n}$；$n$ 有理则周期
处理
- 变换：平移，尺度
- 插补
- 分解：直/交流，奇偶，脉冲，正交函数
系统描述
- 系统图：加法器，乘法器，数乘，积分，微分，延时
LTI 中零输入=齐次解，零状态=特解

线性时不变系统

离散：
- 信号：冲激分解
- 系统：冲激响应；卷积和
- 卷积和运算：图解法（反折，重叠） / 解析法（都可以分类讨论）
- 单位冲激响应 $h[t]$
卷积
- 卷积分段点：两个函数零点的和
- 单边函数积分限
- 宽度是原波形和
- 线性
- 时移/微积分：对任何一个 = 对卷积（带 $u(t-t_0)$ 可巧算！）
- 尺度 $f_1(at)\star f_2(at) = \frac1{|a|} f(at)$
- $f \ast \delta = f$, $f \ast \delta’ = f’$；大多数卷积用拉氏变换就好
差分方程/微分方程
- 零输入/零状态响应：起始条件 $0^-$；初始条件 $0^+$
- 自由/强迫响应
- $\sum_0^n C_i \frac{\text{d}^{i}r(t)}{\text{d}t^{i}}=\sum_0^m C_i \frac{\text{d}^{i}\delta(t)}{\text{d}t^{i}}$
  - $n>m$: $h(t)=(\sum_0^n A_ie^{\lambda_i t})u(t)$
  - $n\le m$: $h(t)=(\sum_0^n A_ie^{\lambda_i t})u(t)+\sum_1^{m-n}B_i \delta^{(i)}(t)$
- 差分方程
  - $j^n+(-j)^n \sim cos(\frac{n\pi}{2})$
  - 齐次解：$y_\lambda = (\sum_0^{m-1}C_in^i) \lambda^n$，$\lambda$ 为 $m$ 重根
  - 特解：
    - $n^k \sim n^m\sum_0^k D_in^i$，有 $m$ 重 $1$ 特征根
    - $a^n \sim(\sum_0^m D_in^i)a^n$，$a$ 为 $m$ 重特征根
    - $\sin(\beta n) \sim D_1\sin(\beta n)+D_2\cos(\beta n)$

傅里叶分析

傅里叶 (Fourier) 级数
- 正交：无限积分为 $0$
- 正余弦形式 ($n>0$)：$a_n=\frac 2{T}\int_0^T x(t)\cos(n\omega_0 t)\text{d}t, b_n=\frac 2{T}\int_0^T x(t)\sin(n\omega_0 t)\text{d}t$
- 指数形式 ($n\in\mathbb{Z}$)：$\dot a_n = \frac1T \int_0^T x(t)e^{-jn\omega_0t}\text{d}t$
- 转换：$a_n=2Re(\dot a_n), b_n=-2Im(\dot a_n)$ （实信号）
- 含义
  - $|\dot a_n|^2$: n 次谐波的功率（负的也要考虑，通常双倍）
  - $\bar P = \frac1T\int |x(t)|^2\text{d}t$: 平均功率
  - $\sqrt{\bar P}$: 信号有效值
  - Parseval’s Relation: $\bar P = \sum_{-\infty}^{\infty} |a_k|^2$ （证明：只展开一个傅里叶系数；后同理）
- tips
  - $\sum_{-\infty}^{\infty}\delta(t-kT)$: $a_n=\frac1T$
  - $\sum_{-\infty}^{\infty}u(t-kT-\frac\tau2)-u(t-kT+\frac\tau2)$: $a_n=\frac{\tau}{T} Sa(n\omega_1 \frac\tau2)$
  - 单段函数：直接积分
- 收敛：平方可积/绝对可积且有限区间有有限间断点（Dirichlet 条件）
- 性质
  - 线性
  - $x(t-t_0)\sim e^{-jk\omega_0t_0}a_k$
  - $x(-t)\sim a_{-k}=a_k^\ast$
  - $e^{jM\omega_0 t}x(t) \sim a_{k-M}$
- From 拉普拉斯变换/傅里叶变换：$a_k=\frac 1T F(jk\omega_0)=\frac 1T F(jk\frac{2\pi}{T})$
- $\sum n^{-2} = \frac{\pi^2}{6}$, $\sum(2n-1)^{-2} = \frac{\pi^2}{8}$
傅里叶变换
- Intro: 考虑幅频密度 $\frac{F(n\omega_1)}{\Delta f}$，考虑 $T\to\infty, n\omega_1\to\omega$ 得到变换
- 正变换：$F(\omega)=\int_{-\infty}^{\infty}f(t)e^{-j\omega t }\text{d}t$
- 逆变换：$f(t)=\frac{1}{2\pi}\int_{-\infty}^{\infty}F(\omega)e^{j\omega t }\text{d}\omega$
- 例
  - $u(t-\frac\tau2)-u(t+\frac\tau2)$：$\tau \operatorname{Sa}(\frac{\omega\tau}{2})$
  - $\operatorname{Sa}(\omega_0 t)$: $\frac{\pi}{\omega} (u(\omega-\omega_0)-u(\omega+\omega_0))$
  - 单边指数 $e^{-\alpha t}u(t)$：$\frac1{\alpha+j\omega}$; $e^{\alpha t}u(-t)$: $\frac{1}{\alpha-j\omega}$ （考虑共轭性）
  - 双边指数 $e^{-\alpha|t|}$: $\frac{2\alpha}{\alpha^2+\omega^2}$
  - $\delta(t)$: $1$; $\frac{1}{2\pi}$: $\delta(\omega)$
  - $\operatorname{sgn}(t)$: $\frac{2}{j\omega}$
  - $u(t)$: $\pi\delta(\omega)+\frac1{j\omega}$
  - $1-|t|$: $\operatorname{Sa}(\frac\omega2)^2$
  - tip: $\int\operatorname{Sa}(\omega)\text{d}\omega$ 方波
- 周期信号
  - $\cos \omega_0 t \sim \pi(\delta(\omega-\omega_0)+\delta(\omega+\omega_0))$
  - $\sin \omega_0 t \sim \frac\pi j(\delta(\omega-\omega_0)-\delta(\omega+\omega_0))$
  - 冲激采样信号：$F[f_p(t)] = \sum_\infty \frac{\pi}{T_s}\delta(\omega-n\omega_s)$
  - 一般周期信号 $\sum a_k e^{jk\omega_0 t} \sim 2\pi\sum a_k\delta(\omega-k\omega_0)$
  - ($\sum_{k=-\infty}^{\infty}e^{-j\omega k T} = \frac{2\pi}{T}\sum_{n=-\infty}^{\infty}\delta(\omega-n\frac{2\pi}{T})$)
- 性质：
  - 线性
  - $x(t-t_0)\sim e^{-j\omega t_0}X(\omega), e^{j\omega_0 t}x(t)\sim X(\omega-\omega_0)$
  - $x^\ast(t)\sim X^\ast(-\omega)$
  - $x’(t) \sim j\omega X(\omega), \int x(t)\text{d}t \sim \frac{X(\omega)}{j\omega}+\pi X(0)\delta(\omega), (-jt)x(t)\sim X’(\omega)$
  - $x(at)\sim \frac1{|a|}X(\frac{\omega}{a})$
  - 对偶 $x(t)\sim X(\omega)$ 则 $X(t)\sim 2\pi x(-\omega)$
  - 卷积 $x_1\ast x_2 \sim X_1X_2, x_1x_2 \sim \frac{1}{2\pi} X_1\ast X_2$
- Parseval’s Theorem $\int_\infty |x(t)|^2\text{d}t = \frac1{2\pi} \int_\infty|X(j\omega)|^2\text{d}\omega$
- 采样
  - 抽样原理：编码变换-ADC-（信道）-滤波器-DAC-解码变换
  - (Nyquist) 采样定理：$\omega_s \ge 2\omega_m$
频率域分析
- 适用：零状态，稳态
- 常微分方程：$H(\omega)=\frac{Simulate(\omega)}{Response(\omega)}$ （系数）
  - 对三角函数：关注幅频、相频，直接叠加
- 无失真条件：$|H(\omega)| = K, \varphi(\omega)=-\omega t_0$ ($K$: 增益；$t_0$: 群延时)
- 滤波：频率特性
  - 理想低通阶跃响应：$r(t)=\frac12 + \frac1\pi (t-t_0)\int_0^{\omega_c}\frac{\sin\omega(t-t_0)}{\omega(t-t_0)}\text{d}t\omega = \frac12+\frac1\pi (t-t_0)\operatorname{Si}(\omega_c(t-t_0))$, $t_{\text{rise}}=\frac{2\pi}{\omega_c}=t_c$
  - 非理想低通特性：通/阻带有起伏 $\pm\delta_1/\delta_2$，通带边缘 $\omega_p$, 阻带边缘 $\omega_s$
  - 工程低通：Butterworth, Chebyshev, Cauer （幅频特性逼近更好，$h(t)$ 更差）
  - 物理可实现系统：因果，平方可积
  - 佩利－维纳准则：$\int_{\infty}\frac{|\ln|H(j\omega)||}{1+\omega^2}\text{d}\omega < \infty$ （物理可实现必要条件）
- 调制解调：
  - $s_{AM}(t)=(1+km(t))\cos\omega_0 t$
  - $S_{AM}(\omega)=M(\omega)(\frac12 \delta(\omega-\omega_0)+\frac12 \delta(\omega+\omega_0))=\frac12(M(\omega-\omega_0)+M(\omega+\omega_0))$
  - 解调：再乘 $\cos\omega_0 t$ ，使 $S(\omega)=\frac14 M(\omega-2\omega_0)+\frac12 M(\omega)+\frac12(\omega+2\omega_0)$ ，再过低通

离散傅里叶分析

离散傅里叶级数 DFS
- 有限项级数，频谱周期
- 离散信号可以认为是连续信号的冲激采样
- $a_k=\frac1{NT_s}\sum_0^{N-1} x(nT_s)e^{-jk\frac{2\pi}{N}n}$
- $a_k$ 例
  - 周期方波($N_1/N$): $\frac1N \frac{\sin \frac\pi N k(2N_1+1)}{\sin\frac{\pi}{N}k}$ （注意这里的 $N_1$ 对应连续的 $\frac\tau2$ 而非 $\tau$）
DTFT
- 对比CFS 有 $\frac{2\pi}{N}k \to \omega$
- $X(e^{j\omega})=\sum_\infty x[n]e^{-j\omega n}$
- $x[n]=\frac1{2\pi} \int_{2\pi} X(e^{j\omega})e^{j\omega n}\text{d}\omega$
- 收敛条件：$\sum|x[n]|^2<\infty$ or $\sum|x[n]| < \infty$ 且一致收敛
- 例
  - $\delta[n] \sim 1$
  - 矩形脉冲 $|n|\le N_1$: $\frac{\sin(2N_1+1)\frac\omega2}{\sin\frac\omega2}$
  - 频域矩形 $\frac{\sin\omega_s n}{\pi n} \sim u(\omega-\omega_s)-u(\omega+\omega_s)$
  - 实指数 $a^nu(n) \sim \frac1{1-ae^{-j\omega}}$
  - 非因果实指数 $a^nu(-n) \sim \frac{1}{1-a^{-1}e^{j\omega}}$
  - 双边指数 $a^{|n|} \sim \frac{1-a^2}{1+a^2-2a\cos\omega}$
  - 常数 $1\sim2\pi\sum_\infty\delta[\omega-2\pi k]$
  - 一般周期：$2\pi \sum_N a_k \delta[\omega-\frac{2\pi}{N}k]$ 的周期化
- 性质
  - 周期性，线性，时移频移，时间反转，共轭对称
  - 差分 $x[n]-x[n-1] \sim (1-e^{-j\omega})X(e^{j\omega})$
  - 求和 $\sum_{-\infty}^{n}x[k] \sim \frac{X(e^{j\omega})}{1-e^{-j\omega}}+\pi X(\omega=0)\delta(\omega)$ 的周期化
  - 时域内插 $x_k(n) \sim X(e^{jk\omega})$
  - 频域微分 $nx[n] \sim j\frac{\text{d}X(e^{j\omega})}{\text{d}\omega}$
  - Parseval定理 $\sum_\infty|x[n]|^2 = \frac1{2\pi} \int_{2\pi} |X(e^{j\omega})|^2\text{d}\omega$
  - 卷积性质 $x(n)\ast h(n) \sim X(\omega)H(\omega)$
  - 调制性质 $x(n)h(n) \sim \frac1{2\pi} X(\omega)\ast H(\omega)$

拉普拉斯变换

双边拉氏变换 $X(s)=\int_{-\infty}^{\infty} x(t)e^{-st}\text{d}t$
反变换 $X(s)=\frac{1}{2\pi j}\int_{\sigma-j\infty}^{\sigma+j\infty}X(s)e^{st}\text{d}s$
ROC：平行 $j$ 轴，极点为边界，时限信号 ROC 无限，左右边信号
零极点图：零点 ○, 极点 x；可能抵消；注意分母 $z^{-1}$ 自带一个 $0$ 零点
拉氏变换对
- $u(t)\sim\frac1s, \operatorname{Re}(s)>0$ ($\sim \frac1s + \pi\delta(s)$)
- $\delta(t)\sim1$
- $1 \sim 2\pi\delta(s)$
- $e^{-at}u(t) \sim \frac{1}{s+a}$
- $\sin\omega t\ u(t)\sim\frac{\omega}{s^2+\omega^2}$, $\cos\omega t\ u\sim\frac{s}{s^2+\omega^2}$
- $\operatorname{Rect}_{\tau}(t) \sim \tau \operatorname{Sah}\frac{s\tau}{2}$ （宽度 $\tau$）；对称三角（宽度 $2\tau$）：$(\tau\operatorname{Sah}\frac{s\tau}{2})^2$
性质
- $x(t-t_0) \sim X(s)e^{-st_0}$
- $x(t)e^{s_0t} \sim X(s-s_0)$ （注意 ROC 平移）
- $x(at) \sim \frac{1}{|a|}X(\frac sa)$ （注意 ROC 尺度变换）
- $x^\ast(t)\sim X^\ast(s^\ast)$ （若 $x(t)$ 实则极点共轭也是极点）
- $x_1(t)\ast x_2(t) \sim X_1(s)X_2(s)$, $x_1(t)x_2(t)\sim \frac1{2\pi j}\int_{c-j\infty}^{c+j\infty}F(\sigma)G(s-\sigma)\text{d}\sigma$
- $x’(t)\sim sX(s)$, $-tx(t)\sim X’(s)$, $\int_{-\infty}^{t}x(\tau)\text{d}\tau \sim \frac{X(s)}{s}$, $\frac{x(t)}{t} \sim \int_{s}^{\infty} X(\eta)\text{d}\eta$
  - 单边 $x’(t)\sim sX(s)-x(0^-)$ , $x^{(-1)}(t)=\frac{X(s)}{s}+\frac{x^{(-1)}(0^-)}{s}$
- $x(\infty)=\lim_{s\to 0}sX(s)$ （条件：因果，原函数无 $\delta(t)$)（推导：幂级数展开）
- $x(0^+)=\lim_{s\to\infty} sX(s)$ （条件：因果，极点 <0 且至多一个 0）（推导：考虑 $\int_{0^+}^{\infty}e^{-st}\text{d}x(t)$ 换元）
- 周期信号只有单边 $f(s)=\sum_\infty f_1(t-nT) \sim \frac{F_1(s)}{1-e^{-sT}}$
- 没有对偶性
单边：$[0^-,\infty]$ or $[-\infty, 0^+]$ ROC 为最右极点之右
LTI $H(s)$
- 因果稳定：$\infty\in ROC$；极点<0
全通网络：$|H(j\omega)|=K$

Z 变换

$X(z)=\sum_\infty x[n]z^{-n}$
- $z=e^{sT}=e^{j\omega}$
- 有限长序列的ROC是整个有限Z平面
- 反变换 $x(n)=\frac1{2\pi j}\oint_{|z|=r} X(z)z^{n-1}\text{d}z$ （逆时针）
- 技巧：$\frac1z X(z)=\sum \frac {C_i}{z-z_i}$
幅频响应：极点峰值，零点凹陷
变换对
- $\delta(n) \sim 1$
- $u(n) \sim \frac z {z-1}, |z|>1$
- $a^n u(n), -a^n u(-n-1) \sim \frac{z}{z-a}$
- $na^nu(n)\sim \frac {az} {(z-a)^2}$
- $z_0^n x(n) \sim X(\frac{z}{z_0})$
- $x(-n) \sim X(z^{-1})$, $x^\ast(n) \sim X^\ast(z^\ast)$
- 时域内插 $x_k=x(n/k) \sim X(z^k)$
- $nx(n)\sim -zX’(z)$
- $x(n+n_0)\sim X(z)z^{n_0}$
  - 单边右移 $x(n-n_0) \sim z^{-n_0}(X(z) + \sum_{1}^{n_0}x(-k)z^{k})$
  - 单边左移 $x(n+n_0) \sim z^{n_0}(X(z)-\sum_{0}^{n_0-1} x(k)z^{-k})$
- $x(0)=\lim_{z\to\infty} X(z)$, $x(\infty)=\lim_{z\to 1} (z-1)X(z)$ （因果；推导：按 Z 变换定义展开；时移性质）

操作系统速成

Fri, 13 Jun 2025 23:10:59 +0800

Intro

操作系统：是软件，且是系统软件；基本职能是控制和管理系统资源；提供服务，方便用户使用
- 四大特征：并发，共享，虚拟，不确定
- 类型：分时，实时，微机，网络，分布式，嵌入式，智能卡，云OS
- 架构：微内核 micro kernel，宏内核/单体内核 monolithic kernel；SMP(Symmetric MultiProcessing)
- 主要模块：进程管理，内存管理，设备管理，文件管理，用户
IO 基础
- 脱机输入输出，批处理系统
- 缓冲：解决速度不匹配问题；spooling
- 中断：减少轮询；分为 IO (timer), Hard error, Soft error/exception
- DMA
- SPOOLing
  - 把一台物理设备虚拟成逻辑上的多台设备
  - 驱动程序：预输入，井管理，缓输出
  - 架构：接口-内存缓冲-井（暂时持久化）-内存缓冲-设备
作业：一个完整的任务，包括多个作业步/程序

内存管理

作用：提高主存的利用率，将尽可能多的作业同时加载到主存中
层次：寄存器，主存，辅助存储器
部分：寄存器，L1，L2，L3/主存，本地二级，远程二级
需求：重定位，保护，共享，逻辑组织，物理组织
管理技术：单一连续，固定分区，动态分区，分页/分段，虚拟内存
- 重定位：分区导致的；静态/动态重定位：动态链接/PIC
- 存储保护：上下限寄存器
- 碎片：分区-内碎片；动态-外碎片
- 可变分区分配算法
  - 首次适配：空闲分区链表按地址排序；分配快，回收效率高，碎片多，性能下降
  - 临近适配：循环首次适应，记忆上次指针位置；分配较快，碎片少
  - 最佳适配：空闲分区链表按块从小到大排序；分配慢，回收慢，利用率高，碎片小多
  - 最差适配：空闲分区从大到小；分配较快，回收慢，碎片中等
- 算法对比
  - 复杂度：最佳（2+2）> 最差（1+2）>首次（1+1）>循环（1+1）
  - 小碎片产生的可能性：最佳 >首次 > 循环 > 最差
  - 后继大作业分配成功的可能性：最佳 >首次 > 循环 > 最差
- 内存扩充技术：主辅存交换
  - 覆盖技术：预先程序分块
  - 交换技术：引入分页分段
虚拟存储系统
- 系统抖动：反复换出换入的现象
- 任务：地址映射，缺页处理，物理内存回收分配
- 特点：延迟分配，用户空间不受物理限制
- 基础：异常中断机制；页表项
- 地址翻译：页表页号+偏移；快表 TLB 页号+flag
- 多级页表；反向页表（逻辑页号+进程ID Hash）
- 空闲页：位图，链表
淘汰算法
- 最优淘汰算法 Optimal：淘汰下次访问最远的
- FIFO：某些情况抖动大
- LRU：计数器，定时清理；复杂，会淘汰新页
- 访问 FIFO：低效
- NUR / 时钟算法：初始/访问1，扫描清零；rw: 先R后W
- (Unix) 双时钟前指针更新 flag，后指针淘汰
- 年龄法/老化法：NUR 但是换成计数器
读取/清除策略：请求式，预先式；驻留集：可直接访问物理内存（有效虚拟内存）
替换策略：页缓冲（RO空闲页表，W修改页表）
内存分配算法
- Buddy System：二分，用于分配页；Linux lazy merge
- Slab System：用于分配 Bytes；slub (Linux), slob (embed)

进程管理

进程：系统进行资源分配和调度的一个可并发执行的独立单位
- 组成：代码段(RO)，数据上下文（用户层，内核层，寄存器）
- 管理结构：PCB
- 一个进程只能对应于一个程序
- fork, exec
状态转换
- 三状态：Running, Ready, Block
- 五状态：Created(Limited by Process Number), Ready, Running, Sleep(Block/Wait/Uninterruptable sleep), Terminated(Traced/Stopped)
- 挂起 Suspend: 需要评估加载资源
- *Linux: Ready/Running, Sleeping, Uninterruptable sleep, Stopped, Zombie
- *Windows: Ready, Standby, Running, Waiting, Transition, Terminated
- 神秘 Job control block: 提交，后备，运行，完成
PCB：进程（标识，CPU，调度，记录）、内存、IO、文件
- struct proc：核心内容，常驻内存部分
- struct text: 代码段相关
- struct user: 用户信息，proc 结构，信号处理，事件记录等
- PCB 链表
- 模式：内核态用户态
线程
- 进程：资源分配单位；线程：调度执行单位
- 独立资源：执行状态，上下文，TLS，控制块
- 共享资源：地址空间，程序代码，全局变量，设备文件
- 优势：创建，终止，切换，通信快（x
- 用户级多线程：假的，切换更快，更轻
调度
- 层次：长程/高级，中程/中极，短程/低级：队列，内存，CPU；通常只有一个进程调度
- 准则：面向用户/系统；优先 IO、交互、段、优先级
- 调度方式：不可剥夺，可剥夺
- 时机：中断，异常，Trap
调度算法
- FCFS/FIFO：简单，不可抢占
- SJF/SPN 最短优先：较简单，难预测
- SRT 最短剩余时间：抢占，难预测，好于 SPN
- HRRN 最高相应比：R=1+Waited/Runtime，折中
- Round Robin 时间片轮转：剥夺式；改进：不同规格时间片
- (Unix, Windows) Feedback：优先调度优先级最高的队列；高优先级时间片短；时间片用完降低优先级
- (Linux) CFS 完全公平调度：vruntime = 实际运行时间 * NICE_0_LOAD/ 当前进程权重；队列按 vruntime 排
多核处理器
- 调度：公共就绪队列，私有就绪队列，两级
- 负载均衡：推/拉
- 亲和性（软，硬）；原因：hot cache, tlb
实时调度：硬实时任务必须按时完成，软实时任务尽量完成
- 静态表驱动，静态优先级驱动抢占调度，基于动态规划的调度，动态尽力调度
- 时限调度：最早截止时间，最小松弛（最晚启动）时间
- RMS 速率单调调度：（周期任务）调度 U=1/T 最大的任务；要求 $\sum \frac{t_i}{T_i}\le n(2^{1/n}1)$
优先级逆转
- 原因：高优先被低优先互斥阻塞
- 解决：优先级继承（改任务优先级）；优先级置顶（设资源优先级）
多处理器调度
- 负载共享：全局队列
- 群调度：全局“群”队列；分配
- 处理器专派：线程绑核
- 动态调度：？

进程间通信

同步与互斥
- 临界资源：一个时刻只能被一个进程访问或使用的资源
- 临界区：是一段代码。进程通过这段代码访问临界资源
  - 原子性，可嵌套，可中断
- 实现方法：硬件支持，用户态算法，操作系统
  - 中断禁用：仅单处理器，单临界区，危险
  - 特殊指令：简单
  - 用户态算法：可能死锁饥饿
    - Peterson 算法
  - 操作系统：信号量（需了解算法）
    - P/V, wait/signal
同步实例
- 半同步：单向等待依赖
- 生产者和消费者问题: semaphore_t buf, ch; mutex<queue_t> queue;
  - producer: P(buf); push queue; V(ch);
  - consumer: P(ch); pop queue; V(buf);
- RWLock: mutex<int> count; mutex rwlock;
  - reader: if (count++ == 0) P(rwlock); READ; if (--count == 0) V(rwlock);
  - writer: P(rwlock); WRITE; V(rwlock)
  - 解决 writer 饿死：维护 writer wait flag
- 管程：RAII 锁 Mutex<T>
消息
- 进程间数据交换：消息，共享内存，管道 FIFO，socket，软中断/信号 signal
- 原语：send, recv
- signal: PCB 有 signal field 和对应 handler；无优先级，针对进程，不及时，用户态处理
- FIFO pipe: 命名 mknod/mkfifo, 匿名 pipe；类似字符文件，单向；匿名管道用于同一进程族；环形缓冲区 ring buffer *PIPE_SIZE=64k, PIPE_BUF=4k；
- 消息：msgget, msgsnd, msgrcv
- 共享内存：shmget, shmat, shmdt
死锁
- 原因：资源竞争；硬件资源分配不当；软件编写不当
- 条件：充分（循环等待）；必要（互斥，保持并等待，不可剥夺）
- 资源分配图 Resource allocation graph RAG
- 应对方法：
  - 预防：消除条件之一
    - 保持且等待：静态分配策路，失败全回滚
    - 不可剥夺：剥夺
    - 循环等待：资源排序，只能申请相较已获得编号更大的资源
  - 避免：允许条件，算法避免死锁
    - 介入时间：进程启动时，资源分配时
    - 拒绝进程启动：进程需要资源总和≤可用资源
    - 银行家算法：申请者告知未来最大需求；分配者计算死锁
      - 数据：max, alloc, need, available; request
      - (a) request < need （否则 error）
      - (b) request < available （否则 block）
      - (c) 试修改： need -= request; alloc += request（check alloc < max）
      - (d) Coffman 算法：假定 need 全同时变成 request，找到可行进程链；$O(n^2)$
    - 适用条件：进程间无同步，事先声明需求和可用资源
  - 死锁检测（从死锁恢复）：Coffman 算法
    - 死锁消除：撤销死锁进程，剥夺资源

附：Peterson 算法

马原概念速成

Wed, 11 Jun 2025 15:10:59 +0800

导论

本质和使命：实现无产阶级和人类的解放
基本立场、基本观点、基本方法的有机统一
创立与发展
- 社会根源：生产力发展，社会两级分化，资本主义的经济危机
- 阶级基础
  - 三大工人运动：法国里昂工人起义英国宪章运动德国西里西亚纺织工人起义；阶级诞生，实践经验；无理论，无党
著作
- 1846 德意志意识形态历史唯物主义
- 1848 共产党宣言马克思主义的诞生
- 1867 资本论剩余价值学说
主要内容（可用于解释价值）
- 理论的基础：马哲学
- 理论的论证：马政治经济学
- 理论的归宿：科学社会主义
理论根源：德国古典哲学（黑，费）、英国古典政治经济学（亚当斯密，大卫李嘉图）和英国法国的空想社会主义（圣西门，傅里叶，欧文）
历程：马，列，毛，中特（邓，江（三个代表），胡（科学发展观）），习
- 同中国具体实际中华优秀传统文化相结合
特征：科学性人民性实践性发展性；体现本质使命；科学性与革命性的统一

世界的物质性及发展规律

哲学既是世界观又是方法论
- “哲学家们只是用不同的方式解释世界，而问题在于改变世界。”
- 哲学的基本问题：思维和存在的关系 / 本体论，可知论
唯物主义
- 发展：古代朴素（古希腊/中国），形而上学（自然科学，霍布斯，梅特利），辨证历史
- 物质的唯一特性/原则：客观实在性
- 运动
  - 运动是物质的存在方式、根本属性
  - 物质是一切运动变化和发展过程的实在基础和承担者
  - 运动是绝对的、静止是相对的
- 意识：
  - 是自然、社会历史（劳动/实践）的产物，是物质世界的主观映象，客观内容和主观形式的统一
  - 反作用意识/有能动作用（x4）；主观能动性与客观规律性
- 世界的物质统一性；一切从实际出发
唯物辩证法
- vs 形而上学：矛盾运动和发展的动力和源泉
- 两大特征：联系和发展：
  - 是唯物辩证法的总观点和总特征
  - 联系：客观，普遍（内，间，世界），多样(4)，条件(3)；联系导致运动
  - 发展：实质是新事物的产生和旧事物的灭亡；新事物必然战胜旧事物；发展是一个过程
唯物辩证法三大规律
- 对立统一规律/矛盾
  - 是普遍联系的根本内容，是永恒发展的内在动力，是唯物辩证法的实质和核心
  - 属性：对立（斗争性）和统一（同一性）
    - 相互联结、相辅相成，斗争性是无条件的绝对的
    - 同一性是有条件的相对的
    - 在事物发展中的作用（3+2）
    - 矛盾的共性/普遍性和个性/特殊性、绝对和相对的道理，是关于事物矛盾问题的精髓
  - 普遍性（时，物），特殊性（不同物，不同时，不同方面）
  - 两点论：对立且统一，主要且次要
  - 重点论：把握主要（矛盾、方面）
- 质量互变：质、量、度；量变和质变：相辅相成（准备，结果，渗透）
- 否定之否定
  - 肯定（存在）和否定（灭亡）
  - 否定是事物内部矛盾运动的结果；是事物发展的环节，是新旧事物联系的环节，实质是扬弃（扬长弃短）
  - 前进性与曲折性
唯物辩证法五大范畴：原因和结果、必然性和偶然性、可能性和现实性、现象和本质、内容和形式
马克思主义方法论
- 唯物辩证法：是批判的和革命的，是客观辩证法与主观辩证法的统一，是伟大的认识工具（矛盾分析法）
- 方法论：辩证思维方法

认识世界和改造世界

实践观
- 发展：康黑费，马恩，列，中
- 本质：人类能动地改造世界的社会性的物质活动
- 结构：主体，客体，手段
- 基本特征：直接现实，自觉能动，社会历史
- 与认知：来源，发展动力，实践是认识的目的，是检验真理性唯一标准
认识论
- 本质：主体在实践基础上对客体的能动反映
  - 路线：唯物（反映论）、唯心（先验论）
  - 反映论：能动革命的，x直观被动的；特点：摹写性，创造性
- 规律/过程
  - 实践-理性/感性认知-实践
  - 感性认知：直接性，具体性
  - 理性认识
    - 形式：概念，判断，推理
    - 特点：间接性，抽象性
  - 感性/理性辩证统一：依赖，发展深化，互相渗透
    - 错误：唯理论和经验论
    - 感性→理性：实践，辩证思维
  - 从认识到实践
    - 必要性重要性：认识世界的目的是改造世界，认识的真理性只有在实践中才能得到检验和发展
    - 条件：从实际出发，经过路线、方针、政策等中介，为群众所掌握，有正确的实践方法（？
  - 认识过程反复性和无限性（人有限而物无限）
真理观价值观
- 真理
  - 本质：对客观事物的本质及其规律的正确反映
  - 客观性：思想内容、检验标准都客观；决定了一元性
  - 绝对性：内容，认识能力；相对性：世界部分，特定事物
  - 绝对相对的辩证统一：相互渗透包含，真理辨证转化
  - 真理与谬误：主观是否与客观相符合；对立，联系，斗争，可转化
- 实践是检验真理的唯一标准
  - 原因：真理的本质和实践的直接现实性
  - 补充：逻辑证明
  - 有确定性/绝对性 | 不确定性/相对性/条件性
- 价值
  - 特定属性的客体对于主体需要的意义
  - 基本特性：主体性，客观性，多维性，社会历史性
  - 价值评价：
    - 是关于价值现象的认识活动，是主体对客体是否具有满足主体需要的属性做出肯定或否定的评判
    - 特点：以价值关系为认识对象，与主体有直接联系，正确与否依赖于相关的知识性认识
    - 并不是一种主观随意性的认识活动，而是具有客观性的认识活动
    - 功能：激励，规范制约，导向
  - 价值观
    - 是人们价值本质的认识评价标准评价方法的观点体系
  - 价值和真理在实践中的辩证统一：实践以之为前提；时间和认知中他们相互制约、相互引导、相互促进
- 认识世界和改造世界
  - 辩证统一：改造是目的，认识是前提
  - 认识世界和改造世界的过程是从必然走向自由的过程（用来反对宿命论和唯意志论）
    - 认识是能动的展示，是自由的可能性；改造是能动的确证，是自由的现实性
    - 自由发展：自然经济（依赖人），商品经济（依赖物），共产主义（自由全面）
    - 三重维度：人与自然，人与社会，人与自身
    - 自由条件：认识+实践
    - 认识必然、争取自由是一个历史过程
  - 一切从实际出发，实事求是：是马要求，是中共路线核心

人类社会及其发展规律

社会基本矛盾及其运动规律
- 社会存在与社会意识
  - 是社会历史观的基本问题（唯心：社会意识主导）
  - 社会存在：是社会生活的物质方面，包括生产方式（决定性），地理环境，人口
    - 生产方式是生产力和生产关系的统一体是社会历史发展的决定力量
  - 社会意识：是社会生活的精神方面，是社会存在的反映；具有不同形态/形式/复杂结构
    - 个体意识，群体意识；社会心理，社会意识形式；上层建筑意识形式（意识形态）
  - 辩证统一：存在决定意识，相对独立（3），反作用
  - 文化为社会：思想保证，精神动力，凝聚力，智力支持
- 生产力与生产关系
  - 生产力：客观现实性，社会历史性
    - 劳动者
    - 劳动资料：包括生产工具；划分经济时代，衡量生产力水平
    - 劳动对象：自然物，原料；侧面反映生产力
  - 生产关系
    - 是社会关系中最基本的关系
    - 构成：生产资料所有制，人际关系/地位，产品分配关系
    - 分类：公有制，私有制
  - 矛盾运动规律
    - 生产力决定生产关系（性质，变革）
    - 生产关系对生产力具有能动的反作用
    - 生产关系一定要适合生产力状况的规律
  - 规律价值：道德转生产力，可以为政党
- 经济基础与上层建筑
  - 经济基础：是生产关系的总和
  - 上层建筑：经济基础之上的意识形态以及相应的制度、组织和设施
    - 构成：思想（文化），政治；互相提供保证/精神指导
    - 政治居主导地位，国家政权是核心；国家按地域管理，依靠暴力手段维持
    - 国体：阶级地位安排；政体：统治/政权构成形式
  - 矛盾运动规律
    - 经济基础决定上层建筑（性质，变革，物质基础）
    - 上层建筑对经济基础具有反作用
- 社会形态更替的一般规律及特殊形式
  - 社会形态
    - 是关于社会运动的具体形式、发展阶段和不同质态的范畴
    - 包括经济形态，政治形态，意识形态
    - 构成：经济基础和上层建筑
    - 五种社会形态
  - 社会形态更替的必然性：生产力与生产关系矛盾运动的规律性
  - 人们的历史选择性：人民群众的选择性
  - 社会形态更替的前进性与曲折性，渐进性与跨越性
社会历史发展的动力
- 社会基本矛盾：
  - 生产力和生产关系、经济基础和上层建筑的矛盾
  - 是动力，是冲突根源，会转化
- 阶级斗争和社会革命
  - 阶级斗争是人类社会发展到一定阶段才出现的设社会现象；是动力；阶级分析法是认知方法
  - 社会革命：是社会形态的变更，是社会基本矛盾运动基础上的社会生活的全面变革（包括对人，对自然，思想变革）
  - 改革：在不改变社会基本制度，变革生产关系和上层建筑的某些方面环节，从而促进生产力发展和社会进步
  - 改革意义：生产方式，生活方式，思维
  - 科技：推动发展，受自然、人、社会制度影响
人民群众在历史发展中的作用
- 人民群众是历史的创造者
  - 唯物史观：群众史观；立足人，社会，历史
  - 史观产生根源：认知，社会历史，阶级
- 人民群众：
  - 质（推动历史者），量（大多数）
  - 是一个历史范畴
  - 最稳定的主体部分始终是从事物质资料生产的劳动群众
  - 创造物质、精神，变革社会
  - 受经济，政治，精神文化制约
- 个人：必然性+偶然性；受制约
- 分析法：历史，阶级

资本主义的本质及其规律

劳动价值论
- 商品经济
  - 形成：分工，资料产品分属
  - 阶段：个体，雇佣
- 商品因素
  - 使用价值和价值
  - 价值是交换价值的基础，交换价值是价值的表现形式
  - 价值和使用价值对立统一
- 劳动：
  - 二重性：具体劳动（形成使用价值，自然属性）和抽象劳动（形成价值，社会属性）
  - 具体劳动和抽象劳动也是矛盾统一
  - 复杂劳动是多倍的简单劳动
- 社会必要劳动时间：正常生产条件下，平均熟练程度、劳动强度下，“具体劳动”时间；决定商品价值量
- 货币
  - 职能：价值尺度，流通手段，贮藏手段，支付手段，世界货币
  - 简化商品交换；没解决商品经济基本矛盾
- 价值规律：
  - 商品的价值量由生产商品的社会必要劳动时间决定，商品交换以价值量为基础，按照等价交换的原则进行，形成价值规律：商品的价格围绕商品的价值自发波动（商品经济）
  - 作用：自发调节生产，刺激生产力，调整收入分配
  - 后果：劳动浪费，垄断，生产者分化
- 商品经济的基本矛盾：私人劳动和社会劳动的矛盾
剩余价值理论
- 资本原始积累
  - 是生产者与生产资料相分离，货币资本迅速集中于少数人手中的历史过程
  - 途径：暴力掠夺生产资料、产品/财富
- 资本主义经济制度是以资本家占有生产资料和以雇佣劳动为基础的经济制度
- 劳动力成为商品
  - 劳动力：人的体力和脑力的总和
  - 是资本主义雇佣劳动制度的形成前提
  - 条件：劳动者是自由人，劳动者一无所有
  - 劳动力商品的价值：生存，生活，训练；使用价值是价值的源泉
- 资本
  - 价值形式/价值构成：不变资本（生产资料），可变资本（购买劳动力）
  - 物质构成/技术构成：生产资料，劳动力
  - 有机构成：由技术构成构成决定并反映技术构成变化的价值构成
- 生产剩余价值
  - 剩余价值：剩余劳动时间内创造的、被无偿占有的价值
  - 是资本主义生产方式的绝对规律，是资本主义生产的直接目的和决定性动机
  - 资本主义生产过程两重性：物质资料，剩余价值（价值增值）；资本主义生产过程是劳动过程和价值增殖过程的统一
  - 生产基本方法：绝对剩余价值（必要劳动时间不变，延长时间、提高强度），相对（缩短必要劳动时间）
- 资本积累
  - 是剩余价值的资本化
  - 简单再生产：剩余价值不再用于生产；物质资料再生产和资本主义生产关系再生产的统一
  - 扩大再生产：剩余价值部分资本化
  - 是财富占有分化、社会失业的原因
  - 历史趋势：生产社会性，资本集中
- 循环周转与再生产
  - 产业资本的循环，资本的周转，社会资本的再生产和流通
  - 社会资本：相互联系、相互依存的个别资本的总和
  - 社会再生产顺利进行：社会总产品（价值，实物）能实现，社会生产（生产资料，消费资料）成比例
- 工资与剩余价值的分配：只要资本雇佣劳动的基本经济关系不变，资本主义工资的本质就不会发生根本变化
- 意义：由于唯物史观和剩余价值的发现，社会主义由空想变为科学
资本主义基本矛盾
- 基本矛盾：资本主义私人占有的生产关系与社会化生产力之间的矛盾
  - 表现：个别企业生产的有组织性和整个社会生产无政府状态之间的矛盾；资本主义生产无限扩大的趋势与劳动人民有支付能力的需求相对狭小之间的矛盾
- 经济危机实质：生产相对过剩
- 再生产的周期性：危机，萧条，复苏，高涨；资本主义基本矛盾运动的阶段性决定

资本主义的发展及其趋势

垄断资本主义的形成与发展
- 资本主义两个阶段：自由竞争，垄断
- 垄断
  - 是少数资本主义大企业，为了利润，对一个或几个部门商品的生产、销售和价格，进行操纵和控制
  - 形成：生产集中和资本集中
    - 生产集中：生产资料、劳动力和商品的生产集中于大企业
    - 资本集中：吞并、合并
  - 是资本家追求剩余价值的结果
  - 垄断利润：垄断地位获得的高额利润；源自剩余价值
- 垄断竞争
  - 没有消除产生竞争的经济条件，必须通过竞争来维持
  - 规模大、时间长、手段残酷、程度激烈、而且具有更大的破坏性
- 金融垄断资本
  - 由工业垄断资本和银行垄断资本融合形成的一种垄断资本
  - 金融寡头：指操纵国民经济命脉，并在实际上控制国家政权的少数垄断资本家或垄断资本家集团
  - 形成条件：金融自由化，金融创新
  - 控制方式：经济领域参与制；国家个人联合
- 国家垄断资本主义：国家政权和私人垄断资本融合
  - 原因：支配大规模生产力/资料，应对经济危机，缓和社会矛盾
  - 形式：国营企业，合资企业，参与私人垄断资本，宏观调节，微观规制
  - 积极作用：发展生产力，突破私人局限性，再分配，引导现代化
- 向世界范围扩展
  - 动因：输出过剩资本，取得别国垄断，抢夺市场，获得生产资料
  - 形式：借贷资本，生产资本，商品资本
- 经济全球化
  - 表现：生产、贸易、金融全球化
  - 动因：生产力的发展，适宜的组织形式（跨国公司），各国经济体制的变革
  - 积极影响：科技，就业，贸易
  - 消极：收益不平等，环境恶化，经济风险
  - 应对：是必然趋势，以构建人类命运共同体的理念引领经济全球化
正确认识当代资本主义的新变化
- 所有制：
  - 国家资本形成并发挥重要作用
    - 国家出资，推行政府政策，为私人垄断资本的发展
  - 法人资本崛起并成为居主导
    - 是法人股东化的产物
    - 两种形式：企业法人资本所有制，机构法人资本所有制
- 垄断资本变强
- 缓和劳资关系：职工参与决策，终身雇佣，职工持股
- 阶层结构：高级职业经理成为实际控制者；知识型和服务型劳动者增加
- 经济调节机制和经济危机形态：二战后：国家开始对经济进行全面干预；1970s后：强化市场、弱化政府干预，福利制度改革减少政府财政负担，放松对经济和金融的管制，释放经济活力
- 政治制度：多元化，加强法制，改良主义政党
- 变化原因：生产力发展，斗争，社会主义制度影响，改良主义政党上台
资本主义的历史地位和发展趋势
- 相较封建进步：用科学技术，剩余价值+竞争+上层建筑推动生产力
- 为社会主义所代替的历史必然性
  - 必然：内在矛盾
  - 长期

社会主义的发展及其规律

社会主义
- 思想：工人阶级的意识
- 运动：工人阶级改造资本主义的实践
- 制度：取代资本主义的新的社会制度
16-19 空想社会主义
- 早期（家庭手工业）：财产公有，共同劳动，人人平等
- 空想平均（工厂手工业）：论述了从私有制过渡到公有制的必然性，并以法律条文的形式阐述了理想社会的纲领和原则
- 批判空想（机器大工业）：圣西门，傅里叶，欧文
- 意义：新见解，无产阶级论，不具备科学和实践
- 缺陷：出路，资本主义雇佣制本质，资本主义发展规律，找到社会力量
科学社会主义
- 标志：剩余价值和唯物史观；坚持科学的立场、观点和方法
- 发展：第一国际与巴黎公社，第二国际与马恩晚年，十月革命
- 预测：无产阶级革命至少将在几个主要的资本主义国家同时发生，社会主义可能在经济文化落后的俄国首先取得胜利
- 意义：变成现实，建立国家，鼓舞革命，掀起解放斗争，推广马列主义和无产阶级政党
- 教训：放弃了社会主义道路，放弃了无产阶级专政，放弃了共产党的领导地位，放弃了马克思列宁主义，结果使得已经相当严重的经济、政治、社会、民族矛盾进一步计划最终导致制度剧变、国家解体
科学社会主义的基本原则
- 资本主义必然灭亡，社会主义必然胜利；无产阶级是最先进最革命的阶级；无产阶级革命是无产阶级进行斗争的最高形式，以建立无产阶级专政的国家为目的；要在生产资料公有制基础上组织生产；要对社会生产进行有计划的指导和调节，实行按劳分配的原则；要合乎自然规律地改造和利用自然；坚持科学的理论指导；政党是无产阶级的先锋队，坚持无产阶级政党的领导；发展生产力；共产主义是人类最美好的社会
- 正确把握：坚持一般原则；与本国实际相结合；不断总结新鲜经验
一些规律
- 经济文化相对落后的国家走向社会主义建设社会主义的长期性：生产力，经济，上层建筑，国际环境，马理论
- 社会主义发展道路的多样性：生产力，历史文化，时代实践
- 探索适合本国国情的社会主义发展道路：坚持马科学态度，以当时当地的历史条件出发，充分吸收人类一切文明成果
- 社会主义在实践探索中开拓前进：遵循人类社会发展，遵循社会主义建设，遵循共产党执政
共产主义
- 预见未来社会的方法论
  - 在揭示人类社会发展一般规律的基础上指明社会发展的方向
  - 在剖析资本主义社会旧世界中阐发未来新世界的特点
  - 在社会主义社会发展中不断深化对未来共产主义社会的认识
  - 立足于揭示未来社会的一般特征，而不作详尽的细节描绘
- 共产主义社会的基本特征
  - 物质财富极大丰富，消费资料按需分配
  - 社会关系高度和谐，人们精神境界极大提高
    - 阶级，国家，战争消亡
    - 三大差别（工业和农业、城市和农村、脑力劳动和体力劳动）消失
  - 每个人自由而全面的发展，人类从必然王国向自由王国的飞跃
    - 旧式分工的消除为人的自由而全面的发展创造条件
    - 自由时间的延长为人的自由而全面的发展提供了广阔的前景
    - 劳动不再是单纯的谋生手段，而成为“生活的第一需要”
- 实现共产主义是历史发展的必然要求：是能够实现的社会理想，是人类最伟大的事业
- 实现共产主义是一个长期的历史过程

马原速成

Tue, 10 Jun 2025 23:10:59 +0800

一、导论

什么是马克思主义

马克思主义是由马克思、恩格斯创立并为后继者所不断发展的科学理论体系，是关于自然、社会和人类思维发展一般规律的学说，是关于社会主义必然代替资本主义、最终实现共产主义的学说，是关于无产阶级解放、全人类解放和每个人自由而全面发展的学说，是无产阶级政党和社会主义国家的指导思想，是指引人民创造美好生活的行动指南。
三个组成部分：马克思主义哲学、马克思主义政治经济学和科学社会主义

什么是马克思主义基本原理

含义：对马克思主义立场观点方法的集中概括，是马克思主义在其形成、发展和运用过程中经过实践反复检验而确立起来的具有普遍真理性的理论。
特点：具有普遍的、根本的和长远的指导意义。
马克思主义的基本立场，是马克思主义观察、分析和解决问题的根本立足点和出发点。
马克思主义的基本观点，是关于自然、社会和人类思维发展一般规律的科学认识，是对资本主义社会和社会主义社会发展规律的科学认识，是对人类思想成果和社会实践经验的科学总结。
马克思主义的基本方法，是建立在辩证唯物主义和历史唯物主义世界观和方法论基础上，指导我们正确认识世界和改造世界的思想方法和工作方法。

马克思主义的创立与发展

德国古典哲学、英国古典政治经济学、英法空想社会主义为马克思主义的创立提供了直接的理论来源。
细胞学说、能量守恒定律、生物进化论，为马克思主义的创立提供了自然科学前提。
1848年2月，《共产党宣言》发表

马克思主义的基本特征

科学性，人民性，实践性，发展性
基本特征一句话概括：科学性与革命性的统一

二、世界的物质性及其发展规律

世界多样性与物质统一性

物质范畴是一切唯物哲学的理论基石。
- 恩：“物、物质无非是各种物的总和，而这个概念就是从这一总和中抽象出来的”
物质范畴的理论意义：坚持了唯物主义一元论；坚持了能动的反映论和可知论，批判了不可知论；体现了唯物论和辩证法的统一，克服了形而上学唯物主义的缺陷；体现了唯物主义自然观与历史观的统一
物质的根本属性是运动。
物质世界的二重化：一方面，世界分化为自然界与人类社会（劳动，人的印记，人的实践活动）；另一方面，世界分化为客观世界和主观世界。
意识的起源：自然界长期发展；社会历史发展。
物质决定意识，意识对物质具有能动的反作用。
主观能动性和客观规律性的辩证统一：一方面，尊重客观规律是正确发挥主观能动性的前提；另一方面，只有充分发挥主观能动性，才能正确认识和利用客观规律。
世界的统一性在于它的物质性，世界（自然界，社会，意识）统一于物质。物质的统一性是多样性的统一。

事物的普遍联系和变化发展

唯物辩证法认为，世界上的万事万物都处于普遍联系之中，普遍联系引起事物的变化发展。
事物的普遍联系的性质：客观性，普遍性，多样性，条件性
对立统一规律是唯物辩证法的实质和核心。
矛盾的同一性是指矛盾着的对立面相互依存、相互贯通的性质和趋势；矛盾的斗争性是矛盾着的对立面相互排斥、相互分离的性质和趋势。矛盾的同一性和斗争性相互联结、相辅相成，在事物发展中具有重要作用。
矛盾的普遍性是指矛盾存在于一切事物中，存在于一切事物发展过程的始终；矛盾的特殊性是指各个具体事物的矛盾、每一个矛盾的各个方面在发展的不同阶段上各有其特点。事物是由多种矛盾构成的。
量变是质变的必要准备；质变是量变的必然结果。
任何事物内部都包含肯定的方面与否定的方面，由于矛盾双方的相互作用，当否定的方面上升至支配地位时，事物就会由肯定走向对自身的否定，再由否定进一步走向更高阶段的肯定，即否定之否定。否定之否定规律揭示了事物发展的前进性与曲折性的统一。
任何事物都是内容与形式的统一；本质与现象是揭示事物内在联系和外在表现的一对范畴；原因与结果是揭示事物引起和被引起关系的一对范畴；必然与偶然是揭示事物产生、发展和衰亡过程中的不同趋势的一对范畴。现实与可能是反映事物的过去、现在和将来关系的一对范畴

三、实践与认识及其发展规律

实践与认识

实践是人类能动地改造世界的社会性的物质活动
科学实践观的意义：克服了旧唯物主义的根本缺陷；揭示了实践对认识的决定作用；在人类思想史上第一次揭示了社会生活的实践本质；为人们能动地认识世界和改造世界提供了基本的思想方法和工作方法。
实践的本质：客观实在性；自觉能动性；社会历史性
实践的基本结构：主体，客体，中介。实践的基本结构是历史的变化发展的。
实践形式的基本类型：物质生产实践，社会政治实践，科学文化实践
实践对认识的决定作用：实践是认识的来源；实践是认识发展的动力；实践是认识的目的；实践是检验认识真理性的唯一标准。
认识的本质是主体在实践基础上对客体的能动反映。
辩证唯物主义认识论有两个突出的特点：一是把实践的观点引入认识论；二是把辩证法应用于反映论考察认识的发展过程。
人们认识一定事物的过程，是一个从实践到认识，再从认识到实践的过程。
感性认识和理性认识是人对客观世界的两种不同水平的反映形式。两者辩证统一。
从认识到实践的飞跃的重要性：认识世界的目的是改造世界；认识的真理性只有在实践中才能得到检验和发展

真理与价值

马克思主义真理观：真理与客观事物之间的符合关系是建立在人类能动地改造客观世界的实践基础上的，是通过人的能动的反映活动而实现的，并且必然随着人类实践的发展而拓展和深化。
客观性是真理的本质属性。真理的客观性决定了真理的一元性。
真理的绝对性是指真理主客观统一的确定性和发展的无限性。它有两个方面的含义：一是指任何真理都标志着主观与客观相符合；二是人类认识按其本性来说，能够正确认识无限发展着的物质世界，认识每前进一步，都是对无限发展着的物质世界的接近。
真理的相对性：人们在一定条件下对客观事物及其本质和发展规律的正确认识总是有限度的、不完善的。
真理的绝对性和相对性辩证统一。
真理与谬误相互对立；真理与谬误的对立是相对的，它们在一定条件下可以互相转化。
实践是检验真理的唯一标准的原因：真理是人们对客观事物及其发展规律的正确反映，它的本性在于主观和客观相符合；实践具有直接现实性。实践的直接现实性是它的客观实在性的具体表现
价值是反映主体和客体之间意义关系的哲学范畴，是客体对个人、群体乃至整个社会的生活和活动所具有的意义
价值的基本特性：主体性，客观性，多维性，社会历史性
价值评价是主体对客体的价值以及价值大小所作的评判或判断。
价值评价的特点：评价以主客体之间的价值关系为认识对象；评价结果与评价主体直接相关；评价结果的正确与否依赖于对客体状况和主体需要的认识；价值评价有科学与非科学之别。
价值观是人们关于价值本质的认识以及对人和事物的评价标准、评价原则和评价方法的观点的体系。
人们的实践活动总是受着真理尺度和价值尺度的制约。真理尺度与价值尺度是紧密联系、不可分割的辩证统一关系。

认识世界和改造世界

认识世界和改造世界是相互依赖、相互制约的辩证统一关系。
改造客观世界和改造主观世界是辩证统一的。
自由是表示人的活动状态的范畴，是指人在活动中通过认识和利用必然所表现出的一种自觉自主的状态。
认识必然和争取自由，是人类认识世界和改造世界的根本目标，是一个历史性的过程。
一切从实际出发,就是要把客观存在的事物作为观察和处理问题的根本出发点。

四、人类社会及其发展规律

人类社会的存在与发展

社会存在是指社会物质生活条件，是社会生活的物质方面，主要包括自然地理环境、人口因素和物质生产方式。
社会意识是社会存在的反映，是社会生活的精神方面。根据不同的主体，社会意识可分为个体意识和群体意识。根据不同的层次，社会意识可分为社会心理和社会意识形式。社会意识形式有意识形态和非意识形态之分。
社会存在是社会意识内容的客观来源，社会意识是社会物质生活过程及其条件的主观反映。
社会意识的能动作用是通过指导人们的实践活动实现的。
生产力是人类在生产实践中形成的改造和影响自然以使其适合社会需要的物质力量。
生产力的基本要素：劳动资料，劳动对象，劳动者
生产关系是社会关系中最基本的关系
生产资料公有制和私有制。生产力和生产关系的矛盾运动中内在的联系就是生产关系一定要符合生产力状况的规律。
经济基础是指由社会一定发展阶段的生产力所决定的生产关系的总和。
上层建筑是建立在一定经济基础之上的意识形态以及与之相适应的制度、组织和设施。
国体是指社会各阶级在国家中的地位，表明国家政权掌握在哪个阶级手里；政体是指统治阶级实现其阶级统治的具体组织形式。
交往是唯物史观的重要范畴，指在一定历史条件下的现实的个人、群体、阶级、民族、国家之间在物质和精神上相互往来、相互作用、彼此联系的活动。交往与生产力发展相伴随。
物质交往和精神交往。
交往的作用：促进生产力的发展；促进社会关系的进步；促进文化的发展与传播；促进人的全面发展。
社会进步的两个方面：社会形态从低级到高级，同一社会形态内部的发展。
社会进步促进人的发展，推动人类解放。
社会形态包括社会的经济形态、政治形态和意识形态，是三者具体的、历史的统一。
- 列宁：“世界历史发展的一般规律，不仅丝毫不排斥个别发展阶段在发展的形式或顺序上表现出特殊性，反而是以此为前提的。”
社会形态更替的必然性指社会形态依次更替的过程和规律是客观的，基本趋势是确定不移的。其历史选择性归根结底是人民群众的选择性。
文明是人类创造的所有物质成果、精神成果和制度成果的总和，是标志社会进步程度的范畴，反映了人类社会实践活动的积极成果。文明发展的程度体现了民族，国家，社会发展的水平。
人类文明具有多样性。

社会历史发展的动力

社会发展动力是一个系统，其中基础性和根本性的动力是社会基本矛盾。
社会基本矛盾是指贯穿社会发展过程始终，规定社会发展过程的基本性质和基本趋势，并对社会历史发展起根本推动作用的矛盾。生产力和生产关系、经济基础和上层建筑的矛盾是社会基本矛盾。
社会基本结构主要包括经济结构、政治结构和观念结构。
首先，生产力是社会基本矛盾运动中最基本的动力因素，是人类社会发展和进步的最终决定力量；生产力是社会进步的根本内容，是衡量社会进步的根本尺度。
社会基本矛盾特别是生产力和生产关系的矛盾，决定着社会中其他矛盾的存在和发展。
社会基本矛盾是其他一切社会矛盾的根源，规定和制约着社会主要矛盾的存在和发展，社会主要矛盾是社会基本矛盾的具体体现。
阶级斗争是社会基本矛盾在阶级社会中的表现。
阶级和阶级斗争观点是唯物史观的基本观点。
- 恩格斯：“用‘历史唯物主义’这个名词来表达一种关于历史过程的观点……这种观点认为，一切重要历史事件的终极原因和伟大动力是社会的经济发展，是生产方式和交换方式的改变，是由此产生的社会之划分为不同的阶级，是这些阶级彼此之间的斗争。”
阶级斗争是阶级利益根本冲突的对抗阶级之间的对立和斗争；阶级斗争对阶级社会发展的推动作用突出地表现在社会形态的更替中。
革命根源于社会基本矛盾的尖锐化。
科技革命是推动经济和社会发展的强大杠杆
- 马克思：“伟大的历史杠杆”，“最明显的字面意义而言的革命力量”
科技革命的影响：首先，对生产方式产生了深刻影响；其次，对生活方式产生了巨大影响；最后，促进了思维方式的变革。
文化对社会发展的影响：第一，文化为社会发展提供思想指引；第二，文化为社会发展提供精神动力；第三，文化为社会发展提供凝聚力量。

人民群众在历史发展中的作用

人民群众是历史的创造者（唯物史观中的群众史观）
- 马克思：“人的本质不是单个人所固有的抽象物，在其现实性上，它是一切社会关系的总和”
人的本质属性是社会属性。
人民群众在创造历史过程中的决定作用：人民群众是社会物质财富的创造者；人民群众是社会精神财富的创造者；人民群众是社会变革的决定力量。
人民群众创造历史的活动受到一定社会历史条件的制约：经济条件，政治条件，精神文化条件
马克思主义群众观点：坚信人民群众自己解放自己的观点，全心全意为人民服务的观点，一切向人民群众负责的观点，虚心向人民群众学习的观点。
群众，阶级，政党，领袖环环相扣，构成一个有机整体

资本主义的本质及规律

商品经济和价值规律

商品经济是以交换为目的而进行生产的经济形式，是一定社会历史条件的产物。商品经济得以产生的社会历史条件有两个：一是存在社会分工，二是生产资料和劳动产品属于不同的所有者。
商品是用来交换、能满足人的某种需要的劳动产品，具有使用价值和价值两个因素或两种属性，是使用价值和价值的矛盾统一体。使用价值和价值对立统一。
价值是交换价值的基础，交换价值是价值的表现形式。
商品是劳动产品，生产商品的劳动具有二重性，即具体劳动和抽象劳动。
劳动生产率指的是劳动者生产使用价值的效率。
货币：商品内在的使用价值和价值的矛盾转化为为商品和货币的外在矛盾。
价值规律：商品的平均价格和价值是相一致的。
价值规律的作用：第一，自发地调节生产资料和劳动力在社会各生产部门之间的分配比例；第二，自发地刺激社会生产力的发展；第三，自发地调节社会收入的分配。
价值规律的消极后果：导致社会资源浪费；阻碍技术进步；导致收入两极分化。
私人劳动和社会劳动的矛盾是商品经济的基本矛盾。社会性质：由社会分工决定；私人性质：由生产资料私有制决定。这个矛盾是商品经济其他一切矛盾的基础。具体劳动能否还原为抽象劳动，在根本上取决于私人劳动和社会劳动能否实现统一。
- 马克思：“商品拜物教”：人与人之间一定的社会关系被物与物的关系所掩盖
马克思劳动价值论的理论和实践意义：第一，马克思劳动价值论扬弃了英国古典政治经济学的观点，为剩余价值论的创立奠定了基础（马克思：“理解政治经济学的枢纽”）；第二，马克思劳动价值论揭示了私有制条件下商品经济的基本矛盾，为从物与物的关系背后揭示人与人的关系提供了理论依据。第三，马克思劳动价值论揭示了商品经济的一般规律，对理解社会主义市场经济具有指导意义。
马克思主义政治经济学是经济学上的一场深刻革命，它站在无产阶级立场，运用辩证唯物主义和历史唯物主义的科学方法，批判继承了英国古典政治经济学的合理成分，创立了科学的劳动价值论和剩余价值论，深刻揭示了资本主义生产和剥削的秘密，揭露了无产阶级与资产阶级之间阶级对立和斗争的经济根源，论证了资本主义必然灭亡和社会主义必然胜利的客观规律，指明了无产阶级的历史使命是推翻资本主义制度和建立社会主义制度，最终实现共产主义。

资本主义经济制度

劳动力成为商品的两个基本条件：其一，劳动者在法律上是自由人，能够把自己的劳动力当作自己的商品来支配；其二，劳动者没有任何生产资料，没有生活资料来源，因而不得不依靠出卖劳动力为生。实质上是剥削工人的雇佣劳动关系。
- 马克思：“劳动力的价值，是由生产、发展、维持和延续劳动力所必需的生活必需品的价值决定的。”
资本主义生产过程具有二重性：一方面是生产物质资料的劳动过程；另一方面是生产剩余价值的过程，即价值增殖过程。
绝对剩余价值是指在必要劳动时间不变的条件下，由于延长工作日的长度或提高劳动强度而生产的剩余价值。
相对剩余价值是指在工作日长度不变的条件下，通过缩短必要劳动时间而相对延长剩余劳动时间所生产的剩余价值。
把剩余价值转化为资本，或者说，剩余价值的资本化，就是资本积累。资本积累是资本主义扩大再生产的源泉。
资本循环是资本从一种形式出发，经过一系列形式的变化，又回到原来出发点的运动。资本的周转。
剩余价值理论深刻揭露了资本主义生产关系的剥削本质，阐明了资产阶级与无产阶级之间阶级斗争的经济根源，指出了无产阶级革命的历史必然性。
资本主义基本矛盾：生产社会化和生产资料资本主义私人占有之间的矛盾。
资本主义发展到一定阶段，就会发生以（相对）生产过剩为基本特征的经济危机。
资本主义经济危机具有周期性，这是由资本主义基本矛盾运动的阶段性决定的。

（后续部分不是简答题和辨析题的要点，故不作整理）

抽象代数速成

Wed, 28 May 2025 18:00:00 +0800

此文尚未完工，可能还会有重大改动或者被废弃

群

关系：有序对集合
- 等价：反身，对称，传递
- 等价类 $[a]$，等价关系商集，分类/划分
群
- 代数运算
- 群：代数运算，结合律，单位元，逆元
- 交换群，有限群
- 性质：
  - 单位元唯一，逆元唯一，消去律成立
  - 方幂的指数法则
- 充要条件1：结合，左单位，左逆
- 充要条件2：结合，$ax=b, ya=b$ 有解
子群 $H<G$
- 平凡：$G, \lbrace e\rbrace$
- 性质：$H,G$ 单位元相同，逆元相同
- 充要条件1：$ab\in H, a^{-1}\in H$
- 充要条件2：$ab^{-1}\in H$
- 充要条件3：有限，$ab\in H$
- 子群的交是子群，子群并是子群<=>包含，子群乘积是子群<=任一正规
同构 $\cong$
- 同态：$\forall a,b\in G, \phi(ab)=\phi(a)\phi(b)$
  - 单位元、逆元对应
  - $\operatorname{ord}(\phi(a)) \mid \operatorname{ord}(a)$
  - 子群、正规子群保持
  - $\ker \phi = \phi^{-1}(e’) = \lbrace x\in G \mid \phi(x) = e’\rbrace \triangleleft G$
  - 循环群 $\langle g\rangle$ 的同态由 $\phi(g)$ 确定
  - 自然同态 $G \to G/H: a \to \bar{a}$
- 同构：一一映射的同态
  - 恒等同构 $\iota$
  - $\phi(e)=e’$, $\phi(a^{-1})=a’^{-1}$, $\phi^{-1}$ 是同构映射
  - 同构是等价关系
  - 判定：构造 $\phi$，同态+单满
- 群同态基本定理：
  - 若 $\phi: G\to G’$ 满，则 $G/\ker \phi \cong G’$ - 满同态的集合结构（并非同构）：$\ker \phi \times G'$
  - $HK/K \cong H/(H\cap K)$ （$H$ 不需要正规）- $HK$ 的结构：$K \times (H/(H\cap K))$
  - $(G/N)/(K/N)\cong G/K$
阶
- $\operatorname{ord}(a) = \min\lbrace r\rbrace \quad\text{s.t.}\quad a^r=e$
- $\operatorname{ord}(a)\mid|G|$
循环群
- 存在 $a$ 使 $G=\langle a\rangle$
- $a^r$ 是生成元 $\Leftrightarrow$ $r, |G|$ 互素；$G$ 恰有 $\phi(n)$ 个生成元
- $\langle a^r\rangle = \langle a^{gcd(r,n)}\rangle$
- 结构：无限 $\cong(\mathbb{Z},+)$, 有限 $\cong(\mathbb{Z_n},+)$；子群是循环群（推论：$\langle a\rangle$ 的子群为 $\lbrace\langle a^d\rangle | d|\operatorname{ord}(a)\rbrace$ ）
- 循环群 $\langle g\rangle$ 的同态由 $\phi(g)$ 确定
- 素数阶群是循环群（拉格朗日定理）（2.2.23 $pq$ 阶群是循环群）
置换群
- 每一个有限群同构于一个置换群
- $n$次置换群 $S_n$ 的阶是 $n!$。
- $\tau\sigma\tau^{-1} = \left(\begin{array}{} \tau(1) & \tau(2) &\cdots &\tau(n) \newline \tau(\sigma(1)) & \tau(\sigma(2)) &\cdots &\tau(\sigma(n)) \end{array}\right)$
- 轮换 $(i_1i_2\cdots i_n)$
- $(a,b)=(1,a)(1,b)(1,a)$
- 不相交的轮换是可以交换的，每一个置换可（唯一）表为一些不相交轮换的乘积
- 每个置换都可表为对换的乘积
- 奇偶置换，将一个置换表示为对换的乘积，所用对换个数奇偶性唯一
子群
- $gA=gB\Leftrightarrow A=B \Leftrightarrow Ag=Bg$
- $H\cdot H = H$
- $A,B$ 是子群，$AB$ 是子群 $\Leftrightarrow AB=BA$
- 陪集 $aH$ （$H$ 是子群，非正规时，陪集结构比较丑陋）；陪集集 $G/H=\lbrace gH|g\in G\rbrace$
- $aH=H$ $\Leftrightarrow$ $aH$ 为群 $\Leftrightarrow$ $a\in H$
- $aH=bH \Leftrightarrow a\in H$
- 拉格朗日定理：
  - $H$ 在 $G$ 中的指数 / $H$ 陪集个数 $[G : H] = |G/H| = |H \backslash G| = \frac{|G|}{|H|}$
  - 一个元素的阶都是 $|G|$ 的因子
  - $[G : K] = [G : H][H : K]$
  - $|A||B| = |AB||A\cap B|$ （证明：构造 $A/A\cap B \to A/B: x(A\cap B)\mapsto xB$）
  - 费马定理：$a^{p-1}\equiv1\mod p$
正规子群
- $H\triangleleft G$ : $\forall a\in G, aH = Ha$
  - 平凡：$G,\lbrace e\rbrace$；只有平凡正规子群的是单群
  - 交换群的子群是正规子群
  - 正规子群的子群是正规子群
  - 正规子群的交、积是正规子群
  - $[G:H]=2 \Rightarrow H\triangleleft G$
- 判定：$\forall a\in G, aha^{-1}\in H$
- 商群：陪集 $aH$ 集合，$|G/H|=[G:H]=\frac{|G|}{|H|}$ （可以考虑成 $\cong \lbrace a\rbrace$）
- tip：
  - 对置换群，利用 $\tau\sigma\tau^{-1}$
  - $\forall \sigma\in G, H\triangleleft G$, 有 $\sigma^{[G:H]}\in H$
  - 交换群
直积
- 外直积： $G_1 \times G_2$ or $G_1 \oplus G_2$
  - $|G_1\times G_2| = |G_1||G_2|$
  - $\operatorname{ord}(a,b)=lcm(\operatorname{ord}(a),\operatorname{ord}(b))$
  - $\langle m \rangle \times \langle n \rangle$ 循环 $\Leftrightarrow$ $gcd(\operatorname{ord}(m), \operatorname{ord}(n)) = 1$
- 内直积：$HK$ if $H\cap K = \lbrace e\rbrace , H,K\triangleleft G$
- 内直积充要条件：$G$ 中每个元素唯一表示为 $hk$，且 $h,k$ 可交换（证明：考虑 $hkh^{-1}k^{-1}\in H\cap K = \lbrace{e}\rbrace$）
- 内直积（若存在）同构于外直积
环 $(R,+,\cdot)$
- $(R,+)$ 交换群，乘法结合律、分配律成立
- 单位：乘可逆元（注意和单位元区别）
- 子环 $S<R$：加法封闭，乘法封闭
- 无零因子：乘消去律成立
- 整环：无零因子，有单位元，交换
- 域：加交换群，去除0后为乘交换群（除0可逆的整环）
  - 例：$\mathbb{C,R,Q},F[x],\mathbb{Q}[\sqrt{d}],Z_p$
  - 可定义除法 $a\div b=a\cdot b^{-1}$
- 理想 $I\triangleleft R$：加法封闭，乘法吸收，$IR\subseteq I$, $RI\subseteq I$
  - 充要条件：$a-b, ar, ra \in I$
  - 平凡：$\lbrace 0\rbrace , R$
  - 理想的交、和是理想
  - 主理想 $\langle a \rangle$ 为最小的含 $a$ 理想/带 $a$ 理想的交
    - 交换环：$\langle a \rangle = \lbrace xa+ma, x\in R, m\in Z\rbrace$
    - $R$ 有单位元：$\langle a \rangle =\lbrace xa,x\in R\rbrace$
  - 素理想：$a,b\in R, ab\in P \Rightarrow a\in P \text{ or } b\in P$
    - $R$ 有单位元、交换，则 $P$ 素 $\Leftrightarrow$ $R/P$ 是整环
  - 极大理想 $M$：不存在理想 $N$, $M\subset N \subset R$
    - $R$ 有单位元、交换，则 $P$ 极大 $\Leftrightarrow$ $R/P$ 是域
    - $R$ 有单位元、交换，则 $P$ 极大 $\Rightarrow$ $P$ 素
- 商环 $R/I$：由+交换，$I$ 显然正规
- 环同态：加乘同态
  - 整数乘、整数幂次同态，乘单位
  - 满同态：$\phi(e)=e’$；$R’$ 无零因子，$\phi(e)=e’ \text{ or } 0$；若 $\phi(e_1)=e_1'$
- 中国剩余定理：若 $R$ 单位且交换，$I,J$ 是理想，$I+J=R$，则
  1. $I\cap J = IJ$
  2. $R/IJ \cong R/I \times R/J$
- 特征 $\operatorname{Char}\ R = \min\lbrace n | \forall a\in R, na=0, n\in \mathbb{N}^*\rbrace$
  - $R$ 有单位元，$\operatorname{Char}(R)=\operatorname{ord}(e)$
  - Char 整环是素数
  - $F$ 是域，则有子域 $F’\cong Z_{\operatorname{Char}\ F}$
奇怪的群
- $G$ （群/环）的中心 $C(G)$：$\lbrace g | gx=xg. \forall x \in G\rbrace$ 是子群/子环
- $G$ 的内自同构群 $\operatorname{Inn}(G)=\lbrace f(x)=gxg^{-1} | g\in G\rbrace$ 是自同构群 $\operatorname{Aut}(G)$ 的正规子群，$\operatorname{Aut}(G) / \operatorname{Inn}(G) = \operatorname{Out}(G)$ 为外自同构群
- $GL_n$: $n$ 阶可逆矩阵乘法群；$SL_n$: $n$ 阶行列式 1 矩阵乘法群
- 生成子群 $\langle S\rangle = \cap _{S\subseteq H<G} H, S\subseteq G$
  - 若 $S=\lbrace s_1,…s_n\rbrace$，记 $\langle S\rangle = \langle s_1…s_n\rangle$
  - $S=\lbrace s_1^{l_1}…s_k^{l_k} | s_1…s_k\in S, l_i\in \mathbb{Z}\rbrace$ (tip: $s_i, s_j$ 可重复（不交换）)
- 变换群：
  - 令 $S_X$ 为 $X$ 中所有可逆变换组成的集合，$S_X$ 关于变换合成构成群，称为对称群
  - $S_X$ 的子群为变换群
  - 凯莱定理：每个群都同构于一个变换群 $G_\mathcal{l} = \lbrace \phi_a(x)=ax|a\in G\rbrace$
- $p$ 素，$Z^\star_p$ 是 $p-1$ 阶循环群
- $n$次置换群 $S_n$ 的阶是 $n!$。
- $A_n$ 偶置换构成 $S_n$ 的一个子群称为 $n$ 次交错群
- 整数环的理想：找到最小元，构成主理想
方法论
- 集合相等：包含且被包含（某方向可用 $|G|$ 相等替代） / 单射+满射
- 没思路：数学归纳法

lug 源码速览

Mon, 24 Feb 2025 09:37:00 +0800

lug 是 sjtug mirror 最为核心一个组件。其主要功能是定时跑脚本；功能很简单，代码量不少，结构很是清晰。

├── Dockerfile
├── LICENSE
├── README.md
├── cli/lug
│   ├── license.go
│   └── main.go
├── go.mod
├── go.sum
└── pkg
    ├── config
    │   └── config.go
    ├── exporter
    │   └── exporter.go
    ├── helper
    │   ├── disk_usage.go
    │   └── max_length_slice.go
    ├── manager
    │   ├── json_rest.go
    │   └── manager.go
    └── worker
        ├── executor.go
        ├── executor_invoke_worker.go
        ├── external_worker.go
        ├── shell_script_executor.go
        ├── utilities.go
        ├── utility_rlimit.go
        └── worker.go

先从入口开始吧。入口位于 cli/lug，licence.go 由 scripts/gen_license.sh （从被 git ignore 的 vendor/）生成，看起来像是圣遗物…主要的还是 main.go。

离散数学笔记

Wed, 15 Jan 2025 14:00:00 +0800

“x>y” 并非命题
简单命题/原子命题：不含联结词的命题
P→Q 中，P 为前件/前项/条件，Q 为后件/后项/结论
代入规则：从简单到复杂
⊽ 异或 ↑与非 ↓或非
除非：¬P→Q
悖论并非命题
推理形式：由前提和结论经蕴涵词联结而成的；正确的：重言的
等值：AB共同的命题变项任一解释，且不同的命题变项任意解释，真值相同
等值定理：A=B ⇔ A↔B
置换规则：等值可任意替换
等值公式：
- 分配律：
  - P∨(Q∧R) = (P∨Q)∧(P∨R)
  - P∧(Q∨R) = (P∧Q)∨(P∧R)
  - P→(Q→R) = (P→Q)→(P→R)
- 吸收律
  - P∨(P∧Q) = P
  - P∧(P∨Q) = P
- 前提合并 P→(Q→R) = (P∧Q)→R = Q→(P→R)
- (P→R)∧(Q→R) = (P∨Q)→R
- 归谬论 (P→Q)∧(P→¬Q) = ¬P
n 元联结词个数：2^2^n
基底：完备，联结词不能相互表示；元素不超过3个
¬A = A*⁻；A〜A⁻，¬A〜A* （证明尽量避免星号）
推理演算：前提引入，结论引用，代入规则，置换规则，分离规则，条件证明规则/附加前提
归结证明：子句集，归结
形式化
- 有的 A 是 B：(∃x)(A(x)∧B(x))
- A 都是 B 的：(∀x)(A(x)→B(x))
- 仅当 A 才 B: B→A

集合论

外延表示法：0,1,2 或 0,1,2,… 或 0,1,2,…,7,8,9

Flattened Device Tree Blob

Tue, 14 Jan 2025 14:00:00 +0800

Device Tree 是一个硬件系统的描述，是对于 ACPI 的一个静态、轻量级的平替。它在定制主板/PCB的 ARM 和 RISC-V 系统上广泛使用；但在一些传统技术积累深厚的平台和兼容 UEFI 的系统上 ACPI 仍是更常见的选择。

当 Kernel 被 boot 时，它首先得通过 ACPI 或 Device Tree 获得设备信息，尤其是内存和 CPU 信息；有了这些信息内核才能初始化内存子系统、内核堆、任务队列等最最基础的内核模块。

Device Tree 和 ACPI 都有网页版的规范文件，光看篇幅就能看出 Device Tree 相当简单，而 ACPI 功能丰富。

Flattened Device Tree Blob (FDT/DTB) 则是 bootloader 传递给 kernel 的 Device Tree 二进制编码，这是本文的主角，由 spec 的第五章描述；但要能解析 FDT 还是得看完整个 spec。

基本结构

它通过类似 JSON 的树状结构描述设备树。不同于 JSON 的超多类型，Device Tree 只由两种元素构成：Node 和 Property。Node 是一个带名字的子元素列表，而 Property 是一个键值对，其中值由一串 u32 构成（实质上类似 void*，由驱动自行解析内容）。可以描述如下：

原子操作与内存顺序

Tue, 14 Jan 2025 14:00:00 +0800

注：本文作于刚学完计算机组成时，对真实 CPU 设计理解较少，有不少事实错误与过度简化，但结论应当是没有问题的。仅供参考，欢迎交流。

额外资料：

https://users.cs.utah.edu/~aburtsev/cs5460/lectures/lecture13-memory-ordering/lecture13-memory-barriers.pdf

https://www.puppetmastertrading.com/images/hwViewForSwHackers.pdf

当我第一次遇到“原子操作”

曾经我刚接触原子操作时，产生了造自旋锁的梦；然而 Linus 的言论给我泼了一盆冷水：

In fact, I’d go even further: don’t ever make up your own locking routines. You will get the wrong, whether they are spinlocks or not. You’ll get memory ordering wrong, or you’ll get fairness wrong, or you’ll get issues like the above “busy-looping while somebody else has been scheduled out”.

当我兴致勃勃地搜索内存顺序——发现 C++ 规定多达六种顺序，网上的解释也五花八门。

CPP Reference (解读: 1 2 3) 定义了大量术语，包括 sequenced-before carries dependency (simply/strongly) happen before modification order release sequence dependency-ordered before inter-thread happens-before visible side-effects，建立了一个极其复杂、一看就是给编译器开发者而非普通开发者和 CPU 开发者写的依赖图模型。

[Rust 每日一库] base64

Tue, 26 Nov 2024 19:10:59 +0800

又功能一相当基础的小而美库

核心功能

base64 库把核心功能在 engine::Engine

pub trait Engine {
    fn internal_encode(&self, input: &[u8], output: &mut [u8]) -> usize;
    fn internal_decoded_len_estimate(&self, input_len: usize) -> Self::DecodeEstimate;
    fn internal_decode(
        &self,
        input: &[u8],
        output: &mut [u8],
        decode_estimate: Self::DecodeEstimate,
    ) -> Result<DecodeMetadata, DecodeSliceError>;

}

然后它实现了一个 GeneralPurpose 实现了这个 Trait

值得注意的是它的实现用到了循环展开

fn read_u64(s: &[u8]) -> u64 {
    u64::from_be_bytes(s[..8].try_into().unwrap())
}
fn internal_encode(&self, input: &[u8], output: &mut [u8]) -> usize {
    let mut input_index: usize = 0;

    const BLOCKS_PER_FAST_LOOP: usize = 4;
    const LOW_SIX_BITS: u64 = 0x3F;

    // we read 8 bytes at a time (u64) but only actually consume 6 of those bytes. Thus, we need
    // 2 trailing bytes to be available to read..
    let last_fast_index = input.len().saturating_sub(BLOCKS_PER_FAST_LOOP * 6 + 2);
    let mut output_index = 0;

    if last_fast_index > 0 {
        while input_index <= last_fast_index {
            // Major performance wins from letting the optimizer do the bounds check once, mostly
            // on the output side
            let input_chunk =
                &input[input_index..(input_index + (BLOCKS_PER_FAST_LOOP * 6 + 2))];
            let output_chunk =
                &mut output[output_index..(output_index + BLOCKS_PER_FAST_LOOP * 8)];

            // Hand-unrolling for 32 vs 16 or 8 bytes produces yields performance about equivalent
            // to unsafe pointer code on a Xeon E5-1650v3. 64 byte unrolling was slightly better for
            // large inputs but significantly worse for 50-byte input, unsurprisingly. I suspect
            // that it's a not uncommon use case to encode smallish chunks of data (e.g. a 64-byte
            // SHA-512 digest), so it would be nice if that fit in the unrolled loop at least once.
            // Plus, single-digit percentage performance differences might well be quite different
            // on different hardware.

            let input_u64 = read_u64(&input_chunk[0..]);

            output_chunk[0] = self.encode_table[((input_u64 >> 58) & LOW_SIX_BITS) as usize];
            output_chunk[1] = self.encode_table[((input_u64 >> 52) & LOW_SIX_BITS) as usize];
            output_chunk[2] = self.encode_table[((input_u64 >> 46) & LOW_SIX_BITS) as usize];
            output_chunk[3] = self.encode_table[((input_u64 >> 40) & LOW_SIX_BITS) as usize];
            output_chunk[4] = self.encode_table[((input_u64 >> 34) & LOW_SIX_BITS) as usize];
            output_chunk[5] = self.encode_table[((input_u64 >> 28) & LOW_SIX_BITS) as usize];
            output_chunk[6] = self.encode_table[((input_u64 >> 22) & LOW_SIX_BITS) as usize];
            output_chunk[7] = self.encode_table[((input_u64 >> 16) & LOW_SIX_BITS) as usize];

            let input_u64 = read_u64(&input_chunk[6..]);

            output_chunk[8] = self.encode_table[((input_u64 >> 58) & LOW_SIX_BITS) as usize];
            output_chunk[9] = self.encode_table[((input_u64 >> 52) & LOW_SIX_BITS) as usize];
            output_chunk[10] = self.encode_table[((input_u64 >> 46) & LOW_SIX_BITS) as usize];
            output_chunk[11] = self.encode_table[((input_u64 >> 40) & LOW_SIX_BITS) as usize];
            output_chunk[12] = self.encode_table[((input_u64 >> 34) & LOW_SIX_BITS) as usize];
            output_chunk[13] = self.encode_table[((input_u64 >> 28) & LOW_SIX_BITS) as usize];
            output_chunk[14] = self.encode_table[((input_u64 >> 22) & LOW_SIX_BITS) as usize];
            output_chunk[15] = self.encode_table[((input_u64 >> 16) & LOW_SIX_BITS) as usize];

            let input_u64 = read_u64(&input_chunk[12..]);

            output_chunk[16] = self.encode_table[((input_u64 >> 58) & LOW_SIX_BITS) as usize];
            output_chunk[17] = self.encode_table[((input_u64 >> 52) & LOW_SIX_BITS) as usize];
            output_chunk[18] = self.encode_table[((input_u64 >> 46) & LOW_SIX_BITS) as usize];
            output_chunk[19] = self.encode_table[((input_u64 >> 40) & LOW_SIX_BITS) as usize];
            output_chunk[20] = self.encode_table[((input_u64 >> 34) & LOW_SIX_BITS) as usize];
            output_chunk[21] = self.encode_table[((input_u64 >> 28) & LOW_SIX_BITS) as usize];
            output_chunk[22] = self.encode_table[((input_u64 >> 22) & LOW_SIX_BITS) as usize];
            output_chunk[23] = self.encode_table[((input_u64 >> 16) & LOW_SIX_BITS) as usize];

            let input_u64 = read_u64(&input_chunk[18..]);

            output_chunk[24] = self.encode_table[((input_u64 >> 58) & LOW_SIX_BITS) as usize];
            output_chunk[25] = self.encode_table[((input_u64 >> 52) & LOW_SIX_BITS) as usize];
            output_chunk[26] = self.encode_table[((input_u64 >> 46) & LOW_SIX_BITS) as usize];
            output_chunk[27] = self.encode_table[((input_u64 >> 40) & LOW_SIX_BITS) as usize];
            output_chunk[28] = self.encode_table[((input_u64 >> 34) & LOW_SIX_BITS) as usize];
            output_chunk[29] = self.encode_table[((input_u64 >> 28) & LOW_SIX_BITS) as usize];
            output_chunk[30] = self.encode_table[((input_u64 >> 22) & LOW_SIX_BITS) as usize];
            output_chunk[31] = self.encode_table[((input_u64 >> 16) & LOW_SIX_BITS) as usize];

            output_index += BLOCKS_PER_FAST_LOOP * 8;
            input_index += BLOCKS_PER_FAST_LOOP * 6;
        }
    }

    // Encode what's left after the fast loop.

    const LOW_SIX_BITS_U8: u8 = 0x3F;

    let rem = input.len() % 3;
    let start_of_rem = input.len() - rem;

    // start at the first index not handled by fast loop, which may be 0.

    while input_index < start_of_rem {
        let input_chunk = &input[input_index..(input_index + 3)];
        let output_chunk = &mut output[output_index..(output_index + 4)];

        output_chunk[0] = self.encode_table[(input_chunk[0] >> 2) as usize];
        output_chunk[1] = self.encode_table
            [((input_chunk[0] << 4 | input_chunk[1] >> 4) & LOW_SIX_BITS_U8) as usize];
        output_chunk[2] = self.encode_table
            [((input_chunk[1] << 2 | input_chunk[2] >> 6) & LOW_SIX_BITS_U8) as usize];
        output_chunk[3] = self.encode_table[(input_chunk[2] & LOW_SIX_BITS_U8) as usize];

        input_index += 3;
        output_index += 4;
    }

    if rem == 2 {
        output[output_index] = self.encode_table[(input[start_of_rem] >> 2) as usize];
        output[output_index + 1] =
            self.encode_table[((input[start_of_rem] << 4 | input[start_of_rem + 1] >> 4)
                & LOW_SIX_BITS_U8) as usize];
        output[output_index + 2] =
            self.encode_table[((input[start_of_rem + 1] << 2) & LOW_SIX_BITS_U8) as usize];
        output_index += 3;
    } else if rem == 1 {
        output[output_index] = self.encode_table[(input[start_of_rem] >> 2) as usize];
        output[output_index + 1] =
            self.encode_table[((input[start_of_rem] << 4) & LOW_SIX_BITS_U8) as usize];
        output_index += 2;
    }

    output_index
}

O3 优化下，x86_64 的汇编代码就是朴素的一堆 mov, and 和 shr；arm 汇编倒是做了乱序处理；然而实测在 x86_64 (ryzen 6800h) 上展开与否并不会显著影响性能（提升平均 5% 左右且不稳定）。个人不是很喜欢这个做法

SJTUG mirror-intel 源码浏览笔记

Sun, 27 Oct 2024 15:30:00 +0800

此文尚未完工，可能还会有重大改动或者被废弃

这个项目不知道为啥带个 “intel”。就当 intel 赞助了吧。

mirror-intel 的工作流程大概是请求命中对应代理/缓存策略，若有缓存就返回缓存，没有就提交一个下载任务，然后反向代理。

话不多说，开始看代码！

Repos

crate::repos 里硬编码了所有 endpoint 的路由和处理方式。如果要加 endpoint 就要改这里。

日志

开篇日志。本项目基于 tokio-rs/tracing 做日志；它通过 crate::setup_log 函数绑定 stdout 并从环境读取日志格式配置。

配置文件

本项目基于 figment 做配置文件。

它从 Rocket.toml 和 mirror-intel.toml 两个文件中读取配置，项目也提供了模板配置文件。

配置文件结构定义如下：

/// Global application config.
pub struct Config {
    /// Upstream endpoints for redirecting, reverse-proxying and caching.
    pub endpoints: Endpoints,
    /// Github release related configs.
    pub github_release: GithubReleaseConfig,
    
    /// S3 storage to store cached files.
    pub s3: S3Config,
    /// Path of temporary buffer directory.
    pub buffer_path: PathBuf,
    /// and other config items
    ...
}

/// Endpoints of origin servers.
pub struct Endpoints {
    pub rust_static: String,
    pub homebrew_bottles: String,
    pub pypi_packages: String,
    pub fedora_iot: String,
    pub fedora_ostree: String,
    pub flathub: String,
    pub crates_io: String,
    pub dart_pub: String,
    pub guix: String,
    pub pytorch_wheels: String,
    pub linuxbrew_bottles: String,
    pub sjtug_internal: String,
    pub flutter_infra: String,
    pub flutter_infra_release: String,
    pub github_release: String,
    pub nix_channels_store: String,
    pub pypi_simple: String,
    pub opam_cache: String,
    pub gradle_distribution: String,
    /// Upstream override rules.
    pub overrides: Vec<EndpointOverride>,
    /// Paths starts with any of these prefixes will be unconditionally redirected to S3 storage.
    pub s3_only: Vec<String>,
}

/// Configuration for S3 storage.
pub struct S3Config {
    /// Name of the S3 storage.
    pub name: String,
    /// S3 endpoint of the storage service.
    pub endpoint: String,
    /// Website endpoint of the S3 service.
    pub website_endpoint: String,
    /// Bucket name.
    pub bucket: String,
}

/// Configuration for Github Release endpoint.
pub struct GithubReleaseConfig {
    /// Repositories allowed to be cached.
    ///
    /// Accessing a repository that is not in this list will result in an unconditional redirect.
    pub allow: Vec<String>,
}

/// An upstream endpoint override rule.
pub struct EndpointOverride {
    /// Name of the rule.
    ///
    /// Currently this field is only used for a descriptive purpose.
    pub name: String,
    /// Pattern to match against the origin.
    ///
    /// Note that only plain strings are supported, i.e. no regex, and substring matching is allowed.
    pub pattern: String,
    /// Replacement for the matched pattern.
    pub replace: String,
}

单配置文件解决一切！唯一不足就是 endpoint 列表硬编码在源码里，有的源需要特别处理，只好牺牲扩展性了。（不过 simple_intel 感觉可以做成动态的列表）

[Rust 每日一库] bitflags

Wed, 23 Oct 2024 23:10:59 +0800

bitflags 在宏三大法器中抢夺出了前四名中的一席之地。它本身的功能相当简单。直接看代码：

bitflags::bitflags! {
    pub struct Flags: u32 {
        const A = 0b00000001;
        const B = 0b00000010;
        const C = 0b00000100;
    }
}

或是

pub struct Flags(u32);

bitflags! {
    impl Flags: u32 {
        const A = 0b00000001;
        const B = 0b00000010;
        const C = 0b00000100;
    }
}

然后就可以把 Flags 类似 u128 一样计算使用，不同的是它基于 Flags trait 实现了一些好方法，如同官方 slice 一样，让我们能够轻松使用。

这是一种值得学习的范式：用 declarative macro 实现最小化扩展，然后用一个 trait 实现更多方法。

宏

让我们深入看看 bitflags 的实际实现：教科书式的 declarative macro。

$(#[$outer:meta])*
$vis:vis struct $BitFlags:ident: $T:ty {
    $(
        $(#[$inner:ident $($args:tt)*])*
        const $Flag:tt = $value:expr;
    )*
}

$($t:tt)*

首先它处理了内外的 metadata；以支持诸如嵌套 macro、文档注释、编译标记等额外信息。

然后是逐步的函数式 declarative macro 实现。

它在最后处理了额外的 Token Tree，以支持多类型定义。

总之简单好用就完了。

[Rust 每日一库] hashbrown

Wed, 23 Oct 2024 19:52:59 +0800

hashbrown 库是 Rust 转写的 Google SwissTable，算法细节可以看 CppCon talk。它也是 1.36 之后版本的 Rust 标准库 HashTable 实现。

Layout

大体架构上，它实现了一个 RawTable<T>。不同于 CppCon 中提到的一个 ctrl 一个 bucket 两个向量，它的实现只用了一个 ctrl 指针。

源码中有以下说明：

                       `self.table.ctrl.cast()` returns pointer that
                       points here (to the end of `T0`)
                         ∨
[Pad], T_n, ..., T1, T0, |CT0, CT1, ..., CT_n|, CTa_0, CTa_1, ..., CTa_m
                          \________  ________/
                                   \/
      `n = buckets - 1`, i.e. `RawTable::buckets() - 1`

where: T0...T_n  - our stored data;
       CT0...CT_n - control bytes or metadata for `data`.
       CTa_0...CTa_m - additional control bytes, where `m = Group::WIDTH - 1` (so that the search
                       with loading `Group` bytes from the heap works properly, even if the result
                       of `h1(hash) & self.bucket_mask` is equal to `self.bucket_mask`). See also
                       `RawTableInner::set_ctrl` function.

P.S. `h1(hash) & self.bucket_mask` is the same as `hash as usize % self.buckets()` because the number
of buckets is a power of two, and `self.bucket_mask = self.buckets() - 1`.

本质上是 Grouped Vector，让人眼前一亮！这种做法感觉对缓存非常友好。

[Rust 每日一库] 引言

Tue, 22 Oct 2024 23:10:59 +0800

Rust 提供了 crates.io 作为官方在线库服务；不过即使是拥有 Rust 语言本身的高要求，crates.io 里已然有着和 npm registry 一样的毛病：不少库看似花哨，实际性能低下、包装过多、依赖繁重。

本系列计划或浅或深地按照 crates.io 上热门排名的顺序，选择一些库进行试用和学习；不爽的点可能会批判；但不会深入探究用法和功能，对应需求建议参考对应库的 examples/ 文件夹。

[中国翻訳] Rust 内联汇编 - Rust By Example

Thu, 17 Oct 2024 21:44:59 +0800

原文： Inline assembly - Rust By Example

Rust 通过 asm! 宏提供对内联汇编的支持。它能用来将手写汇编嵌入到编译器生成的汇编输出中。一般来说不必如此，除非有性能或时序需求无法通过其他方式实现。访问低级硬件原语（例如在内核代码里）也可能需要此功能。

注：示例只给出了 x86/x86-64 汇编，但是其他架构也是支持的

内联汇编目前支持以下架构：

x86 和 x86-64
ARM
AArch64
RISC-V
LoongArch

基础用法

我们从理论上最简单的例子开始：

use std::arch::asm;

unsafe {
    asm!("nop");
}

这会向编译器生成汇编中插入一个 NOP (无操作) 指令。注意，所有 asm! 调用都需要在以一个 unsafe 块内，毕竟它可能插入任意指令，然后破坏很多不变量。插入指令在 asm!宏的第一个参数以字符串字面量的形式列出。

输入和输出

不过插入一个什么都不做的指令太无聊了。我们来实际动动数据：

use std::arch::asm;

let x: u64;
unsafe {
    asm!("mov {}, 5", out(reg) x);
}
assert_eq!(x, 5);

这会将值 5 写入 u64 变量 x。可以看到，我们用来指定指令的字面量是一个模板。它约束于 Rust 格式字符串相同的规则；但是插入模板的参数看起来与所熟悉的略有不同。首先，我们需要明确变量是内联汇编的输入还是输出。在此例中，它是一个输出。我们通过写 out 来声明。我们还需要明确汇编需要什么类型的寄存器来放置变量。在此例中，我们通过指定 reg 将其放入任意通用寄存器中。编译器将选择合适的寄存器插入模板，并在内联汇编完成执行后以它为变量。

让我们看看另一个还用到了一个输入的例子：

use std::arch::asm;

let i: u64 = 3;
let o: u64;
unsafe {
    asm!(
        "mov {0}, {1}",
        "add {0}, {number}",
        out(reg) o,
        in(reg) i,
        number = const 5,
    );
}
assert_eq!(o, 8);

这会将 5 加到输入变量 i 上，并将结果写入变量 o。汇编的实现方式是首先将值从 i 复制到输出，然后加上 5。

SJTU Xflops 一轮考核小记

Tue, 15 Oct 2024 15:10:59 +0800

SJTU Xflops 招新啦！

初见试题，就被充实的考试内容、详尽友好的 readme.md 和几乎已完成的代码/测试/构建框架震撼了；Xflops 真是为了本次招新花了很大心思。向命题组致敬🫡！

总共五题，涉及了 OpenMP/MPI 基础、简单算法编写、性能调优等知识。话不多说，直接开始做题！

Bithack

由于本人是按照字母顺序做题的，这是我最开始上手的一道题，是刚开始以为最简单的一道题（看题目资源限制看的），却是最晚写完的，也是本人体感难度最高的一道题；这可能是因为我不太擅长搓算法，尤其是需要精细处理、仔细思考的那些（还是刷题少了）。

由于题目要求不能开堆空间，最开始我想弄一个足够大的 buffer 然后 rotate 时写到 buffer 里然后一块块慢慢搬（如图）；然后发现一越界循环就寄了。

遂放弃额外 buffer 的算法。Chatgpt 告诉我有个 in-place rotate 算法：

reverse_vec(vec, left, right);
reverse_vec(vec, left, left+rotate-1);
reverse_vec(vec, left+rotate, right);

看起来十分可靠。感谢 Chatgpt！

一分钟搓了一个基线 reverse

static void reverse_the_bit_vector_slow (
    bit_vector_t* const bit_vector,
    size_t bit_from,
    size_t bit_to
) {
    while (bit_from < bit_to) {
        bool temp = bit_vector_get(bit_vector, bit_from);
        bit_vector_set(bit_vector, bit_from, bit_vector_get(bit_vector, bit_to));
        bit_vector_set(bit_vector, bit_to, temp);
        bit_from++;
        bit_to--;
    }
}

看起来依旧开销满满，但成绩还不错，毕竟是真 O(n) 算法：

check result: PASSED
performance of -s: 27
performance of -m: 31
performance of -l: 36
------score--------
-s : 65.00 /100
-m : 68.18 /100
-l : 72.00 /100
total score: 69.45 /100

距离满分还有大约 $1.618^7\approx30$ 倍的性能差距。那就优化常数吧！搓一个更快的 reverse 函数。

slurm 和 mpi 软核速成

Sat, 28 Sep 2024 00:00:00 +0800

slurm 可以说是最亲民的跨系统任务调度器了，很多超算也在开心地使用它。因为它是 “Simple Linux Utility for Resource Management”——Linux！谁不爱呢。

它提供了三大功能：

给用户分配互斥/非互斥的算力片段
在分配的算力上启动、执行、监控任务的框架
在资源不足时的任务队列管理

总结起来就是让你能在一堆计算节点上轻松地提交一个多进程任务。功能少，学起来也轻松。

一个 slurm 系统中，有一个中央管理节点（sjtu hpc 叫他登录节点），还有一堆计算节点。每个计算节点都属于一个 partition （sjtu hpc 管他叫队列。一个 partition 会包括一堆节点），我们执行任务的时候可以（应当）指定 partition。

大多数的操作可以借鉴 Slurm 作业调度系统 | 上海交大超算平台用户手册和提交作业 | 未名。本文将关注于 batch file 的编写；写完后 sbatch BATCHFILE && watch -n0.5 squeue -l 一把梭就行。

Hello, world

main.slurm

#!/bin/bash

#SBATCH --job-name=hello-world # squeue/sacct 显示的任务名
#SBATCH --partition=arm128c256g # 选择 partition
#SBATCH --ntasks=4 # srun 并行数
#SBATCH --nodes=1 # 使用节点数
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=1
#SBATCH --output=stdout

echo hello, world

其中，#SBATCH 开头的是传给 sbatch 的参数，这样就可以避免手动输入。

OpenMP 硬核速成

Wed, 25 Sep 2024 00:00:00 +0800

OpenMP 是啥？官方¹如是说：

The OpenMP® API is a scalable model that gives parallel programmers a simple and flexible interface for developing portable parallel applications in C/C++ and Fortran.

OpenMP is suitable for a wide range of algorithms running on multicore nodes and chips, NUMA systems, GPUs, and other such devices attached to a CPU.

它的功能相当简单，就是单进程/共享内存并行计算；具体包括

并行化形如 for(int i=START; i<END; i++) 的循环/静态任务列表 (#pragma omp for/sections)
并行化动态任务 (#pragma omp task)

它的在 C 里的工作方式²类似于 Rust attribute-like macro：通过 #pragma omp XXX 来把对应代码块通过 openmp 魔改，生成可并行代码。不同于 Rust 允许自定义 proc-macro 来 hook ast 解析过程，openmp 需要编译器的原生支持；好在绝大多数的编译器都支持 openmp³。

用 Rust 扩展 Python | 数学建模加速尝试

Sun, 08 Sep 2024 23:10:59 +0800

Python 在数学建模的数值求解上可以说是砍瓜切菜，但是有一个小问题：部分场合有点慢，尤其是涉及列表、ndarray 来回倒腾，循环，隐函数求解，配合一个优化器之类的东西反复调用这个函数，运行起来奇慢无比。我们需要加速他，不然算不完啊！

Rust 在科学计算上并没有 Python 里大而全的 scipy, sympy, matplotlib 等库，生态不够发达。如果我们能够将二者优势结合起来，取 Python 的生态和 Rust 的速度，岂不美哉。

在开始之前需要强调，实际效果还是看重写部分的关键程度。只要不是 100% Rust，就应当评估原 Python 部分所占最终时间的比例。只有当时间比例超过 50% 时，改写才是有意义的。

本文经过测试，发现以下策略卓有成效：

(?) 对于大 ndarray 的 numpy 直接向量化操作（重写性能差不多，没必要）
(x200+) 长列表的复杂的数学计算和映射 ([f(i) for i in arr]) 用 Rust 重写
(x5-10) 热数学计算函数用 Rust 重写
(x8) 用 Rust 重写”优化函数“
(x4-10) 多个重任务的多线程分治

以下策略会适得其反：

(x0.3) 用 Python 的 multiprocessing.pool.Pool
(x0.9) 在 Rust 中频繁调用 Python 函数
(?) 少量轻任务的的多线程分治

测试全部在个人设备上进行 (Python 3.12.5, Windows10, AMD Ryzen 9 7950X)

Artalk 部署 (PostgreSQL)

Thu, 29 Aug 2024 12:10:59 +0800

最近把本博客的评论系统从 Waline 迁移到了 Artalk。主要原因就是 Waline 是纯 js 实现， NodeJS 运行时有点太重了；最近正在把服务整合到新小鸡上，遂迁移。

Artalk 够轻够简单，完全单文件化，连静态资源都被嵌入了可执行文件；不过总比臃肿的 nodejs 要好。 Artalk 另一个优势是可配置项更多，文档更详细，看着就更像个正经项目（然而是高三大佬写的

安装依赖

我们使用 PostgreSQL。首先安装依赖，下载可执行文件

LATEST=v2.8.7
apt install postgresql
wget https://github.com/ArtalkJS/Artalk/releases/download/${LATEST}/artalk_${LATEST}_linux_amd64.tar.gz
tar xf artalk_${LATEST}_linux_amd64.tar.gz
mv artalk_${LATEST}_linux_amd64/artalk /usr/local/bin
rm -r artalk_${LATEST}_linux_amd64.tar.gz artalk_${LATEST}_linux_amd64

配置数据库

-- sudo -u postgres psql
CREATE USER artalk WITH PASSWORD '<CUSTOM PASSWORD>';
CREATE DATABASE artalk_db OWNER artalk;
GRANT ALL PRIVILEGES ON DATABASE artalk_db TO artalk;

配置文件

尽管示例有很多配置项，实际上都可以网页上 ui 配置。配置文件只需要写最基本的暴露端口和数据库配置就行。（不过文件权限是个问题）

/etc/artalk.yml

host: "127.0.0.1"
port: 23333

app_key: <CUSTOM KEY>
locale: zh-CN
timezone: Asia/Shanghai

log:
  enabled: true
  filename: /var/log/artalk/access.log

db:
  type: pgsql
  name: artalk_db
  host: localhost
  port: 5432
  user: artalk
  password: <CUSTOM PASSWORD>

守护进程

我们用 systemd。我个人比较喜欢 DynamicUser

Rustdesk 自建服务器

Mon, 01 Jul 2024 23:10:59 +0800

Rustdesk 是一个功能完备的远程桌面套件。其作为一款开源软件，其 Github Star 数高达 67.8k，得到了开源社区的广泛认可。

其基本架构如图所示：

本文旨在记录 Server 的安装方式和基本使用。

Rustdesk 的软件分发基于 Github Releases。如果是国内服务器，建议先用魔法下到本地再传到服务器上。

把下载的 hbbs 和 hbbr 放到 /usr/local/bin/ 下之后，运行：

sudo mkdir /var/log/rustdesk/ && sudo chmod 777 /var/log/rustdesk/
sudo tee /lib/systemd/system/rustdesk@.service <<EOF >/dev/null
[Unit]
Description=Rustdesk Server
Documentation=https://rustdesk.com/

[Service]
Type=simple
DynamicUser=yes
LimitNOFILE=1000000
ExecStart=/usr/local/bin/%i
WorkingDirectory=/var/lib/rustdesk/
StateDirectory=rustdesk
LogsDirectory=rustdesk
Restart=always
StandardOutput=append:/var/log/rustdesk/%i.log
StandardError=append:/var/log/rustdesk/%i.err
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
# start daemon
sudo systemctl start rustdesk@hbbs
sudo systemctl start rustdesk@hbbr
# key
echo -e "\033[1;33mKey: $(sudo cat /var/lib/rustdesk/id_ed25519.pub)\033[0m"

记录下这里的 key。

Rust 宏编程

Sun, 30 Jun 2024 01:23:59 +0800

所谓宏 (Macro)，指能生成代码的代码。它可以对已有代码进行匹配、替换和生成。

对于我们程序员而言，宏的作用就是减少工作量：利用宏生成一些非常繁琐的、但是避不开的代码，例如

常量的批量定义和文档说明
一段不长不短的套件初始化
要使用变量名本身和源码信息
…

一个广为人知的宏语言是 m4。它的发明让 C 获得了宏编程之力。但相比 Rust 成熟完整的宏编程，m4 显得过于简陋了。

在进入正题前，需要区分两个版本的宏：

declarative macros

这是最原始形态的宏，也是许多教程中会写到的、让人眼前一黑的版本 (macro_rules)。它基于模式/伪正则匹配语法工作。好消息是：它将在未来被逐步废弃。 ~~我们不需要会写，只要能看懂就行。~~ 好吧还是非常好用的，尤其是在一些需要批量生成类似代码的地方。

教程：声明式宏 macro_rules! | course.rs

procedural macros

这是功能完备、实现优雅的现代版本：用 Rust 写 Rust 宏！这也太帅了！

Rust 将宏分为了三类

内联宏，形如 custom!(...)，对应 #[proc_macro]
派生宏，形如 #[derive(CustomDerive)]，对应 #[proc_macro_derive]
属性宏，形如 #[CustomAttribute]，对应 #[proc_macro_attribute]

示例-Json 解析

我们定义 Json 如下：

pub enum ConstValue {
    String(&'static str),
    Number(f64),
    Object(&'static [(&'static str, Self)]),
    Array(&'static [Self]),
    Boolean(bool),
    Null,
}

解析宏如下：

use proc_macro::{self, Group, Ident, Punct, Span, TokenTree, TokenStream};

#[proc_macro]
pub fn json(input: TokenStream) -> TokenStream {
    parse_object(input)
}

fn parse_object(input: TokenStream) -> TokenStream {
    fn check_colun(p: TokenTree) {
        let panic_err = || panic!("expect ':', got {p}");
        if let TokenTree::Punct(p) = &p {
            if p.as_char()!=':' {panic_err()}
        } else {panic_err()}
    }
    
    let mut input = input.into_iter();
    let mut output = TokenStream::new();
    let mut k = input.next();
    loop {
        let Some(key) = k else {break;};

        if let TokenTree::Literal(_) = &key {} else {panic!("expect key literal, got `{key}`")};
        check_colun(input.next().expect("expect ':', got EOF"));
        let value = input.next().expect("expect value, got EOF");
        let value = parse_value(value);

        let mut grp = TokenStream::from_iter([key, punc(',')]);
        grp.extend(value);
        output.extend([
            TokenTree::Group(Group::new(
                proc_macro::Delimiter::Parenthesis, 
                grp
            )),
            punc(','),
        ]);
        k=input.next();
        if let Some(TokenTree::Punct(p)) = &k {
            if p.as_char() == ',' { k=input.next(); }
        }
    }
    
    gen_constvalue(
        "Object", 
        TokenStream::from_iter([
            punc('&'),
            TokenTree::Group(Group::new(
                proc_macro::Delimiter::Bracket, 
                output
            ))
        ])
    )
}


fn parse_array(input: TokenStream) -> TokenStream {
    let mut output = TokenStream::new();
    let mut input = input.into_iter();
    let mut k = input.next();
    loop {
        let Some(value) = k else {break;};

        let v = parse_value(value);
        output.extend(v);
        output.extend([punc(',')]);

        k=input.next();
        if let Some(TokenTree::Punct(p)) = &k {
            if p.as_char() == ',' { k=input.next(); }
        }
    }
    gen_constvalue(
        "Array", 
        TokenStream::from_iter([
            punc('&'),
            TokenTree::Group(Group::new(
                proc_macro::Delimiter::Bracket, 
                output
            ))
        ])
    )
}

fn parse_value(input: TokenTree) -> TokenStream {
    match &input {
        TokenTree::Group(grp) => { // array, object
            match grp.delimiter() {
                proc_macro::Delimiter::Brace => parse_object(grp.stream()),
                proc_macro::Delimiter::Bracket => parse_array(grp.stream()),
                _ => panic!("unsupported value {}", grp.stream()),
            }
        },
        TokenTree::Literal(v) => { // string, number
            match v.to_string().parse::<f64>() {
                Ok(_) => {
                    let mut tt: TokenStream = input.into();
                    tt.extend([ident("as"), ident("f64")]);
                    gen_constvalue("Number", tt)
                },
                Err(_) => gen_constvalue("String", input.into())
            }
        },
        TokenTree::Ident(id) => { // null, true, false
            match id.to_string().as_str() {
                "null" => gen_id("Null"),
                "true" | "false" => gen_constvalue("Boolean", input.into()),
                _ => panic!("identifier {input} not supported"),
            }
        },
        _ => panic!("unexpected symbol {input}"),
    }
}

fn punc(ch: char)->TokenTree {
    TokenTree::Punct(Punct::new(ch, proc_macro::Spacing::Alone))
}

fn ident(id: &str) -> TokenTree {
    TokenTree::Ident(Ident::new(id, Span::call_site()))
}

fn gen_id(id: &str) -> TokenStream {
    TokenStream::from_iter([
        ident("ConstValue"),
        TokenTree::Punct(Punct::new(':', proc_macro::Spacing::Joint)),
        punc(':'), 
        ident(id),
    ])
}

fn gen_constvalue(id: &'static str, inner: TokenStream) -> TokenStream {
    let mut o = gen_id(id);
    o.extend([
        TokenTree::Group(Group::new(
            proc_macro::Delimiter::Parenthesis, 
            inner
        ))
    ]);
    o
}

不过这个例子大概还是声明宏方便些。

Rust vs Go | Web Framework 小横评

Fri, 28 Jun 2024 21:00:00 +0800

本次参赛选手是…

来自 Golang 的 Gin！
来自 Rust 的 Axum！

本次将通过基本的路由和中间件，着重评测二位的性能和上手体验。测试设计很草率，并不代表普遍情况！

选择理由

有读者老爷可能会问了，明明 xxx 性能更强/更成熟/更优雅，为什么不选它？

Golang 方面， Gin 毋庸置疑是最为成熟稳定、生态最丰富的 Web Server Framework. 其 func(*gin.Context) 吃遍天的良好设计极其优雅高效。其他的 Framework 相比它并没有决定性的性能优势，反倒是接口千奇百怪，难以理解。

Rust 方面，本来我是要选 Actix 的，然而它在本机上的性能表现比 Axum 差 20% 以上，而且它的接口个人不太喜欢，尤其是其奇怪的 Response 构造和 path macro。Axum 的接口是最对我胃口的，且性能在第一梯队。

当然，有测试表明，Actix 最大的优势是系统性能友好——它相比 Axum 能省 30% 以上的 CPU、 50% 以上的内存，而性能差距不到 10%。（虽然和我自己测出来的不一样）

Golang 代码

直接依赖： github.com/gin-gonic/gin

代码：

main.go

package main

import "github.com/gin-gonic/gin"

func main() {
    r := gin.New()
    r.Use(Counter())
    r.GET("/count", Count)
    r.NoRoute(NotFound)
    r.Run("localhost:8081")
}

func NotFound(c *gin.Context) {
    c.JSON(200, gin.H{
        "code":  404,
        "message": "not found",
    })
}

func Count(c *gin.Context) {
    msg, _ := c.Get("example")
    c.JSON(200, gin.H{
        "code":  200,
        "message": msg,
    })
}

func Counter() gin.HandlerFunc {
    n := 0
    return func(c *gin.Context) {
        c.Set("example", n)
        n += 1
        c.Next()
    }
}

超级优雅的 Go 风格代码！仅需 35 行！

Nom 小试

Wed, 19 Jun 2024 23:10:59 +0800

Nom 是一个二进制解析框架。它提供了许多特性：

零拷贝切片
流粘包处理
解析器 (Parser) 级联
常用二进制处理工具

Nom 需要配合 impl Fn(Input) -> IResult<Remain, Output, Error> 的解析器工作。

大致来说，它的工作方式是，你告诉 nom 解析字节的某种匹配模式。它会尝试从输入中解析尽可能多的内容，将其余的输入返回给你。

相比 serde ，它更注重于高速的二进制解析，而并不提供 encode/serialize 的功能。它本身只提供了一个约定和一些工具集帮助我们解析。

小试

最近本人在尝试写一个系统检测器。了解到在 Linux 下提供了 /proc/stat 文件，此文件能给出内核运行信息。我们尝试解析一下它吧！

首先是一个数字解析器。btw nom 已经精简到任何解析相关的东西都要我们手动实现。

fn parse_u64(input: &[u8]) -> IResult<&[u8], u64> {
    map_res(digit1, |s| unsafe{core::str::from_utf8_unchecked(s)}
        .parse::<u64>())(input)
}

然后是一个分割器。在一些分割空格的场合十分有用

fn split(n: u8)->impl Fn(&[u8])->IResult<&[u8], &[u8]> {
    move |input| {
        match take_till(|b| b==n)(input){
            Ok((input, output)) => match take_while(|b| b==n)(input) {
                Ok((input, _)) => Ok((input, output)),
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        }
    }
}

随后就开始照着官方文档实现了。完整代码如下：

// ref: https://man7.org/linux/man-pages/man5/proc_stat.5.html

#[derive(Debug)]
pub struct ProcStat {
    pub total: CPUStat,
    pub per_cpu: Vec<CPUStat>,
    /// counts of interrupts serviced since boot time. only total is parsed
    pub intr: u64,
    /// The number of context switches that the system underwent.
    pub ctxt: u64,
    /// boot time, in seconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).
    pub btime: u64,
    /// Number of forks since boot.
    pub processes: u64,
}

#[derive(Debug)]
pub struct CPUStat {
    /// Time spent in user mode.
    pub user: u64,
    /// Time spent in user mode with low priority (nice).
    pub nice: u64,
    /// Time spent in system mode.
    pub system: u64,
    /// Time spent in the idle task.
    pub idle: u64,
    /// Time waiting for I/O to complete. (may lower than actual value)
    pub iowait: u64,
    /// Time servicing interrupts.
    pub irq: u64,
    /// Time servicing softirqs.
    pub softirq: u64,
    /// Stolen time, which is the time spent in other operating systems when
    /// running in a virtualized environment
    pub steal: u64,
    /// Time spent running a virtual CPU for guest operating systems under the
    /// control of the Linux kernel.
    pub guest: u64,
    /// Time spent running a niced guest.
    pub guest_nice: u64,
}

use nom::{
    bytes::complete::{tag, take_till, take_while}, 
    character::{complete::digit1, is_space}, 
    combinator::map_res, 
    IResult,
};

fn parse_u64(input: &[u8]) -> IResult<&[u8], u64> {
    map_res(digit1, |s| unsafe{core::str::from_utf8_unchecked(s)}.parse::<u64>())(input)
}

fn split(n: u8)->impl Fn(&[u8])->IResult<&[u8], &[u8]> {
    move |input| {
        match take_till(|b| b==n)(input){
            Ok((input, output)) => match take_while(|b| b==n)(input) {
                Ok((input, _)) => Ok((input, output)),
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        }
    }
}

fn take_line(input: &[u8]) -> IResult<&[u8], &[u8]> {
    split(b'\n')(input)
}

// input a whole line
fn cpu_stat(input: &[u8])->IResult<&[u8], CPUStat> {
    macro_rules! gen_fields { ($($field:ident),*) => {
        fn inner(input: &[u8])->IResult<&[u8], CPUStat> {
            // check cpu
            let (input, _) = tag("cpu")(input)?;
            let (input, _) = split(b' ')(input)?;
            $(
            let (input, $field) = parse_u64(input)?;
            let (input, _) = take_while(is_space)(input)?;
            )*
            Ok((input, CPUStat {$($field,)*}))
        }
    };}
    gen_fields!(user, nice, system, idle, iowait, irq, softirq, steal, guest, guest_nice);
    inner(input)
}

fn proc_field<'a>(name: &'a str) -> impl Fn(&[u8])->IResult<&[u8], u64>+'a {
    move |input| {
        let _debug_name = name;
        let (input, _) = tag(name)(input)?;
        let (input, _) = take_while(is_space)(input)?;
        let _debug_input2 = unsafe{core::str::from_utf8_unchecked(input)};

        parse_u64(input)
    }
}

pub fn proc_stat(input: &[u8]) -> IResult<&[u8], ProcStat> {
    // will skip remain value in line
    fn try_field<O, F: Fn(&[u8])->IResult<&[u8], O>>(input: &[u8], f: F) -> IResult<&[u8], O> {
        let (mut input, mut line) = take_line(input)?;
        loop {
            match f(line) {
                Ok((_, val)) => {return Ok((input, val));}
                Err(e) => if input.len()==0 {return Err(e);}
            }
            (input, line) = take_line(input)?;
        }
    }

    fn try_field_many<O, F: Fn(&[u8])->IResult<&[u8], O>>(mut input: &[u8], f: F) -> IResult<&[u8], Vec<O>> {
        let mut v = Vec::new();
        loop {
            match f(input) {
                Ok((_, val)) => {
                    (input, _) = take_line(input)?;
                    v.push(val);
                }
                Err(_) => {break;}
            }
        }
        Ok((input, v))
    }
    macro_rules! gen_field {($($field:ident),*) => { 
        fn inner(input: &[u8]) -> IResult<&[u8], ProcStat> {
            let (input, total) = try_field(input, cpu_stat)?;
            let (input, per_cpu) = try_field_many(input, cpu_stat)?;
            $(let (input, $field) = try_field(input, proc_field(stringify!($field)))?;)*
            Ok((input, ProcStat{total, per_cpu, $($field),*}))
        }
    };}
    gen_field!(intr, ctxt, btime, processes);
    inner(input)
}

fn main() {
    let s = std::fs::read("/proc/stat").unwrap();
    let r = proc_stat(&s).unwrap().1;
    println!("{r:#?}");
}

Rust 与 C 第二弹

Sat, 08 Jun 2024 19:10:59 +0800

在前篇中我们已经了解了 Rust 如何调用 C 的代码和给定接口的库。现在让我们更任性一点：我们现在需要定义一个动态链接库接口，协作者只要发布他的实现接口的动态链接库二进制文件，我们就可以对代码不做任何修改，直接动态调用它。

由于 dlopen 与 LoadLibrary 的存在，这肯定是可以实现的。他们只能解析返回静态变量和函数。因此我们实现的一切都需要使用函数和静态变量去传递。

Rust 调用

我们使用 libloading = "0.8" 简化调用过程。

我们期望实现这样一个插件接口

#[repr(C)]
struct MyPlugin{
    name: &'static i8, // CStr
    new: extern "C" fn(i32)->&'static (),
    destroy: unsafe extern "C" fn(&()),
    add: extern "C" fn(&(), x:i32)->i32,
    sub: extern "C" fn(&(), x:i32)->i32,
}

从而能够这样被调用

let p=std::env::current_dir().expect("unable to access library directory");
#[cfg(unix)]
let name="libmylib.so";
#[cfg(windows)]
let name="mylib.dll";
unsafe {
    let lib = libloading::Library::new(p.join(name)).unwrap(); // load from absolute path
    let plgn = lib.get::<&MyPlugin>(b"impls").unwrap();
    println!("load plugin {:?}", core::ffi::CStr::from_ptr(plgn.name));
    let x = (plgn.new)(1);
    assert_eq!((plgn.add)(x,2), 3);
    assert_eq!((plgn.sub)(x,2), -1);
    (plgn.destroy)(x);
}

C library

一个最简单的插件库如下：

#include <stdlib.h>
typedef struct {int x;} calc_t;

calc_t* new(int x){
    calc_t* p=(calc_t*)malloc(sizeof(calc_t));
    p->x=x;
    return p;
}
void destroy(calc_t* p){free(p);}
int add(calc_t* x, int y){return (x->x)+y;}
int sub(calc_t* x, int y){return (x->x)-y;}

typedef const void* plugin_t[5];

#ifdef _MSC_VER
__declspec(dllexport) 
#endif
plugin_t impls={ // 
    "c impl",
    (const void*)new,
    (const void*)destroy,
    (const void*)add,
    (const void*)sub
};

通过 gcc -shared -fPIC -o libmylib.so lib.c 编译出动态链接库，就能用啦！

数据结构速成

Fri, 07 Jun 2024 23:10:59 +0800

前置知识

数据结构

数据之间的逻辑关系
- 集合结构
- 线性结构
- 树形结构
- 图形结构
存储：元素+关系
- 内容分类：数据，关系，附加（非必要但出于优化的、单数据结构内唯一的内容，例如长度、根节点…
- 数据储存方式：顺序，链接
- 关系算法：哈希，索引，树
接口
- 构造，销毁
- 增查删改
- 访问，遍历

数据结构主要讨论关系的存储

算法复杂度

渐进表示法
- $O$ : 渐进上界
- $\Omega$ : 渐进下界
- $\theta$ : 渐进确界
- $o$ : 渐近非紧上界

线性结构

线性表

定义：除了首尾元素，每个元素都有其前驱与后继。每个元素对应唯一非负整数 index.

顺序表

struct Vec<T> {
    T* data;
    size_t len, cap;
};

倍增空间：realloc，至多浪费 $50%$ 空间，换取均摊 $O(0)$ 的内存分配（内存分配很耗时）和 $O(1)$ 的复制。
增/删：后继节点全部需要移动， $O(n)$
查：index 访问 $O(1)$，值访问 $O(n)$
遍历：迭代 index: 0..len
优势：局部性好，index 访问快。
劣势：插入、删除、值访问很慢，均摊浪费 $33%$ 空间。
适用情景：静态，可 index 访问。

链表

struct Node<T> {
    T value;
    Node<T>* next; // 若空则 this 为尾节点
    Node<T>* prev; // （双链表专用）指向前面的节点，若为空则是头节点
};
struct LinkedList<T> {
    Node<T>* head; // 可空或伪节点
    Node<T>* tail; // （双链表专用）可空或伪节点
    size_t len; // 可选，长度
};

增删：a->b->c 变成 a->c 并 delete b， $O(1)$
遍历：循环 p<-(p.next)
查：index 与值都是遍历的 $O(n)$
优势：对已知节点增删快
劣势：访问很慢，浪费 1 或 2 个指针的空间

栈

栈：LIFO 后进先出

Rust 与 C

Tue, 04 Jun 2024 18:10:59 +0800

Rust 很棒，但是 C/C++ 有时候更香，尤其是有已有库、或者是写超级 unsafe 的代码时。

p.s. Why only C deserves? 大概有两条原因

C-FFI 已经成了所有语言兼容的接口标准
C compiler 在任何平台上都有

怎么在 Rust 里调用其他语言呢？

理解 Cargo

我们首先得理解 Cargo 做了什么。

大家都知道，多文件的编译过程就是：分别编译成 object 或 library，然后 link 起来。这其中，最关键的难题是找到文件。我们在编译 C/C++ 时最头痛的就是 not found 和 undefined symbol 满天飞。

Cargo 是怎么组织编译产物的呢？

对于单个 Crate Dep，它会先（如果存在）在 target/${MODE}/build/${CRATE}-hash 下运行 build script，然后在 target/${MODE}/build/${CRATE}-anotherhash 下编译，并将产物文件参与其被依赖的编译之中。

对于依赖图，就是不断取；然后把最后一项任务的产物放在 target/${MODE}/build/ 下。

我们的 foreign library 只需要能构建出产物放在产物文件夹中，被 Cargo 找到就行。

链接库

最朴素的做法是和传统 C 一样，编译出库，然后链接它。

在 Rust 里提供了 rustc-link-xx 的 api。

Rust 指针，引用，生命周期和其他

Mon, 11 Mar 2024 21:00:00 +0801

2024/10 更新：本文为初学 Rust 阶段所作，仅作为个人学习记录，不应作为参考。

Rust 指针

Rust 有其裸指针 *mut T 和 *const T，分别意味着指向的数据是可变/不可变的（实用中唯一的区别就是 Variance，实际通过 unsafe dereference 可以自由修改数据）。

它有以下限制

解引用裸指针是 unsafe 的
对象的所有权管理要手动实现
默认 !Send + !Sync

转换规则

指针和引用之间的转换规则如下：

   &T        &mut T
   ^            ^  
   |            |  
   v            v  
*const T <-> *mut T

引用或指针转换到指针用 as 关键词，而指针转换为引用需要 &(*ptr) 或 &mut(*ptr)。由于解引用是 unsafe 的，此操作需要包装在 unsafe 内。

我们似乎可以构造这么个超模的函数

fn upgrade<T: ?Sized>(v: &T) -> &'static mut T{
    unsafe{&mut*(v as *const T as *mut T)}
}

当当！把不可变引用变成可变性引用了！这就是 unsafe 的威力啊哈哈！

Rust 手动写了一项静态检查，要求 &T 不能转换为 &mut T。因此上面的代码并不能通过编译，尽管理论上他不违背 Rust 语法，我们也可以通过一些奇妙操作绕过这项检查。（见附 #2）

Rust 随感

Sun, 10 Mar 2024 21:00:00 +0800

Rust 的核心哲学在于在不放弃任何底层兼容性（汇编&系统调用）的同时，用一些富有指导性的的最佳实践包装代替脑子内与纯粹的指针、变量和内存打交道，从而兼顾了安全、最佳实践、代码可读性。

Rust 内有一个富有指导性的语义：每一层包装都意味着正确处理必要的开销（无论是运行时意义上还是逻辑语义的意义上），因此通过代码能够轻松预测代码的性能和逻辑。

数据驱动流程

Rust 一大亮点是通过 enum 和模式匹配，让我们可以超级优雅地包装、处理任何数据。过去的大量 if-else 通过流程分支出不同操作，因而流程控制变量与内容变量通常需要分离。Rust 的模式匹配可以将数据和我们的注意力汇聚到 enum 内。

此外，模式匹配加上 Rust 的最后一行作为值的语法，使得对于单个变量的赋值语义集中化了，而不像过去在每一个分支中都可能会发生改动，因而在读代码或是重构的时候十分困难。这很 ergonomic。

例如对于这样一个（检查前序迭代器为满二叉树的）递归：

enum BranchStatus{Empty, Full, NotFull}
// self: (Iterator<Item = bool>)
fn is_full(&mut self)->BranchStatus{
    match self.0.next(){
    None | Some(false) => Empty,
    Some(true) => { // non-empty
        match (self.is_full(), self.is_full()){
        (Empty, Empty) | (Full, Full) => Full,
        _ => NotFull
        }
    }}
}

用 C 写起来是这样的

// bool empty(); bool next();
enum BranchStatus{Empty, Full, NotFull};
BranchStatus isfull(){
    if(empty()) return Empty;
    char node=next();
    if(node==false) return Empty;
    char left=isfull(), right=isfull();
    if(left==Empty && right==Empty || left==Full && right==Full)
        return Full;
    else return NotFull;
}

数据主导和流程主导的差别可窥一二。

异常处理

这里很明显能看到 ES6 的影子。Rust 通过约定了 Result<T, E>作为函数返回值，以及 ? 语法糖，使得 Rust 的异常处理异常简单。另一方面，enumed union 的底层实现既优雅，性能又高。

SOCKS5 的一些小细节

Sun, 28 Jan 2024 09:48:22 +0800

关于 SOCKS5 的协议细节在 RFC 1928 中有详细的记录，本文旨在记录一些值得注意的细节。

握手方法

RFC 中要求合法的 SOCKS5 实现必须实现 GSSAPI。这是很好的，因为可以通过 SSH 等方式来加密我们的连接。然而，常见客户端（curl, browser）都不支持啊！所以现有实现中实现了 GSSAPI 的很少。

CONNECT 请求

CONNECT 请求就是在 CONNECT 成功后直接开始透传，即此时这个连接好似就是客户端直连到远程服务器上一样。

注意 BND.ADDR 和 BND.PORT。rfc 里是这么说的：

BND.PORT contains the port number that the server assigned to connect to the target host, while BND.ADDR contains the associated IP address. The supplied BND.ADDR is often different from the IP address that the client uses to reach the SOCKS server, since such servers are often multi-homed.

新生杯（一）初配置

Mon, 15 Jan 2024 22:31:37 +0800

官方教程中建议使用 Vmware Workstation Player 作为虚拟机在 Ubuntu 上运行 Qt。然而对于使用 Windows 10/11 的我们，隔一层虚拟机来操作过于没事找事了；不如尝试 Windows 本地开发。

Arduino 环境安装

访问 Arduino 官网，下载最新 Windows 版 IDE；富哥可以捐点钱，像我这样的穷鬼就 JUST DOWNLOAD 吧；然后如果不想被邮件骚扰，就继续 JUST DOWNLOAD：下载成功！然后运行安装一把梭。
安装完初次运行会初始化亿会会，我是关掉重新开就立刻加载出来了。然后 Arduino IDE 似乎会装一堆驱动和插件，我就允许了…
Ctrl+, 进入设置，先把语言改成中文（简体），然后 Additional board manager URLs 中填一个 https://espressif.github.io/arduino-esp32/package_esp32_index.json（看起来像是 ardiono ide - esp32 binding）。确认过后 IDE 就会自动加载啦。
由于众所周知的原因，Github 的访问性令人堪忧。所以我们需要设置代理：Ctrl+, 进入设置，选择网络，填上你的代理地址（通常来说 Clash 是 7890 端口，其他的是 1080 端口）。 ~~（不会吧不会吧不会真的有计算机人不会用梯子吧（手动滑稽）~~
装一个 esp32 插件，再装三个库： ESP32Servo，rplidar_arduino, 和新生杯 Simulator。这一步下载量巨大，建议网络配置好再下。

Arduino 的库可以安装到 %userprofile%\Documents\Arduino\libraries (~/Arduino/libraries) 下。所以官方教程中要求我们把 RPLidarDriver 和 Simulator 放到该目录内。

Cloudflare DNS API 初窥

Fri, 12 Jan 2024 12:22:52 +0800

Cloudflare 作为世界上最大的互联网慈善组织，为开发者提供了极其完整的 API 支持。本文关注于 Cloudflare 的 DNS API 部分。

申请 API 令牌(Token)

这是 API 使用过程中唯一图形化的部分了。我们要在用户 API 令牌创建一个令牌。对于我们要操作的 DNS，可以选择编辑区域 DNS 模板，然后填入我们要操作的二级域名（和 IP 地址白名单）。为了最小权限原理，建议填写白名单。

然后就生成了我们的 API Token！注意保存以及保存的安全性，因为离开页面后再也见不到它啦。如果弄丢了只能重新生成部署了。

建议在对应服务器上明文储存，反正有 ssh 帮你拦着风险。

然后就可以尝试验证一下 Token。

curl "https://api.cloudflare.com/client/v4/user/tokens/verify" \
     -H "Authorization: Bearer <API_TOKEN>"

正常情况下应当返回

{
  "result": {
    "id": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "status": "active"
  },
  "success": true,
  "errors": [],
  "messages": [
    {
      "code": 10000,
      "message": "This API Token is valid and active",
      "type": null
    }
  ]
}

DNS Record API

Cloudflare 的 API 采用 RESTful 风格，默认基于 JSON (Content-Type: application/json) 传递数据。

phantun 简单用法

Fri, 12 Jan 2024 11:10:32 +0800

作者介绍。

Phantun 可以把 UDP 流量伪装成 TCP。伪装意味着并不遵从 TCP 的任何流量控制等，只是单纯地把 IP 头中的 UDP 和 TCP 转换了一下。因此，Phantun 并不能经过任何常规的 TCP 代理，因为他们基本上都通过内核 TCP 处理，因此会处理 TCP 的流控。而 Phantun 在常规模式下并不会有常规的 TCP 流控相关包，因此会直接断流（收不到 ACK 包）。在这方面 UDP2Raw 倒是模拟了更多的 TCP 特性，因此可以通过 TCP 代理，但是成为了纯纯的 udp over tcp，性能低下。
最典型的应用是当 ISP 有 UDP 歧视的时候，可以以此减少丢包率；但是不能透过任何代理和防火墙。

打开方式

Phantun 不像 udp2raw 能够自动配置，我们需要按照官网的说明，一步步手动配置。

# 变量
server_port=4567
server_address=example.com
# 第一步：开启内核转发
echo net.ipv4.ip_forward=1 >> /etc/sysctl.conf
echo net.ipv6.conf.all.forwarding=1 > /etc/sysctl.conf # v6
sysctl -p
# 第二步：NAT
## Client：需要把 Phantun 地址 NAT 为 eth0 地址
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
ip6tables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
## Server：需要把来自特定端口的流量全部转发到 TUN 设备，默认为 192.168.201.0/24 和 fcc9::/64 两个地址。
iptables -t nat -A PREROUTING -p tcp -i eth0 --dport $server_port -j DNAT --to-destination 192.168.201.2
ip6tables -t nat -A PREROUTING -p tcp -i eth0 --dport $server_port -j DNAT --to-destination fcc9::2
# 第三步：赋予网络权限
setcap cap_net_admin=+pe phantun_server
setcap cap_net_admin=+pe phantun_client
# 第四步：启动
phantun_server --local $server_port --remote <原本的udp服务器:端口>
phantun_client --local <本地udp监听地址> --remote $server_address:$server_port

交大水源水印原理初窥

Tue, 09 Jan 2024 16:11:00 +0000

本来以为水源只是做了一个简单的 LSB 隐写，顺手撸了一个去除脚本。没想到前两天使用脚本时，水源居然自动刷新了！而且任何 Event Listener Breakpoint 都无法检测到这个回调函数，任由其刷新。今天考完军理，我倒要看看水源用了什么黑魔法。

声明：本人只是出于理论研究的目的对源代码进行研究并提出可能的应对方案，请任何人都不要把水源截图外传，更不要利用本文提到的方式逃避管理。在校内群，请使用链接分享帖子。至于为什么，请自行水源上搜索截图外传（ps 一个我很喜欢的解释）。

水源社区管理规范

第十一条 以下行为被界定为“恶意对抗行为”：

（一）使用技术手段逃避管理；

第十二条 以下行为被界定为“对社区的恶意行为”：

（二）未经授权许可，将他人发布的内容以图片、视频等形式发布到社区以外，并造成不良影响；

找到源代码

通过简单摸索我们会发现，水印被放在一个 .ember-view 内部，通过一个 z-index=9999 且 opacity=0.005 的全屏的 base64 化的 PNG 写入了可能唯一标识了个人账号的三位 base64（大概能表示 $64^3=262,144$ 人，也就是只有二十年的交大人吧/doge）。

由于断点没有任何作用，我只好把一个网页的全部代码下载下来：

全部文件

$ ls
 05d79569ae40510aab461b2563db6b47d00e8cd4.js
 0aa74b582acb6a91dd3e411b2a7bfbc04e260211.js
 108af40fa662a89aaf7a21f877353d51e03f20ab.js
 11312c7a2877d0b500b0e6a8c206a7dddd248d68.js
 13256e7c9a732d6f122bd0ade6ce1667f1056fc8.js
 19b4640f9b7fefd688672e06cba5d97f064376b1.js
 2953c571d30c38ce62223ab7cb71bfa62ff7f6b3.js
 2e3da41114c0548f77ba38b143d059f6e71b6070.js
 3cd5da1afde47c3b2559a9d32fb22dae709bc452.js
 5a71c44fba2bc8a8ba3db3aaed76bbf2edc6ef2b.js
 609808483b2f30b853cf8365c6210db98a45e7bf.js
 755071_2.png
 819585_2.jpg
 9c11c73a9c8a1d753cb2c89ddf7215f2fcbb7d79.js
 a1df1e94bf4b5b5825e5947ad9acccb47fdaaa08.js
 abe5e87ff37d7d06fc18f6e696f906528dfc9da8.js
 ba83de1a244eff6ea32b9cfdb456fc943d55fba2.js
 browser-detect-13a181da51a93c36e477dd3626795ba449290653fdff8a.js
 browser-update-a7811824a1beeecce86fb3546ab789b1788261ece30a33.js
 c0eff5115343eeb12e312488f9572bf683b25619.js
 c36051143379f82fc44d6b2b723f499d097138a6.js
 cdb089134551f0d890ff37adaac1b7fa96a5ba1f.js
 chat-3c2c0a87bea84663ed8fd3479fd008569160424dff2e5904463c1aea.js
 chat_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 chat_desktop_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 checklist-f67957fc54745e2d28d433f45b8fdddd34d8930865fd51c82a0.js
 checklist_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 chunk.5ef2f01c75e63a9864e3.js
 chunk.ef28e73e3d8ce45a79d7.js
 color_definitions_scheme_1_3_2ceb21439b63ac43c0d23727e715500.css
 color_definitions_scheme_2_3_e0c576c10b96945224a8cfc1c5995b7.css
 continous-days-visited-0a1f3a5a289feed212e3b738f8280656ac5cee.js
 d9439395e9e8be8688cc93b588dd8ecf1115a1f8.js
 db287b65037a3ce2491b9ad5245c877b323ff6a8.js
 db38b836d86e35614ac30164555cd84c3bc3c6dd.js
 desktop_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 desktop_theme_37_1522da10433779d746cafc79ea7feff6ebe9d770.css
 desktop_theme_3_3d24bc909a4159746945cecfa8cee8de96493824.css
 desktop_theme_56_353dbf58327f2e62005109874adbb04510666e04.css
 desktop_theme_58_c6d6de17779690824e99a36648e4df96ab67615f.css
 desktop_theme_59_1c846f489c78ccaf6afbd8bb7b7973150ec09bd1.css
 desktop_theme_64_96b396354093d5bcb7d0dab382193683be0e77e8.css
 desktop_theme_65_1cb59dc2d246bcf71678aefca67c06c27cfb7599.css
 desktop_theme_68_8400573319944af0aa635a2f7f7e5d42c3b7fd6c.css
 desktop_theme_74_677da7fcf51b0143ed98730f3aba364459b74f70.css
 desktop_theme_79_a1825946d3fe7d97d214f84d21f15cc07b0884c3.css
 desktop_theme_81_79a7a6e8301d472501b52ee8864518bd570def04.css
 desktop_theme_83_85aa855d093c947c912fee33b90d3f77d331f292.css
 desktop_theme_89_2d9dce6b7b598acbb798bcb9a4cbc8a4769c2d40.css
 desktop_theme_91_259e9839336f626e95899ea3689c6383cce9f638.css
 discourse-automation-797d429c98a553f481d0c33e150e5afe8261a1f4.js
 discourse-automation_b2c67b8084a86f0477766fc1e3b4cc189a786e9.css
 discourse-bbcode-3079b7785a470c5508894ce7e21ef4f760f675fb88ea.js
 discourse-bbcode_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 discourse-cakeday-c97b9d03e7a391b25a24f008ca0ffebfd402e9bb3b6.js
 discourse-cakeday_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 discourse-data-explorer-1248d71f16c4796d46d30ee2597df96b716ad.js
 discourse-data-explorer_b2c67b8084a86f0477766fc1e3b4cc189a78.css
 discourse-details-26aae552e6a41eaae05c07286af29e9d2f47fecac68.js
 discourse-details_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 discourse-docs-d98420e41668b811fce6ebd0cf558a1b271a6e9f13a027.js
 discourse-docs_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 discourse-graphviz-f5d1a9b315dbf288505004c1393ac993f5f053ea34.js
 discourse-graphviz_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 discourse-lazy-videos-96992b2d9c70100602c892be1e0cdf0f3e0be9f.js
 discourse-lazy-videos_b2c67b8084a86f0477766fc1e3b4cc189a786e.css
 discourse-local-dates-453b2b53c09cec847757bb2efbaf4ab6162ecd6.js
 discourse-local-dates_b2c67b8084a86f0477766fc1e3b4cc189a786e.css
 discourse-math-0b9adce705e8554ecc8d6c4ddbf8713c5bb5a589e07a91.js
 discourse-math_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 discourse-narrative-bot-643f10339e287d380f81413fde738a8ad3a6e.js
 discourse-narrative-bot_b2c67b8084a86f0477766fc1e3b4cc189a78.css
 discourse-no-bump-561edd77c2c9cfc1281128910880083ac1c91780c09.js
 discourse-onebox-weibo_b2c67b8084a86f0477766fc1e3b4cc189a786.css
 discourse-presence-eabb23f556643767cf848218ef5a093b1c99496fc6.js
 discourse-presence_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 discourse-solved-08c562b8c2c8394867700f33ad2c8286d8a32019553f.js
 discourse-solved_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 discourse-templates-f4b7f891267b8392caee8f14278e39ed7e726b8d0.js
 discourse-templates_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 discourse-user-notes-afd4dd7029f812c33e086df9b15444d614dae7a3.js
 discourse-user-notes_b2c67b8084a86f0477766fc1e3b4cc189a786e9.css
 docker_manager_admin-fe9cdca37bd3366d6a0ebb4d5b644d58bdb51647.js
 docker_manager_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 ec422ab66afb234aef01dbfd5b072c1d82cfa5c4.js
 enhanced-ignore-827409206e61dc07ed1362d726142ad57abb3468df0d3.js
 ffc47fcf9607be2ef80b9ec1c4313c3abb1235f2.js
 footnote-e4283bf95e4bdcc5062c1bde5e8962932a35f35298b193181cda.js
 footnote_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 footnote_extra-7f7bb8e0891106317fe6883ba187d239709a385df2c386.js
'logo dark_'$'\346\233\262\347\272\277\345\214\226''.svg'
'logo_'$'\346\233\262\347\272\277\345\214\226''.svg'
 optimized-move-posts-notice-0b54397438579007a4dddc41adc0ae280.js
 overrides
 people_hugging.png
 poll-ff562b4ba36654269cfbdd883265f8f6c938a4f003aa2d8547d5d092.js
 poll_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 poll_desktop_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 retort-e9ced6a1c13cdd0ec63d76b9374daafa59cd75762651e24fe095e3.js
 retort_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 retort_desktop_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 sob.png
 spoiler-alert-7994af0f89dbc4d8cfcda8388fbf06cef011ee2cb622a4d.js
 spoiler-alert_b2c67b8084a86f0477766fc1e3b4cc189a786e96.css
 start-discourse-7c0f5f4daf3c942b7b6ecfe8e62e2e5a0f6555924859c.js
 svg-3-f4d1b64487be6085362dcf71d6570447745763ce.js
 vendor.9e07dd0436aff8751322647cc975361e-0b8308ceb741824f018eb.js
 zh_CN-84e3bf8fa7a50b4444752859a8317a818aa929dc3bc74c45a87c70c.js

历史

Fri, 05 Jan 2024 23:05:52 +0800

友链

Fri, 05 Jan 2024 23:05:52 +0800

关于

Fri, 05 Jan 2024 17:38:46 +0800

待施工…

萌备案

Wed, 03 Jan 2024 20:41:29 +0000

申请的事按照官网要求一步步做就好啦。这里记录一下添加图标的经过。

基础版

要从官网下载样式库才能引用萌备的图标。下载下来解压到 /moebeian 就行。

然后在你的网页 footer 上写上

<link rel="stylesheet" type="text/css" href="/moebeian/style.css">
<span class="icon-MOE"> </span>

NexT 主题适配

对于我正在使用的 Hexo-NexT 主题，需要编辑 next 文件夹中的源文件：

<link rel="stylesheet" type="text/css" href="/moebeian/style.css">
<span class="icon-MOE"> </span>
<!--以下是原有的备案-->
{{- next_url(theme.footer.beian.url, theme.footer.beian.icp + ' ') }}

然后在 NexT 配置文件中编辑

beian:
  enable: true
  icp: 萌ICP备xxxx号
  url: https://icp.gov.moe/?keyword=xxxx

当然，萌备样式库放在了 /source/moebeian 下。

ProtoBuf

Thu, 28 Dec 2023 19:57:18 +0000

初次听闻 ProtoBuf，以为他是只是一种“二进制编码的 JSON 平替”。但事实与之相去甚远

基本理解

在此节中我会将 JSON 与 ProtoBuf 进行横向对比。

ProtoBuf 在设计上以“机器快速解析”为终极目标，并尽力减少不必要的数据（但不包括压缩）。为此它舍弃了 JSON 的以下优秀特性：

自解释性：单个 JSON 字符串就可以解析出一个完整的以键值对为基础的对象；然而，ProtoBuf 将格式定义与数据分离，protobuf 数据必须依赖某个目标语言中预定义的类似 struct 的东西、配合 protobuf 的数据编码解码算法才能够解析。
可读性：很明显，作为一种二进制编码，它是不可读的。
简单性/易手搓：JSON 如此流行不可不归功于其语法的简洁明了，这也意味着对于一个新语言而言支持非常简单。而 ProtoBuf 定义了一个新的数据结构，有点点复杂，不太好实现。

当然肯定有不少的优秀特性：

高速解析：由于格式定义和数据的分离，格式定义被预编译进了代码内部，且以二进制编码数据，从而减少了解析时键名解析、类型判断、数值解析等开销，实现了 3-100 倍的解析性能提升。
节省空间¹：ProtoBuf 通过应用编号(Field Numbers)代替了键名，节省了寻键的开销和键的内存占用；ProtoBuf 用 Varint 和 ZigZag 减少了整数这种数据类型的内存占用。最重要的是，ProtoBuf 中所有部分都是可选的，实际传输中可以只传输要传输的那一部分，从而减少传输数据量；而不必像固定 struct 一样不论数据需不需要都会占固定内存。
可变长度²：ProtoBuf LEB128 表示变长数据的长度，实现了非标记（例如 JSON的 {}）变长度。

个人感觉，ProtoBuf 是 Golang 开发者们为了 Golang 这样的静态语言而设计出的高效、扩展性强的结构化可选数据表示方式。如果把静态考虑在内，ProtoBuf 的确是最好的结构化可选数据表示方式。

打开方式

使用 ProtoBuf 需要三步：

安装工具链，详见官网
在 .proto 文件中编写你的 protobuf 格式
用 protoc 把 .proto 文件编译成目标语言的代码
在目标语言中引用编译出来的代码，引用 Google ProtoBuf 官方库，解析编码你的 ProtoBuf 数据

ProtoBuf 语法³

最基础的 protobuf 文件定义示例如下：

git 入门 - 本地篇

Fri, 22 Dec 2023 14:58:40 +0000

git 是最著名的版本管理软件，其最大作用就是离线保存项目的完整编辑经过/历史，并提供了同步，从而能够实现

尽可能离线的多人协作和代码同步
回滚
标注稳定/纪念性版本（增加成就感？）
分支和合并

本文旨在记录学习到的 git 本地基础知识以复习。初学者建议学习 Pro Git book，并借用 Learn git branching 网站形成形象的理解。

约定：“某个”/“特定的”特指在前面的命令中提到的那个。

前言

过去，我对 git 的使用只是单纯的 clone 然后只读地作为库使用它；或者是在单人开发中 add, commit push 一把梭。这时 git 仅仅作为一种比 rsync 更加麻烦的同步工具而被使用，然而其 commit 树带来的众多优秀的本地特性才是 git 的精髓。

若要真正熟练运用 git 这个强大工具，不但要对 commit, branch 等概念有基本的理解，更要理解 git 的数据结构和基本原理。

入门

git init # 初始化一个仓库
# 一通编辑
git add . # 添加当前目录所有文件到 git 暂存区
git commit -m <commit message> # commit

基本概念

.git 目录记录了这个项目编辑改动的全部历史。

commit 指一次提交记录，branch 是一串提交记录。他们保存了一个项目编辑的全部历史经过。

（逻辑上）一个项目中有一个主分支（通常称为 master/main），其他分支都是从主分支中某个 commit 中分叉出来的，即产生了与主分支不同的 commit。

微信小程序光速入门

Sun, 17 Dec 2023 19:28:52 +0000

最小程序组成¹

在官网下载开发者工具安装好。

新建一个目录。一个最小程序组成如下：

//app.js
App({});

{
  "pages": [
    "pages/home"
  ]
}

//pages/home.js
Page({});

<!--pages/home.wxml-->
<view>
  <text>hello world</text>
</view>

调用逻辑：首先运行 app.js。App() 检查了 app.json。在此例中，将其中 pages/home.js 加以处理，其 Page() 编译 pages/home.wxml。

项目配置 `app.json`

app.json 文件配置了小程序的全局参数，包括 pages 列表和 window 字典，和其他。pages 存储了所有待编译的页面，window 包括了这堆页面的全局设定；常用 navigationBarBackgroundColor 与 navigationBarTitleText 两个参数。一个示例如下：

{
  "pages": [
    "pages/home"
  ],
  "window":{
    "navigationBarBackgroundColor": "#fff",
    "navigationBarTitleText": "标题",
    "navigationBarTextStyle":"black"
  }
}

既然有“全局设定”，也就有局部设定。对于一个页面 ${NAME}.js，其 window 设定存储在该目录下 ${NAME}.json 中，会覆盖全局的 window 设定。例如

{
  "navigationBarBackgroundColor": "#000",
  "navigationBarTitleText": "Title"
}

程序启动

App() 必须在 app.js 中调用，必须调用且只能调用一次。不然会出现无法预期的后果。

用 VuePress 写一个文档

Fri, 30 Jun 2023 17:25:54 +0000

安装

首先参考手动安装安装本体

然后 npm i -D vuepress-plugin-md-enhance 安装 md-enhance，下面会参考 Markdown 增强

配置

import { defineUserConfig } from 'vuepress'
import { defaultTheme } from 'vuepress'
import { mdEnhancePlugin } from "vuepress-plugin-md-enhance"

export default defineUserConfig({
    lang: 'zh-CN',
    title: '标题',
    head: [['link', { rel: 'icon', href: '/favicon.svg' }]], // tab 图标
    theme: defaultTheme({
      logo: '/favicon.svg', // 主图标
      sidebar: [
        '文件名（可不带.md）',
      ]
    }),
    plugins: [
    mdEnhancePlugin({
      footnote: true, // 支持脚注
      // container: true, // 支持容器，后来发现默认样式也不错
      align: true,
    }),
  ],
})

// 用以修改颜色
:root {
    --c-brand: #B390D9;
    --c-brand-light: #C4A8E1;
}

html.dark {
    --c-brand: #A594F9;
    --c-brand-light: #CDC1FF;
}

<!--用以修改默认 404 -->
<!--可以添加任何合法的 Vue 元素 -->

PWA

TODO

使用 Hexo + NexT 搭建博客

Mon, 26 Jun 2023 21:01:48 +0000

安装

参考文档 | Hexo：

npm install -g hexo-cli
hexo init my-blog && cd my-blog
npm install

配置 Hexo

我们需要区分两个 _config.yml

After the installation of Hexo and NexT, you may found that there are two configuration files using by Hexo and both called _config.yml:

The first one is under {% label info@site root directory %}, which contains Hexo’s config.

The second one is under {% label primary@theme root directory %} (e.g. themes/next/_config.yml or node_modules/hexo-theme-next/_config.yml), which is provided by NexT and contains theme’s config.

Let’s call the first one – {% label info@Hexo config file %}, and the second one – {% label primary@NexT config file %}.¹

Mon, 01 Jan 0001 00:00:00 +0000

电感，电容，电阻

T型去耦
电阻、电感串算术、并调和、变压/流乘；电导、电容串调和、并算数、变压/流除
磁链守恒：对于一个纯电感回路，由 KVL $\Sigma L_k\frac{\text{d}i_k}{\text{d}t}=0$ 有 $\Sigma L_ki_k$ 守恒
电荷守恒：连到同一节点的电容， $\Sigma Q_k=\Sigma U_kC_k = Const$
时间常数 $\tau_C=RC, \tau_L=L/R$

RLC:

	串联 $R$	并联 $G$
过阻尼	$>2\sqrt{L/C}$	$>2\sqrt{C/L}$
临界阻尼	$=2\sqrt{L/C}$	$=2\sqrt{C/L}$
欠阻尼	$<2\sqrt{L/C}$	$<2\sqrt{C/L}$
无阻尼	$0$	$0$

冲激响应 $h(T)=\frac{\text{d}S(t)}{\text{d}t}$
受控电源等效：与i有关项，需串联到对应路，然后等效电阻；u 项需并联到对应路，然后等效电导；常数项直接等效为电源。注意方向：电流方向应为电压降向。
电容：从正流向负为正参考方向
RC 桥式振荡

拉普拉斯变换

$F(s)=\int_{0^-}^\infty f(t)e^{-st}\text{d}t$
$f(s)=\frac1{2\pi j}\int_{\sigma-j\infty}^{\sigma+j\infty} F(t)e^{st}\text{d}t, t\ge0$

常见变换表：

原函数	像函数
$\delta(t)$	$1$
$\varepsilon(t), 1$	$1/s$
$t^n$	$n!/s^{n+1}$
$\cos(\omega t)$	$\frac{s}{s^2+\omega^2}$
$\sin(\omega t)$	$\frac{\omega}{s^2+\omega^2}$
$e^{-at}$	$1/(s+a)$

性质：

Mon, 01 Jan 0001 00:00:00 +0000

resource file redict
latex \ ignore
table of content generation
template render

wsmの随记

算法笔记

基础

算法复杂度

计算机网络

快速自查

概述

物理层

系统安全

系统安全概述

操作系统安全机制

Microsoft Windows 安全

Linux 操作系统安全

移动操作系统安全

数据库笔记

系统概论

密码学笔记

misc

古典密码

序列密码

分组密码

公钥密码

认证和哈希

后量子密码

考点

信号与系统系统速成

奇怪事项

信号与系统 基础

线性时不变系统

傅里叶分析

离散傅里叶分析

拉普拉斯变换

Z 变换

操作系统速成

Intro

内存管理

进程管理

进程间通信

马原概念速成

导论

世界的物质性及发展规律

认识世界和改造世界

人类社会及其发展规律

资本主义的本质及其规律

资本主义的发展及其趋势

社会主义的发展及其规律

马原速成

一、导论

什么是马克思主义

什么是马克思主义基本原理

马克思主义的创立与发展

马克思主义的基本特征

二、世界的物质性及其发展规律

世界多样性与物质统一性

事物的普遍联系和变化发展

三、实践与认识及其发展规律

实践与认识

真理与价值

认识世界和改造世界

四、人类社会及其发展规律

人类社会的存在与发展

社会历史发展的动力

人民群众在历史发展中的作用

资本主义的本质及规律

商品经济和价值规律

资本主义经济制度

抽象代数速成

群

lug 源码速览

离散数学笔记

集合论

Flattened Device Tree Blob

基本结构

原子操作与内存顺序

[Rust 每日一库] base64

核心功能

SJTUG mirror-intel 源码浏览笔记

Repos

日志

配置文件

信号与系统基础

ProtoBuf 语法³