Haoran Liao | 廖浩然

并行程序设计复习题库

Tue, 30 Jun 2026 00:00:00 GMT

并行程序设计复习题库

题量概览

填空题：98
判断题：72
选择题：72
大题：43

第一章为什么要并行计算

填空题

1-填空-1

并发强调多个任务在同一________内交替执行，而并行强调多个任务在同一________真正同时运行。

答案： 时间段；时刻

解释： 复习资料用“同一时间段内交替执行”和“同一时刻真正同时运行”区分并发和并行。

来源： 并行复习 p.4

1-填空-2

分布式程序把任务拆分到多台物理机器上，并通过________通信协调完成共同目标。

答案： 网络

解释： 资料把分布式定义为多台物理机器通过网络通信协调。

来源： 并行复习 p.4

1-填空-3

任务并行把________任务分配给不同处理单元；数据并行把________操作应用到不同数据子集。

答案： 不同；相同

解释： 资料分别定义任务并行和数据并行。

来源： 并行复习 p.4

1-填空-4

并行程序中核之间的协调主要包括通信、________和同步。

答案： 负载均衡

解释： 复习资料列出通信、负载均衡、同步三类协调。

来源： 并行复习 p.4；并行复习 p.5

1-填空-5

课程材料中，分布式内存编程主要对应 ________，共享内存编程主要对应 Pthreads 和 OpenMP。

答案： MPI

解释： 资料在并行系统处写明分布式：MPI；共享：Pthread、OpenMP。

来源： 并行复习 p.5

1-填空-6

峰值性能常按核心数、每核频率和每周期________操作数相乘估算。

答案： 浮点

解释： 资料列出峰值性能 = 核心数、每核频率、每周期浮点操作数。

来源： 并行复习 p.3

1-填空-7

继续单纯提高 CPU 频率会让集成电路变热，并最终导致________问题。

答案： 不可靠

解释： 资料指出晶体管传递速度加快会使集成电路变热并最终导致不可靠。

来源： 并行复习 p.3

1-填空-8

在批改试卷例子中，4 个助教每人改 25 份试卷属于________并行。

答案： 数据

解释： 资料把每人改 25 份试卷作为数据并行例子。

来源： 并行复习 p.4

1-课本填空-1

书中把并行系统按内存访问方式分为共享内存系统和________内存系统。

答案： 分布式

解释： 课本说明，共享内存系统中各核心原则上可读写每个内存位置；分布式内存系统中每个核心有私有内存，并通过网络发送消息等方式显式通信。

来源： 课本OCR-并行程序设计导论原书第2版 p.19

1-课本补充-填空-1

课本小结指出，由于物理限制，传统处理器性能提升速度大幅下降，芯片制造商转向在一个芯片上集成多个传统处理器，即________集成电路。

答案： 多核

解释： 课本第1章小结把处理器性能提升放缓与多核集成电路的出现直接联系起来。

来源： 课本OCR-并行程序设计导论原书第2版 p.22

1-课本补充-填空-2

在课本全局求和伪代码中，初始化数组 x 后、各核心计算部分和前，需要加入一个同步点，即 ________。

答案： Synchronize_cores()

解释： 课本说明如果某些核心还在初始化 x，其他核心就开始计算部分和会出错，所以需要在初始化和部分求和之间同步。

来源： 课本OCR-并行程序设计导论原书第2版 p.19

1-课本补充-填空-3

树状结构全局求和中，如果核心数是 2 的幂，配对核心可通过当前核心编号与位掩码做按位________得到。

答案： 异或

解释： 课本练习说明，每一阶段通过反转编号中与 bitmask 非零位对应的位得到配对核心编号，可用按位异或实现。

来源： 课本OCR-并行程序设计导论原书第2版 p.24

1-课本概念-填空-1

共享内存系统中，各核心通过访问共享________位置来协调行动。

答案： 内存

解释： 课本第1章小结把共享内存系统定义为各核心共享一个大的内存池，并通过访问共享内存位置协调。

来源： 课本OCR-并行程序设计导论原书第2版 p.23

1-课本概念-填空-2

分布式内存系统中，每个核心有自己的________内存，核心通过网络发送消息协调。

答案： 私有

解释： 课本第1章小结区分共享内存和分布式内存：分布式内存中每个核心都有自己的私有内存。

来源： 课本OCR-并行程序设计导论原书第2版 p.23

1-课本概念-填空-3

MIMD 的中文含义是多________流多数据流。

答案： 指令

解释： 课本把能相互独立运行的核心系统称为多指令流多数据流系统。

来源： 课本OCR-并行程序设计导论原书第2版 p.23

1-课本概念-填空-4

SIMD 的中文含义是单指令流多________流。

答案： 数据

解释： 课本把所有核心执行相同指令、处理各自数据流的系统称为单指令流多数据流系统。

答案： A

解释： 课本第1章小结说明 MPI 用于分布式内存 MIMD 系统的编程。

来源： 课本OCR-并行程序设计导论原书第2版 p.23

大题

1-大题-1

简述为什么需要构建并行系统。要求从单处理器性能提升受限、多核处理器出现、程序员需要利用并行硬件三个角度回答。

答案： 单处理器过去主要依赖晶体管密度增加和速度提升来提高性能，但继续提高速度会带来发热和可靠性问题；与此同时，晶体管密度仍在增加，因此可以在单芯片上放置多个相对简单的处理器，形成多核处理器。硬件已经提供并行资源后，程序必须把计算拆分到多个核心或多台机器上，才能继续获得性能提升。

解释： 答案按资料中的逻辑组织：频率提升受限 -> 利用晶体管密度做多核 -> 需要编写并行程序。

来源： 并行复习 p.3；课程要点-并行程序设计第2版 para 4；课程要点-并行程序设计第2版 para 5

1-大题-2

比较并发、并行和分布式，并说明三者的包含关系。

答案： 并发强调多个任务在同一时间段内交替执行，看起来像同时运行；并行强调多个任务在同一时刻真正同时运行，依赖多个核心或多个计算资源；分布式强调任务分布在多台物理机器上，并通过网络通信协调完成目标。资料给出的关系是：所有并行和分布式程序都是并发的，但并发不一定并行，也不一定分布式。

解释： 核心区别在于“同一时间段”“同一时刻”和“多台物理机器/网络通信”。

来源： 并行复习 p.4；课程要点-并行程序设计第2版 para 7

1-大题-3

比较任务并行和数据并行，并用“批改试卷”的例子说明。

答案： 任务并行把不同任务或功能分配给不同处理单元，例如助教 A 批选择题、助教 B 批填空题、助教 C 批问答题。数据并行把相同操作应用到不同数据子集上，例如 4 个助教每人批 25 份试卷。二者都可能需要通信、负载均衡和同步来协调。

解释： 资料直接给出了任务并行、数据并行定义和批改试卷例子。

来源： 并行复习 p.4；并行复习 p.5

1-课本大题-1

依据课本，说明为什么 GPU 既不是纯 SIMD，也不是纯 MIMD。

答案： GPU 的给定核心上的数据通路可以使用 SIMD 并行，但当代 GPU 可以在单个核心上运行多个指令流；典型 GPU 还有几十个核心，这些核心也能执行独立指令流。因此 GPU 同时具有 SIMD 和 MIMD 的特征，不能简单归为纯 SIMD 或纯 MIMD。

解释： 课本直接强调 GPU 不是纯 SIMD 系统，也不是纯 MIMD 系统，并给出核心内和多核心层面的原因。

来源： 课本OCR-并行程序设计导论原书第2版 p.37

1-课本补充-大题-1

根据课本全局求和例子，说明通信、负载均衡和同步分别在哪里出现。

答案： 通信出现在一个或多个核心把当前部分和发送给另一个核心时；负载均衡出现在第一阶段给每个核心分配大致相同数量、且工作量接近的计算值时；同步出现在必须等数组 x 初始化完成后才能开始部分求和，以及树状归约每一阶段必须等待前一阶段结果可用时。

解释： 课本在全局求和例子后逐项说明了通信、负载平衡和同步，并在伪代码处给出 `Synchronize_cores()` 的必要性。

来源： 课本OCR-并行程序设计导论原书第2版 p.18；课本OCR-并行程序设计导论原书第2版 p.19

1-课本补充-大题-2

推导并比较直接全局求和和树状全局求和中核心0的接收/加法次数。假设核心数 p 是 2 的幂。

答案： 直接方案中，其他 p-1 个核心都把部分和发送给核心0，所以核心0需要完成 p-1 次接收和 p-1 次加法。树状结构中每一阶段问题规模减半，核心0只在每一层接收并合并一次，因此需要 log2(p) 次接收和 log2(p) 次加法。

解释： 课本练习要求推导核心0在原始伪代码和树状结构全局和中的接收与加法数量，树状配对过程见课本图示和位掩码说明。

来源： 课本OCR-并行程序设计导论原书第2版 p.17；课本OCR-并行程序设计导论原书第2版 p.24

1-课本补充-大题-3

为什么课本把“良好的程序开发技术”放在并行程序中特别强调？

答案： 并行程序除了普通程序的算法和实现问题，还要处理核心之间通信、负载均衡、同步、任务划分和调试等问题。课本指出并行程序通常非常复杂，因此更需要良好的程序开发技术，以避免把协调问题隐藏在难以定位的错误中。

解释： 第1章小结和练习前说明并行程序通常复杂，且编写时需要协调通信、负载平衡和同步。

来源： 课本OCR-并行程序设计导论原书第2版 p.22；课本OCR-并行程序设计导论原书第2版 p.23

第二章并行硬件和软件

填空题

2-填空-1

冯诺依曼架构困境指处理器速度和________访问速度之间差距越来越大。

答案： 内存

解释： 资料说明 CPU 和主存分离导致 CPU 大量时间等待数据。

来源： 并行复习 p.5

2-填空-2

Cache 利用两类局部性：时间局部性和________局部性。

答案： 空间

解释： 资料说明程序员不能显式控制 Cache Line，需要利用时间局部性和空间局部性。

来源： 并行复习 p.6

2-填空-3

写回策略会先把被修改的 Cache Line 标记为________，等换出 Cache 后再写回主存。

答案： 脏的

解释： 复习资料对写回的定义是标记 Cache Line 为脏，换出时再写主存。

来源： 并行复习 p.6

2-填空-4

Flynn 分类法按照同时管理的________流数目和数据流数目分类。

答案： 指令

解释： 资料说明 Flynn 分类法按指令流和数据流数目分类。

来源： 并行复习 p.7

2-填空-5

SIMD 可以抽象为一个控制单元和多个________。

答案： ALU

解释： 资料说明 SIMD 有一个控制单元和多个 ALU。

来源： 并行复习 p.8

2-填空-6

MIMD 系统的两类主要形式是共享内存系统和________内存系统。

答案： 分布式

解释： 复习资料说明 MIMD 系统主要类型为共享内存和分布式内存。

来源： 并行复习 p.8

2-填空-7

效率 E 的常用公式是 E = S / ________。

答案： p

解释： 资料说明效率表示 S 接近线性加速比的程度，所以除以 p。

来源： 并行复习 p.16

2-填空-8

固定问题规模、增加核数并希望效率维持不变，称为________扩展性。

答案： 强

解释： 资料定义强扩展性为固定问题规模，增加核数 P，效率维持不变。

来源： 并行复习 p.19

2-课本填空-1

SPMD 程序不是在每个核心上运行不同程序，而是由同一个可执行程序在不同进程/线程上运行，通常依靠________区分各自工作。

答案： 编号或秩

解释： 课本在并行软件部分说明主要关注 SPMD：同一程序在多个进程/线程上运行，再由各自身份决定执行哪部分任务。

来源： 课本OCR-并行程序设计导论原书第2版 p.46

2-课本补充-填空-1

课本小结中，CPU 和内存分离限制指令执行速度的问题称为________瓶颈。

答案： 冯·诺依曼

解释： 课本第2章小结说明，CPU 和内存分离被称为冯·诺依曼瓶颈，因为它限制了指令执行速度。

来源： 课本OCR-并行程序设计导论原书第2版 p.67

2-课本补充-填空-2

虚拟地址和物理地址的对应关系存储在主存中的页表；为减少页表访问，CPU 使用页表缓存，即________。

答案： 转换查找缓冲区（TLB）

解释： 课本说明页表在主存中，直接查页表可能导致额外内存访问，因此 CPU 有转换查找缓冲区存储最近使用的页表条目。

来源： 课本OCR-并行程序设计导论原书第2版 p.68

2-课本补充-填空-3

课本把由处理器和编译器控制、程序员通常不直接控制的低层次并行分为指令级并行和________级并行。

答案： 线程

解释： 课本将 ILP 和 TLP 作为低层次并行讨论，并指出它们通常由处理器和编译器控制，而不是程序员直接控制。

来源： 课本OCR-并行程序设计导论原书第2版 p.68

2-课本概念-填空-1

操作系统通过在执行程序之间快速切换，即使没有多个核心，也能产生多个作业同时运行的________。

答案： 假象

解释： 课本第2章小结说明，多任务操作系统通过快速切换产生多个作业同时运行的假象。

来源： 课本OCR-并行程序设计导论原书第2版 p.67

2-课本概念-填空-2

指令级并行的两种主要类型是流水线和________。

答案： 多发射

解释： 课本第2章小结列出 ILP 两种主要类型：流水线和多发射。

来源： 课本OCR-并行程序设计导论原书第2版 p.68

2-课本概念-填空-3

Flynn 分类法区分系统可同时管理的________流数量和数据流数量。

答案： 指令

解释： 课本说明 Flynn 分类法区分系统可以同时管理的指令流数量和数据流数量。

来源： 课本OCR-并行程序设计导论原书第2版 p.68

2-课本概念-填空-4

如果所有处理器具有相同体系结构，该系统称为________系统。

答案： 同构

解释： 课本说明所有处理器具有相同体系结构的系统是同构系统；处理器功能不同则是异构系统。

答案： A

解释： 课本区分强/弱可扩展性：问题规模保持不变可保持效率称为强可扩展性。

来源： 课本OCR-并行程序设计导论原书第2版 p.71

大题

2-大题-1

结合 `sum += z[i]` 这类数组求和循环，解释时间局部性和空间局部性。

答案： 时间局部性体现在 `sum` 被反复读取和更新，CPU 可以把它保留在寄存器或 Cache 中，避免每次从主存加载。空间局部性体现在数组 `z` 连续存储，访问 `z[0]` 时可能把包含后续元素的 Cache Line 一起读入，之后访问 `z[1]`、`z[2]` 等更容易命中 Cache。

解释： 答案直接来自资料对 `float z[1000]` 求和示例的解释。

来源： 并行复习 p.6

2-大题-2

比较 SIMD 和 MIMD，并说明它们适合的并行模式或系统类型。

答案： SIMD 用一个控制单元向多个 ALU 广播同一条指令，让不同 ALU 处理不同数据，适合规则的数据并行，但复杂分支会降低效率。MIMD 支持多个独立处理单元在多个数据流上运行不同指令，通常异步，是目前使用较多的形式，可进一步分为共享内存系统和分布式内存系统。

解释： 资料在 SIMD/MIMD 小节分别说明了控制单元、ALU、同步/异步、共享内存和分布式内存。

来源： 并行复习 p.8；课程要点-计算机体系结构-量化研究方法-第六版-第四章 para 4；课程要点-计算机体系结构-量化研究方法-第六版-第四章 para 5

2-大题-3

解释加速比、效率、阿姆达尔定律和可扩展性之间的关系。

答案： 加速比衡量并行程序相对串行程序的变快程度，线性加速比是 S=P。效率 E=S/P，表示实际加速比接近线性加速比的程度。阿姆达尔定律说明只要存在串行部分，加速比就有上限。可扩展性描述增加处理器数量时性能能否持续提升；强扩展固定问题规模，弱扩展在增加核数时也增加问题规模。

解释： 资料在性能评估页依次解释了加速比、效率、阿姆达尔定律和强/弱扩展性。

来源： 并行复习 p.16；并行复习 p.17；并行复习 p.18；并行复习 p.19

2-课本大题-1

用课本直方图例子解释为什么直接共享 `bin_counts[b]++` 会出现竞争条件，以及一种避免思路。

答案： 如果两个进程或线程被分配到属于同一个桶 b 的数据元素，它们都会执行 `bin_counts[b]++`。若 `bin_counts` 是共享数组，这两个更新可能交错执行，导致丢失更新，形成竞争条件。避免思路是把 `bin_counts` 划分为各进程/线程的局部计数，例如使用 `loc_bin_counts`，最后再合并局部结果。

解释： 课本在 Foster 方法论的直方图示例中指出，共享 `bin_counts[b]++` 会导致竞争条件，而按进程/线程划分 `loc_bin_counts` 可规避共享更新。

来源： 课本OCR-并行程序设计导论原书第2版 p.64

2-课本补充-大题-1

解释为什么按行遍历二维数组通常比按列遍历更符合缓存局部性。

答案： C 语言二维数组按行连续存储。按行遍历时，读入一个缓存行后会连续使用同一行中相邻元素，空间局部性好；按列遍历时，相邻访问跨越较大地址间隔，已载入的同一缓存行很快被逐出，缓存未命中更多。课本示例中第一对嵌套循环显著快于第二对。

解释： 课本用 MAX=1000 的二维数组循环示例说明，两种嵌套循环因缓存未命中次数不同而有明显性能差异。

来源： 课本OCR-并行程序设计导论原书第2版 p.31

2-课本补充-大题-2

说明课本中 MIMD 系统、混合系统、异构系统和同构系统的关系。

答案： MIMD 系统执行多个独立指令流，每个指令流可有自己的数据流。较大的 MIMD 系统常是混合系统，即多个较小共享内存节点通过互连网络连接。若处理器功能不同，如 CPU 与 GPU 组合，就是异构系统；若所有处理器具有相同体系结构，就是同构系统。

解释： 课本第2章小结在 MIMD 系统段落中依次定义了这些系统类型。

来源： 课本OCR-并行程序设计导论原书第2版 p.69

2-课本补充-大题-3

按课本说明，如何较可靠地测量并行程序运行时间？

答案： 应在源代码中调用计时器，记录挂钟时间；在同构 MIMD 系统中，通常先同步进程/线程再启动计时器，停止计时后取所有进程/线程中的最大运行时间；由于系统可变性，应对同一数据集多次运行，通常取最短时间；为减少可变性，通常每个核心不超过一个进程或线程。

解释： 课本性能小结明确说明计时要用挂钟时间、并行时间要考虑同步和最大运行时间，并建议多次运行取较稳定结果。

来源： 课本OCR-并行程序设计导论原书第2版 p.71

第三章 MPI 进行分布式内存编程

填空题

3-填空-1

MPI 程序通常用 ________ 编译，用 mpiexec 执行。

答案： mpicc

解释： 复习资料给出 `mpicc -o hello hello.c` 和 `mpiexec -n 4 ./hello`。

来源： 并行复习 p.19

3-填空-2

MPI_Init 必须在所有其他 MPI 函数调用________执行。

答案： 之前

解释： 资料说明 MPI_Init 必须在所有其他 MPI 函数调用之前执行。

来源： 并行复习 p.20

3-填空-3

MPI_Comm_rank 用于获取当前进程在通信子中的________。

答案： rank

解释： 资料给出 MPI_Comm_rank 的作用和示例。

来源： 并行复习 p.21

3-填空-4

MPI_Send 的 count 参数表示发送的数据项个数，而不是________数。

答案： 字节

解释： 资料参数表明确 count 是数据项个数，不是字节数。

来源： 并行复习 p.21

3-填空-5

MPI_Recv 可用通配符 MPI_ANY_SOURCE 匹配任意________。

答案： 消息来源进程

解释： 资料说明 source 可用 MPI_ANY_SOURCE 匹配任意来源。

来源： 并行复习 p.22

3-填空-6

MPI 点对点消息匹配主要看 source、tag 和________。

答案： comm

解释： 资料列出 MPI_Recv 与 MPI_Send 匹配需要 source、tag、comm。

来源： 并行复习 p.22

3-填空-7

MPI_Reduce 将多个进程的数据按指定归约操作聚合，并把结果返回到指定________进程。

答案： 根

解释： 资料说明 MPI_Reduce 将结果返回到指定根进程。

来源： 并行复习 p.25

3-填空-8

MPI_Allgather 可以理解为 MPI_Gather 加上 ________。

答案： MPI_Bcast

解释： 资料直接写出 `MPI_Allgather = MPI_Gather + MPI_Bcast`。

来源： 并行复习 p.30

3-课本填空-1

MPI_Init 的目的之一是定义包含启动时所有进程的通信域，称为________。

答案： MPI_COMM_WORLD

解释： 课本说明 MPI_Init 会进行必要设置，其中一个目的就是定义包含用户启动程序所有进程的通信域 MPI_COMM_WORLD。

来源： 课本OCR-并行程序设计导论原书第2版 p.78

3-课本补充-填空-1

从程序员视角看，分布式内存系统由通过网络连接的核心-________对组成，相关存储器只有该核心可直接访问。

答案： 存储

解释： 课本第3章开头把分布式内存系统描述为通过网络连接的核心-存储对。

来源： 课本OCR-并行程序设计导论原书第2版 p.75

3-课本补充-填空-2

MPI 点对点消息通常包含数据和“信封”信息，信封中包括目的进程、发送进程、标签、通信域和________信息。

答案： 消息大小

解释： 课本解释 MPI 发送进程会组装消息，给数据加上信封信息，其中包含目的、源、标签、通信域和消息大小。

来源： 课本OCR-并行程序设计导论原书第2版 p.83

3-课本补充-填空-3

MPI_Bcast 是把单个源进程的数据发送到通信域中的________进程。

答案： 所有

解释： 课本在广播小节说明，source_proc 进程把 data_p 引用的内容发送给通信器中的所有进程。

来源： 课本OCR-并行程序设计导论原书第2版 p.94

3-课本概念-填空-1

MPI 是一个可以从 C 或 Fortran 程序中调用的________库。

答案： 函数

解释： 课本第3章小结第一句说明 MPI 是一个函数库。

来源： 课本OCR-并行程序设计导论原书第2版 p.116

3-课本概念-填空-2

许多系统使用 ________ 编译 MPI 程序，使用 mpiexec 运行 MPI 程序。

答案： mpicc

解释： 课本第3章小结说明许多系统使用 mpicc 编译、mpiexec 运行 MPI 程序。

来源： 课本OCR-并行程序设计导论原书第2版 p.116

3-课本概念-填空-3

C MPI 程序应包含 ________ 头文件以获得 MPI 函数原型、类型和宏。

答案： mpi.h

解释： 课本第3章小结说明 C MPI 程序应该包含 mpi.h 头文件。

来源： 课本OCR-并行程序设计导论原书第2版 p.116

3-课本概念-填空-4

MPI_Comm_rank 获取进程在通信域中的________。

答案： 序列号或 rank

解释： 课本在通信域、MPI_Comm_size 和 MPI_Comm_rank 小节说明该函数获取当前进程编号。

答案： A

解释： 课本第3章小结指出，在 MPI_Reduce 等函数中将相同实际参数传给输入和输出缓冲区称为参数混叠，MPI 明确禁止输出参数与另一个参数混叠。

来源： 课本OCR-并行程序设计导论原书第2版 p.117

大题

3-大题-1

解释 MPI_Send 和 MPI_Recv 的阻塞语义，并说明大消息双向先 Send 后 Recv 为什么可能死锁。

答案： MPI_Recv 一定阻塞，如果消息未到达会等待。MPI_Send 对小消息可能复制到内部缓冲区后返回；对较大消息，如果接收端尚未发起匹配的 MPI_Recv，发送端可能阻塞。若两个进程都先执行大消息 MPI_Send，再执行 MPI_Recv，两个进程都会等待对方先接收，无法到达接收阶段，形成死锁。可以使用 MPI_Sendrecv 或调整收发顺序避免。

解释： 答案结合复习资料对 Send/Recv 语义的描述和参考资料 2 对大消息死锁原因及 Sendrecv 替代方案的说明。

来源： 并行复习 p.23；参考资料2 para 16；参考资料2 para 17；参考资料2 para 41；参考资料2 para 42

3-大题-2

用 MPI 并行梯形积分时，如何划分计算并汇总结果？说明会用到哪些 MPI 函数。

答案： 基本思路是把积分区间划分为若干梯形，每个进程计算自己负责的一部分局部面积，再用 MPI_Reduce 按求和操作把局部结果汇总到 0 号进程，最后由 0 号进程输出总积分值。程序需要 MPI_Init/MPI_Finalize 管理环境，MPI_Comm_rank 获取当前进程编号，MPI_Comm_size 获取进程数，MPI_Reduce 汇总局部积分结果，MPI_Wtime 可用于计时。

解释： 复习资料给出梯形积分公式和 MPI_Reduce 用法；参考资料 2 也列出梯形法中通过 MPI_Reduce 汇总到进程 0。

来源： 并行复习 p.23；并行复习 p.25；并行复习 p.31；参考资料2 para 90；参考资料2 para 92

3-大题-3

比较 MPI 点对点通信和集合通信，说明匹配规则和调用要求。

答案： 点对点通信如 MPI_Send/MPI_Recv 发生在发送方和接收方之间，通过 source、tag、comm 等字段匹配，接收方还可使用 MPI_ANY_SOURCE 和 MPI_ANY_TAG。集合通信涉及通信子中的所有进程，所有进程必须调用相同的集合函数，参数需一致，匹配主要依赖通信子和调用顺序，不能用 MPI_Reduce 与 MPI_Recv 相匹配。

解释： 资料在消息匹配和集合通信与点对点通信部分直接给出这些规则。

来源： 并行复习 p.22；并行复习 p.25；并行复习 p.26

3-课本大题-1

结合课本，说明 MPI_Scatter、MPI_Gather 与 MPI_Allgather 的用途和限制。

答案： MPI_Scatter 可由根进程把数组块分发给各进程；MPI_Gather 可把各进程的局部数组收集到根进程；MPI_Allgather 可理解为先 Gather 再 Bcast，让所有进程获得收集后的向量。课本提醒 Scatter/Gather 示例对块分布且每个块大小相同的向量工作正常，因此使用时要注意数据分布和每进程块大小限制。

解释： 课本给出了 Scatter、Gather 和 Allgather 的函数语义，并指出 Gather/Scatter 示例对相同大小块分布有使用限制。

来源： 课本OCR-并行程序设计导论原书第2版 p.96；课本OCR-并行程序设计导论原书第2版 p.98；课本OCR-并行程序设计导论原书第2版 p.100

3-课本补充-大题-1

用课本梯形法则例子说明 Foster 方法论在 MPI 并行化中的应用。

答案： 先划分任务：计算单个梯形面积和计算面积总和；再识别通信：局部面积需要汇总到总和；然后凝聚：把多个相邻梯形分配给同一进程形成较大的局部任务；最后映射：把局部梯形块映射到各进程，每个进程计算局部积分，再通过归约通信汇总。

解释： 课本在 MPI 梯形法则中用 Foster 方法论分析任务、通信、聚合和映射，并以图示说明单个梯形面积与总和之间的通信。

来源： 课本OCR-并行程序设计导论原书第2版 p.85；课本OCR-并行程序设计导论原书第2版 p.90

3-课本补充-大题-2

说明 MPI_Reduce、MPI_Allreduce、MPI_Bcast、MPI_Scatter 和 MPI_Gather 的核心区别。

答案： MPI_Reduce 把全局操作结果放到单个指定进程；MPI_Allreduce 把结果放到所有进程；MPI_Bcast 从单个源进程把数据发送给所有进程；MPI_Scatter 从根进程把不同数据块分散给各进程；MPI_Gather 把各进程数据块收集到根进程。

解释： 课本第3章小结和集合通信小节分别给出这些集合通信函数的用途。

来源： 课本OCR-并行程序设计导论原书第2版 p.94；课本OCR-并行程序设计导论原书第2版 p.96；课本OCR-并行程序设计导论原书第2版 p.98；课本OCR-并行程序设计导论原书第2版 p.117

3-课本补充-大题-3

为什么发送零字节消息仍可能有非零运行时间？

答案： 即使 count 为 0，通信仍需要函数调用、进入 MPI 运行时、构造和处理消息信封、进行进程匹配与同步等控制操作。这些固定开销与消息数据字节数无关，因此零字节消息运行时间仍可能非零。

解释： 课本练习提出 count 为 0 的发送成本问题；前文对消息信封和发送语义的说明支持固定控制开销的解释。

来源： 课本OCR-并行程序设计导论原书第2版 p.83；课本OCR-并行程序设计导论原书第2版 p.124

第四章 Pthreads 进行共享内存编程

填空题

4-填空-1

pthread_create 的线程入口函数类型必须是 `void* -> ________`。

答案： void*

解释： 资料函数原型注释写明线程入口函数必须是 void* 到 void*。

来源： 并行复习 p.35

4-填空-2

pthread_join 会阻塞调用它的线程，直到目标线程正常________。

答案： 返回

解释： 资料说明 pthread_join 阻塞调用线程直到目标线程正常返回。

来源： 并行复习 p.35

4-填空-3

竞争条件是多个线程同时读取某个共享变量并操作，变量值与线程执行________有关。

答案： 顺序

解释： 资料定义竞争条件时强调共享变量的值与线程执行顺序有关。

来源： 并行复习 p.36

4-填空-4

互斥锁保证同一时刻只有________个线程可以进入临界区。

答案： 一

解释： 资料定义互斥锁保证同一时刻只有一个线程进入临界区。

来源： 并行复习 p.36

4-填空-5

sem_wait 在信号量值大于 0 时会将其减________并继续执行。

答案： 一

解释： 资料说明 sem_wait 若信号量值 > 0，减一并继续执行。

来源： 并行复习 p.39

4-填空-6

路障要求一组线程在某一点集合，等________线程都到达后再继续。

答案： 所有

解释： 资料定义路障为等所有线程到达后统一继续。

来源： 并行复习 p.39

4-填空-7

条件变量通常需要搭配________锁一起使用。

答案： 互斥

解释： 资料说明条件变量需要搭配互斥锁一起使用。

来源： 并行复习 p.40

4-填空-8

线程安全版本的 strtok 是 ________。

答案： strtok_r

解释： 资料说明可以使用线程安全版本 strtok_r。

来源： 并行复习 p.46

4-课本填空-1

Pthreads 程序启动线程常用函数是 pthread_create，停止或等待线程完成常用函数是________。

答案： pthread_join

解释： 课本 Pthreads 小结说明，pthread_create 和 pthread_join 分别用于启动和停止一个线程函数。

来源： 课本OCR-并行程序设计导论原书第2版 p.166

4-课本补充-填空-1

课本把观察或调试时可能暂时消失的并发错误称为________。

答案： Heisenbugs

解释： 课本说明，附加调试器或添加 printf 可能改变线程相对时间，使错误似乎消失，这类错误称为 Heisenbugs。

来源： 课本OCR-并行程序设计导论原书第2版 p.139

4-课本补充-填空-2

忙等待实现栅栏时，如果要重复使用计数器，必须处理计数器________问题，否则第二个栅栏可能失效或挂起。

答案： 重置

解释： 课本说明第一个栅栏完成后 counter 等于 thread_count；若不能正确重置，第二个栅栏不会阻塞，或重置时导致线程挂起。

来源： 课本OCR-并行程序设计导论原书第2版 p.149

4-课本补充-填空-3

Pthreads 条件变量总是与一个________锁相关联。

答案： 互斥

解释： 课本介绍条件变量时明确说条件变量总是与一个互斥锁相关联。

来源： 课本OCR-并行程序设计导论原书第2版 p.151

4-课本概念-填空-1

从程序员角度看，共享内存系统是所有核心都可以访问所有________位置的系统。

答案： 内存

解释： 课本第4章开头回顾共享内存系统的定义。

来源： 课本OCR-并行程序设计导论原书第2版 p.127

4-课本概念-填空-2

互斥锁用于保证对临界区的________访问。

答案： 互斥

解释： 课本说明 mutex 是 mutual exclusion 的缩写，用于限制对临界区的访问，使一次只有一个线程访问。

来源： 课本OCR-并行程序设计导论原书第2版 p.142

4-课本概念-填空-3

二元信号量只使用两个值：________和1。

答案： 0

解释： 课本说明二元信号量只使用 0 和 1；0 对应锁定，1 对应解锁。

来源： 课本OCR-并行程序设计导论原书第2版 p.146

4-课本概念-填空-4

栅栏是一种同步点，在所有线程到达之前，没有线程可以________栅栏继续前进。

答案： 越过

解释： 课本定义栅栏为线程都处于同一位置的同步点，在所有线程到达前没有线程可以越过。

答案： A

解释： 课本说明 pthread_cond_broadcast 将解除所有被阻塞的线程。

来源： 课本OCR-并行程序设计导论原书第2版 p.151

大题

4-大题-1

分析在循环内部对全局变量加锁累加，为什么性能可能很差；给出更好的思路。

答案： 如果每次循环迭代都在 `global_sum += ...` 前后加锁，那么临界区执行次数等于迭代次数，锁和解锁会发生大量次。其他线程需要等待，调度器还可能频繁唤醒和切换线程，CPU 周期消耗在同步和调度上，而不是有效计算。更好的思路是每个线程先用私有局部变量累计自己的部分，最后只进入一次临界区把局部结果合并到全局变量。

解释： 参考资料 3 直接分析了 Pthreads 求平方和的两个代码片段：循环内锁导致 N 次 lock/unlock，局部和再合并能减少同步。

来源： 参考资料3 para 2；参考资料3 para 36；参考资料3 para 37；参考资料3 para 38

4-大题-2

比较忙等待、互斥量、信号量和条件变量的适用点。

答案： 忙等待通过反复检查条件来同步，能控制顺序但浪费 CPU，线程数超过核心数时性能可能很差。互斥量保证同一时刻只有一个线程进入临界区，适合保护共享变量更新，但进入顺序由系统调度决定。信号量适合一个线程等待另一个线程完成某些操作，也可以允许一定数量线程进入。条件变量用于等待某个条件成立，通常与互斥锁搭配，等待时释放锁，被唤醒后重新加锁。

解释： 答案分别来自忙等待、互斥量、信号量、条件变量小节。

来源： 并行复习 p.36；并行复习 p.37；并行复习 p.38；并行复习 p.39；并行复习 p.40；并行复习 p.41

4-大题-3

解释伪共享的形成过程，并给出至少两种避免思路。

答案： 伪共享发生在多个线程修改不同变量，但这些变量落在同一个 Cache Line 中。某个线程修改自己的变量时，会使其他核心中同一 Cache Line 的副本失效；另一个线程再修改邻近变量时又要重新获取该 Cache Line，导致缓存行反复失效/同步，性能急剧下降。避免思路包括给结构体成员填充或对齐，让不同线程频繁写的变量落在不同 Cache Line；或者让每个线程先在私有局部变量中累加，最后再少量写回共享内存。

解释： 复习资料和参考资料 3 均解释了不同变量同处一个 cache line 导致性能下降，以及私有局部变量累加的改法。

来源： 并行复习 p.44；并行复习 p.45；参考资料3 para 162；参考资料3 para 166；参考资料3 para 172

4-课本大题-1

课本为什么强调线程安全？以静态局部变量为例说明。

答案： 线程安全指一个代码块由多个线程运行时仍能正常工作。普通 C 局部变量从线程自己的栈分配，通常是私有的；但静态局部变量跨调用保持存在，在多个线程调用同一函数时实际上会被共享，可能导致意外的共享状态和竞争。因此，串行程序中可用的函数放到多线程程序中不一定安全。

解释： 课本在线程安全小节说明，静态局部变量会在调用函数的线程之间有效共享，这是串行函数在多线程程序中可能出错的重要原因。

来源： 课本OCR-并行程序设计导论原书第2版 p.50；课本OCR-并行程序设计导论原书第2版 p.70

4-课本补充-大题-1

比较忙等待、互斥锁和信号量在控制线程顺序或临界区访问上的差异。

答案： 忙等待通过反复测试共享标志控制顺序，简单但浪费 CPU，且受优化和调度影响；互斥锁适合保护临界区，只保证互斥，不保证线程按编号顺序进入；信号量可表示资源计数或事件通知，二元信号量能像互斥锁一样使用，也能用于生产者-消费者式的消息到达通知。

解释： 课本分别讨论忙等待、自旋、互斥锁随机进入临界区、以及用信号量让线程发送消息。

来源： 课本OCR-并行程序设计导论原书第2版 p.140；课本OCR-并行程序设计导论原书第2版 p.143；课本OCR-并行程序设计导论原书第2版 p.146；课本OCR-并行程序设计导论原书第2版 p.147

4-课本补充-大题-2

为什么用互斥锁数组直接改造线程消息传递示例仍可能崩溃？

答案： 如果线程0远领先于线程1，它可能在线程1设置给线程0的消息指针前，就锁住自己的互斥锁并执行打印；此时 messages[my_rank] 仍是 NULL，解除空指针引用会崩溃。问题不只是互斥访问，而是还需要表达“消息已经到达”的同步条件。

解释： 课本用两个线程的事件顺序说明，单纯在写和读周围加互斥锁仍可能让线程读取 NULL 指针。

来源： 课本OCR-并行程序设计导论原书第2版 p.145；课本OCR-并行程序设计导论原书第2版 p.146

4-课本补充-大题-3

为什么条件变量等待通常应该放在 while 循环中？

答案： 线程可能因为 signal/broadcast 之外的事件解除阻塞，即虚假唤醒；即使确实被唤醒，条件也可能已被其他线程改变。因此等待返回后应重新检查条件，不满足就再次等待。

解释： 课本明确说明虚假唤醒存在，`pthread_cond_wait` 通常应放在 while 循环中；单线程唤醒时继续前也应确认条件。

来源： 课本OCR-并行程序设计导论原书第2版 p.152

第五章用 OpenMP 进行共享内存编程

填空题

5-填空-1

OpenMP 的 pragma 总是以 `#pragma ________` 开始。

答案： omp

解释： 资料说明 OpenMP 的 pragma 总是以 `# pragma omp` 开始。

来源： 并行复习 p.47

5-填空-2

`#pragma omp parallel` 并行块末尾有一个隐式________。

答案： barrier

解释： 资料提醒并行代码块末尾存在隐式 barrier。

来源： 并行复习 p.47

5-填空-3

OpenMP 中，在 parallel 指令之前声明的变量默认是________变量。

答案： 共享

解释： 资料总结并行指令之前声明的变量默认共享。

来源： 并行复习 p.49

5-填空-4

OpenMP 的 reduction 子句会为每个线程创建归约变量的________副本。

答案： 私有

解释： 资料说明 OpenMP 自动为每个线程创建 variable 的私有副本。

来源： 并行复习 p.50

5-填空-5

`#pragma omp parallel for` 后面只能跟 ________ 循环。

答案： for

解释： 资料明确该指令后面只能跟 for 循环。

来源： 并行复习 p.50

5-填空-6

如果第 i 次迭代依赖第 i-1 次迭代结果，就存在数据________，不能直接并行化。

答案： 依赖

解释： 资料用 a[i]=a[i-1]+1 说明数据依赖性冲突。

来源： 并行复习 p.51

5-填空-7

schedule(static, 1) 在资料中表现为按线程轮转分配每次________个迭代。

答案： 一

解释： 资料用 12 次迭代、3 个线程、chunk size 为 1 展示轮转调度。

来源： 并行复习 p.54

5-填空-8

atomic 通常只保护紧跟其后的________条共享变量更新语句。

答案： 一

解释： 资料说明 atomic 只保护接下来一条 C 语言赋值语句。

来源： 并行复习 p.58；并行复习 p.60

5-课本填空-1

OpenMP 的 reduction 子句会为每个线程创建归约变量的________变量，运行时再按归约运算合并结果。

答案： 私有

解释： 课本解释 `reduction(+: global_result)` 时说明，OpenMP 为每个线程创建私有变量来存储线程结果，然后合并。

来源： 课本OCR-并行程序设计导论原书第2版 p.185

5-课本补充-填空-1

OpenMP 的 `parallel for` 指令通过在线程之间分配循环的________来并行化 for 循环。

答案： 迭代

解释： 课本说明 parallel for 指令分叉线程执行结构化块，并通过在线程之间分配 for 循环迭代来实现并行化。

来源： 课本OCR-并行程序设计导论原书第2版 p.186

5-课本补充-填空-2

schedule 子句中，`runtime` 类型表示调度方式在运行时由________变量确定。

答案： 环境

解释： 课本说明 runtime 调度是在运行时根据环境变量确定的。

来源： 课本OCR-并行程序设计导论原书第2版 p.197

5-课本补充-填空-3

课本 OpenMP 任务示例中，`taskwait` 作为任务的________，强迫当前任务等待子任务完成。

答案： 栅栏

解释： 课本 Fibonacci 示例说明 taskwait 指令作为任务的一个栅栏，等待子任务完成。

来源： 课本OCR-并行程序设计导论原书第2版 p.214

5-课本概念-填空-1

OpenMP 程序通常通过 `#pragma omp ________` 创建一组线程执行结构化块。

答案： parallel

解释： 课本 OpenMP 入门示例使用 `#pragma omp parallel` 分叉线程执行 Hello。

来源： 课本OCR-并行程序设计导论原书第2版 p.175

5-课本概念-填空-2

OpenMP 归约子句 `reduction(+:x)` 中的 `+` 表示归约________。

答案： 运算符

解释： 课本解释 reduction 时说明加号表示归约运算符是加法。

来源： 课本OCR-并行程序设计导论原书第2版 p.185

5-课本概念-填空-3

OpenMP `parallel for` 指令后面的结构化块必须是一个________循环。

答案： for

解释： 课本说明 parallel for 后的结构化块必须是 for 循环。

来源： 课本OCR-并行程序设计导论原书第2版 p.186

5-课本概念-填空-4

OpenMP schedule 子句的一般形式是 `schedule(<type>[, <________>])`。

答案： chunksize

解释： 课本给出 schedule 子句形式为 `schedule(<type>[, <chunksize>])`。

答案： A

解释： 课本说明 taskwait 指令作为任务的栅栏，强迫任务等待子任务完成。

来源： 课本OCR-并行程序设计导论原书第2版 p.214

大题

5-大题-1

为什么资料中的第一个 OpenMP pi 值估计并行版本有问题？如何修改？

答案： 问题在于 `factor` 在并行区外定义，默认共享，并且每次迭代的正负号依赖前一次迭代，存在数据依赖和共享变量竞争。修改思路是把 `factor` 设为 private，并在每次迭代中由 k 的奇偶性独立计算 `factor=1.0` 或 `-1.0`，同时对 `sum` 使用 `reduction(+:sum)`。

解释： 资料在 pi 值估计部分给出了错误版本、原因和更新后的 private(factor)+reduction 写法。

来源： 并行复习 p.52；并行复习 p.53

5-大题-2

比较 static、dynamic、guided 调度，并说明负载不均衡循环应如何选择。

答案： static 在循环开始前分配固定块，调度开销最小，但如果迭代耗时差异大，会导致某些线程过重。dynamic 把迭代分成小块，线程完成后动态领取新块，负载均衡好但有同步调度开销。guided 也是动态调度，但开始块大、后期块逐渐减小，适合大规模迭代。若迭代工作量随 i 增大而显著变化，默认 static 大块划分可能让后段线程过重，应考虑 dynamic 或 guided。

解释： 答案来自循环调度、schedule 子句和调度方式区别部分。

来源： 并行复习 p.53；并行复习 p.54；并行复习 p.55；并行复习 p.56；参考资料4 para 28；参考资料4 para 29

5-大题-3

比较 OpenMP 中 critical、atomic 和锁，并说明嵌套 critical 为什么可能死锁。

答案： atomic 适合保护一条简单的共享变量更新语句，只保护紧跟其后的单一更新。critical 可以保护更一般的代码段；未命名 critical 默认使用同一全局锁，命名 critical 可区分不同临界区。锁通常更适合互斥数据结构。若在一个未命名 critical 内再次进入未命名 critical，线程已持有外层锁又尝试获取同一把锁，会自己等待自己而死锁；即使命名不同，也可能出现两个线程分别持有不同锁并等待对方锁的交叉死锁。

解释： 复习资料在 atomic、critical、锁和嵌套 critical 死锁处均给出说明。

来源： 并行复习 p.58；并行复习 p.59；并行复习 p.60；参考资料4 para 86；参考资料4 para 92

5-课本大题-1

用课本 OpenMP 梯形法例子说明 `global_result += my_result` 为什么是临界区，并给出两种修正方法。

答案： 多个线程都会读写共享变量 `global_result`，且更新顺序会影响结果；课本时间表展示了两个线程分别计算 1 和 2 时可能最终只保存其中一个更新。因此该语句是临界区。修正方法一是用 `#pragma omp critical` 让每次只有一个线程更新；方法二是使用 `reduction(+: global_result)`，让每个线程写私有副本，最后由 OpenMP 合并。

解释： 课本先用时间表展示 `global_result += my_result` 的竞争条件，随后给出 critical 和 reduction 两种 OpenMP 改法。

来源： 课本OCR-并行程序设计导论原书第2版 p.180；课本OCR-并行程序设计导论原书第2版 p.181；课本OCR-并行程序设计导论原书第2版 p.185

5-课本大题-2

课本中 OpenMP task/taskwait 的作用是什么？为什么 task 往往需要配合 single 使用？

答案： task 指令把函数调用或递归子问题创建为可由线程执行的任务；taskwait 像该任务的栅栏，强迫当前任务等待子任务完成后再继续使用结果。课本还说明，如果在 parallel 区中直接写多个函数调用，每个线程都会执行这些调用；single 可保证只有一个线程负责创建任务，再由线程组执行任务。

解释： 课本 Fibonacci 和函数调用示例分别解释了 taskwait 对子任务的等待，以及 single 防止所有线程重复创建同一批任务。

来源： 课本OCR-并行程序设计导论原书第2版 p.214；课本OCR-并行程序设计导论原书第2版 p.220

5-课本补充-大题-1

为什么 OpenMP 的 `parallel for` 不能无条件用于所有 for 循环？

答案： OpenMP 只能直接并行化迭代次数可确定的 for 循环，不能直接并行化 while 或 do-while；更重要的是，循环迭代之间不能存在会改变结果的数据依赖。例如后一轮依赖前一轮结果的循环，直接并行化会破坏语义。

解释： 课本在 parallel for 注意事项中说明了 for 循环形式和迭代次数限制，前文也用数据依赖例子说明不能直接并行化。

来源： 课本OCR-并行程序设计导论原书第2版 p.187

5-课本补充-大题-2

根据课本练习，说明如何用 OpenMP 改写计数排序，以及主要性能风险。

答案： 计数排序对每个元素 a[i] 计算列表中小于它的元素个数，再写入 temp[count]。外层 i 循环的各次计算相对独立，可用 parallel for 分配给线程；每个线程使用私有 count 和循环变量。风险在于算法本身是 O(n^2)，并且对相等元素的稳定性判断、temp 写入位置和内存访问模式都要正确处理，实际性能还要与串行 Count_sort 和 qsort 比较。

解释： 课本编程作业给出 Count_sort 串行代码，并要求实现并行版本、比较其与串行 Count_sort 和 qsort 的性能。

来源： 课本OCR-并行程序设计导论原书第2版 p.225；课本OCR-并行程序设计导论原书第2版 p.226

5-课本补充-大题-3

课本练习中，矩阵-向量乘法为什么可能出现伪共享？两种缓解方式是什么？

答案： 如果多个线程写向量 y 中相邻元素，而这些元素落在同一缓存行上，不同处理器之间会不断使对方缓存行失效，即使线程写的是不同 y 元素，也会发生伪共享。缓解方式一是在 y 中填充，使不同线程同时写的元素不共享缓存行；方式二是让每个线程在私有存储中计算自己的 y 片段，完成后再复制到共享 y。

解释： 课本练习要求分析 8000x8000 矩阵-向量乘法中的伪共享，并提出填充 y 或使用线程私有 y 片段两种修改。

来源： 课本OCR-并行程序设计导论原书第2版 p.223；课本OCR-并行程序设计导论原书第2版 p.224

第六章 CUDA 异构编程

填空题

6-填空-1

CUDA 中 CPU 端称为 host，GPU 端称为________。

答案： device

解释： 资料写明 CPU(host) 负责管理调度，GPU(device) 负责大规模并行计算。

来源： 并行复习 p.64

6-填空-2

CUDA C 程序由 Host Code 和 ________ Code 两部分组成。

答案： Device

解释： 资料列出 Host Code 和 Device Code。

来源： 并行复习 p.64；并行复习 p.65

6-填空-3

申请 GPU 显存使用 ________，释放 GPU 显存使用 cudaFree。

答案： cudaMalloc

解释： 资料列出 cudaMalloc 和 cudaFree。

来源： 并行复习 p.65

6-填空-4

CUDA kernel 调用语法是 `kernel<<<gridDim, ________>>>(args);`。

答案： blockDim

解释： 资料给出 `kernel<<<gridDim, blockDim>>>(args);`。

来源： 并行复习 p.67

6-填空-5

一维全局线程编号常写作 `blockDim.x * blockIdx.x + ________`。

答案： threadIdx.x

解释： 资料向量加法 kernel 示例使用该表达式。

来源： 并行复习 p.67

6-填空-6

CUDA 线程组织三层是 Thread、Block 和 ________。

答案： Grid

解释： 资料列出 Thread、Block、Grid 三层。

来源： 并行复习 p.67

6-填空-7

一个 warp 通常包含 ________ 个线程。

答案： 32

解释： 资料说明一个 warp 是 32 个线程。

来源： 并行复习 p.67；并行复习 p.68

6-填空-8

`__syncthreads()` 是________级线程同步屏障。

答案： block

解释： 资料说明 `__syncthreads()` 适用于 block 级线程同步。

来源： 并行复习 p.69

6-填空-9

Unified Memory 让 CPU 和 GPU 使用同一________访问内存。

答案： 指针

解释： 资料说明 Unified Memory 让 CPU 和 GPU 使用同一指针访问内存。

来源： 并行复习 p.71

6-填空-10

共享内存 bank conflict 会导致访问被________化，从而降低性能。

答案： 串行

解释： 资料说明 bank conflict 时 CUDA 会串行化访问。

来源： 并行复习 p.71

6-课本填空-1

CUDA 程序中，threadIdx.x 给出线程在其线程块中的相对索引；blockIdx.x 给出________在网格中的索引。

答案： 线程块

解释： 课本说明 threadIdx.x 是线程在块中的索引，blockIdx.x 是块在网格中的索引。

来源： 课本OCR-并行程序设计导论原书第2版 p.235

6-课本补充-填空-1

从主机角度看，CUDA 核函数调用通常是________的；若主机要使用设备结果，可调用 cudaDeviceSynchronize。

答案： 异步

解释： 课本小结说明核函数在设备上启动后，设备和主机可以同时执行；主机可通过 cudaDeviceSynchronize 阻塞等待设备完成。

来源： 课本OCR-并行程序设计导论原书第2版 p.274

6-课本补充-填空-2

CUDA 统一内存最常用的分配函数是________。

答案： cudaMallocManaged

解释： 课本小结给出 `cudaMallocManaged(void** ptr, size_t size)` 用于分配统一内存。

来源： 课本OCR-并行程序设计导论原书第2版 p.275

6-课本补充-填空-3

CUDA 中线程块集合称为________。

答案： 网格

解释： 课本小结说明由核函数启动的线程块集合称为网格。

来源： 课本OCR-并行程序设计导论原书第2版 p.274

6-课本概念-填空-1

CUDA 线程可通过 threadIdx、blockIdx、blockDim 和 ________ 获取网格信息。

答案： gridDim

解释： 课本第6章小结列出线程可检查的四个结构：threadIdx、blockIdx、blockDim、gridDim。

来源： 课本OCR-并行程序设计导论原书第2版 p.274

6-课本概念-填空-2

CUDA 中线程束中的线程以________方式执行。

答案： SIMD

解释： 课本小结说明线程束是线程块中线程的子集，线程束中的线程以 SIMD 方式执行。

来源： 课本OCR-并行程序设计导论原书第2版 p.275

6-课本概念-填空-3

CUDA 原子操作 `atomicAdd(xp, y)` 会把 y 加到 ________ 指向的内存位置。

答案： xp

解释： 课本给出 atomicAdd 语义：将 y 添加到 xp 指向的内存位置，并返回原始值。

来源： 课本OCR-并行程序设计导论原书第2版 p.276

6-课本概念-填空-4

共享内存被划分为多个________，若同一 warp 多线程访问同一库不同位置会串行化。

答案： 库

解释： 课本说明共享内存被划分为库，访问不同库可并行，访问同一库不同位置必须串行化。

答案： A

解释： 课本说明多个线程访问同一库中不同内存位置时必须串行化；读取同一位置可广播。

来源： 课本OCR-并行程序设计导论原书第2版 p.262

大题

6-大题-1

说明一个简单 CUDA 向量加法程序的 host-device 基本流程。

答案： Host 端先准备输入数据并用 cudaMalloc 申请 GPU 显存，然后用 cudaMemcpyHostToDevice 将数据从 CPU 拷贝到 GPU。随后调用 `__global__` kernel，kernel 中每个线程通过 `blockDim.x * blockIdx.x + threadIdx.x` 计算自己的全局编号并处理一个或一段数据。kernel 调用后可用 cudaDeviceSynchronize 等待 GPU 完成，再用 cudaMemcpyDeviceToHost 把结果拷回 CPU，最后 cudaFree 释放 GPU 显存。

解释： 答案综合资料中的 cudaMalloc/cudaMemcpy/cudaFree、kernel、线程编号和同步说明。

来源： 并行复习 p.65；并行复习 p.66；并行复习 p.67；课程要点-CUDA体系结构 para 4；课程要点-CUDA体系结构 para 5；课程要点-CUDA体系结构 para 6

6-大题-2

解释 warp 分支分化和 divergent loop 为什么会降低性能。

答案： 一个 warp 中的线程按 SIMD 模式执行，同一时刻只能执行同一条指令。如果同一个 warp 内线程因为 `threadIdx.x` 等条件进入不同分支，硬件会先执行一条路径并屏蔽另一部分线程，再执行另一条路径并屏蔽前一部分线程，等价于串行化不同路径。divergent loop 也是类似：循环次数不同的线程在每一轮中只有尚未结束的线程继续执行，其他线程被屏蔽，导致有效并行度下降。

解释： 资料在分支分化和 divergent loop 小节直接解释了两次路径执行和循环轮次屏蔽。

来源： 并行复习 p.68；并行复习 p.69；课程要点-CUDA体系结构 para 11；课程要点-CUDA体系结构 para 12

6-大题-3

概述 CUDA 内存模型，并解释共享内存 bank conflict 及一种避免方法。

答案： CUDA 存储层次包括寄存器、本地内存、共享内存、全局内存和常量内存。寄存器属于线程且在片上；本地内存虽然名字叫本地，但大数组等可能存放在片外；共享内存位于片上，由一个 block 内线程共享；全局内存和常量内存可被所有线程访问。共享内存被划分为多个 memory bank，如果同一 block 内多个线程在同一时钟周期访问同一 bank 的不同地址，就会发生 bank conflict，访问被串行化、性能下降。避免方法包括让不同线程访问不同 bank，或通过 padding 改变地址映射。

解释： 资料的 CUDA 内存模型表格和共享内存 bank conflict 小节给出这些点；体系结构 DOCX 也标注了 GPU memory structures 对应课本页码。

来源： 并行复习 p.70；并行复习 p.71；并行复习 p.72；课程要点-计算机体系结构-量化研究方法-第六版-第四章 para 14；课程要点-CUDA体系结构 para 15；课程要点-CUDA体系结构 para 16

6-课本大题-1

说明 CUDA 中 warp 分歧和 `__syncthreads()` 的两个重要限制。

答案： 一个 warp 当前通常包含 32 个线程，并以单指令流多数据流方式运行；同一 warp 内线程走不同 if-else 分支时会发生分歧，分支路径需要分别执行，影响效率。`__syncthreads()` 的限制有两点：第一，块中所有线程都必须执行到该调用，否则部分线程会永久等待；第二，它只同步同一个线程块内的线程，不能同步普通网格中的不同线程块。

解释： 课本分别在 warp 小节和 `__syncthreads()` 警告中说明了分歧、所有线程都必须调用、以及只同步一个块。

来源： 课本OCR-并行程序设计导论原书第2版 p.253；课本OCR-并行程序设计导论原书第2版 p.259；课本OCR-并行程序设计导论原书第2版 p.260

6-课本补充-大题-1

解释 CUDA 统一内存的便利性和限制。

答案： 统一内存通过 cudaMallocManaged 分配，返回的指针在主机和设备上都有效，系统会在主机和设备之间自动复制更新的数据，简化了显式 cudaMemcpy 管理。但统一内存不能让设备访问主机栈变量地址；在某些设备上主机和设备不能同时访问同一统一内存；性能也可能比显式区分主机/设备内存更慢。

解释： 课本统一内存段落说明了 cudaMallocManaged 的语义、主机栈指针限制和统一内存可能较慢的注意事项。

来源： 课本OCR-并行程序设计导论原书第2版 p.240；课本OCR-并行程序设计导论原书第2版 p.275

6-课本补充-大题-2

比较 CUDA 线程束洗牌和共享内存在树形求和中的作用。

答案： 两者都用于快速实现树结构全局求和，减少昂贵的全局原子更新。线程束洗牌允许同一 warp 内线程读取其他线程寄存器中的值，可用 `__shfl_down_sync` 做树形合并；共享内存方案把中间结果存入块内共享内存，再用块内同步保证各 warp 结果可见。共享内存方案还要注意 bank conflict。

解释： 课本说明 CUDA 提供线程束洗牌和共享内存两种快速树结构操作替代方法，并给出共享内存同步和库冲突分析。

来源： 课本OCR-并行程序设计导论原书第2版 p.261；课本OCR-并行程序设计导论原书第2版 p.262；课本OCR-并行程序设计导论原书第2版 p.276

6-课本补充-大题-3

为什么并行双调排序在小输入上不一定比 qsort 快，但在大输入上可能明显更快？

答案： 小输入时 GPU 启动、同步和并行算法额外步骤的开销占比高，课本 2048 个整数实验中 qsort 比单块并行双调排序更快或相近；大输入时大量线程块和线程能充分利用 GPU 并行度，课本 2,097,152 个整数实验中并行双调排序比串行 qsort 快 40 多倍。

解释： 课本表 6.18 和 6.19 比较了小列表和大列表上 qsort、串行双调排序和并行双调排序的运行时间。

来源： 课本OCR-并行程序设计导论原书第2版 p.273

并行程序设计复习笔记

Tue, 30 Jun 2026 00:00:00 GMT

第 1 章为什么需要并行计算

1.2 为什么需要建立并行系统

单核性能提升受限

过去单处理器性能提升主要依赖晶体管密度增加。
晶体管变小可以提高速度，但会带来更高功耗和散热压力。
风冷散热逐渐接近极限，继续单纯提高单核速度变得困难。
因此，提高计算能力的重要方向转向并行化。

多核处理器

多核处理器：在一个芯片上集成多个相对简单、完整的处理器核心。
单核系统：传统只有一个 CPU 核心的处理器系统。
普通串行程序通常不能自动利用多核，程序员需要学习并行编程。

并行化的两种基本方式

| 类型 | 含义 | 例子 | |---|---|---| | 任务并行 | 把不同任务分配给不同核心 | 一个核心读文件，一个核心处理数据，一个核心写结果 | | 数据并行 | 把数据分给不同核心，各核心执行相同或类似操作 | 把数组分段，每个核心求一段和 |

并行程序的协调问题

| 问题 | 含义 | |---|---| | 通信 | 核心之间交换部分结果或状态 | | 负载平衡 | 尽量让各核心工作量接近，避免部分核心空闲 | | 同步 | 某些阶段需要等待其他核心完成后才能继续 |

1.3 并行系统的分类

按内存访问方式分类

共享内存系统

多个核心共享同一块内存。
原则上，每个核心都可以读写每个内存位置。
核心可通过共享变量进行协调。

核心0   ┐
核心1   ├── 共享内存
...    │
核心p-1 ┘

分布式内存系统

每个核心或节点有自己的私有内存。
核心之间通常不能直接访问彼此内存。
需要通过网络发送消息进行通信。

核心0 -- 内存0     ┐
核心1 -- 内存1     ├── 网络
...               │
核心p-1 -- 内存p-1 ┘

按指令流和数据流分类

这类分类通常称为 Flynn 分类法。它从两个维度描述并行系统：

指令流（instruction stream）：处理器执行的指令序列。
数据流（data stream）：指令作用的数据序列。

根据“指令流数量”和“数据流数量”，Flynn 分类法一共分为四类：

| 类型 | 全称 | 指令流 | 数据流 | 含义 | 常见例子 | |---|---|---|---|---|---| | SISD | Single Instruction Single Data | 单 | 单 | 一个处理器顺序执行一条指令流，处理一个数据流 | 传统单核串行计算机 | | SIMD | Single Instruction Multiple Data | 单 | 多 | 多个处理单元执行同一条指令，但作用在不同数据上 | 向量处理器、GPU 的部分模型 | | MISD | Multiple Instruction Single Data | 多 | 单 | 多条指令流作用在同一个数据流上；现实中很少作为通用模型 | 少数容错、冗余计算模型 | | MIMD | Multiple Instruction Multiple Data | 多 | 多 | 多个处理器或核心可以独立执行不同指令，并处理不同数据 | 多核 CPU、集群 |

本书主要关注 SIMD 和 MIMD：

SIMD 更像“同一条指令同时作用在多份数据上”。
MIMD 更像“多个独立处理器各自执行自己的指令流”。
MISD 理论上存在，但在通用并行程序设计中很少作为主要模型。

第 1 章小结

| API | 主要用途 | |---|---| | MPI | 分布式内存 MIMD 系统 | | Pthreads | 共享内存 MIMD 系统 | | OpenMP | 共享内存系统，重点用于 MIMD | | CUDA | NVIDIA GPU 编程 |

并发、并行、分布式

| 概念 | 重点 | |---|---| | 并发 | 多个任务在同一时间段内推进，不一定真正同时执行 | | 并行 | 多个任务实际同时执行，任务通常耦合更紧密 | | 分布式 | 多个任务分布在不同机器或节点上，通过网络协作 |

第 2 章并行硬件与并行软件

2.1 背景知识

2.1.1 冯·诺依曼体系结构

基本组成

经典冯·诺依曼体系结构包括：

主存
CPU：也叫处理器或核心
互连网络：连接 CPU 和主存

主存

主存由一组存储位置组成。
每个位置有：
- 地址：用于访问该位置。
- 内容：保存指令或数据。

CPU

| 部件 | 作用 | |---|---| | 控制单元 | 决定执行哪条指令 | | 数据通路 | 执行实际指令 | | 寄存器 | 保存数据和程序状态 | | 程序计数器 | 保存下一条将执行指令的地址 |

冯·诺依曼瓶颈

CPU 和主存分离。
指令和数据必须通过互连网络传输。
CPU 执行速度可能远快于内存访问速度，导致 CPU 等待内存。
互连网络限制了程序访问指令和数据的速率。

类比：

CPU = 工厂
主存 = 仓库
互连 = 道路
如果运输速度跟不上生产速度，道路就成为瓶颈。

2.1.2 进程、多任务和线程

进程

进程：正在执行的程序实例。

进程通常包括：

可执行机器语言程序
内存块：代码、调用栈、堆等
资源描述符：如文件描述符
安全信息：可访问哪些资源
状态信息：是否可运行、是否等待资源、寄存器内容等

多任务

多任务操作系统支持多个程序在同一时间段内运行。
单核系统也可通过时间片轮流执行不同进程，让它们看起来同时运行。
如果进程等待资源，会进入阻塞态，此时操作系统可以运行其他进程。

线程

线程：进程内部的执行单元，用于把程序划分为多个相对独立的任务。是 CPU 资源调度的单元

特点：

同一进程内的线程共享大部分资源。
线程切换通常比进程切换更快。
每个线程需要自己的程序计数器和调用栈。

线程共享与独有内容：

| 类型 | 内容 | |---|---| | 共享 | 可执行文件、进程内存、大部分资源、I/O 设备 | | 独有 | 程序计数器、调用栈 |

图 2.2：有三个线程的进程

2.2 冯·诺依曼模型的改进

本节介绍三类改进：

缓存
虚拟内存
低级别并行性

2.2.1 缓存基础

缓存的作用

缓存用于缓解冯·诺依曼瓶颈。
思想：
- 一次传输一块数据或指令，而不是单个数据项。
- 把常用数据和指令放在更靠近 CPU 的高速存储中。

CPU 缓存：CPU 能以比访问主存更快速度访问的一组内存位置。缓存速度快，但容量通常远小于主存。

局部性

| 类型 | 含义 | 例子 | |---|---|---| | 时间局部性 | 最近访问过的内容，近期可能再次访问 | 循环中反复使用变量 | | 空间局部性 | 访问某位置后，附近位置可能很快被访问 | 顺序遍历数组 |

数组例子：

float z[1000];
sum = 0.0;
for (i = 0; i < 1000; i++)
    sum += z[i];

数组连续存储，访问 z[i] 后通常接着访问 z[i+1]，符合空间局部性。

缓存行

缓存行 / 缓存块：内存和缓存之间传输的基本单位。
一次缓存缺失通常会把包含目标数据的一整行读入缓存。
如果一个缓存行保存 z[0] 到 z[15]，那么第一次访问 z[0] 后，后续访问 z[1] 到 z[15] 可能直接命中。

多级缓存

| 层级 | 特点 | |---|---| | L1 | 最小、最快、最接近 CPU | | L2 | 比 L1 大，速度较慢 | | L3 | 更大，通常更慢 |

CPU 访问数据时通常按 L1 -> L2 -> L3 -> 主存 的顺序查找。

缓存命中与缺失

| 概念 | 含义 | |---|---| | 缓存命中 hit | 所需数据或指令在缓存中 | | 缓存缺失 miss | 所需数据或指令不在缓存中，需要访问更慢层级 |

例子：L1 缺失但 L2 命中。

缓存缺失可能导致 CPU 暂停，等待数据从主存或低层缓存取回。

写策略

| 策略 | 做法 | 特点 | |---|---|---| | 写直达 | 写缓存时同时写主存 | 主存更新及时，写入开销较大 | | 写回 | 先只写缓存并标记为脏，替换时再写回主存 | 写入较快，但需要维护脏数据 |

2.2.2 缓存映射

缓存映射问题：主存中的一个数据块被读入缓存时，应该放在缓存的哪个位置？

三种映射方式

| 方式 | 含义 | 特点 | |---|---|---| | 全相联缓存 | 主存块可放入缓存任意位置 | 灵活，硬件复杂 | | 直接映射缓存 | 每个主存块只能放入唯一缓存行 | 简单，但冲突多 | | n 路组相联缓存 | 每个主存块可放入某组中的 n 个位置之一 | 折中方案 |

直接映射例子

主存有 16 个块，缓存有 4 行：

缓存行索引 = 主存块索引 mod 4

映射：

0, 4, 8, 12 -> 0
1, 5, 9, 13 -> 1
2, 6, 10, 14 -> 2
3, 7, 11, 15 -> 3

两路组相联例子

缓存 4 行，分成两组：

组 0：缓存行 0、1
组 1：缓存行 2、3

组索引 = 主存块索引 mod 2

映射：

偶数主存块：可放入缓存行 0 或 1
奇数主存块：可放入缓存行 2 或 3

表 2.1：16 个主存块分配到 4 个缓存行

| 主存索引 | 全相联 | 直接映射 | 两路组相联 | |---:|---|---:|---| | 0 | 0、1、2 或 3 | 0 | 0 或 1 | | 1 | 0、1、2 或 3 | 1 | 2 或 3 | | 2 | 0、1、2 或 3 | 2 | 0 或 1 | | 3 | 0、1、2 或 3 | 3 | 2 或 3 | | 4 | 0、1、2 或 3 | 0 | 0 或 1 | | 5 | 0、1、2 或 3 | 1 | 2 或 3 | | 6 | 0、1、2 或 3 | 2 | 0 或 1 | | 7 | 0、1、2 或 3 | 3 | 2 或 3 | | 8 | 0、1、2 或 3 | 0 | 0 或 1 | | 9 | 0、1、2 或 3 | 1 | 2 或 3 | | 10 | 0、1、2 或 3 | 2 | 0 或 1 | | 11 | 0、1、2 或 3 | 3 | 2 或 3 | | 12 | 0、1、2 或 3 | 0 | 0 或 1 | | 13 | 0、1、2 或 3 | 1 | 2 或 3 | | 14 | 0、1、2 或 3 | 2 | 0 或 1 | | 15 | 0、1、2 或 3 | 3 | 2 或 3 |

缓存替换策略

当多个主存块可映射到多个缓存位置时，需要决定替换哪一行。
LRU：Least Recently Used，最近最少使用。
思想：优先逐出最久没有被访问的缓存行。

2.2.3 缓存和程序：示例

核心结论

CPU 缓存由硬件控制，程序员不能直接决定缓存内容。
但程序员可以利用局部性写出更缓存友好的代码。
C 语言二维数组按行优先存储，因此按行访问通常比按列访问快。

行优先存储

A[4][4] 在内存中按行连续存储：

| 缓存行 | A 的元素 | |---:|---| | 0 | A[0][0] A[0][1] A[0][2] A[0][3] | | 1 | A[1][0] A[1][1] A[1][2] A[1][3] | | 2 | A[2][0] A[2][1] A[2][2] A[2][3] | | 3 | A[3][0] A[3][1] A[3][2] A[3][3] |

两种循环顺序

按行访问，缓存友好：

for (i = 0; i < MAX; i++)
    for (j = 0; j < MAX; j++)
        y[i] += A[i][j] * x[j];

按列访问，缓存不友好：

for (j = 0; j < MAX; j++)
    for (i = 0; i < MAX; i++)
        y[i] += A[i][j] * x[j];

原因：

第一种访问顺序类似：A[0][0], A[0][1], A[0][2], A[0][3]，连续。
第二种访问顺序类似：A[0][0], A[1][0], A[2][0], A[3][0]，不连续。

缓存缺失分析

假设：

MAX = 4
一个缓存行保存 4 个 double
缓存只能保存两行 A
循环开始时 A 不在缓存中

结果：

按行访问：每行第一次访问缺失，之后同一行命中；约 4 次缺失。
按列访问：频繁跨行访问，缓存行容易被替换；缺失更多。

结论：对 C 的二维数组，优先按行遍历，能更好利用空间局部性。

2.2.4 虚拟内存

核心概念

虚拟内存：让程序使用虚拟地址，由系统映射到实际物理地址。
页：虚拟内存和物理内存管理的基本块。
页表：记录虚拟页到物理页的映射关系。

TLB

TLB：Translation Lookaside Buffer，旁路转换缓冲区。
作用：缓存少量页表项，加速虚拟地址到物理地址的转换。
常见大小：几十到几百个条目。

| 概念 | 含义 | |---|---| | TLB 命中 | 虚拟页号在 TLB 中，地址转换较快 | | TLB 缺失 | 虚拟页号不在 TLB 中，需要访问页表 | | 页面错误 | 要访问的页不在主存中，只在磁盘上，需要从磁盘调入 |

虚拟内存与缓存的区别

| 对比 | CPU 缓存 | 虚拟内存 | |---|---|---| | 主要控制者 | 硬件 | 硬件 + 操作系统 | | 慢速后备存储 | 主存 | 磁盘 | | 写策略 | 可写直达或写回 | 通常使用写回，避免频繁访问磁盘 |

2.2.5 指令级并行

指令级并行（Instruction-Level Parallelism，ILP）：通过让多个处理器组件或功能单元同时执行指令来提高处理器性能。

ILP 的两种主要方法：

| 方法 | 核心思想 | |---|---| | 流水线 | 把功能单元分成多个阶段，多个指令在不同阶段重叠执行 | | 多发射 | 复制功能单元，同时启动多条可并行执行的指令 |

几乎所有现代 CPU 都会使用流水线和多发射。

流水线

流水线类似工厂装配线：不同阶段同时处理不同任务。

浮点加法可拆成多个阶段：

获取操作数
比较指数
移位一个操作数
相加
标准化结果
四舍五入
存储结果

如果每个阶段需要 1 ns，单个浮点加法仍需 7 ns。但在循环中，不同加法可以同时处于不同阶段：

for (i = 0; i < 1000; i++)
    z[i] = x[i] + y[i];

效果：

非流水线：1000 次加法约需 7000 ns。
7 阶段流水线：理想情况下约需 1006 ns。
原因：流水线填满后，几乎每 1 ns 产生一个结果。

注意：k 阶段流水线通常无法获得严格 k 倍加速。

限制：

阶段速度受最慢功能单元限制。
等待操作数、分支等延迟可能导致流水线暂停。

多发射

多发射处理器：复制功能单元，尝试同时执行程序中的多条不同指令。

例子：

for (i = 0; i < 1000; i++)
    z[i] = x[i] + y[i];

如果有两个浮点加法器：

第一个加法器计算 z[0] 时，第二个可以计算 z[1]。
第一个计算 z[2] 时，第二个可以计算 z[3]。

多发射分类：

| 类型 | 调度时机 | 说明 | |---|---|---| | 静态多发射 | 编译时 | 编译器安排哪些指令同时执行 | | 动态多发射 | 运行时 | 处理器运行时安排，也称超标量处理器 |

前瞻执行

前瞻执行（speculation）：编译器或处理器预测后续执行路径，并提前执行相关指令。

分支预测例子：

z = x + y;
if (z > 0)
    w = x;
else
    w = y;

系统可能预测 z > 0，于是提前执行 w = x。

指针别名预测例子：

z = x + y;
w = *a_p;

系统可能预测 a_p 不指向 z，于是尝试同时执行两个赋值。

前瞻执行的关键：

如果预测正确，保留结果。
如果预测错误，丢弃预测结果并重新执行正确路径。
硬件通常会把预测执行结果先放在缓冲区中，确认正确后再提交到寄存器或内存。

指令重排

动态多发射系统可以无序执行指令。
现代处理器通常仍按顺序加载指令，并按程序顺序提交结果。
优化编译器也可能重排指令。
指令重排会影响共享内存编程，后续需要注意内存可见性和同步问题。

2.2.6 硬件多线程

ILP 的局限

ILP 很难利用长依赖链程序中的并行性。

例子：直接计算斐波那契数列。

f[0] = f[1] = 1;
for (i = 2; i <= n; i++)
    f[i] = f[i-1] + f[i-2];

每一项依赖前两项，几乎没有可以同时执行的指令。

线程级并行

线程级并行（Thread-Level Parallelism，TLP）：通过同时执行不同线程来提供并行性。

特点：

比 ILP 粒度更粗。
并行单位是线程，而不是单条指令。
当当前线程因为等待内存等原因暂停时，可以切换去执行另一个线程。

硬件多线程

硬件多线程：处理器支持线程之间的快速切换，使系统在一个线程暂停时继续执行其他线程。

分类：

| 类型 | 做法 | 特点 | | ------ | -------------------- | ----------------------- | | 细粒度多线程 | 每条指令后都可在线程间切换，跳过暂停线程 | 可减少暂停浪费，但单个活跃线程也可能被频繁打断 | | 粗粒度多线程 | 只有线程因耗时操作暂停时才切换 | 切换次数较少，但遇到暂停前可能仍会浪费周期 |

2.3 并行硬件

2.3.2 SIMD 系统

基本特点

SIMD：Single Instruction Multiple Data，单指令流多数据流。
一个控制单元向多个数据通路广播同一条指令。
各数据通路对自己的数据执行相同指令，或者在不适用时空闲。

抽象 SIMD 系统：

条件分支带来的问题

SIMD 要求所有数据通路执行相同指令或空闲，这可能降低整体性能。

例子：

for (i = 0; i < n; i++)
    if (y[i] > 0.0)
        x[i] += y[i];

执行过程：

每个数据通路都要加载对应的 y[i] 并判断是否为正。
若 y[i] > 0，该通路执行加法。
若 y[i] <= 0，该通路在其他通路执行加法时只能空闲。

同步执行约束

经典 SIMD 系统中，各数据通路必须同步运行。
每个数据通路必须等待下一条指令广播后才能继续。
数据通路通常没有自己的指令存储区，不能把指令保存起来延迟执行。

数据并行性

数据并行性：把数据划分给多个处理器或数据通路，并让它们对各自的数据子集执行相同或相似的指令。

SIMD 系统主要利用的就是数据并行性。

GPU 不是纯 SIMD

图形处理 API 通常用点、线、三角形表示对象表面，再通过图形处理流水线生成屏幕像素。
流水线中的可编程阶段由着色器函数指定。
着色器函数通常很短，并且可以应用到图形流中的大量元素，因此天然具有隐式并行性。
GPU 每个处理核心通常包含大量数据通路，可用 SIMD 并行提高吞吐量。
GPU 处理图像时数据量很大，需要很高的数据传输速率，因此严重依赖硬件多线程来隐藏内存访问暂停。
GPU 在小问题上可能表现较差，因为需要大量线程才能让数据通路保持忙碌。
GPU 会使用 SIMD 式的数据并行，但不是纯 SIMD 系统。
给定核心上的多个数据通路可以执行 SIMD 并行。
当代 GPU 的单个核心也可以运行多个指令流。
典型 GPU 有几十个核心，这些核心也能执行相互独立的指令流。
因此，GPU 既不是纯 SIMD，也不是纯 MIMD，而是混合了多种并行特征。

GPU 的内存特征

GPU 可以使用共享内存，也可以使用分布式内存。
大型 GPU 系统可能同时包含两种特征：
- 一些核心访问共同的共享内存块。
- 其他核心访问不同的共享内存块。
- 访问不同内存块的核心可以通过网络通信。
本书后续主要讨论使用共享内存的 GPU。

2.3.3 MIMD 系统

基本特点

MIMD：Multiple Instruction Multiple Data，多指令流多数据流。
支持多个并行指令流运行在多个数据流上。
通常由多个独立处理单元或核心组成。
每个处理单元通常有自己的控制单元和数据通路。

抽象 MIMD 系统：

异步执行

MIMD 系统通常是异步的。
各处理器可以按自己的速度运行。
许多 MIMD 系统没有全局时钟。
即使多个处理器执行相同指令序列，在任意时刻也可能处于不同语句。
如果需要让处理器在某些点对齐，程序员必须显式同步。

MIMD 的两类内存系统

| 类型 | 特点 | 通信方式 | |---|---|---| | 共享内存系统 | 多个处理器通过互连网络连接到同一内存系统，每个处理器可访问每个内存位置 | 通过共享数据结构隐式通信 | | 分布式内存系统 | 每个处理器和自己的私有内存配对，处理器-内存对通过网络连接 | 通过消息或函数访问显式通信 |

共享内存系统：

分布式内存系统：

共享内存系统

最常见的共享内存系统使用一个或多个多核处理器。
多核处理器在单个芯片上包含多个 CPU 或核心。
核心通常有私有 L1 缓存，其他缓存可能共享，也可能不共享。

共享内存多核系统分为：

| 类型 | 全称 | 特点 | |---|---|---| | UMA | Uniform Memory Access，统一内存访问 | 所有核心访问所有内存位置的时间相同，编程较容易 | | NUMA | Non-Uniform Memory Access，非统一内存访问 | 访问本地内存更快，访问其他芯片连接的内存更慢 |

UMA 多核系统：

NUMA 多核系统：

分布式内存系统

最常见的分布式内存系统称为集群。
集群通常由一系列商用系统组成，例如通过以太网连接的 PC。
集群中的节点是通过通信网络连接在一起的计算单元。
现代集群节点通常本身就是共享内存系统，并带有一个或多个多核处理器。
为了区别于纯分布式内存系统，这类系统有时称为混合系统。
现在通常默认集群具有共享内存节点。

网格

网格提供基础设施，把地理上分布的大型计算机网络组织成统一的分布式内存系统。
网格通常是异构系统：不同节点可能由不同类型的硬件构成。

2.3.5 缓存一致性

缓存一致性问题

在共享内存多核系统中，多个核心的缓存可能保存同一个变量的副本。

问题：

核心 0 更新变量 x 后，核心 1 缓存中的 x 可能仍是旧值。
写直达会更新主存，但不一定更新其他核心缓存中的副本。
写回甚至可能暂时只更新核心 0 的缓存，主存和其他核心都看不到新值。

缓存一致性问题：当多个处理器缓存同一变量或同一缓存行时，需要保证一个处理器的更新能被其他处理器正确看到。

监听缓存一致性

监听缓存一致性（snooping cache coherence）：各核心监听互连网络上的更新广播。

要点：

广播通常针对缓存行，不是单个变量。
互连不一定必须是总线，但必须支持从一个处理器向其他处理器广播。
监听可用于写直达缓存，也可用于写回缓存。
写回缓存需要额外通信，因为更新不会立刻写入主存。

基于目录的缓存一致性

监听协议需要频繁广播，在大规模系统中广播成本高，可扩展性差。

基于目录的缓存一致性：使用一个称为目录的数据结构记录每个缓存行的状态。

目录通常记录：

某缓存行当前在哪些核心的缓存中有副本。
缓存行是否被修改。
缓存行的有效/无效状态。

工作方式：

某核心读取一个缓存行时，目录记录该核心拥有该行副本。
某核心更新该缓存行时，先查询目录。
系统只通知那些真正保存该缓存行副本的核心，使其副本失效。

优缺点：

| 方案 | 优点 | 缺点 | |---|---|---| | 监听协议 | 简单，适合小规模共享系统 | 广播成本高，不易扩展 | | 目录协议 | 只通知相关核心，适合较大系统 | 目录需要额外存储和维护开销 |

伪共享

CPU 缓存由硬件实现，并且按缓存行工作，而不是按单个变量工作。这可能导致伪共享。

伪共享：多个核心访问的是不同变量，但这些变量位于同一个缓存行中，导致系统像它们共享同一变量一样不断失效缓存行。

串行例子：

int i, j, m, n;
double y[m];

/* y 初始化为 0 */
for (i = 0; i < m; i++)
    for (j = 0; j < n; j++)
        y[i] += f(i, j);

可以把外层循环的迭代划分给多个核心。例如两个核心时：

/* 私有变量 */
int i, j, iter_count;

/* 共享变量 */
int m, n, core_count;
double y[m];

iter_count = m / core_count;

/* 核心 0 */
for (i = 0; i < iter_count; i++)
    for (j = 0; j < n; j++)
        y[i] += f(i, j);

/* 核心 1 */
for (i = iter_count; i < 2 * iter_count; i++)
    for (j = 0; j < n; j++)
        y[i] += f(i, j);

关键假设：

m = 8
double 是 8 字节
缓存行是 64 字节
y[0] 位于缓存行开头

于是一个缓存行正好能存下 8 个 double，即 y[0]..y[7] 全部位于同一个缓存行。

发生过程：

核心 0 更新 y[0]..y[3]。
核心 1 更新 y[4]..y[7]。
两个核心没有访问彼此的元素。
但这些元素属于同一个缓存行。
因此任一核心执行 y[i] += f(i, j) 时，都可能使另一个核心缓存中的同一行失效。
另一个核心下一次访问自己的 y 元素时，必须重新从内存取回该缓存行。

影响：

程序结果仍正确，但会产生大量不必要的内存访问，严重降低性能。
如果内层循环次数 n 很大，这种额外内存访问会非常频繁。

常见缓解方法：

使用线程或进程本地临时变量。
最后再把本地结果复制或归约到共享存储。
必要时通过填充、对齐或调整数据布局，避免不同线程频繁写同一缓存行。

2.3.6 共享内存与分布式内存

共享内存对程序员更直观：可以通过共享数据结构隐式协调处理器工作。
分布式内存需要显式发送消息，编程负担通常更重。
但硬件上，共享内存系统需要维护互连、缓存一致性和访问延迟，扩展到大规模系统更困难。
因此，大规模系统常采用分布式内存或混合结构。

2.4 并行软件

2.4.1 并行化、通信和同步

易并行示例

数组加法：

double x[n], y[n];

for (int i = 0; i < n; i++)
    x[i] += y[i];

并行化方法：把数组元素划分给不同进程或线程。

例如有 p 个进程/线程：

进程/线程 0 负责 0 ~ n/p - 1
进程/线程 1 负责 n/p ~ 2n/p - 1
依此类推

并行化时需要做的事

在进程/线程之间分配工作。
保证每个进程/线程工作量大致相同，即负载平衡。
尽量减少通信量。
安排进程/线程之间的同步。
安排进程/线程之间的通信。

通信与同步常常相关：

分布式内存程序通常通过进程间通信隐式同步。
共享内存程序通常通过线程同步来完成通信。

2.4.3 共享内存

共享变量与私有变量

在共享内存程序中：

| 变量类型 | 含义 | |---|---| | 共享变量 | 任意线程都可以读写 | | 私有变量 | 只能由某一个线程访问 |

线程之间通常通过共享变量通信，因此通信是隐式的。

动态线程和静态线程

| 类型 | 做法 | 优点 | 缺点 | |---|---|---|---| | 动态线程 | 主线程等待请求，按需派生工作线程，完成后线程终止并加入主线程 | 资源只在线程实际运行时占用 | 频繁创建和连接线程可能耗时 | | 静态线程 | 主线程完成设置后一次性派生所有线程，所有工作结束后再统一停止 | 避免频繁创建/销毁线程，性能可能更好；更接近分布式内存编程范式 | 空闲线程资源无法释放 |

本书后续经常使用静态线程范例。

非确定性

非确定性：同一个输入可能导致不同输出。

在异步执行的 MIMD 系统中，多个线程独立运行，每个线程完成语句的相对速度可能每次运行都不同，因此输出顺序或结果可能变化。

例子：

printf("Thread %d > my_x = %d\n", my_rank, my_x);

两个线程的输出顺序可能不同：

Thread 0 > my_x = 7
Thread 1 > my_x = 19

也可能是：

Thread 1 > my_x = 19
Thread 0 > my_x = 7

如果只是输出顺序不同，通常问题不大；但在共享内存更新中，非确定性可能导致错误结果。

竞争条件

竞争条件：多个线程或进程同时访问共享资源，并且访问顺序会影响结果。

例子：

my_val = Compute_val(my_rank);
x += my_val;

x += my_val 通常不是一条不可分割的操作，而是大致包含：

把 x 加载到寄存器。
把 my_val 加载到寄存器。
相加。
把结果写回 x。

如果两个线程交错执行，可能都先读到旧的 x = 0，最后一个写回的结果覆盖另一个线程的更新，导致结果错误。

原子性

原子操作：操作执行期间不会被其他线程打断或观察到中间状态。

对于共享变量更新，理想情况是每个线程的：

x += my_val;

作为一个原子操作完成。

临界区

临界区：一次只能由一个线程执行的代码块。

如果一个线程正在执行临界区，其他线程必须被排除在外。这称为互斥访问。

互斥量

互斥量（mutex，也叫互斥锁、锁）：用于保证临界区互斥访问的同步对象。

使用方式：

my_val = Compute_val(my_rank);
Lock(&add_my_val_lock);
x += my_val;
Unlock(&add_my_val_lock);

流程图：

要点：

互斥量保证一次只有一个线程执行 x += my_val。
互斥量不规定哪个线程先执行。
临界区会被串行化，因此临界区应尽可能少、尽可能短。

忙等待

忙等待（busy-waiting）：线程进入循环，不断测试某个条件是否成立。

例子：保证线程 1 在线程 0 更新 x 之后再更新。

my_val = Compute_val(my_rank);

if (my_rank == 1)
    while (!ok_for_1);  /* 忙等待循环 */

x += my_val;           /* 临界区 */

if (my_rank == 0)
    ok_for_1 = true;   /* 允许线程 1 更新 x */

特点：

优点：概念简单，容易理解。
缺点：等待线程会持续占用 CPU 资源，即使它暂时没有做有用工作。

信号量和监视器

信号量：类似互斥量，也可用于线程同步，具体行为细节不同。
监视器：更高级的互斥机制，是一个对象，其方法一次只能由一个线程执行。

线程安全

线程安全：函数或代码在多线程环境中被并发调用时，仍能得到正确结果，不会因为共享状态产生错误。

很多串行程序中的函数可以直接用于并行程序，但需要注意例外。

典型问题：函数内部使用静态局部变量。

普通局部变量位于线程自己的调用栈上，通常是私有的。
静态局部变量在函数调用结束后仍然存在。
如果多个线程同时调用该函数，就可能共享并覆盖同一个静态变量。

例子：strtok 一类函数不是线程安全的。

第一次调用时传入一个字符串。
后续调用依赖函数内部保存的静态状态继续分割字符串。
如果两个线程同时使用，后一个线程可能覆盖前一个线程的内部状态，导致结果错误。

结论：

多线程程序中要确认库函数是否线程安全。
避免在多个线程间隐式共享函数内部状态。
必要时使用线程安全版本的函数，或把状态显式放在线程私有存储中。

2.4.4 分布式内存

基本特点

在分布式内存程序中，每个核心或进程只能直接访问自己的私有内存。
进程之间不能直接读写对方变量。
通信通常通过消息传递完成。

消息传递

消息传递 API 至少提供两类函数：

| 函数 | 作用 | |---|---| | Send | 向另一个进程发送消息 | | Receive | 从另一个进程接收消息 |

示意：

rank

消息传递程序通常用序列号或 rank 标识进程。
如果共有 p 个进程，rank 通常为 0, 1, ..., p-1。
发送和接收时需要指定通信对象的 rank。

SPMD

SPMD：Single Program Multiple Data，单程序多数据。

含义：

多个进程运行同一个可执行文件。
每个进程根据自己的 rank 通过不同分支执行不同操作。
每个进程处理不同数据。

典型结构：

my_rank = Get_rank();

if (my_rank == 1) {
    /* 进程 1 发送消息 */
    Send(message, MSG_CHAR, 100, 0);
} else if (my_rank == 0) {
    /* 进程 0 接收消息 */
    Receive(message, MSG_CHAR, 100, 1);
}

同名变量不共享

在分布式内存中，不同进程中的同名变量属于不同内存块。

例如两个进程中都声明：

char message[100];

这不是同一块内存：

进程 0 的 message 位于进程 0 的私有内存。
进程 1 的 message 位于进程 1 的私有内存。
若要把进程 1 的 message 传给进程 0，必须显式发送消息。

核心区别：

| 模型 | 通信方式 | |---|---| | 共享内存 | 通过共享变量隐式通信 | | 分布式内存 | 通过 Send / Receive 显式通信 |

2.5 输入和输出

2.5.1 MIMD 系统

这里的 MIMD 不是在讲“做计算的模型”本身，而是在讲：多个独立进程/线程同时运行时，如何处理输入和输出。

为什么 I/O 容易出问题

MIMD 程序中，多个进程/线程可能同时访问：

stdin
stdout
stderr
同一个文件

问题：

输出顺序不确定，多个进程的输出可能交错。
输入分配不明确：不知道哪个进程应该读哪个输入。
多个进程同时写同一个文件，可能导致内容混乱或覆盖。

标准输入输出约定

为避免混乱，书中采用以下规则：

| 场景 | 约定 | |---|---| | 分布式内存程序 | 只有进程 0 访问 stdin | | 共享内存程序 | 只有主线程或线程 0 访问 stdin | | stdout / stderr | 所有进程/线程都可以访问 | | 调试以外的正式输出 | 通常只让一个进程/线程输出最终结果 | | 普通文件 | 通常只让一个进程/线程访问同一个文件 |

为什么通常让 0 号进程负责 I/O

进程 0 或线程 0 通常被当作“主控者”。
可以避免多个进程同时读输入造成不确定性。
可以先由 0 号进程读取输入，再通过消息传递或共享变量分发给其他进程/线程。

2.6 性能

并行程序的主要目标通常是提高性能。评价性能时，常用指标是加速比和效率。

2.6.1 MIMD 系统中的加速比和效率

理想情况

如果一个问题可以被平均分给 p 个核心，并且没有额外开销，那么：

并行运行时间 = 串行运行时间 / p

这种理想情况称为线性加速。

线性加速比

线性加速比：使用 p 个核心时，加速比达到 p。

也就是：

$$ S = p $$

含义：

用 2 个核心，理想上快 2 倍。
用 4 个核心，理想上快 4 倍。
用 p 个核心，理想上快 p 倍。

实际中很难完全达到线性加速，因为存在同步、通信、临界区、线程创建等开销。

加速比

加速比（speedup）定义为：

$$ S = \frac{T_{\text{serial}}}{T_{\text{parallel}}} $$

其中：

| 符号 | 含义 | |---|---| | $T_{\text{serial}}$ | 串行程序运行时间 | | $T_{\text{parallel}}$ | 并行程序运行时间 | | $S$ | 并行程序相对串行程序快了多少倍 |

例子：

串行运行 100s
并行运行 25s

则：

$$ S = \frac{100}{25} = 4 $$

表示并行程序快了 4 倍。

效率

效率（efficiency）衡量核心是否被充分利用。

定义：

$$ E = \frac{S}{p} $$

把加速比公式代入：

$$ E = \frac{T_{\text{serial}}}{p \cdot T_{\text{parallel}}} $$

其中：

| 符号 | 含义 | |---|---| | $p$ | 使用的核心数或进程/线程数 | | $S$ | 加速比 | | $E$ | 效率 |

解释：

$E = 1$：完全理想，所有核心都被充分利用。
$E < 1$：存在开销，核心没有被完全利用。
$E$ 越接近 1，说明并行化效果越好。

问题规模对性能的影响

一般来说：

增加问题规模时，加速比和效率可能增加。
减少问题规模时，加速比和效率可能降低。

原因：

并行程序通常有固定开销，例如线程创建、通信、同步、数据分发和结果收集。
问题规模较小时，固定开销占比大，并行收益容易被抵消。
问题规模较大时，计算量增加，固定开销被摊薄，核心更容易保持忙碌。

为什么实际加速比会低于线性加速

常见原因：

负载不均衡：有些核心先完成后等待。
通信开销：进程/线程之间需要交换数据。
同步开销：临界区、互斥锁、屏障等会让部分核心等待。
串行部分：程序中有些部分无法并行。
额外开销：线程创建、数据分发、结果收集等。

2.6.2 阿姆达尔定律

阿姆达尔定律（Amdahl's Law）：如果程序中有一部分必须串行执行，那么无论增加多少核心，整体加速比都会受到这部分串行代码的限制。

基本公式

设：

| 符号 | 含义 | |---|---| | $p$ | 核心数 | | $r$ | 程序中必须串行执行的比例 | | $1-r$ | 程序中可以并行执行的比例 |

并行运行时间近似为：

$$ T_{\text{parallel}} = rT_{\text{serial}} + \frac{(1-r)T_{\text{serial}}}{p} $$

加速比为：

$$ S = \frac{1}{r + \frac{1-r}{p}} $$

当核心数 $p$ 趋近无穷大时：

$$ S \leq \frac{1}{r} $$

也就是说，串行部分越大，最大加速比越低。

例子：90% 可并行

假设：

串行运行时间 $T_{\text{serial}} = 20$
90% 可并行
10% 必须串行

则：

$$ T_{\text{parallel}} = 0.9 \times \frac{20}{p} + 0.1 \times 20 = \frac{18}{p} + 2 $$

加速比：

$$ S = \frac{20}{\frac{18}{p} + 2} $$

当 $p$ 很大时，$\frac{18}{p}$ 接近 0，所以：

$$ S \leq \frac{20}{2} = 10 $$

结论：即使并行部分做得很好，甚至使用很多核心，只要 10% 不能并行，最大加速比也不会超过 10。

核心结论

阿姆达尔定律强调：优化并行程序时，不能只看可并行部分，也要关注串行瓶颈。
串行比例 $r$ 决定了理论最大加速比。
如果串行部分是 $1/100$，最大加速比也只能接近 100。
要获得更高加速比，需要减少串行部分，或增大问题规模，让并行部分占比更高。

注意

阿姆达尔定律通常假设问题规模固定。实际中，随着核心数增加，我们也可能处理更大的问题，此时加速表现可能比固定规模分析更好。

2.6.3 可扩展性

可扩展性：描述并行程序在增加处理器或核心数量时，性能能否持续提升的能力。

常用符号：

| 符号 | 含义 | |---|---| | $n$ | 问题规模，也可近似看作串行总工作量 | | $P$ | 处理器、线程或进程数量 | | $T_{\text{serial}}$ | 串行运行时间，近似为 $n$ | | $T_{\text{parallel}}$ | 并行运行时间 | | $T_{\text{overhead}}$ | 并行额外开销，如通信、同步、线程创建、数据分发等 | | $E$ | 并行效率 |

并行时间可粗略写成：

$$ T_{\text{parallel}} = \frac{T_{\text{serial}}}{P} + T_{\text{overhead}} $$

也就是：

并行时间 = 理想分摊后的计算时间 + 并行额外开销

由于：

$$ E = \frac{S}{P} $$

且：

$$ S = \frac{T_{\text{serial}}}{T_{\text{parallel}}} $$

所以：

$$ E = \frac{T_{\text{serial}}}{P \cdot T_{\text{parallel}}} $$

如果令 $T_{\text{serial}} = n$，并且：

$$ T_{\text{parallel}} = \frac{n}{P} + T_{\text{overhead}} $$

则：

$$ E = \frac{n}{P(\frac{n}{P} + T_{\text{overhead}})} = \frac{n}{n + P T_{\text{overhead}}} $$

这个公式说明：如果问题规模 $n$ 不变，只增加处理器数 $P$，那么分母中的 $P T_{\text{overhead}}$ 会变大，效率 $E$ 通常会下降。

可扩展性分为两类：

| 类型 | 含义 | 关注点 | |---|---|---| | 强扩展性 | 固定问题规模，增加核心数 $p$，效率仍能基本保持不变 | 同一个问题能否靠更多核心跑得更快 | | 弱扩展性 | 增加核心数 $p$ 的同时，按相同规模增加问题规模，效率仍能基本保持不变 | 核心更多时，能否处理更大的问题 |

强扩展性

问题规模固定。
增加核心数 $P$。
如果效率 $E$ 能保持不变或下降很少，说明程序具有强扩展性。
只有通信、同步等并行开销很小时，才容易获得好的强扩展性。

例子：同样大小的矩阵乘法，从 4 个核心增加到 8 个核心，看运行时间是否接近减半。

理想情况下没有额外开销：

$$ T_{\text{parallel}} = \frac{T_{\text{serial}}}{P} $$

此时效率：

$$ E = 1 $$

现实中通常有额外开销：

$$ E = \frac{n}{n + P T_{\text{overhead}}} $$

因此当 $P$ 增大时，强扩展效率通常会下降。

弱扩展性

增加核心数 $P$。
同时按相同比例增加问题规模。
如果效率 $E$ 能保持不变或下降很少，说明程序具有弱扩展性。

例子：4 个核心处理 4GB 数据，8 个核心处理 8GB 数据。如果运行时间基本不变，说明弱扩展性较好。

如果：

P -> aP
n -> bn

则效率近似变为：

$$ E = \frac{bn}{bn + aP T_{\text{overhead}}} $$

如果 $a = b$，即核心数和问题规模按相同比例增加，那么效率有可能保持稳定。

对比

强扩展性问的是：同一个问题，用更多核心能不能更快？
弱扩展性问的是：更多核心能不能处理更大的问题，同时保持效率？
并行程序不是核心越多越好，因为 $P$ 变大时，通信、同步等额外开销也会被放大。

第 3 章使用 MPI 进行分布式内存编程

3.1 MPI 概述

重点

本章重点：

通信
- 点对点通信
- 集合通信
发送和接收消息的语义
- 是否阻塞
- 消息匹配
- 消息顺序

MPI 是什么

MPI：Message Passing Interface，消息传递接口。
MPI 用于分布式内存编程。
MPI 程序的基本执行单位通常是进程，不是线程。
MPI 实际上是一个函数库，不是一门新的编程语言。
进程之间通过显式发送和接收消息来通信。

3.2 编译与执行

编译

使用 mpicc 编译 MPI 程序：

mpicc -o hello hello.c

执行

使用 mpiexec 启动多个 MPI 进程：

mpiexec -n 4 ./hello

含义：

-n 4：启动 4 个进程。
./hello：每个进程运行同一个可执行文件。

这体现了 MPI 常见的 SPMD 模型：多个进程运行同一个程序，但根据自己的 rank 执行不同逻辑。

3.3 MPI 初始化和结束

MPI_Init

MPI_Init 必须在所有其他 MPI 函数调用之前执行。

作用：

初始化 MPI 运行环境。
建立通信环境。
通常可以理解为所有 MPI 进程进入 MPI 环境的起点。

函数原型：

int MPI_Init(int *argc, char ***argv);

MPI_Finalize

MPI_Finalize 用于关闭 MPI 环境并清理资源。

函数原型：

int MPI_Finalize(void);

基本程序结构

#include <mpi.h>

int main(int argc, char* argv[]) {
    MPI_Init(&argc, &argv);

    /* MPI 程序主体 */

    MPI_Finalize();
    return 0;
}

注意：实际函数名是 MPI_Init 和 MPI_Finalize，大小写要一致。

3.4 通信子、进程数和 rank

通信子

通信子（communicator）：一组可以互相发送消息的进程集合。

常用通信子：

MPI_COMM_WORLD

含义：由 MPI_Init 创建，包含用户启动的所有 MPI 进程。

MPI_Comm_size

获取通信子中的进程总数。

int MPI_Comm_size(MPI_Comm comm, int *size);

示例：

int size;
MPI_Comm_size(MPI_COMM_WORLD, &size);

MPI_Comm_rank

获取当前进程在通信子中的编号，即 rank。

int MPI_Comm_rank(MPI_Comm comm, int *rank);

示例：

int rank;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);

rank 的作用

rank 用于区分不同进程。
rank 常用于决定每个进程执行什么任务。
rank 也用于指定消息发送目标或消息来源。

3.5 MPI_Send

MPI_Send 用于点对点发送消息。

函数原型：

int MPI_Send(
    void *buf,
    int count,
    MPI_Datatype datatype,
    int dest,
    int tag,
    MPI_Comm comm
);

参数：

| 参数 | 含义 | |---|---| | buf | 要发送的数据起始地址 | | count | 要发送的数据项个数，不是字节数 | | datatype | MPI 数据类型，如 MPI_INT、MPI_FLOAT、MPI_CHAR | | dest | 目标进程的 rank | | tag | 消息标签，用于区分不同消息 | | comm | 通信子，常用 MPI_COMM_WORLD |

tag 的作用

tag 用于区分同一对进程之间的不同消息。

例子：

一部分浮点数用于加法，使用 tag = 0。
一部分浮点数用于减法，使用 tag = 1。

接收方可以通过 tag 判断收到的消息应该如何处理。

3.6 MPI_Recv

MPI_Recv 用于点对点接收消息。

函数原型：

int MPI_Recv(
    void *buf,
    int count,
    MPI_Datatype datatype,
    int source,
    int tag,
    MPI_Comm comm,
    MPI_Status *status
);

参数：

| 参数 | 含义 | |---|---| | buf | 接收缓冲区起始地址 | | count | 最多接收的数据项数量，不是字节数 | | datatype | MPI 数据类型，如 MPI_INT、MPI_FLOAT | | source | 消息来源进程的 rank，可用 MPI_ANY_SOURCE | | tag | 消息标签，可用 MPI_ANY_TAG | | comm | 通信子，常用 MPI_COMM_WORLD | | status | 返回消息状态，也可用 MPI_STATUS_IGNORE 忽略 |

MPI_Status

MPI_Status 至少包含以下常用信息：

| 字段 | 含义 | |---|---| | MPI_SOURCE | 实际发送消息的进程 rank | | MPI_TAG | 实际接收消息的 tag | | MPI_ERROR | 错误码 |

如果接收方事先不知道实际收到了多少个数据项，可以用 MPI_Get_count 从 status 中查询。

int MPI_Get_count(
    MPI_Status *status_p,
    MPI_Datatype datatype,
    int *count_p
);

含义：

status_p：某次 MPI_Recv 返回的状态。
datatype：接收时使用的数据类型。
count_p：输出参数，保存实际接收到的数据项个数。

常用 MPI 数据类型

MPI 通信时必须说明数据类型。count 表示数据项个数，datatype 说明每个数据项是什么类型。

| MPI 类型 | C 类型 | |---|---| | MPI_CHAR | char | | MPI_SHORT | short | | MPI_INT | int | | MPI_LONG | long | | MPI_LONG_LONG | long long | | MPI_UNSIGNED | unsigned int | | MPI_FLOAT | float | | MPI_DOUBLE | double | | MPI_LONG_DOUBLE | long double | | MPI_BYTE | 原始字节 |

3.7 消息匹配

一个 MPI_Recv 能否匹配某个 MPI_Send，主要看三项：

source == 发送方 rank
recv_tag == send_tag
recv_comm == send_comm

还需要满足：

接收类型和发送类型匹配。
接收缓冲区足够大，即 recv_buff_sz >= send_buff_sz。

通配符

MPI 提供两个接收方通配符：

| 通配符 | 含义 | |---|---| | MPI_ANY_SOURCE | 接收任意来源进程的消息 | | MPI_ANY_TAG | 接收任意 tag 的消息 |

注意：通配符只能在接收方使用。

3.8 MPI_Send 和 MPI_Recv 的阻塞语义

MPI_Recv

MPI_Recv 一定是阻塞的。

含义：

如果匹配的消息还没到达，MPI_Recv 会一直等待。
除非出错或被取消，否则进程会挂起在接收调用上。

MPI_Send

MPI_Send 是否阻塞取决于消息大小和 MPI 实现。

常见情况：

| 情况 | 行为 | |---|---| | 消息较小 | MPI 可能复制到内部缓冲区，然后立即返回 | | 消息较大 | 如果接收方还没准备好，发送方可能阻塞 |

所以：MPI_Send 可能立即返回，也可能阻塞。

常见实现里有两种发送机制：

| 机制 | 典型场景 | 行为 | |---|---|---| | eager 模式 | 消息较小 | MPI 先把消息复制到内部缓冲区，MPI_Send 可能很快返回 | | rendezvous 模式 | 消息较大 | 发送方通常要等接收方开始匹配接收，MPI_Send 可能阻塞 |

所以不能把普通 MPI_Send 简单理解为“一定阻塞”或“一定非阻塞”。它的返回行为和消息大小、MPI 实现、接收方状态都有关。

消息不可超越

MPI 要求同一发送进程连续发送给同一接收进程的消息不能乱序。

也就是说：

同一个进程连续发送的几条消息，必须按发送顺序到达。
不同发送进程之间的消息没有这个顺序保证。

例子：

进程 1 连续发送 A、B 给进程 0
进程 0 不会先收到 B 再收到 A

但如果：

进程 1 发送 A
进程 2 发送 B

进程 0 可能先收到 A，也可能先收到 B。

MPI_Ssend

MPI_Ssend 是同步发送（synchronous send）。

额外的 s 表示 synchronous。它和 MPI_Send 的参数相同，但语义更严格：

MPI_Ssend 保证阻塞。
只有当匹配的接收操作已经开始后，MPI_Ssend 才能返回。
它不会像普通 MPI_Send 那样因为消息较小、被复制到内部缓冲区就提前返回。

函数原型：

int MPI_Ssend(
    void *msg_buf_p,
    int msg_size,
    MPI_Datatype msg_type,
    int dest,
    int tag,
    MPI_Comm communicator
);

和 MPI_Send 的关系：

| 函数 | 是否一定阻塞 | 返回条件 | |---|---|---| | MPI_Send | 不一定 | 可能复制到缓冲区后立即返回，也可能等待接收方 | | MPI_Ssend | 是 | 必须等匹配接收开始后才能返回 |

用途：

可以用来检查程序通信顺序是否安全。
如果把 MPI_Send 换成 MPI_Ssend 后程序挂起或崩溃，说明原程序可能依赖了 MPI 的内部缓冲区。
若使用 MPI_Ssend 后程序仍能正常运行，通常说明原来的点对点通信顺序更安全。
MPI_Ssend 的参数和 MPI_Send 相同，所以常见调试方式是直接把 MPI_Send 临时替换成 MPI_Ssend。

3.9 集合通信

集合通信是多个进程共同参与的通信操作。和点对点通信不同，集合通信通常要求通信子中的所有相关进程都调用同一个集合通信函数。

MPI_Reduce

MPI_Reduce 用于把多个进程的数据按某种操作归约，并把结果存到指定的 root 进程。

常见用途：求和、求最大值、求最小值等。

示例：

MPI_Reduce(
    &local_sum,     /* 每个进程提供的本地数据 */
    &total_sum,     /* 归约结果，只在 root 进程有效 */
    1,              /* 数据个数，这里是 1 个 double */
    MPI_DOUBLE,     /* 数据类型 */
    MPI_SUM,        /* 归约操作：求和 */
    0,              /* root 进程编号，结果放到 rank 0 */
    MPI_COMM_WORLD  /* 通信子 */
);

参数含义：

| 参数 | 含义 | |---|---| | sendbuf | 每个进程提供的本地数据地址 | | recvbuf | 归约结果存放地址，只在 root 进程有效 | | count | 数据项个数 | | datatype | 数据类型，如 MPI_DOUBLE | | op | 归约操作，如 MPI_SUM | | root | 接收最终结果的进程 rank | | comm | 通信子 |

MPI 预定义归约算子

| 算子 | 含义 | |---|---| | MPI_MAX | 最大值 | | MPI_MIN | 最小值 | | MPI_SUM | 总和 | | MPI_PROD | 乘积 | | MPI_LAND | 逻辑与 | | MPI_BAND | 按位与 | | MPI_LOR | 逻辑或 | | MPI_BOR | 按位或 | | MPI_LXOR | 逻辑异或 | | MPI_BXOR | 按位异或 | | MPI_MAXLOC | 最大值以及最大值所在位置 | | MPI_MINLOC | 最小值以及最小值所在位置 |

例子：4 个进程分别有：

rank 0: local_sum = 1.5
rank 1: local_sum = 2.0
rank 2: local_sum = 3.5
rank 3: local_sum = 4.0

执行 MPI_Reduce 后，只有 rank 0 上：

total_sum = 1.5 + 2.0 + 3.5 + 4.0;  /* 11.0 */

其他进程上的 total_sum 不保存最终归约结果。

树形结构通信

集合通信指的是通信子中所有进程共同参与的通信函数。MPI_Send 和 MPI_Recv 是点对点通信，不属于集合通信。

MPI_Reduce 内部通常不会简单地让所有进程都直接把结果发给 0 号进程，因为这样 root 进程需要接收和计算太多次。

如果 comm_sz = 1024：

简单集中到 0 号进程：0 号进程需要接收并计算 1023 次。
树形结构归约：大约只需要 log2(1024) = 10 轮通信和计算。

树形归约示意：

核心思想：

每一轮把相邻进程或局部结果两两合并。
合并后的部分和继续向上归约。
最终结果到达 root 进程。
这样能减少 root 进程的通信压力。

Reduce 和 Scan 的数据流对比：

区别：

MPI_Reduce：把所有进程的数据归约到一个 root 进程。
MPI_Scan：做前缀归约，每个进程得到从 rank 0 到自己这一段的部分归约结果。

集合通信与点对点通信的区别

集合通信和点对点通信的调用规则不同，不能把它们当成一类操作来匹配。

1. 所有进程必须调用同一个集合通信函数

通信子中的所有进程==必须调用相同的集合通信函数==。

错误例子：

rank 0 调用 MPI_Reduce
rank 1 调用 MPI_Recv

这种程序是错误的，可能导致挂起或崩溃。

2. 集合通信参数必须兼容

每个进程传给集合通信的关键参数必须一致或兼容。

以 MPI_Reduce 为例：

所有进程必须使用相同的通信子。
所有进程必须使用相同的归约操作。
所有进程必须指定相同的 root。
数据类型和数据个数必须匹配。

如果一个进程把 root 设为 0，另一个进程把 root 设为 1，程序就是错误的。

3. 非 root 进程也要传入对应参数

在 MPI_Reduce 中，接收缓冲区 recvbuf 只在 root 进程上真正使用。

但所有进程仍然需要调用同一个函数，并传入对应位置的参数。非 root 进程上的 recvbuf 不保存最终结果，通常可以理解为无效或被忽略。

4. 集合通信不靠 tag 匹配

点对点通信通过以下信息匹配：

source
tag
comm

集合通信不使用 tag。它的匹配主要由以下因素决定：

通信子 comm
调用的集合函数类型
调用顺序

因此，如果同一个通信子里连续调用两次 MPI_Reduce，MPI 会把所有进程的第一次 MPI_Reduce 匹配在一起，把第二次 MPI_Reduce 匹配在一起。

多次 MPI_Reduce 调用示例

假设所有进程都执行两次 MPI_Reduce，并且通信子相同：

MPI_Reduce(&a, &b, 1, MPI_INT, MPI_SUM, 0, comm);
MPI_Reduce(&c, &d, 1, MPI_INT, MPI_SUM, 0, comm);

则：

第一次调用只会和其他进程的第一次调用匹配。
第二次调用只会和其他进程的第二次调用匹配。
即使变量名不同，MPI 也不根据变量名匹配，只根据集合通信调用顺序匹配。

所以集合通信中，所有进程必须以相同顺序调用相同的集合通信函数。

不要混用输入和输出缓冲区

对于 MPI_Reduce，通常不应该把发送缓冲区和接收缓冲区写成同一个地址，例如：

MPI_Reduce(&x, &x, 1, MPI_DOUBLE, MPI_SUM, 0, comm);

这种写法可能导致结果不可预测，甚至是非法的。

更安全的写法是：

MPI_Reduce(&local_x, &global_x, 1, MPI_DOUBLE, MPI_SUM, 0, comm);

其中：

local_x：每个进程自己的输入数据。
global_x：root 进程保存归约结果。

MPI_Bcast

MPI_Bcast 用于广播：把 root 进程上的一份数据发送给通信子中的所有进程。

它可以看作是树形归约通信方向的“反向操作”：归约是把多个进程的数据汇总到 root，广播是把 root 的数据分发给所有进程。

函数原型：

int MPI_Bcast(
    void *data_p,
    int count,
    MPI_Datatype datatype,
    int source_proc,
    MPI_Comm comm
);

参数：

| 参数 | 含义 | |---|---| | data_p | 数据缓冲区；root 上是输入，其他进程上是输出 | | count | 数据项个数 | | datatype | 数据类型 | | source_proc | root 进程 rank，即数据来源 | | comm | 通信子 |

示例：

MPI_Bcast(a_p, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
MPI_Bcast(b_p, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
MPI_Bcast(n_p, 1, MPI_INT,    0, MPI_COMM_WORLD);

含义：

rank 0 上的 a_p、b_p、n_p 是源数据。
调用后，通信子中所有进程都得到相同的 a、b、n。

树形广播示意：

注意：

MPI_Bcast 是集合通信，通信子中的所有进程都必须调用。
所有进程传入的 count、datatype、source_proc、comm 必须匹配。
与手写多次 MPI_Send 相比，MPI_Bcast 通常更简洁，也可能由 MPI 库用树形结构优化。

MPI_Scatter

MPI_Scatter 用于分散：root 进程把一整块数据切成多段，分别发送给通信子中的各个进程。

可以理解为：

root 上的大数组 -> 每个进程拿到其中一小段

典型用途：

root 进程读入完整向量。
每个进程只处理自己负责的子向量。
避免把完整向量复制到所有进程，节省内存和通信量。

函数原型：

int MPI_Scatter(
    void *send_buf_p,
    int send_count,
    MPI_Datatype send_type,
    void *recv_buf_p,
    int recv_count,
    MPI_Datatype recv_type,
    int src_proc,
    MPI_Comm comm
);

重点参数：

| 参数 | 含义 | |---|---| | send_buf_p | root 进程上的完整发送缓冲区 | | send_count | 发送给每个进程的数据项个数 | | recv_buf_p | 每个进程接收自己那一段数据的缓冲区 | | recv_count | 每个进程实际接收的数据项个数 | | src_proc | root 进程 rank |

注意：send_count 不是 send_buf_p 中的总数据量，而是每个进程收到多少个元素。

如果通信子中有 comm_sz 个进程，MPI_Scatter 会把 send_buf_p 指向的数据分成 comm_sz 个片段：

第 1 个片段 -> rank 0
第 2 个片段 -> rank 1
第 3 个片段 -> rank 2
...

所以 root 上的发送缓冲区至少需要容纳：

send_count * comm_sz

个元素。

例子：有 comm_sz 个进程，向量总长度为 n，则每个进程收到：

local_n = n / comm_sz

调用时通常类似：

MPI_Scatter(x, local_n, MPI_DOUBLE,
            local_x, local_n, MPI_DOUBLE,
            0, MPI_COMM_WORLD);

MPI_Bcast、MPI_Scatter 和 MPI_Gather 的数据方向对比：

MPI_Gather

MPI_Gather 用于收集：每个进程把自己的一段数据发送给 root，root 把这些片段按 rank 顺序拼成完整数据。

可以理解为：

每个进程的一小段 -> root 上的大数组

它和 MPI_Scatter 方向相反：

| 函数 | 数据方向 | |---|---| | MPI_Scatter | root 分发给所有进程 | | MPI_Gather | 所有进程收集到 root |

函数原型：

int MPI_Gather(
    void *send_buf_p,
    int send_count,
    MPI_Datatype send_type,
    void *recv_buf_p,
    int recv_count,
    MPI_Datatype recv_type,
    int dest_proc,
    MPI_Comm comm
);

重点参数：

| 参数 | 含义 | |---|---| | send_buf_p | 每个进程要发送的本地数据 | | send_count | 每个进程发送的数据项个数 | | recv_buf_p | root 进程上的接收缓冲区，用来存放完整结果 | | recv_count | root 从每个进程接收的数据项个数 | | dest_proc | root 进程 rank，即结果收集到哪里 |

注意：recv_count 是从每个进程接收多少项，不是 root 最终接收到的总项数。最终总量通常是：

recv_count * comm_sz

root 上的 recv_buf_p 会按进程 rank 顺序存放结果：

rank 0 的数据 -> 第 1 块
rank 1 的数据 -> 第 2 块
rank 2 的数据 -> 第 3 块
...

MPI_Gather 和 MPI_Scatter 的重点都是 count 参数的含义：

MPI_Scatter 的 send_count：root 发给每个进程多少个元素。
MPI_Gather 的 recv_count：root 从每个进程收多少个元素。
它们都不是 root 缓冲区里的总元素数。

MPI_Allgather

MPI_Allgather 用于全局聚集：每个进程发送一段数据，并且每个进程最终都得到所有进程的数据。

可以理解为：

MPI_Allgather = MPI_Gather + MPI_Bcast

也就是说，它先把各进程的数据聚集成完整结果，再让所有进程都拥有这份完整结果。实际 MPI 实现不一定真的分两步执行，但语义上可以这样理解。

区别：

| 函数 | 谁得到完整结果 | |---|---| | MPI_Gather | 只有 root 进程 | | MPI_Allgather | 所有进程 |

函数原型：

int MPI_Allgather(
    void *send_buf_p,
    int send_count,
    MPI_Datatype send_type,
    void *recv_buf_p,
    int recv_count,
    MPI_Datatype recv_type,
    MPI_Comm comm
);

和 MPI_Gather 相比，MPI_Allgather 没有 root 参数，因为所有进程都会得到完整结果。

例子：4 个进程中：

int sendval = rank + 1;
int recvbuf[4];

MPI_Allgather(&sendval, 1, MPI_INT,
              recvbuf, 1, MPI_INT,
              MPI_COMM_WORLD);

执行后，每个进程的：

recvbuf = [1, 2, 3, 4]

注意：

所有进程都要提供 recvbuf。
recvbuf 大小通常至少是 recv_count * comm_sz。
和 MPI_Gather 不同，MPI_Allgather 没有 dest_proc/root 参数，因为结果不是只发给某一个进程，而是发给所有进程。

MPI_Allgather 和 MPI_Alltoall 的语义对比：

MPI_Allgather 的常见实现之一是环算法：

环算法的直观过程：

每个进程一开始有自己的本地数据。
第 0 轮发送自己的数据。
之后每一轮把上一轮收到的数据继续传给右侧进程，同时从左侧进程接收新数据。
经过 p - 1 轮后，每个进程都拥有所有进程的数据。

另一类实现是递归倍增/蝶式通信：

它每一轮和更远距离的伙伴进程交换已有数据，轮数约为 log2(p)。实际 MPI 库会根据消息大小、进程数和网络结构选择实现方式。

MPI_Allreduce

MPI_Allreduce 会把归约结果发送给通信子中的所有进程。

如果希望所有进程都得到总和，应使用：

MPI_Allreduce(
    &local_sum,
    &total_sum,
    1,
    MPI_DOUBLE,
    MPI_SUM,
    MPI_COMM_WORLD
);

区别：

| 函数 | 结果保存在哪些进程 | |---|---| | MPI_Reduce | 只保存在 root 进程 | | MPI_Allreduce | 所有参与进程都得到结果 |

全局和的两种实现模式

全局和的目标是：每个进程一开始只有自己的局部值，最后所有进程都得到全局求和结果。

示例初始值：

rank 0:  5
rank 1:  2
rank 2: -1
rank 3: -3
rank 4:  6
rank 5:  5
rank 6: -7
rank 7:  2

总和为：

5 + 2 - 1 - 3 + 6 + 5 - 7 + 2 = 9

模式一：先归约，再分发

第一阶段：树形归约，把所有值逐步加到 root 进程。

第二阶段：root 再把结果广播给所有进程。

特点：

思路简单：先做 Reduce，再做 Broadcast。
root 先得到最终结果，然后再分发给其他进程。
可理解为 MPI_Allreduce = MPI_Reduce + MPI_Bcast 的一种实现思路。

模式二：蝶式模式

蝶式模式中，每一轮进程和一个“伙伴进程”交换当前部分和，交换后双方都更新自己的结果。

8 个进程需要 log2(8) = 3 轮：

第 1 轮：距离 1 的进程交换
(0,1), (2,3), (4,5), (6,7)

第 2 轮：距离 2 的进程交换
(0,2), (1,3), (4,6), (5,7)

第 3 轮：距离 4 的进程交换
(0,4), (1,5), (2,6), (3,7)

图示：

特点：

每一轮所有进程都参与交换和计算。
每个进程最终都直接得到全局结果。
不需要先集中到 root 再广播。
适合实现 MPI_Allreduce 这类所有进程都需要结果的集合通信。

3.10 MPI 程序中的 I/O 处理

基本规则

在 MPI 程序中：

输出：所有进程都可以访问 stdout，但输出顺序不可预测。
输入：通常只有 0 号进程访问 stdin。

因此常见做法是：

0 号进程从标准输入读取数据。
0 号进程把输入数据发送给其他进程。
其他进程通过 MPI_Recv 接收这些数据。

示例：0 号进程读入并分发参数

if (my_rank == 0) {
    printf("Enter a, b, and n\n");
    scanf("%lf %lf %d", a_p, b_p, n_p);

    for (dest = 1; dest < comm_sz; dest++) {
        MPI_Send(a_p, 1, MPI_DOUBLE, dest, 0, MPI_COMM_WORLD);
        MPI_Send(b_p, 1, MPI_DOUBLE, dest, 0, MPI_COMM_WORLD);
        MPI_Send(n_p, 1, MPI_INT,    dest, 0, MPI_COMM_WORLD);
    }
} else {
    MPI_Recv(a_p, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD,
             MPI_STATUS_IGNORE);
    MPI_Recv(b_p, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD,
             MPI_STATUS_IGNORE);
    MPI_Recv(n_p, 1, MPI_INT,    0, 0, MPI_COMM_WORLD,
             MPI_STATUS_IGNORE);
}

代码含义

my_rank == 0：
- 0 号进程负责提示用户输入。
- 读取 a、b、n。
- 通过循环把三个参数发送给 rank 1 到 comm_sz - 1 的所有进程。
my_rank != 0：
- 非 0 号进程不访问 stdin。
- 它们分别从 0 号进程接收 a、b、n。

图示

注意点

count 是数据项个数，不是字节数。
a_p 和 b_p 是 double*，所以使用 MPI_DOUBLE。
n_p 是 int*，所以使用 MPI_INT。
MPI_STATUS_IGNORE 表示忽略接收状态。
这里三条消息都使用 tag = 0，能够正确接收是因为同一发送方到同一接收方的消息不会乱序。

更简洁的替代方案

如果所有进程都需要同样的输入数据，更常见的写法是使用广播：

MPI_Bcast(a_p, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
MPI_Bcast(b_p, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
MPI_Bcast(n_p, 1, MPI_INT,    0, MPI_COMM_WORLD);

MPI_Bcast 表示：root 进程把数据广播给通信子中的所有进程。

3.11 MPI 计时与同步

MPI_Wtime

MPI_Wtime 用于获取当前进程的墙上时钟时间（wall time），单位是秒，返回值类型是 double。

它常用于测量某段 MPI 程序的运行时间：

double start, end;

start = MPI_Wtime();

do_work();

end = MPI_Wtime();

printf("Elapsed time = %f seconds\n", end - start);

注意：

MPI_Wtime() 返回的是当前进程看到的时间。
并行程序中各进程开始执行某段代码的时刻可能不同。
如果要测量一段并行计算的整体耗时，通常要先同步，再开始计时。

MPI_Barrier

MPI_Barrier 是屏障同步函数：

int MPI_Barrier(MPI_Comm comm);

含义：

通信子 comm 中的所有进程都必须到达这个调用点。
只有所有进程都到达后，大家才能继续往下执行。
如果有进程还没到，其他已经到达的进程会阻塞等待。

典型用途：同步后再测量并行区域时间。

MPI_Barrier(MPI_COMM_WORLD);
double start = MPI_Wtime();

do_parallel_work();

MPI_Barrier(MPI_COMM_WORLD);
double end = MPI_Wtime();

if (rank == 0) {
    printf("Parallel section took %f seconds\n", end - start);
}

为什么前后都加 MPI_Barrier：

前面的 MPI_Barrier：保证所有进程都准备好后再开始计时。
后面的 MPI_Barrier：保证所有进程都完成并行段后再停止计时。
这样测到的时间更接近整个并行计算段的真实耗时。

3.12 MPI 派生数据类型

MPI 的基本数据类型只能描述连续的 int、double、char 等数据。实际程序里经常需要发送更复杂的内存布局，例如矩阵的一列、结构体中的几个字段，或者二维数组中的一个子块。

派生数据类型的作用是：告诉 MPI“我要发送的数据在内存中怎样分布”，让 MPI 直接按这个布局通信，而不需要程序员手动把数据打包到临时数组。

典型使用流程：

MPI_Datatype new_type;

/* 1. 创建派生类型 */
/* MPI_Type_vector / MPI_Type_indexed / MPI_Type_create_struct 等 */

/* 2. 提交类型，之后才能用于通信 */
MPI_Type_commit(&new_type);

/* 3. 在 Send/Recv 或集合通信中使用 */
MPI_Send(buf, 1, new_type, dest, tag, comm);

/* 4. 不再使用后释放 */
MPI_Type_free(&new_type);

`MPI_Type_contiguous`

MPI_Type_contiguous 用来描述一段连续的数据，相当于把多个相同类型的数据组合成一个新类型。

int MPI_Type_contiguous(
    int count,
    MPI_Datatype old_type,
    MPI_Datatype *new_type_p
);

例子：把 4 个连续的 MPI_DOUBLE 看成一个新类型。

`MPI_Type_vector`

MPI_Type_vector 用来描述“重复出现的等长块”，每个块之间有固定间隔。它常用于发送矩阵的一列。

int MPI_Type_vector(
    int count,
    int blocklength,
    int stride,
    MPI_Datatype old_type,
    MPI_Datatype *new_type_p
);

参数含义：

| 参数 | 含义 | |---|---| | count | 有多少个块 | | blocklength | 每个块包含多少个旧类型元素 | | stride | 相邻块起点之间相隔多少个旧类型元素 | | old_type | 原始 MPI 数据类型 | | new_type_p | 输出的新派生类型 |

示意图：

`MPI_Type_indexed`

MPI_Type_indexed 比 vector 更灵活：每个块的长度和起始位置都可以不同。

int MPI_Type_indexed(
    int count,
    int blocklengths[],
    int displacements[],
    MPI_Datatype old_type,
    MPI_Datatype *new_type_p
);

适合描述不规则位置的数据。

`MPI_Type_create_subarray`

MPI_Type_create_subarray 用来描述多维数组中的一个子数组。它常用于矩阵块划分，例如从一个二维矩阵里发送某个矩形区域。

`MPI_Type_create_struct`

MPI_Type_create_struct 用来描述由不同类型字段组成的数据布局。例如一个结构体里既有 int，也有 double，并且只想发送其中某些字段。

结构体填充和 `extent`

C 结构体中可能存在内存对齐填充。也就是说，字段之间或结构体末尾可能有一些程序员没有显式声明的空字节。

如果直接把结构体当成连续内存发送，可能会把不需要的填充字节或相邻字段一起发送出去。派生数据类型可以只描述真正需要通信的字段。

还有一个容易混淆的概念是 extent：它表示 MPI 在连续排列多个该类型对象时，相邻对象起点之间的跨度。结构体有填充时，extent 可能大于字段本身的有效数据长度。

必要时可以用 MPI_Type_create_resized 调整派生类型的 extent。

核心记忆：

派生数据类型描述的是内存布局，不是新建一份数据。
创建后必须 MPI_Type_commit，不用后要 MPI_Type_free。
发送非连续数据时，派生类型通常比手动打包更清晰，也更不容易出错。

3.13 MPI 死锁、`Sendrecv` 和非阻塞通信

点对点通信中的死锁

如果两个进程都先执行阻塞发送，再执行接收，就可能互相等待。

典型错误模式：

rank 0: MPI_Send(... rank 1 ...); MPI_Recv(... rank 1 ...);
rank 1: MPI_Send(... rank 0 ...); MPI_Recv(... rank 0 ...);

当消息较大或使用同步发送时，两个进程都在等对方先接收，程序就可能卡住。

解决方式一：调整发送接收顺序

让一边先发送后接收，另一边先接收后发送，就能避免两边同时卡在发送上。

解决方式二：`MPI_Sendrecv`

MPI_Sendrecv 把一次发送和一次接收合成一个调用，适合相邻进程交换数据。

int MPI_Sendrecv(
    const void *sendbuf,
    int sendcount,
    MPI_Datatype sendtype,
    int dest,
    int sendtag,
    void *recvbuf,
    int recvcount,
    MPI_Datatype recvtype,
    int source,
    int recvtag,
    MPI_Comm comm,
    MPI_Status *status
);

它的价值是：程序员不用手动安排“谁先发、谁先收”，MPI 会处理这个交换过程。

缓冲发送

MPI_Bsend 是缓冲发送。它依赖用户提供的缓冲区，发送数据可以先被拷贝到这个缓冲区中。

注意：缓冲发送不是首选的死锁解决方案。更常用的是重新安排通信顺序、使用 MPI_Sendrecv，或者使用非阻塞通信。

非阻塞通信

非阻塞通信的核心是：函数调用可以先返回，通信在后台继续进行。

常用函数：

MPI_Isend(..., MPI_Request *request);
MPI_Irecv(..., MPI_Request *request);

I 表示 immediate。调用返回只表示“通信请求已经发起”，不表示通信已经完成。

因此必须配合等待或测试函数：

MPI_Wait(&request, &status);
MPI_Test(&request, &flag, &status);
MPI_Waitall(count, requests, statuses);

最重要的规则：

对 MPI_Isend，在通信完成前，不要修改或释放发送缓冲区。
对 MPI_Irecv，在通信完成前，不要读取接收缓冲区中的结果。
是否完成要看 MPI_Wait / MPI_Test 等函数。

MPI_Request 可以理解成一次未完成通信的“句柄”：

多个非阻塞通信可以一起等待：

也可以等待其中任意一个或一部分完成：

一句话总结：

阻塞通信：调用返回时，相关通信条件已经满足。
非阻塞通信：调用先返回，但之后必须 wait/test，才能确认通信完成。

第 4 章使用 Pthreads 进行共享内存编程

4.1 Pthreads 概述

Pthreads 是什么

Pthreads 是 POSIX 线程库，用于在共享内存系统中编写多线程程序。

和 MPI 的主要区别：

| 对比项 | MPI | Pthreads | |---|---|---| | 所在章节 | 第 3 章 | 第 4 章 | | 编程对象 | 进程 | 线程 | | 内存模型 | 分布式内存 | 共享内存 | | 数据是否默认共享 | 不共享；每个进程有自己的地址空间 | 共享；同一进程内线程可以访问共享变量 | | 通信方式 | 显式消息传递 | 通过共享变量隐式通信 | | 典型 API | MPI_Send、MPI_Recv、MPI_Reduce、MPI_Bcast | pthread_create、pthread_join、pthread_mutex_lock、sem_wait | | 协调重点 | 发送/接收、集合通信、消息匹配、阻塞语义 | 临界区、互斥锁、信号量、条件变量、读写锁 | | 常见问题 | 死锁、消息匹配错误、通信开销 | 数据竞争、伪共享、线程不安全、锁竞争 | | 适合场景 | 多机器、集群、大规模分布式计算 | 单机多核、小到中等规模共享内存并行 |

核心区别：

MPI：进程之间不共享内存，所以靠消息传递。
Pthreads：线程之间共享内存，所以靠同步保护。

MPI 中，每个进程像独立的执行单元，有自己的内存。要交换数据，必须显式调用：

MPI_Send(...);
MPI_Recv(...);

Pthreads 中，多个线程在同一个进程内运行，可以直接访问同一个共享变量。因此重点不是发送消息，而是防止多个线程同时乱改共享数据：

pthread_mutex_lock(&mutex);
/* 临界区 */
pthread_mutex_unlock(&mutex);

性能瓶颈也不同：

| 模型 | 常见性能瓶颈 | |---|---| | MPI | 通信次数、消息大小、网络延迟、集合通信效率 | | Pthreads | 锁竞争、临界区太长、缓存一致性开销、伪共享、线程调度 |

两者都可以使用 SPMD 思路：同一份程序由多个执行单元运行。区别是 MPI 通常用 rank 区分进程，Pthreads 通常用线程编号区分线程。

共享内存系统适合在同一台机器上使用多个线程，规模通常不会太大，因为多个核心访问共享内存时会受到内存带宽、总线、缓存一致性等因素限制。

Pthreads 程序的核心问题

Pthreads 的重点不是“如何传消息”，而是：

线程之间如何通信：通过访问共享变量。
如何避免写写冲突：避免多个线程同时写同一个共享变量。
如何构造临界区：把一次只能由一个线程执行的代码包起来。
如何表达锁：使用互斥量 pthread_mutex_t。

Pthreads 程序也经常采用 SPMD 思路：所有线程运行同一个线程函数，但根据线程编号处理不同数据。

4.2 Hello World 示例

编译与运行

编译 Pthreads 程序时需要加 -pthread：

gcc -pthread hello_pthread.c -o hello_pthread
./hello_pthread

代码

#include <stdio.h>
#include <pthread.h>

void* say_hello(void* arg) {
    int thread_id = *(int*)arg;
    printf("Hello from thread %d!\n", thread_id);
    return NULL;
}

int main() {
    const int NUM_THREADS = 4;
    pthread_t threads[NUM_THREADS];
    int ids[NUM_THREADS];

    for (int i = 0; i < NUM_THREADS; i++) {
        ids[i] = i;
        pthread_create(&threads[i], NULL, say_hello, (void*) &ids[i]);
    }

    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("All threads finished. Goodbye!\n");
    return 0;
}

如果线程数运行时才确定，可以动态分配线程对象数组：

pthread_t* threads = malloc(num_threads * sizeof(pthread_t));

4.3 pthread_create：启动线程

在启动线程前，需要先创建线程对象：

pthread_t thread;

每个线程对应一个 pthread_t 对象。创建线程使用：

int pthread_create(
    pthread_t* thread,
    const pthread_attr_t* attr,
    void* (*start_routine)(void*),
    void* arg
);

参数：

| 参数 | 含义 | | --------------- | ---------------------- | | thread | 指向线程对象的指针，创建成功后保存线程 ID | | attr | 线程属性，通常传 NULL | | start_routine | 线程要执行的函数 | | arg | 传给线程函数的参数 |

线程函数的固定形式通常是：

void* thread_func(void* arg);

如果要传多个参数，常见做法是定义结构体，把结构体指针作为 arg 传入。

4.4 pthread_join：等待线程结束

pthread_join 用来等待一个线程结束：

int pthread_join(pthread_t thread, void** retval);

重点：

pthread_join 不会主动停止线程。
它会阻塞调用它的线程，直到目标线程正常返回。
常用于主线程等待所有子线程执行完毕。

典型写法：

for (int i = 0; i < NUM_THREADS; i++) {
    pthread_join(threads[i], NULL);
}

如果主线程不等待子线程，主线程可能先结束，导致整个进程退出，子线程还没来得及完成。

4.5 共享变量、冲突和临界区

线程如何通信

Pthreads 中，同一个进程内的多个线程共享地址空间，因此线程可以直接访问同一批全局变量、堆内存和静态变量。

也就是说，线程之间的通信通常是隐式的：

线程 A 写共享变量
线程 B 读共享变量

这比 MPI 的显式发送和接收更方便，但也更容易出错。

写写冲突

如果多个线程同时写同一个共享变量，就可能出现写写冲突。

例子：

sum += my_val;

这行代码看起来是一条语句，但底层通常包含：

从内存读取 sum。
加上 my_val。
把结果写回 sum。

如果两个线程同时执行，就可能都读到旧值，最后其中一个写入覆盖另一个写入，导致结果错误。

竞争条件

竞争条件：多个线程同时访问某个共享资源，并且程序结果依赖于线程执行的先后顺序。

例子：共享变量 x 初始值为 0，两个线程几乎同时执行：

y = compute();   /* Thread 0: y = 1; Thread 1: y = 2 */
x = x + y;

理想情况下，最终应该得到：

x = 1 + 2 = 3

但实际执行可能是：

线程 0 读到 x = 0，准备加 y = 1。
线程 1 也读到 x = 0，准备加 y = 2。
线程 0 写回 x = 1。
线程 1 写回 x = 2，覆盖线程 0 的结果。

最终得到 x = 2，而不是 x = 3。这说明 x = x + y 不是原子操作。

临界区

临界区：一次只能允许一个线程执行的代码区域。

通常，临界区里面放的是更新共享变量的操作。

对于共享变量更新，常见做法是把更新语句放进临界区：

lock();
sum += my_val;
unlock();

临界区越大，串行化越严重；临界区越小，程序通常越容易保持并行性能。

临界区要解决的问题是：让多个线程对共享变量的访问变成互斥访问，从而避免多个线程同时修改同一个共享变量。

互斥锁

忙等待会持续占用 CPU，因此更常用的方式是使用互斥锁和信号量。

互斥锁（mutex）是一种线程同步机制，用来保证同一时刻只有一个线程可以进入临界区。

Pthreads 使用 pthread_mutex_t 表示互斥量：

pthread_mutex_t mutex;

初始化

使用互斥锁前需要初始化：

int pthread_mutex_init(
    pthread_mutex_t* mutex_p,
    const pthread_mutexattr_t* attr_p
);

一般情况下，属性参数传 NULL：

pthread_mutex_init(&lock, NULL);

上锁

进入临界区前调用：

int pthread_mutex_lock(pthread_mutex_t* mutex_p);

含义：

如果锁空闲，当前线程获得锁并继续执行。
如果锁已被其他线程持有，当前线程阻塞等待。

解锁

离开临界区后调用：

int pthread_mutex_unlock(pthread_mutex_t* mutex_p);

含义：释放锁，让其他等待线程有机会进入临界区。

销毁

互斥锁不再使用时，应销毁：

int pthread_mutex_destroy(pthread_mutex_t* mutex_p);

典型使用方式

pthread_mutex_t lock;
pthread_mutex_init(&lock, NULL);

pthread_mutex_lock(&lock);

/* 临界区 */
sum += my_val;

pthread_mutex_unlock(&lock);

pthread_mutex_destroy(&lock);

使用锁的目的不是提高速度，而是保证共享变量更新的正确性。

互斥锁的局限：不能保证执行顺序

互斥锁只能保证：

同一时刻只有一个线程进入临界区

但它不能保证：

线程按照指定顺序进入临界区

所以，如果临界区里的操作对顺序敏感，仅使用互斥锁仍然可能得到不同结果。

典型例子：多个线程各自生成一个矩阵，然后把它乘到共享结果矩阵 product_mat 上。

void* Thread_work(void* rank) {
    long my_rank = (long) rank;
    matrix_t my_mat = Allocate_matrix(n);
    Generate_matrix(my_mat);

    pthread_mutex_lock(&mutex);
    Multiply_matrix(product_mat, my_mat);
    pthread_mutex_unlock(&mutex);

    Free_matrix(&my_mat);
    return NULL;
}

互斥锁可以保证一次只有一个线程执行：

Multiply_matrix(product_mat, my_mat);

但问题是：不同线程进入临界区的顺序由操作系统调度决定。

矩阵乘法不满足交换律：

A * B * C != C * B * A

因此，线程执行乘法的顺序不同，最终的 product_mat 可能不同。

结论：互斥锁适合保护共享变量，避免同时写；但如果操作本身对顺序敏感，还需要额外机制规定线程执行顺序。

信号量

有些同步模式不是简单的“只能一个线程进临界区”，而是“一个线程要等另一个线程完成某些操作后才能继续”。这种情况更适合使用信号量。

使用信号量需要引入：

#include <semaphore.h>

信号量和互斥锁最大的区别：

| 对比项 | 互斥锁 | 信号量 | |---|---|---| | 核心含义 | 保护同一段临界区，避免多个线程同时进入 | 表达“某件事已经发生，另一个线程可以继续了” | | 所属关系 | 谁 lock，通常谁 unlock | 没有所有权，任何线程都可以 post | | 典型用途 | 互斥访问共享变量 | 控制线程之间的先后顺序 | | 顺序控制 | 不保证线程进入顺序 | 可用于让线程等待某个事件发生 |

对于当前学习目的，最关键的区别是：信号量没有所有权。

一句话记忆：

mutex：谁 lock，通常谁 unlock；重点是保护同一段临界区。
semaphore：任何线程都可以 post；重点是通知另一个线程可以继续。

也就是说：

主线程可以把所有信号量初始化为 0，表示这些事件一开始都尚未发生。
任意线程都可以对任意信号量执行 sem_wait。
任意线程也可以对任意信号量执行 sem_post。
因此，一个线程可以通过 sem_post 唤醒另一个正在等待该信号量的线程。

更准确地说，信号量的重点不是“加锁”，而是表达：

某个事件已经发生，等待这个事件的线程可以继续了

这和互斥锁不同：互斥锁通常强调“==谁加锁，谁解锁==”。信号量更像一个可被不同线程共同操作的通知器或计数器。

sem_init：初始化

int sem_init(
    sem_t* semaphore_p,
    int shared,
    unsigned initial_val
);

参数：

semaphore_p：信号量对象地址。
shared：是否用于进程间共享。通常写 0，表示用于同一进程内的线程之间。
initial_val：信号量初值。常见地，0 表示事件尚未发生，等待线程需要阻塞。

例子：

sem_t sem;
sem_init(&sem, 0, 0);

当 initial_val = 0 时，先执行 sem_wait 的线程会阻塞，直到其他线程执行 sem_post。

sem_wait：等待

int sem_wait(sem_t* semaphore_p);

含义：

如果信号量值 > 0，将其减 1，然后线程继续执行。
如果信号量值 = 0，线程阻塞，直到其他线程执行 sem_post 发出通知。

可以理解为：

等待某个事件发生；如果还没发生，就睡眠等待

sem_post：通知/释放

int sem_post(sem_t* semaphore_p);

含义：

将信号量值加 1。
如果有线程正在 sem_wait 中阻塞，可能唤醒其中一个。

可以理解为：

宣布某个事件已经发生；如果有人在等，就叫醒一个

sem_destroy：销毁

int sem_destroy(sem_t* semaphore_p);

信号量不再使用时，应调用 sem_destroy 销毁。

典型用法：控制线程先后顺序

sem_t sem;
sem_init(&sem, 0, 0);

/* 线程 A */
sem_wait(&sem);
do_after_B();

/* 线程 B */
do_something();
sem_post(&sem);

/* 不再使用时 */
sem_destroy(&sem);

总结：

信号量的重点是表达“事件发生了，可以继续”。
它比互斥锁更适合控制线程之间的先后顺序。
初值为 0 时，表示事件还没发生，等待线程会阻塞。
sem_post 可以由另一个线程调用，用来通知等待线程继续执行。
初值为 1 的二进制信号量可以模拟互斥锁，但这不是这里最重要的用法。

忙等待、互斥锁和信号量对比

这三者都可以用于协调线程，但解决问题的重点不同。

本节最重要的主线不是“这三个工具分别叫什么”，而是：

它们能不能控制线程之间的执行顺序？

如果只是避免多个线程同时进入临界区，用互斥锁通常就够了；如果要求线程 A 做完后线程 B 才能继续，就需要能表达先后关系的机制。

| 机制 | 核心思想 | 能否控制执行顺序 | 等待时是否占用 CPU | 是否有所有权 | 适合解决的问题 | 主要风险 | |---|---|---|---|---|---|---| | 忙等待 | 用共享标志变量和空循环反复检查条件 | 可以，但方式低效 | 占用 CPU，一直空转 | 没有明确所有权 | 简单地强制线程按某个顺序执行 | 浪费 CPU；线程数多于核心数时可能严重变慢；还可能受编译器优化影响 | | 互斥锁 | 把一段临界区锁起来，一次只允许一个线程进入 | 不能精确控制，只保证互斥 | 通常阻塞，不持续空转 | 有所有权，谁 lock 通常谁 unlock | 保护共享变量或共享数据结构，避免同时写 | 不保证进入临界区的顺序；临界区太大会导致串行化 | | 信号量 | 用计数器表达资源数量或事件是否发生 | 可以，用 wait/post 表达先后关系 | 信号量为 0 时阻塞 | 没有所有权，任何线程都可以 post | 控制线程先后顺序、生产者-消费者同步，也可模拟互斥锁 | 用法更灵活，也更容易把 wait/post 顺序写错 |

一句话记忆：

忙等待：一直问“轮到我了吗？”
互斥锁：保护“这段代码一次只能一个线程执行”。
信号量：通知“某件事发生了，等待者可以继续”。

最终记忆：

互斥锁解决“不能同时执行”的问题；
信号量更适合解决“必须按某个顺序执行”的问题；
忙等待也能做顺序控制，但代价是一直占用 CPU。

栅栏

栅栏（barrier）是一个同步点：所有线程都必须到达这里，任何线程才允许继续往后执行。

可以把栅栏理解成“阶段分界线”：

线程 0: 做 A --- 到达栅栏 | 等待 | 做 B
线程 1: 做 A --------- 到达栅栏 | 做 B
线程 2: 做 A -- 到达栅栏  | 等待 | 做 B

只有最后一个线程也到达栅栏后，所有线程才一起越过栅栏，进入下一阶段。

常见用途：

| 用途 | 说明 | |---|---| | 更准确计时 | 先让所有线程在栅栏处集合，再一起开始计时，避免有的线程先开始、有的线程晚开始。 | | 调试并行程序 | 在某个位置放栅栏，然后让 0 号线程打印，表示所有线程都已经运行到这个点。 | | 阶段同步 | 保证上一阶段所有线程都完成后，才能进入下一阶段。 |

和互斥锁的区别：

| 机制 | 重点 | |---|---| | mutex | 防止多个线程同时进入同一段临界区。 | | barrier | 要求多个线程都到达同一个位置后再一起继续。 |

重要风险：如果某个线程永远到不了栅栏，其他线程会一直等在那里，程序就会卡住。因此，栅栏适合用于“所有线程都会执行到这里”的阶段同步。

条件变量

条件变量（condition variable）用于让线程在某个条件尚未满足时睡眠等待，等其他线程改变条件后再被唤醒。

典型调用：

pthread_cond_wait(&cond_var, &mutex);

它不是“拿着锁睡觉”。这个函数会在内部原子地完成几件事：

把当前线程放进 cond_var 的等待队列。
==释放 mutex==，让其他线程有机会修改共享状态。
让当前线程睡眠，不再占用 CPU 忙等。
被唤醒后，返回之前会重新获得 mutex。

为什么必须释放 mutex：如果等待线程一直拿着锁睡眠，其他线程就无法进入临界区修改条件，也就无法唤醒它。

通常写法：

pthread_mutex_lock(&mutex);
while (!condition_is_true) {
    pthread_cond_wait(&cond_var, &mutex);
}
/* 条件已经满足，继续处理共享数据 */
pthread_mutex_unlock(&mutex);

注意：这里通常用 while，不是 if。因为线程被唤醒后，条件不一定仍然成立，需要重新检查。

读写锁

读写锁（read-write lock）适合读多写少的共享资源。

它允许多个线程同时读共享资源，但只允许一个线程写；并且写操作进行时，其他线程不能读也不能写。

锁状态：

| 锁状态 | 其他线程能否同时操作 | |---|---| | 无锁 | 所有线程都可以竞争加锁 | | 读锁（共享） | 其他线程可以继续加读锁 | | 写锁（独占） | 不允许其他线程加读锁或写锁 |

初始化和销毁：

pthread_rwlock_t rwlock;

pthread_rwlock_init(&rwlock, NULL);
pthread_rwlock_destroy(&rwlock);

加读锁：

pthread_rwlock_rdlock(&rwlock);

如果当前没有写锁，就可以成功加读锁。
多个线程可以同时持有读锁。

加写锁：

pthread_rwlock_wrlock(&rwlock);

只有当前没有其他线程持有读锁或写锁时，才会成功。
写锁是独占访问。

解锁：

pthread_rwlock_unlock(&rwlock);

读锁和写锁都用同一个 pthread_rwlock_unlock 解锁。

一句话记忆：

读读可以并发，写写不能并发，读写也不能并发。

多线程链表操作

链表的主要操作可以分为两类：

读操作：查找、遍历，不修改链表结构。
写操作：插入、删除，会修改指针。

因为不能让多个线程同时修改同一个指针，所以链表并发访问需要同步。

常见加锁方式：

| 方法 | 思路 | 特点 | |---|---|---| | 整个链表加锁 | 所有读写操作都先拿同一把锁 | 最简单，但并发度最低 | | 每个节点加锁 | 每个节点都有自己的锁 | 并发度更高，但实现复杂、空间开销大，通常最慢 | | 读写锁 | 读操作共享，写操作独占 | 读多写少时效果最好 |

使用读写锁时：

多个查找线程可以同时持有读锁，一起读链表。
插入或删除线程需要写锁，写锁期间不允许其他线程读或写。

效率结论：

当读操作很多、写操作较少时，读写锁通常比“整个链表加一把互斥锁”更高效。
当写操作较多时，读写锁的优势会变小，通常只比整个链表加锁快一点。
每个节点单独加锁看起来更细粒度，但锁操作太多，而且每个节点都要额外存锁，通常代价最大。

线程安全性

线程安全：一段代码或一个函数在多线程环境中被并发调用时，仍然能得到正确结果，不会因为共享状态被互相覆盖而出错。

判断线程安全时，不能只看自己写的代码，还要看调用的库函数是否线程安全。

例子：多个线程共同读取文本，每个线程读一行，再把这一行拆成单词。

读输入可以用信号量保护：

sem_wait(&sems[my_rank]);
fg_rv = fgets(my_line, MAX, stdin);
sem_post(&sems[next]);

这样可以避免多个线程同时读 stdin。但是，后面如果使用 strtok 拆单词，程序仍然可能线程不安全：

my_string = strtok(my_line, " \t\n");
while (my_string != NULL) {
    my_string = strtok(NULL, " \t\n");
}

原因是 strtok(NULL, ...) 需要知道“上一次拆到哪里了”。strtok 会把这个位置保存在函数内部的静态状态中，类似：

static char* saved_position;

单线程中这没有问题；但多线程中，线程 0 正在拆自己的字符串时，线程 1 也调用 strtok，就可能覆盖这个内部位置。于是线程 0 下一次调用 strtok(NULL, ...) 时，可能继续拆线程 1 的字符串。

注意：问题不在 my_line。my_line 是线程自己的局部数组，通常位于各自栈上。真正的问题是 strtok 内部隐藏了共享状态。

解决办法是使用可重入版本 strtok_r：

char* saveptr;
char* my_string;

my_string = strtok_r(my_line, " \t\n", &saveptr);
while (my_string != NULL) {
    printf("%s\n", my_string);
    my_string = strtok_r(NULL, " \t\n", &saveptr);
}

strtok_r 把“拆到哪里了”这个状态放到调用者提供的 saveptr 中。如果每个线程都有自己的 saveptr，线程之间就不会互相覆盖解析位置。

保证线程安全的常见方法：

避免共享可变状态，尽量使用局部变量或线程私有变量。
如果必须共享状态，就用互斥锁、信号量、读写锁等同步机制保护。
使用线程安全或可重入的库函数，例如用 strtok_r 替代 strtok。
检查整个代码块，包括它调用的函数；只要其中某个函数内部有未保护的共享状态，整体就可能线程不安全。

忙等待

忙等待（busy-waiting）：一个线程反复测试某个条件是否成立，在条件成立前不做其他有用工作。

例子：用共享变量 flag 控制线程进入临界区的顺序。

y = Compute(my_rank);
while (flag != my_rank);
x = x + y;
flag++;

核心理解：

while (flag != my_rank); 的循环体是空的，只是在反复检查条件。
条件不满足时，线程会一直占用 CPU 等待。
可以用来强制线程按某种顺序进入临界区，但效率通常不好。
如果编译器优化或硬件重排改变了语句顺序，可能破坏程序正确性。
它依赖共享变量可见性，实际编程中要非常谨慎。

忙等待的关键问题：轮到的线程可能没被调度

忙等待最重要的问题是：如果 flag 已经轮到某个线程，但操作系统恰好没有把 CPU 分配给这个线程，那么其他线程即使在运行，也只能卡在忙等待里空转。

假设有 2 个核心、5 个线程，并用 flag 控制线程按编号进入临界区：

while (flag != my_rank);
/* 临界区 */
flag++;

表 4.2：带有忙等待的可能事件序列。

| 时间 | flag | 线程 0 | 线程 1 | 线程 2 | 线程 3 | 线程 4 | |---:|---:|---|---|---|---|---| | 0 | 0 | 临界区 | 忙等待 | 暂停 | 暂停 | 暂停 | | 1 | 1 | 终止 | 临界区 | 暂停 | 忙等待 | 暂停 | | 2 | 2 | — | 终止 | 暂停：轮到它但没被调度 | 忙等待 | 忙等待 | | ... | 2 | — | — | 仍未调度 | 空转 | 空转 | | ? | 2 | — | — | 临界区 | 暂停 | 忙等待 |

关键点：

当 flag = 2 时，只有线程 2 能进入临界区。
如果线程 2 没有被操作系统调度，线程 3 和线程 4 即使在运行，也只能反复检查条件。
线程 3、4 不能修改 flag，所以程序没有任何有效进展。
直到操作系统重新调度线程 2，程序才会继续推进。

所以，当线程数多于核心数时，忙等待可能让 CPU 时间浪费在“不能推进程序的线程”上，性能会显著下降。

一句话对比：

| 机制 | 操作系统调度后会发生什么 | 临界区执行顺序 | |---|---|---| | 忙等待 | 随机调度到某个线程运行；如果没有选中 flag 对应的线程，被调度的线程只能空转 | 可以通过 flag 人为规定顺序 | | 互斥量 | 等待锁的线程会被阻塞，操作系统不会让它们一直空转；能获得锁的线程运行后可以推进程序 | 不能确定顺序，由操作系统和锁竞争结果决定 |

因此：

忙等待虽然浪费 CPU，但可以用 flag 强行规定线程进入临界区的顺序。
互斥量不浪费 CPU 空转，但不保证哪个线程先进入临界区。
当线程数多于核心数时，忙等待最怕“轮到的线程没有被调度”，因为其他线程运行也无法推进。

互斥锁与忙等待的性能对比

互斥锁和忙等待都可以用来保护临界区，但行为不同。

互斥锁的特点：

第一个成功调用 pthread_mutex_lock 的线程会先进入临界区。
后续哪个线程获得锁由系统调度决定，Pthreads 不保证按调用顺序获得锁。
有限数量的线程尝试获取锁时，最终都会有机会获得锁。
等待锁的线程通常会被阻塞，不会像忙等待那样持续占用 CPU。

忙等待的特点：

线程会反复检查条件。
当线程数不超过核心数时，忙等待和互斥锁版本的运行时间可能接近。
当线程数超过核心数时，忙等待线程会占用核心空转，影响真正能进入临界区的线程运行，性能会明显下降。

如果线程数不超过核心数，理想情况下加速比可以接近线程数：

T_serial / T_parallel ≈ thread_count

也就是达到近似线性加速。

表 4.1：在两个四核处理器系统上，使用 n = 10^8 项的 π 程序运行时间，单位为秒。

| 线程数 | 忙等待版本 | 互斥锁版本 | |---:|---:|---:| | 1 | 2.90 | 2.90 | | 2 | 1.45 | 1.45 | | 4 | 0.73 | 0.73 | | 8 | 0.38 | 0.38 | | 16 | 0.50 | 0.38 | | 32 | 0.80 | 0.40 | | 64 | 3.56 | 0.38 |

结论：

在线程数 <= 8 时，两种方法差异不明显。
线程数超过核心数后，忙等待版本变慢。
互斥锁版本更稳定，因为等待线程不会一直占用 CPU。

4.6 矩阵-向量乘法

问题

给定矩阵 A[m][n] 和向量 x[n]，计算结果向量 y[m]：

y[i] = A[i][0] * x[0] + A[i][1] * x[1] + ... + A[i][n-1] * x[n-1]

并行思路：按行划分

矩阵-向量乘法适合按行划分：

每个线程负责若干行。
线程只写自己负责的 y[i]。
A 和 x 对所有线程共享，只读。
y 是共享数组，但不同线程写不同位置。

因此，如果划分得当，通常不需要对 y[i] 加锁。

示意：

线程 0：计算 y[0 .. local_m-1]
线程 1：计算 y[local_m .. 2*local_m-1]
线程 2：计算 y[2*local_m .. 3*local_m-1]
...

线程函数大致如下：

void* Pth_mat_vect(void* rank) {
    long my_rank = (long) rank;
    int local_m = m / thread_count;
    int my_first_row = my_rank * local_m;
    int my_last_row = (my_rank + 1) * local_m - 1;

    for (int i = my_first_row; i <= my_last_row; i++) {
        y[i] = 0.0;
        for (int j = 0; j < n; j++) {
            y[i] += A[i][j] * x[j];
        }
    }

    return NULL;
}

为什么没有数据竞争

在这种按行划分中：

A：所有线程只读。
x：所有线程只读。
y[i]：每个元素只由一个线程写。

所以线程之间不会同时写同一个 y[i]，一般不会产生写写冲突。

伪共享风险

虽然不同线程写的是不同的 y[i]，但仍然可能发生伪共享。原因是 CPU 缓存按缓存行工作，而不是按单个变量工作。

如果一个缓存行是 64 字节，一个 double 是 8 字节，那么一个缓存行可以放：

64 / 8 = 8 个 double

也就是说，y[0] 到 y[7] 很可能在同一个 cache line 里。不同线程写不同的 y[i]，逻辑上没有写同一个变量，但硬件缓存一致性协议会把整条 cache line 当成同步单位。

结果：

程序结果通常仍然正确。
但 cache line 会在多个核心之间反复失效和重新获取，性能可能明显下降。

同样运算量不代表同样快

矩阵-向量乘法的一个重要现象是：算术运算次数相同，不代表运行时间和并行效率相同。

例如下面三种矩阵规模：

8,000,000 x 8
8,000 x 8,000
8 x 8,000,000

它们都有：

m * n = 64,000,000

所以内层乘加次数一样。按纯算法复杂度看，它们应该差不多；但实际运行时间可能差很多，原因主要是缓存行为不同。

这段代码的核心访问模式是：

for (int i = my_first_row; i <= my_last_row; i++) {
    y[i] = 0.0;                  /* 写 y */
    for (int j = 0; j < n; j++) {
        y[i] += A[i][j] * x[j];  /* 读 A，读 x，读写 y */
    }
}

这里有两个重要概念：

| 概念 | 含义 | |---|---| | 写缺失（write miss） | 写 y[i] 时，包含 y[i] 的 cache line 不在当前核心缓存里 | | 读缺失（read miss） | 读 x[j] 时，包含 x[j] 的 cache line 不在当前核心缓存里 |

注意：CPU 不是只搬一个 double，而是把包含该元素的整条 cache line 搬进缓存。

情况一：`8,000,000 x 8`，主要问题是 `y` 的写缺失

矩阵形状是：

A: 8M x 8
x: 8 x 1
y: 8M x 1

x 只有 8 个元素，很容易长期留在 cache 中。但 y 有 800 万个元素，每算一行就要写一个新的 y[i]。

如果 y[i] 所在的 cache line 不在当前核心缓存里，CPU 要先把这一整条 cache line 读进来，再修改它。这就是写缺失，也常叫写分配缺失。

直观理解：

y 太长，每次写到新的 y 位置，缓存里往往还没有这块数据，
于是频繁发生 y 的写缺失。

情况二：`8 x 8,000,000`，主要问题是 `x` 的读缺失，同时 `y` 可能伪共享

矩阵形状是：

A: 8 x 8M
x: 8M x 1
y: 8 x 1

这时 y 很短，但每一行都要扫完整个 x：

for (int j = 0; j < n; j++) {
    y[i] += A[i][j] * x[j];
}

x 有 800 万个元素，远远大于 cache。访问 x[j] 时，经常发现对应 cache line 不在缓存里，于是发生大量读缺失。

直观理解：

x 太长，每次读 x[j] 都可能要从内存重新搬一条 cache line，
于是频繁发生 x 的读缺失。

这个形状还有一个并行性能问题：y 只有 8 个元素，多个线程很容易写入同一条 cache line。

对于 8 x 8,000,000，m = 8。如果用 4 个线程：

线程 0：y[0], y[1]
线程 1：y[2], y[3]
线程 2：y[4], y[5]
线程 3：y[6], y[7]

假设 y[0] 从一个缓存行开头开始，那么一个缓存行正好容纳 8 个 double：

| 同一个 cache line（64B） | | | | | | | | |---|---|---|---|---|---|---|---| | y[0] | y[1] | y[2] | y[3] | y[4] | y[5] | y[6] | y[7] | | 线程 0 写 | 线程 0 写 | 线程 1 写 | 线程 1 写 | 线程 2 写 | 线程 2 写 | 线程 3 写 | 线程 3 写 |

缓存一致性看到的是整条 cache line，而不是单个 y[i]：

线程 0 写 y[0] 或 y[1]  -> 其他核心中这整条 cache line 失效
线程 1 写 y[2] 或 y[3]  -> 线程 0 所在核心中的同一条 cache line 又失效
线程 2 / 线程 3 写入    -> 继续让这条 cache line 在核心之间来回抢占

逻辑上每个线程写不同的 y[i]，没有普通数据竞争；但这些 y[i] 可能都在同一个缓存行里。一个线程写入时，会让其他核心缓存中的整行失效，这就是伪共享。

更严重的是，原始写法会在内层循环中反复写 y[i]：

y[i] += A[i][j] * x[j];

如果 n = 8,000,000，每个 y[i] 会被更新 800 万次，伪共享会被放大。

所以 8 x 8,000,000 的性能差，通常有两层原因：

x 很长，导致大量读缺失。
y 很短，多个线程写的 y[i] 可能挤在同一条 cache line 中，导致伪共享。

情况三：`8,000 x 8,000`，缓存压力更均衡

矩阵形状是：

A: 8K x 8K
x: 8K x 1
y: 8K x 1

它的总运算量同样是 64,000,000，但 x 和 y 都没有达到 800 万那么极端。

因此：

x 没有特别长，读缺失相对少一些。
y 也没有特别长，写缺失相对少一些。
不同线程写 y 的区间较大，伪共享通常只可能出现在分界处附近。

所以它虽然算术运算量一样，但缓存表现更平衡，实际运行时间可能更好。

改进思路

更好的写法是先用线程私有变量累加，最后只写一次共享数组：

double temp = 0.0;

for (int j = 0; j < n; j++) {
    temp += A[i][j] * x[j];
}

y[i] = temp;

这样可以减少对 y[i] 的反复写入，也能明显降低伪共享的影响。

一句话记忆：

8M x 8：y 很长，主要是写缺失。
8 x 8M：x 很长，主要是读缺失；y 很短，还可能伪共享。
8K x 8K：x、y 都没那么极端，缓存表现更平衡。

核心结论：共享内存程序中，线程即使写不同变量，也可能因为这些变量位于同一个缓存行而互相拖慢；这个问题从算法复杂度里看不出来，必须结合缓存行、内存布局和线程划分分析。

第 5 章使用 OpenMP 进行共享内存编程

5.1 OpenMP 概述

本章重点：

如何创建线程。
如何隐式创建线程。
如何使用 schedule 调度循环迭代。
如何用 OpenMP 修饰原本已有的 for 循环。
如何通过调度实现负载均衡。
OpenMP 变量的作用域规则。

OpenMP 是什么

OpenMP 是用于共享内存并行编程的 API。它和 Pthreads 一样面向共享内存系统，但编程方式更高层。

核心区别：

Pthreads：程序员显式创建线程，并明确指定每个线程要执行什么。
OpenMP：程序员通常只需要声明某个代码块可以并行执行；具体任务如何分配、哪个线程执行哪部分，主要交给编译器和运行时系统。

也就是说：

Pthreads：手动管理线程。
OpenMP：标注哪里可以并行，剩下交给编译器和运行时。

OpenMP 的抽象层次更高，甚至可以看作是为了把已有串行程序逐步改造成并行程序而设计的。

OpenMP 和 Pthreads 的区别

| 对比项 | Pthreads | OpenMP | |---|---|---| | 编程方式 | 显式线程编程 | 通过编译指令声明并行区域 | | 线程行为 | 程序员明确写出每个线程做什么 | 编译器和运行时决定任务如何分配 | | 代码形式 | 调用线程库函数，如 pthread_create | 使用编译指令，如 #pragma omp parallel | | 抽象层次 | 更底层，控制更细 | 更高层，代码更简洁 | | 编译要求 | 只要能链接 Pthreads 库，普通 C 编译器一般即可 | 需要编译器支持 OpenMP | | 适合场景 | 需要精细控制线程行为 | 循环并行、规则任务划分、快速并行化 |

5.2 第一个 OpenMP 程序

`parallel` 基本块

OpenMP 的编译指令总是以 #pragma omp 开始。最基本的并行指令是：

#pragma omp parallel

OpenMP 中最基本的并行结构是：

#pragma omp parallel
{
    /* 多个线程都会执行这里的代码 */
}

如果使用 num_threads(thread_count)，就可以指定并行区域中要创建多少个线程：

#pragma omp parallel num_threads(thread_count)
Hello();

这里的意思是：创建 thread_count 个线程，并让每个线程都执行一次 Hello()。

如果不写 num_threads，线程数通常由 OpenMP 运行时系统决定，常见情况是按机器上的核心数来设置。

程序运行到 `parallel` 时发生什么

在 parallel 指令之前，程序只有一个线程在执行，也就是程序启动时的原始线程。

当程序运行到 #pragma omp parallel 时：

原来的线程继续执行。
OpenMP 额外启动 thread_count - 1 个线程。
原始线程和新启动的线程组成一个线程组。
线程组中的每个线程都会执行 parallel 后面的代码块。
并行代码块结束处==有一个隐式 barrier==。
所有线程都完成该代码块后，新启动的线程终止，原始线程继续执行后面的串行代码。

OpenMP 常见线程术语：

| 术语 | 含义 | |---|---| | 主线程 | 程序开始时的第一个执行线程，编号通常是 0 | | 父线程 | 遇到 parallel 指令并启动一组线程的线程；很多情况下就是主线程 | | 子线程 | 由父线程启动的额外线程 | | 线程组 | 执行同一个 parallel 代码块的一组线程 |

可以把 parallel 理解成：

串行代码
    |
    | 遇到 #pragma omp parallel
    v
创建线程组：线程 0, 线程 1, ..., 线程 p-1
    |
所有线程执行同一个并行代码块
    |
隐式 barrier：所有线程都到达后才能继续
    |
子线程结束，主线程继续执行后面的串行代码

这比 Pthreads 更高层：Pthreads 中通常需要手动保存每个线程的数据结构、用循环创建线程、再用循环等待线程结束；OpenMP 把这些线程创建和回收细节隐藏在 parallel 指令背后。

Hello World 示例

#include <stdio.h>
#include <stdlib.h>
#include <omp.h>

void Hello(void);

int main(int argc, char* argv[]) {
    int thread_count = strtol(argv[1], NULL, 10);

    #pragma omp parallel num_threads(thread_count)
    Hello();

    return 0;
}

void Hello(void) {
    int my_rank = omp_get_thread_num();
    int thread_count = omp_get_num_threads();

    printf("Hello from thread %d of %d\n", my_rank, thread_count);
}

几个重要函数：

| 函数 | 含义 | |---|---| | omp_get_thread_num() | 返回当前线程在线程组中的编号 | | omp_get_num_threads() | 返回当前并行区域中的线程总数 |

输出顺序不确定

编译和运行：

gcc -fopenmp hello.c -o hello
./hello 4

可能输出：

Hello from thread 0 of 4
Hello from thread 1 of 4
Hello from thread 2 of 4
Hello from thread 3 of 4

也可能输出：

Hello from thread 3 of 4
Hello from thread 1 of 4
Hello from thread 2 of 4
Hello from thread 0 of 4

原因：多个线程并行执行，哪个线程先运行到 printf 是不确定的。

编译支持

Pthreads 本质上是一个函数库，可以链接到 C 程序中。因此只要系统有 Pthreads 库，普通 C 编译器通常就可以编译 Pthreads 程序。

OpenMP 不只是普通函数库调用，它依赖编译器识别和处理 #pragma omp ... 这类编译指令。因此，如果 C 编译器不支持 OpenMP，就可能无法把 OpenMP 程序编译成真正的并行程序。

#pragma 是 C/C++ 的预处理器指令，用来给编译器提供“建议”或“指示”。如果编译器完全不认识某个 #pragma，通常会忽略它而不是报错；但是如果程序调用了 omp_get_thread_num() 这类 OpenMP 函数，仍然需要 OpenMP 头文件和运行时库支持。

5.3 OpenMP 的变量作用域

在 #pragma omp parallel 中，变量作用域非常重要。

基本规则：

在并行基本块外声明的变量，默认是共享变量。
在并行基本块内声明的变量，默认是私有变量。

例如：

int x = 0;  /* 默认共享 */

#pragma omp parallel
{
    int my_rank = omp_get_thread_num();  /* 每个线程各有一份 */
    x += my_rank;                        /* 多个线程共享同一个 x */
}

注意：共享变量如果被多个线程同时更新，仍然可能产生竞争条件。OpenMP 虽然比 Pthreads 写法更简单，但它仍然是共享内存并行，线程安全问题不会自动消失。

5.4 `schedule` 子句

`schedule` 用来做什么

schedule 子句用于控制 parallel for 中循环迭代如何分配给线程。

如果不显式写 schedule，OpenMP 会使用默认调度方式。想指定循环调度方式，可以在 parallel for 指令中加入 schedule 子句。

没有显式调度：

sum = 0.0;

#pragma omp parallel for num_threads(thread_count) \
    reduction(+:sum)
for (int i = 0; i <= n; i++) {
    sum += f(i);
}

加入 schedule：

sum = 0.0;

#pragma omp parallel for num_threads(thread_count) \
    reduction(+:sum) schedule(static, 1)
for (int i = 0; i <= n; i++) {
    sum += f(i);
}

这里 schedule(static, 1) 表示：采用静态调度，并且每个迭代块的大小是 1。

基本形式

schedule(<type>[, <chunksize>])

其中：

type 表示调度方式。
chunksize 表示每个迭代块中包含多少次连续迭代。

在 OpenMP 中，一个迭代块（chunk）指的是从串行 for 循环的迭代编号空间里切出来的一段连续编号区间。块大小就是这个区间中包含的迭代次数。

常见调度类型

| 类型 | 分配时机 | 核心含义 | 适合场景 | |---|---|---|---| | static | 循环开始前 | 先把迭代分好，再交给各线程 | 每次迭代工作量差不多 | | dynamic | 循环运行时 | 线程完成当前块后，再向运行时系统请求新块 | 每次迭代工作量不均匀 | | guided | 循环运行时 | 类似动态调度，但块大小通常逐渐变小 | 工作量不均匀，同时想减少调度开销 | | auto | 编译器或运行时决定 | 调度方式交给系统选择 | 不想手动指定策略 | | runtime | 运行时决定 | 根据环境变量决定调度方式 | 想运行时切换调度策略 |

只有 static、dynamic 和 guided 可以显式指定 chunksize。

`static` 调度类型

static 调度会在循环开始前把迭代块分配给线程。分配完成后，循环运行期间不再动态调整。

假设有 12 个迭代，编号为 0 到 11，并且有 3 个线程。

使用 schedule(static, 1)：

schedule(static, 1)

线程 0：0, 3, 6, 9
线程 1：1, 4, 7, 10
线程 2：2, 5, 8, 11

因为块大小是 1，所以每个 chunk 只有 1 次迭代，然后按轮流方式分给线程。

使用 schedule(static, 2)：

线程 0：0, 1, 6, 7
线程 1：2, 3, 8, 9
线程 2：4, 5, 10, 11

使用 schedule(static, 4)：

线程 0：0, 1, 2, 3
线程 1：4, 5, 6, 7
线程 2：8, 9, 10, 11

如果省略 chunk size，默认调度由具体 OpenMP 实现决定；大多数情况下近似于：

schedule(static, total_iterations / thread_count)

也就是每个线程拿到一段较大的连续迭代范围。

static 的优点是调度开销小。如果每次迭代的工作量差不多，它通常是不错的选择。它还有一个好处：后续循环如果使用相同迭代次数，线程通常会被分配到相同范围，这对缓存局部性和 NUMA 系统可能有帮助。

调度图的正确读法

这张图主要画的是：哪些串行迭代编号被分配给哪个线程。

需要注意：

图中的横向位置表示串行循环的迭代编号，例如 0, 1, 2, ...，不是实际时间轴。
chunk 是按“串行循环的迭代编号空间”切出来的连续区间。
图没有体现真实执行时多个线程同时运行的并行性。
dynamic 和 guided 的具体分配会受运行时调度影响，所以图中只是可能的调度结果之一。

例如 schedule(static, 2) 中，一个 chunk 可以是：

迭代 0, 1
迭代 2, 3
迭代 4, 5
...

这些 chunk 会被分配给不同线程。图画的是“编号区间归属”，不是“哪个线程在某个时间点正在执行”。

`dynamic` 调度类型

dynamic 调度会把迭代分解成固定大小的连续 chunk，但这些 chunk 不会在循环开始前全部固定分给线程。

执行过程是：

线程完成一个 chunk -> 向运行时系统请求下一个 chunk -> 直到所有迭代完成

例如：

#pragma omp parallel for schedule(dynamic, 2)
for (int i = 0; i < n; i++) {
    work(i);
}

这里每个线程每次领取 2 个连续迭代。哪个线程先完成，就先领取下一个 chunk。

如果省略 chunk size：

#pragma omp parallel for schedule(dynamic)

默认 chunk size 通常为 1。

static 和 dynamic 的关键区别：

static：循环开始前就固定分配。
dynamic：运行时先到先得地领取 chunk。

dynamic 适合每次迭代耗时不一致的循环。例如后面的迭代计算量更大时，先完成的线程可以继续领取任务，负载更均衡。

代价是：每次领取 chunk 都要和运行时系统交互，所以会产生调度开销。增大 chunk size 可以减少领取次数，在负载均衡和调度开销之间折中。

`guided` 调度类型

guided 和 dynamic 类似，也是线程完成一个 chunk 后，再向运行时系统请求下一个 chunk。

区别在于 chunk 大小：

dynamic, 2：每次都领 2 个迭代
guided, 2：一开始领大块，后面逐渐变小，最小通常不低于 2

guided 的直观理解：

刚开始剩余任务多 -> 分配较大的 chunk，减少调度次数
后面剩余任务少 -> 分配较小的 chunk，方便线程平均收尾

例如：

#pragma omp parallel for schedule(guided, 2)
for (int i = 0; i < 100; i++) {
    work(i);
}

可能的分配趋势：

前期：0-24, 25-43, 44-57, ...
中期：69-76, 77-82, 83-87, ...
后期：88-89, 90-91, 92-93, ...

这里的 2 是最小 chunk size。后面 chunk 会越来越小，但通常不会小于 2，最后剩余不足时除外。

guided 适合这种情况：每个迭代耗时不完全一样，但又不想像 dynamic, 1 那样产生太多调度开销。

三种调度的记忆方式

static：提前固定分。
dynamic：运行时按固定小块抢任务。
guided：运行时抢任务，但块大小从大到小。

一句话总结：schedule 控制的是“循环迭代怎么分给线程”。如果每次迭代工作量接近，static 通常开销小；如果工作量不均匀，dynamic 或 guided 更容易负载均衡，其中 guided 试图在动态负载均衡和调度开销之间折中。

5.5 OpenMP 同步：`atomic`、`critical` 和锁

`atomic` 指令

如果只是保护==一个共享变量==的单一更新操作，可以使用：

#pragma omp atomic
x += 1;

atomic 比 critical 更窄，只能保护紧接着的一条特定 C 语句，通常用于对一个共享变量进行简单更新。

可以使用 atomic 的例子：

#pragma omp atomic
x += 1;

#pragma omp atomic
x++;

#pragma omp atomic
x = y;      /* 原子写 */

#pragma omp atomic
x *= 2;

不适合使用 atomic 的例子：

#pragma omp atomic
x += y++;   /* 同时修改 x 和 y，不是单一共享变量更新 */

一句话记忆：

atomic：保护一个共享变量的一次简单更新。
critical：保护一整段临界区代码。

`critical` 临界区

如果要保护一段代码，可以使用 critical：

#pragma omp critical
{
    /* 临界区代码 */
}

默认情况下，所有没有名字的 critical 区域共享同一把全局锁。也就是说，任何线程都不能同时执行任意一个未命名的 critical 区域，即使这些区域保护的是完全无关的数据。

如果不同临界区保护的是不同资源，可以给临界区命名：

#pragma omp critical(queue0)
{
    /* 只和 queue0 这个名字对应的临界区互斥 */
}

这样 OpenMP 只会对同名的 critical(queue0) 加锁，不同名字的临界区可以并行执行。

OpenMP 锁函数

OpenMP 也提供显式锁函数：

omp_init_lock(&lock);
omp_set_lock(&lock);
omp_unset_lock(&lock);
omp_test_lock(&lock);

含义：

| 函数 | 含义 | |---|---| | omp_init_lock | 初始化锁 | | omp_set_lock | 获取锁；如果锁不可用就等待 | | omp_unset_lock | 释放锁 | | omp_test_lock | 尝试获取锁；不一定阻塞 |

显式锁更灵活，但也更容易写出死锁。简单场景下，优先考虑 critical 或 atomic。

嵌套 `critical` 和死锁

如果嵌套使用未命名 critical，可能死锁：

#pragma omp critical
{
    /* 临界区 A */

    #pragma omp critical
    {
        /* 临界区 B */
    }
}

原因：外层已经拿到默认 critical 的全局锁，内层又试图获取同一把锁，线程会卡在自己已经持有的锁上。

给临界区命名也不能完全避免死锁。如果两个线程按相反顺序获取两把不同的锁，也可能互相等待：

#pragma omp critical(one)
{
    #pragma omp critical(two)
    {
        /* 线程 u：先 one 后 two */
    }
}

#pragma omp critical(two)
{
    #pragma omp critical(one)
    {
        /* 线程 v：先 two 后 one */
    }
}

可能发生：

| 时间 | 线程 u | 线程 v | |---|---|---| | 0 | 进入临界区 one | 进入临界区 two | | 1 | 等待临界区 two | 等待临界区 one | | 2 | 阻塞 | 阻塞 |

这就是死锁。

`atomic` 和 `critical` 的区别

| 对比项 | atomic | critical | |---|---|---| | 保护范围 | 一条简单更新语句 | 一段代码块 | | 适合场景 | x++、x += value 这类单变量更新 | 多条语句、复杂数据结构更新 | | 开销 | 通常更小 | 通常更大 | | 灵活性 | 较低 | 较高 | | 是否能替代锁 | 只能替代很简单的锁场景 | 更接近互斥锁 |

如果临界区只有特定的赋值或更新语句，优先考虑 atomic。如果不能用 atomic 表达，再使用 critical。

注意：atomic 和 critical 不是同一把锁。下面代码的输出仍然是不确定的：

#pragma omp atomic
x += 1;

#pragma omp critical
x = 1;

原因：atomic 只保证自己的原子更新，critical 只保证进入临界区的互斥；它们之间没有自动建立同一个互斥关系。

一句话总结：OpenMP 的核心思想是“用编译指令标注并行结构”，比 Pthreads 更高层；但只要多个线程访问共享变量，仍然需要考虑作用域、调度和同步。简单单变量更新用 atomic，复杂临界区用 critical 或显式锁。

WSL2 外设与多媒体配置笔记

Tue, 16 Jun 2026 00:00:00 GMT

这篇文章由 WSL2 相关笔记合并整理而来，主要覆盖 USB 设备转发、摄像头视频流测试，以及 WSLg 下的音频重定向配置。

usb通信

Windows 安装 usbipd

winget install usbipd

连接 USB 设备

在附加 USB 设备之前，请确保 WSL 命令行处于打开状态。这会使 WSL 2 轻型 VM 保持运行。

备注

此文档假定已安装 usbipd-win 4.0.0 或更高版本

通过以 管理员 模式打开 PowerShell 并输入以下命令列出连接到 Windows 的所有 USB 设备。列出设备后，选择并复制要附加到 WSL 的设备总线 ID。

usbipd list

在附加 USB 设备之前，必须使用该命令 usbipd bind 来共享设备，从而允许它附加到 WSL。这需要管理员权限。选择要在 WSL 中使用的设备的总线 ID，然后运行以下命令。运行命令后，请再次使用命令 usbipd list 验证设备是否共享。

usbipd bind --busid 4-4

若要附加 USB 设备，请运行以下命令。（不再需要使用提升的管理员提示。确保 WSL 命令提示符处于打开状态，以使 WSL 2 轻型 VM 保持活动状态。请注意，只要 USB 设备连接到 WSL，Windows 将无法使用它。一旦连接到 WSL，任何在 WSL 2 上运行的发行版都可以使用该 USB 设备。请确认设备是否已连接 usbipd list。在 WSL 提示符下，运行 lsusb 以验证 USB 设备是否已列出，并且可以使用 Linux 工具与之交互。

usbipd attach --wsl --busid <busid>

打开 Ubuntu（或首选 WSL 命令行），并使用以下命令列出附加的 USB 设备：

lsusb

应会看到刚刚附加的设备，并且能够使用普通 Linux 工具与之交互。根据应用程序，可能需要配置 udev 规则，以允许非根用户访问设备。

在 WSL 中使用设备后，可以物理断开 USB 设备的连接，或者从 PowerShell 运行以下命令：

usbipd detach --busid <busid>

原理

总体架构概述

usbipd（USB/IP Device Manager）的实现基于 客户端-服务器架构 和 网络化的设备共享 理念。其核心原理可以概括为：

将 Windows 主机上的物理 USB 设备通过网络协议"导出"，然后由 WSL 2 内的 Linux 内核通过 USB/IP 客户端协议"导入"并识别为本地设备。

技术原理分层解析

1. USB/IP 协议基础

USB/IP 是一个开源项目，其核心思想是将 USB 协议封装在 TCP/IP 协议中传输：

物理USB设备 → USB协议数据 → TCP/IP封装 → 网络传输 → TCP/IP解封装 → 虚拟USB设备

2. Windows 端（服务器端）工作原理

a. 设备识别与绑定

# 在Windows PowerShell中
usbipd list
# 输出显示所有可用USB设备及其BUSID

原理：usbipd 通过 Windows Driver Kit (WDK) 接口枚举系统上的 USB 设备，获取每个设备的详细信息。

b. 设备共享（绑定）

usbipd bind --busid <BUSID>

底层操作：

创建虚拟 USB 控制器：为指定设备创建虚拟的 USB 主机控制器
协议封装：将 USB 请求块 (URB) 序列化为 USB/IP 协议格式
网络服务启动：在指定端口 (3240) 监听连接请求

c. 网络传输层

协议：TCP/IP
端口：默认 3240
数据格式：自定义的 USB/IP 协议头 + USB 数据载荷

3. WSL 2 端（客户端）工作原理

a. USB/IP 客户端驱动

WSL 2 内核已经编译了 usbip-host 驱动模块：

# 在WSL2中检查驱动
lsmod | grep usbip
modprobe usbip-host    # 加载驱动

b. 设备附加流程

# 连接到Windows主机并附加设备
usbip attach -r <Windows-IP> -b <BUSID>

详细过程：

TCP 连接建立：连接到 Windows 主机的 3240 端口
设备枚举：获取可用的共享设备列表
驱动绑定：将远程设备绑定到本地虚拟 USB 端口
设备节点创建：在 /dev/ 下创建相应的设备文件

4. 数据传输流程

请求路径（WSL 2 → Windows）

应用程序 → Linux USB子系统 → usbip-host驱动 → TCP socket → 网络 → 
Windows TCP栈 → usbipd服务 → 解析USB/IP协议 → 原生USB API调用 → 物理设备

响应路径（Windows → WSL 2）

物理设备响应 → 原生USB API → usbipd服务 → USB/IP协议封装 → 网络传输 → 
WSL2 TCP栈 → usbip-host驱动 → 协议解析 → Linux USB子系统 → 应用程序

5. 内核层面的交互

Windows 内核层面：

usbipd. Sys：内核模式驱动程序，处理实际的 USB 通信
用户模式服务：管理连接和设备状态
与原生 USB 栈交互：通过标准的 Windows USB 驱动程序接口

Linux 内核层面（WSL 2）：

usbip-core. Ko：核心协议处理模块
usbip-host. Ko：客户端功能实现
虚拟 USB 主机控制器：模拟本地 USB 硬件

6. 网络通信细节

协议数据包结构：

struct usbip_header {
    uint32_t command;        // 命令类型
    uint32_t seqnum;         // 序列号
    uint32_t devid;          // 设备ID
    uint32_t direction;      // 数据传输方向
    uint32_t ep;             // 端点号
    // ... 其他字段
    uint32_t transfer_buffer_length; // 数据长度
    // 实际USB数据跟随在后
};

主要命令类型：

USBIP_CMD_SUBMIT：提交 USB 请求
USBIP_CMD_UNLINK：取消请求
USBIP_RET_SUBMIT：请求完成响应

7. 性能考量与优化

延迟处理：

批量传输缓冲：对批量传输进行缓冲以减少小包开销
等时传输优化：对音频、视频等实时设备特殊处理
零拷贝技术：在可能的情况下避免数据复制

带宽管理：

TCP 拥塞控制：依赖 TCP 的流量控制机制
服务质量 (QoS)：优先处理实时设备数据

8. 安全性机制

连接认证：

# 基于IP地址的访问控制
usbipd bind --busid <BUSID> --allowed-principals <IP-address>

数据传输安全：

本地回环网络：默认使用 127.0.0.1，不暴露到外部网络
无加密：USB/IP 协议本身不加密，但在本地环境下可接受

9. 设备类型支持差异

良好支持的设备：

USB 存储设备（U 盘、移动硬盘）
USB 串口设备
USB 网络适配器
HID 设备（键盘、鼠标）

有限支持的设备：

等时传输设备：摄像头、音频设备（有延迟问题）
高速设备：USB 3.0+设备可能受网络带宽限制
特殊功能设备：需要特定驱动程序的设备

10. 与 WSLg 的协同工作

当同时使用 USBIP 和 WSLg 时：

物理USB设备 → usbipd (Windows) → USB/IP协议 → WSL2 usbip-client → 
Linux设备节点 → 应用程序 → WSLg音频重定向 → Windows音频输出

这种架构允许某些设备通过 USB/IP 直接访问，而其他设备（如音频）通过 WSLg 重定向。

视频流

1. Share 端口

用连接 USB 设备这里的方法，将摄像头先 share，再 attach 到 wsl 中

2. 设置环境变量

由于 X11 共享内存（MIT-SHM）扩展权限问题导致的。wsl和windows宿主机共享了x11内存，导致wsl无法直接使用摄像头

export XLIB_SKIP_ARGB_VISUALS=1
export LIBGL_ALWAYS_INDIRECT=0
# guvcview # 测试摄像头的录制软件

3. 测试代码

import cv2
import time

def display_camera_feed():
    """
    优化的摄像头实时显示，解决卡顿问题
    按 'q' 键退出程序
    """
    # 打开默认摄像头
    cap = cv2.VideoCapture(0, cv2.CAP_V4L2)
    
    # 检查摄像头是否成功打开
    if not cap.isOpened():
        print("错误：无法打开摄像头")
        return
    
    # 关键优化：设置缓冲区大小为1，避免帧积压
    cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
    
    # 设置视频格式和参数
    cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'))
    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
    cap.set(cv2.CAP_PROP_FPS, 30)
    
    print("摄像头初始化中...")
    time.sleep(1)
    print("摄像头已打开，按 'q' 键退出")
    
    while True:
        # 读取帧
        ret, frame = cap.read()
        
        if not ret or frame is None:
            print("警告：无法读取帧，跳过此帧")
            continue
        
        # 关键优化：清空缓冲区，确保获取最新帧
        cap.grab()
        
        # 显示图像
        cv2.imshow('Camera Feed', frame)
        
        # 关键优化：使用更短的等待时间
        if cv2.waitKey(1) & 0xFF  ord('q'):
            break
    
    # 清理资源
    cap.release()
    cv2.destroyAllWindows()

def display_camera_feed_alternative():
    """
    备选方案：使用线程读取帧，进一步优化性能
    """
    import threading
    from queue import Queue
    
    # 帧队列
    frame_queue = Queue(maxsize=2)
    stop_event = threading.Event()
    
    def capture_frames():
        cap = cv2.VideoCapture(0, cv2.CAP_V4L2)
        cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
        cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'))
        cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
        cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
        cap.set(cv2.CAP_PROP_FPS, 30)
        
        while not stop_event.is_set():
            ret, frame = cap.read()
            if ret and frame is not None:
                # 如果队列满了，丢弃旧帧
                if frame_queue.full():
                    try:
                        frame_queue.get_nowait()
                    except:
                        pass
                frame_queue.put(frame)
        
        cap.release()
    
    # 启动捕获线程
    capture_thread = threading.Thread(target=capture_frames)
    capture_thread.start()
    
    print("摄像头已启动（线程版本），按 'q' 键退出")
    
    try:
        while True:
            if not frame_queue.empty():
                frame = frame_queue.get()
                cv2.imshow('Camera Feed (Threaded)', frame)
            
            if cv2.waitKey(1) & 0xFF  ord('q'):
                break
    finally:
        stop_event.set()
        capture_thread.join()
        cv2.destroyAllWindows()

if __name__  "__main__":
    display_camera_feed()
	# display_camera_feed_alternative() # 备选方案

即可看到视频画面了

音频重定向

使用WSLg的音频重定向
较新版本的WSL2引入了WSLg，它提供了音频重定向功能，无需额外配置即可使用Windows的音频设备：

确保WSL2版本足够新：

 wsl --version

如果版本低于1.0.0，请更新WSL2：

# 在Windows PowerShell中运行   
wsl --update

安装必要的音频工具：

sudo apt-get update

sudo apt-get install -y pulseaudio alsa-utils

配置PulseAudio使用WSLg的音频服务：

# 创建或编辑PulseAudio配置文件
mkdir -p ~/.config/pulse
echo "default-server = unix:/mnt/wslg/PulseServer" > ~/.config/pulse/client.conf

测试音频重定向：

# 安装一个简单的音频测试工具
sudo apt-get install -y sox 
# 测试录音
rec test.wav

之后应该就可以正常的在WSL2当中使用麦克风设备了

然后播放

play test.wav

ROS 2 基础与常用开发笔记

Tue, 16 Jun 2026 00:00:00 GMT

这篇文章由 ROS 学习笔记合并整理而来，按基础概念、常用命令、工作空间、节点通信机制、DDS、Launch、坐标系管理和 URDF 的顺序组织。

1. 什么是ROS

机器人界的 Android

1 和 2 的区别

架构

ROS 1 的架构下，所有节点需要使用 Master 进行管理 ROS 2 使用基于 DDS 的 Discovery 机制，和 Master 说拜拜

DDS 协议：数据分发服务

以数据为中心

接口

重设 api

编译器

新的编译系统 ament colcon

2. ROS CMD

1. 核心概念与帮助

在任何命令后加上 -h 或 --help 可以查看详细帮助。

ros2 -h
ros2 run -h
ros2 node list -h

2. 节点 (Node) 相关命令

节点是 ros2 中可执行的进程。

3. 话题 (Topic) 相关命令

话题是节点间发布/订阅的异步通信机制。

4. 服务 (Service) 相关命令

服务是节点间请求/响应的同步通信机制。

示例：调用服务

# 调用 /spawn 服务，生成第二个乌龟
ros2 service call /spawn turtlesim/srv/Spawn '{x: 5.5, y: 9.0, theta: 1.57, name: "turtle2"}'

5. 参数 (Parameter) 相关命令

参数是节点的配置值，可以在运行时动态修改。

示例：参数操作

# 列出 /turtlesim 节点的所有参数
ros2 param list /turtlesim

# 设置背景颜色的红色通道值
ros2 param set /turtlesim background_r 150

# 将所有参数导出到当前目录的 turtlesim. Yaml 文件
ros2 param dump /turtlesim > turtlesim. Yaml

6. 动作 (Action) 相关命令

动作是长时间运行、可抢占、带有反馈的任务通信机制。

示例：发送动作目标

# 让乌龟旋转 360 度，并显示反馈信息
ros2 action send_goal /turtle 1/rotate_absolute turtlesim/action/RotateAbsolute "theta: 6.28" --feedback

7. 功能包 (Package) 和构建 (Build) 相关命令

| 命令 | 描述 | 常用选项 | | :--- | :--- | :--- | | ros2 pkg list | 列出所有已安装的功能包 | | | ros2 pkg create <pkg_name> | 创建一个新的功能包 | --build-type {ament_cmake, ament_python}, --dependencies <deps>, --node-name <node_name> | | ros2 pkg prefix <pkg_name> | 查看功能包的安装路径 | | | ros2 pkg executables <pkg_name> | 列出功能包中的可执行文件 | | | ros2 pkg xml <pkg_name> | 输出功能包的 package. Xml 内容 | | | colcon build | 编译工作空间中的功能包 | --packages-select <pkg_name> (只编译指定包), --symlink-install (符号链接安装，便于 Python 开发) | | colcon list | 列出工作空间中所有功能包 | |

8. 运行 (Run) 和启动 (Launch) 相关命令

| 命令 | 描述 | 常用选项 | | :--- | :--- | :--- | | ros2 run <pkg_name> <executable_name> | 直接运行功能包中的某个可执行节点 | --ros-args (传递 ROS 参数), --param <name>:=<value> | | ros2 launch <pkg_name> <launch_file.py> | 通过启动文件运行一组节点 | --arguments <args>, --params-file <file> |

示例：运行节点

# 运行 turtlesim 包中的 turtlesim_node 节点，并设置节点名和参数
ros2 run turtlesim turtlesim_node --ros-args --remap __node:=my_turtle --param background_r:=100

9. 接口 (Interface) 相关命令

接口是消息 (. Msg)、服务 (. Srv) 和动作 (. Action) 的定义。

10. 分布式通信设置

在多机系统中至关重要。

11. 数据录制与回放 (Bag)

12. 守护进程管理

ros2 CLI 使用一个守护进程来缓存节点、话题等信息，加速查询。

🚀 综合实战示例：Turtlesim

这是一个综合使用多种命令的经典示例：

启动模拟器：
```
ros2 run turtlesim turtlesim_node
```

查看节点和话题：

ros2 node list        # 应看到 /turtlesim
ros2 topic list -t    # 应看到 /turtle 1/cmd_vel, /turtle 1/pose 等

控制乌龟运动（新开终端）：

ros2 run turtlesim turtle_teleop_key
# 此时可以用键盘方向键控制乌龟移动

查看节点信息：

ros2 node info /turtlesim # 查看 turtlesim 节点发布了/订阅了哪些话题和服务

录制数据（新开终端）：
```
ros2 bag record /turtle 1/cmd_vel /turtle 1/pose
```
控制乌龟运动一会儿，然后 Ctrl+C 停止录制。
回放数据（停止其他所有节点）：
```
ros2 bag play <生成的bag文件名>`
```
你会看到乌龟按照刚才的路径自动运动，即使没有运行 teleop 节点。

希望这份超全的指南能成为你学习和开发 ros2 的得力助手！

3. workspace & pkg

ROS 2 工作空间管理

概述

存放项目开发相关文件的文件夹

Src: 代码空间 (Source Space) Install: 安装空间 (Install Space) Build：编译空间 (Build Space) Log: 日志空间 (Log Space)

1. Rosdepc - ROS 依赖管理工具 (中国用户推荐)

rosdepc 是 rosdep 的国内镜像版，解决了直接使用官方 rosdep 更新慢、失败率高的问题。

安装 rosdepc

# 通过 pip 安装（推荐）
sudo pip install rosdepc

# 如果系统默认 python 是 python3，也可以使用 pip3
# sudo pip3 install rosdepc

初始化 rosdepc

只需在每台电脑上执行一次：

# 初始化 rosdepc
sudo rosdepc init

# 更新 rosdepc 的数据库（从国内源，速度很快）
rosdepc update

核心使用方法

在工作空间的 src 目录同级（即 ros2_ws 目录下）执行：

# 安装工作空间中所有功能包所需的系统依赖
rosdepc install -i --from-path src --rosdistro $ROS_DISTRO -y

# 分解说明：
# -i: --ignore-packages-from-source, 忽略源中的包（通常不需要，可省略）
# --from-path src: 从指定的 src 路径查找 package.xml
# --rosdistro $ROS_DISTRO: 指定你的 ROS 发行版（如 humble, iron 等）
# -y: 对所有提示自动回答 yes

实际例子（假设你的 ROS 版本是 humble）：

cd ~/ros2_ws
rosdepc install --from-path src --rosdistro humble -y

检查依赖

# 检查但不安装依赖（用于查看缺少哪些依赖）
rosdepc check --from-path src --rosdistro $ROS_DISTRO

2. Colcon - ROS 2 构建工具

colcon 是 ROS 2 的构建系统工具，替代了 ROS 1 中的 catkin_make。

安装 colcon

# Ubuntu/Debian
sudo apt install python3-colcon-common-extensions

# 或者通过 pip
sudo pip install colcon-common-extensions

核心构建命令

在工作空间根目录（~/ros2_ws）下执行：

# 基本构建：编译所有包
colcon build

# 编译特定包（最常用！）
colcon build --packages-select <your_package_name>

# 编译时跳过某些包
colcon build --packages-skip <package_to_skip>

# 并行编译以加快速度（使用所有CPU核心）
colcon build --parallel-workers $(nproc)

# 编译并创建符号链接（Python开发推荐）
colcon build --symlink-install

# 编译时跳过测试
colcon build --cmake-args -DBUILD_TESTING=0

常用组合命令

# 开发中最常用的组合：只编译一个包，使用符号链接，并行编译
colcon build --packages-select my_package --symlink-install --parallel-workers $(nproc)

# 编译并忽略依赖错误（谨慎使用）
colcon build --packages-select my_package --allow-overriding my_package

清理和重建

# 清理特定包的构建文件
colcon build --packages-select my_package --cmake-clean-first

# 彻底删除构建产物（需要重新编译）
rm -rf build install log

# 或者只删除特定包的构建产物
rm -rf build/my_package install/my_package

信息查询命令

# 列出工作空间中的所有包
colcon list

# 显示包的详细信息
colcon info <package_name>

# 列出包中的可执行文件
colcon list --packages-select <package_name> --executables

3. 完整工作流程示例

假设你要创建一个名为 my_robot 的新包：

# 1. 创建并进入工作空间
mkdir -p ~/ros2_ws/src
cd ~/ros2_ws

# 2. 创建Python包（假设依赖 rclpy 和 std_msgs）
ros2 pkg create my_robot --build-type ament_python --dependencies rclpy std_msgs

# 3. 安装系统依赖（关键步骤！）
rosdepc install -i --from-path src --rosdistro humble -y

# 4. 编写你的代码（编辑 src/my_robot/my_robot/my_robot_node.py 等文件）

# 5. 编译包（使用符号链接便于Python开发）
colcon build --packages-select my_robot --symlink-install

# 6. 激活工作空间
source install/setup.bash

# 7. 运行你的节点
ros2 run my_robot my_robot_node

4. 故障排除技巧

Rosdepc 常见问题

# 如果初始化失败，可以尝试删除后重新初始化
sudo rm -rf /etc/ros/rosdepc
sudo rosdepc init
rosdepc update

# 如果某个依赖安装失败，可以手动安装
# 先查看需要什么依赖
rosdepc check --from-path src --rosdistro humble

Colcon 常见问题

# 如果编译失败，查看详细错误信息
colcon build --packages-select my_package --event-handlers console_direct+

# 如果Python包修改后没生效，检查是否使用了 --symlink-install
# 如果没有，需要重新编译或者使用符号链接重新构建

5. 高级用法

# 运行测试
colcon test --packages-select my_package

# 生成编译数据库（用于IDE代码补全）
colcon build --cmake-args -DCMAKE_EXPORT_COMPILE_COMMANDS=ON

# 使用特定CMake配置
colcon build --cmake-args -DCMAKE_BUILD_TYPE=Release

# 编译后运行所有测试并显示结果
colcon test
colcon test-result --verbose

记住这个开发循环：修改代码 → 编译 (colcon build) → 运行测试。使用 --packages-select 可以显著提高开发效率，特别是大型项目中

好的，我们来详细梳理在工作空间（Workspace）中，功能包（Package）从创建、编写、构建到测试的完整流程和命令。

ROS 2 工作空间内功能包 (Package) 完整管理指南

1. 准备工作：创建与初始化工作空间

# 1. 创建工作空间目录结构
mkdir -p ~/ros2_ws/src
cd ~/ros2_ws

# 2. （可选但推荐）安装工作空间内所有包所需的系统依赖
# 注意：先确保已安装并初始化 rosdepc（如前所述）
rosdepc install -i --from-path src --rosdistro $ROS_DISTRO -y
# 示例（如果您的ROS2版本是Humble）：
# rosdepc install -i --from-path src --rosdistro humble -y

2. 功能包创建 (Package Creation)

创建新包的基本命令格式

cd ~/ros2_ws/src
ros2 pkg create <package_name> --build-type <build_type> --dependencies <dependencies>

具体示例

创建 C++ 包：

ros2 pkg create my_cpp_pkg --build-type ament_cmake --dependencies rclcpp std_msgs

创建 Python 包：

ros2 pkg create my_py_pkg --build-type ament_python --dependencies rclpy std_msgs

创建包含特定节点的包：

# 创建时直接指定节点名
ros2 pkg create my_robot --build-type ament_cmake --node-name my_robot_node --dependencies rclcpp

创建包含特定 launch 文件的包：

# 创建时直接指定launch文件名
ros2 pkg create my_launch_pkg --build-type ament_cmake --dependencies rclcpp --launch-file my_launch.launch.py

创建命令的常用选项

| 选项 | 说明 | 示例 | |------|------|------| | --build-type | 指定构建类型 | ament_cmake, ament_python | | --dependencies | 指定 ROS 2 依赖 | rclcpp rclpy std_msgs sensor_msgs | | --node-name | 创建时同时生成节点模板 | my_node | | --license | 指定许可证 | Apache-2.0, MIT | | --description | 包描述 | "My awesome ROS2 package" |

3. 功能包构建 (Package Building)

基本构建命令

在工作空间根目录 (~/ros2_ws) 下执行：

# 构建所有包
colcon build

# 构建特定包（最常用！）
colcon build --packages-select <package_name>

# 构建时跳过某些包
colcon build --packages-skip <package_to_skip>

高级构建选项

# 构建并使用符号链接（Python开发推荐）
colcon build --packages-select my_py_pkg --symlink-install

# 并行构建加速
colcon build --packages-select my_pkg --parallel-workers $(nproc)

# 构建并显示详细输出
colcon build --packages-select my_pkg --event-handlers console_direct+

# 构建时传递CMake参数（C++包）
colcon build --packages-select my_cpp_pkg --cmake-args -DCMAKE_BUILD_TYPE=Release

# 构建但不运行测试
colcon build --packages-select my_pkg --cmake-args -DBUILD_TESTING=0

清理和重建

# 清理特定包的构建文件
colcon build --packages-select my_pkg --cmake-clean-first

# 彻底删除构建产物
rm -rf build/ install/ log/

# 只删除特定包的产物
rm -rf build/my_pkg/ install/my_pkg/

4. 功能包测试 (Package Testing)

# 运行所有测试
colcon test

# 运行特定包的测试
colcon test --packages-select my_pkg

# 显示测试结果
colcon test-result --all

# 显示详细的测试结果（包括失败信息）
colcon test-result --verbose

5. 功能包信息查询 (Package Inspection)

# 列出工作空间中所有包
colcon list

# 列出已安装的所有包（包括系统包）
ros2 pkg list

# 查看包的详细信息
ros2 pkg prefix my_pkg  # 查看安装路径
ros2 pkg xml my_pkg     # 查看package.xml内容

# 列出包中的可执行文件
ros2 pkg executables my_pkg

# 查看包的依赖关系
rosdep keys my_pkg      # 查看系统依赖

6. 功能包运行 (Package Execution)

# 首先激活工作空间环境
source ~/ros2_ws/install/setup.bash

# 运行包中的节点
ros2 run my_pkg my_node

# 运行launch文件
ros2 launch my_pkg my_launch.launch.py

# 查看节点列表，确认节点已运行
ros2 node list

7. 完整开发工作流示例

示例：创建并开发一个 Python 包

# 1. 进入工作空间src目录
cd ~/ros2_ws/src

# 2. 创建Python包
ros2 pkg create my_py_package --build-type ament_python --dependencies rclpy --node-name my_py_node

# 3. 编辑节点代码
nano my_py_package/my_py_package/my_py_node.py
# （这里编写你的Python代码）

# 4. 编辑package.xml（如果需要添加更多依赖）
nano my_py_package/package.xml

# 5. 编辑setup.py（如果需要修改入口点）
nano my_py_package/setup.py

# 6. 返回工作空间根目录并安装依赖
cd ~/ros2_ws
rosdepc install -i --from-path src --rosdistro humble -y

# 7. 构建包（使用符号链接便于开发）
colcon build --packages-select my_py_package --symlink-install

# 8. 激活环境并运行
source install/setup.bash
ros2 run my_py_package my_py_node

示例：创建并开发一个 C++包

# 1. 创建C++包
cd ~/ros2_ws/src
ros2 pkg create my_cpp_package --build-type ament_cmake --dependencies rclcpp --node-name my_cpp_node

# 2. 编辑CMakeLists.txt（如果需要修改编译选项）
nano my_cpp_package/CMakeLists.txt

# 3. 编辑源代码
nano my_cpp_package/src/my_cpp_node.cpp

# 4. 构建并运行
cd ~/ros2_ws
colcon build --packages-select my_cpp_package
source install/setup.bash
ros2 run my_cpp_package my_cpp_node

8. 常用文件结构说明

C++ 包典型结构

my_cpp_package/
├── CMakeLists.txt          # 构建配置
├── include/               # 头文件
│   └── my_cpp_package/
├── package.xml            # 包元数据
├── src/                   # 源代码
│   └── my_cpp_node.cpp
└── test/                  # 测试代码

Python 包典型结构

my_py_package/
├── package.xml            # 包元数据
├── resource/             # 资源文件
├── setup.cfg             # Python安装配置
├── setup.py              # Python构建配置
├── test/                 # 测试代码
└── my_py_package/        # Python模块
    ├── __init__.py
    └── my_py_node.py     # 节点代码

9. 故障排除技巧

# 如果找不到包，检查是否正确source了工作空间
echo $ROS_PACKAGE_PATH

# 如果编译失败，查看详细错误信息
colcon build --packages-select my_pkg --event-handlers console_direct+

# 如果依赖问题，检查package.xml中的依赖声明
# 并确保运行了rosdepc install

这个完整的流程涵盖了从包创建到运行的所有关键步骤。记住核心循环：创建 → 编写 → 构建 → 测试 → 运行。使用 --packages-select 可以大大提高开发效率！

4. Node

1. Node 是什么？🤖

Node = 一个做特定事的程序

比如：一个控制电机的程序、一个读取相机数据的程序、一个处理图像的算法程序
每个 Node 只管好自己的事，通过 ROS 2 与其他 Node 聊天协作

2. 最简单的理解方式 🎯

# 你的机器人系统里可能有这些 Node：
/camera_node     # 专门处理相机
/lidar_node      # 专门处理雷达  
/move_node       # 专门控制移动
/decision_node   # 专门做决策

# 它们这样聊天：
相机Node："我看到前面有障碍物" → (通过话题) → 决策Node
决策Node："请向右转" → (通过服务) → 移动Node
移动Node："正在转弯，已完成50%" → (通过动作) → 决策Node

3. 简单代码示例

1. Python 节点代码示例 🐍

简单的发布者节点 (`my_publisher.py`)

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from std_msgs.msg import String
import time

class MyPublisher(Node):
    def __init__(self):
        super().__init__('my_publisher_node')
        self.publisher_ = self.create_publisher(String, 'chatter', 10)
        self.timer = self.create_timer(1.0, self.timer_callback)
        self.counter = 0
        self.get_logger().info('Publisher node started!')

    def timer_callback(self):
        msg = String()
        msg.data = f'Hello ROS2! Count: {self.counter}'
        self.publisher_.publish(msg)
        self.get_logger().info(f'Publishing: "{msg.data}"')
        self.counter += 1

def main(args=None):
    rclpy.init(args=args)
    node = MyPublisher()
    
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.destroy_node()
        rclpy.shutdown()

if __name__  '__main__':
    main()

简单的订阅者节点 (`my_subscriber.py`)

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from std_msgs.msg import String

class MySubscriber(Node):
    def __init__(self):
        super().__init__('my_subscriber_node')
        self.subscription = self.create_subscription(
            String,
            'chatter',
            self.listener_callback,
            10)
        self.get_logger().info('Subscriber node started!')

    def listener_callback(self, msg):
        self.get_logger().info(f'I heard: "{msg.data}"')

def main(args=None):
    rclpy.init(args=args)
    node = MySubscriber()
    
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.destroy_node()
        rclpy.shutdown()

if __name__  '__main__':
    main()

2. C++ 节点代码示例 ⚙️

简单的发布者节点 (`my_publisher.cpp`)

#include "rclcpp/rclcpp.hpp"
#include "std_msgs/msg/string.hpp"
#include <chrono>

using namespace std::chrono_literals;

class MyPublisher : public rclcpp::Node {
public:
    MyPublisher() : Node("my_publisher_node"), count_(0) {
        publisher_ = this->create_publisher<std_msgs::msg::String>("chatter", 10);
        timer_ = this->create_wall_timer(
            1s,
            std::bind(&MyPublisher::timer_callback, this));
        RCLCPP_INFO(this->get_logger(), "Publisher node started!");
    }

private:
    void timer_callback() {
        auto message = std_msgs::msg::String();
        message.data = "Hello ROS2! Count: " + std::to_string(count_++);
        publisher_->publish(message);
        RCLCPP_INFO(this->get_logger(), "Publishing: '%s'", message.data.c_str());
    }
    
    rclcpp::TimerBase::SharedPtr timer_;
    rclcpp::Publisher<std_msgs::msg::String>::SharedPtr publisher_;
    size_t count_;
};

int main(int argc, char * argv[]) {
    rclcpp::init(argc, argv);
    auto node = std::make_shared<MyPublisher>();
    rclcpp::spin(node);
    rclcpp::shutdown();
    return 0;
}

简单的订阅者节点 (`my_subscriber.cpp`)

#include "rclcpp/rclcpp.hpp"
#include "std_msgs/msg/string.hpp"

class MySubscriber : public rclcpp::Node {
public:
    MySubscriber() : Node("my_subscriber_node") {
        subscription_ = this->create_subscription<std_msgs::msg::String>(
            "chatter",
            10,
            std::bind(&MySubscriber::listener_callback, this, std::placeholders::_1));
        RCLCPP_INFO(this->get_logger(), "Subscriber node started!");
    }

private:
    void listener_callback(const std_msgs::msg::String::SharedPtr msg) const {
        RCLCPP_INFO(this->get_logger(), "I heard: '%s'", msg->data.c_str());
    }
    
    rclcpp::Subscription<std_msgs::msg::String>::SharedPtr subscription_;
};

int main(int argc, char * argv[]) {
    rclcpp::init(argc, argv);
    auto node = std::make_shared<MySubscriber>();
    rclcpp::spin(node);
    rclcpp::shutdown();
    return 0;
}

4. 入口点 (Entry Point) 配置说明 🚪

入口点 = 告诉系统："这个包里的这个文件是启动入口"

对于 Python 包 (`ament_python`)

文件：setup.py

from setuptools import setup
import os
from glob import glob

package_name = 'my_py_pkg'

setup(
    name=package_name,
    version='0.0.0',
    packages=[package_name],
    data_files=[
        ('share/ament_index/resource_index/packages',
            ['resource/' + package_name]),
        ('share/' + package_name, ['package.xml']),
    ],
    install_requires=['setuptools'],
    zip_safe=True,
    maintainer='your_name',
    maintainer_email='your_email@example.com',
    description='TODO: Package description',
    license='TODO: License declaration',
    tests_require=['pytest'],
    
    # 🔥 最重要的入口点配置 🔥
    entry_points={
        'console_scripts': [
            # 格式：'节点名 = 包名.文件名:函数名'
            'my_node = my_py_pkg.my_node:main',
            'camera_driver = my_py_pkg.camera_node:main',
            'simple_publisher = my_py_pkg.simple_pub:main',
        ],
    },
)

对应文件结构：

my_py_pkg/
├── setup.py          # 在这里配置入口点
├── package.xml
└── my_py_pkg/        # Python包目录
    ├── __init__.py
    ├── my_node.py    # 包含 main() 函数
    ├── camera_node.py
    └── simple_pub.py

对于 C++ 包 (`ament_cmake`)

文件：CMakeLists.txt

# 添加可执行文件
add_executable(my_cpp_node src/my_cpp_node.cpp)

# 链接ROS2库
ament_target_dependencies(my_cpp_node
  "rclcpp"
  "std_msgs"
)

# 🔥 最重要的入口点配置 🔥
# 安装可执行文件到 lib/<包名>
install(TARGETS
  my_cpp_node
  camera_driver
  simple_publisher
  DESTINATION lib/${PROJECT_NAME}
)

# 安装启动文件等其他资源
install(DIRECTORY
  launch
  DESTINATION share/${PROJECT_NAME}
)

对应文件结构：

my_cpp_pkg/
├── CMakeLists.txt    # 在这里配置编译和安装
├── package.xml
├── include/
└── src/
    ├── my_cpp_node.cpp      # 主函数在这里
    ├── camera_driver.cpp
    └── simple_publisher.cpp

5. 如何创建和运行 🏃

创建包时指定入口点

# 创建Python包并指定节点名（自动配置入口点）
ros2 pkg create my_pkg --build-type ament_python --node-name my_node

# 创建C++包并指定节点名（自动配置入口点）  
ros2 pkg create my_pkg --build-type ament_cmake --node-name my_node

手动添加多个入口点

如果已经创建了包，需要添加更多节点：

对于 Python：

在 my_py_pkg/ 目录下创建新的 .py 文件
确保文件中有 def main(): 函数
在 setup.py 的 entry_points 中添加新行

对于 C++：

在 src/ 目录下创建新的 .cpp 文件
在 CMakeLists.txt 中添加 add_executable() 和 ament_target_dependencies()
在 install(TARGETS ...) 中添加新的可执行文件名

6. 构建和运行 🏗️

# 构建包
colcon build --packages-select my_pkg

# 运行节点（系统会自动找到入口点）
ros2 run my_pkg my_node
ros2 run my_pkg camera_driver
ros2 run my_pkg simple_publisher

7. 重要提醒 ⚠️

Python 文件需要可执行权限：
```
chmod +x my_py_pkg/my_node.py
```
每次修改 setup.py 或 CMakeLists.txt 后需要重新构建
入口点名字可以自定义，不一定要和文件名一样
一个包可以有多个入口点（多个可执行节点）

8. 简单总结 🎯

| 项目 | Python 包 | C++ 包 | |------|-----------|--------| | 配置文件 | setup.py | CMakeLists.txt | | 配置位置 | entry_points | add_executable() + install() | | 文件要求 | 要有 def main(): 函数 | 要有 int main() 函数 | | 构建后 | 生成在 install/lib/python3.10/site-packages/ | 生成在 install/lib/包名/ |

最简单的理解：入口点就是告诉 ROS 2："当我运行 ros2 run 包名 XXX 时，到底应该执行哪个文件！"

5. Topic

好的！我们来详细解释 ROS 2 中 Node 间传输数据的重要机制：Topic（话题）。

ROS 2 Topic（话题）详解

1. Topic 是什么？📡

Topic = Node 之间的聊天频道

就像微信群：一个人发言（发布），多个人收听（订阅）
异步通信：发言者不管有没有人听，都会一直说
一对多通信：一个话题可以有多个发布者和多个订阅者

2. 直观比喻 🎯

# 现实世界的例子：
传感器Node："温度是25°C" → /temperature_topic → 显示Node、控制Node、记录Node

# 就像：
新闻电台 → 广播频率 → 所有收音机听众

3. Topic 通信模型 📊

[发布者 Node] → (消息) → [/topic_name] → (消息) → [订阅者 Node]
      ↑                          ↑                          ↑
   Publisher                    Topic                    Subscriber
    (说话)                     (聊天频道)                   (听话)

4. 核心特性 ✨

| 特性 | 说明 | | -------- | -------------------- | | 异步 | 发布者不需要等待订阅者响应 | | 解耦合 | 发布者和订阅者互相不知道对方存在 | | 多对多 | 支持多个发布者和多个订阅者 | | 类型安全 | 每个 Topic 有固定的消息类型 | | 实时性 | 适合连续数据流传输 |

5. 常用命令 🛠️

查看 Topic 信息

# 列出所有活跃的Topic
ros2 topic list

# 列出Topic并显示消息类型
ros2 topic list -t

# 查看Topic的详细信息
ros2 topic info /chatter

# 查看Topic的消息类型
ros2 topic type /chatter

监听和发布数据

# 监听某个Topic的消息（实时显示）
ros2 topic echo /chatter

# 手动向Topic发布消息
ros2 topic pub /chatter std_msgs/msg/String "{data: 'Hello ROS2'}"

# 以固定频率发布消息
ros2 topic pub /chatter std_msgs/msg/String "{data: 'Hello'}" --rate 1

# 查看Topic的消息频率
ros2 topic hz /chatter

# 查看Topic的数据带宽
ros2 topic bw /chatter

安装写好的功能包

sudo apt install ros-humble-usb-cam

作用：安装摄像头驱动

相机驱动底层代码：usb_cam 包已经处理了USB设备的打开、数据采集、格式转换等复杂工作
图像消息的序列化/反序列化：ROS2已经提供了标准的 sensor_msgs/Image 消息类型
通信底层代码：Topic的发布订阅机制ROS2已经实现好了

场景1：直接使用（最简单）

如果你只是想要显示摄像头画面，确实不用写代码

ros2 run usb_cam usb_cam_node_exe
ros2 run learning_topic topic_webcam_sub

场景2：自定义处理（最常见）

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from sensor_msgs.msg import Image
from cv_bridge import CvBridge
import cv2

class MyImageProcessor(Node):
    def __init__(self):
        super().__init__('my_image_processor')
        # 订阅原始图像
        self.subscription = self.create_subscription(
            Image,
            '/image_raw',  # 订阅usb_cam发布的话题
            self.image_callback,
            10)
        self.bridge = CvBridge()
        
    def image_callback(self, msg):
        # 将ROS图像消息转换为OpenCV格式
        cv_image = self.bridge.imgmsg_to_cv2(msg, "bgr8")
        
        # 在这里添加你的处理代码
        # 例如：图像识别、边缘检测、目标跟踪等
        gray_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
        edges = cv2.Canny(gray_image, 100, 200)
        
        # 显示处理结果
        cv2.imshow('Processed Image', edges)
        cv2.waitKey(1)

def main(args=None):
    rclpy.init(args=args)
    node = MyImageProcessor()
    rclpy.spin(node)
    rclpy.shutdown()

if __name__  '__main__':
    main()

问题

异步传输数据

发布者一直在对外发布信息，并不知道接收者究竟有没有接收到信息

因此可以用service 来解决

6. Service

7. Action

1. Action 是什么？🎯

Action = 处理长时间、可取消、有进度反馈的任务的机制

就像点餐后的完整流程：

下单（目标） → 厨师开始做菜（执行） → 不时汇报进度（反馈） → 上菜（结果）
或者：中途可以取消订单（取消）

其实是通过 service 和 topic 来实现的实际上就是一种应用层的通信机制

2. 直观比喻 🍳

# 客户端："请做一份披萨，30分钟内完成"
# 服务端："开始做披萨...20%完成...50%完成...披萨做好了！"

# 或者：
# 客户端："取消做披萨！"
# 服务端："好的，已取消"

3. Action 通信模型 📊

[客户端 Node] → (目标) → [/action_name] → (目标) → [服务端 Node]
     ↓               ↓               ↓               ↓
  Client          Action           Action         Server
 (顾客)           (订单系统)        (订单系统)       (厨师)
     ↓               ↓               ↓               ↓
[等待结果] ← (结果) ← [反馈] ← (进度) ← [执行任务]
     ↑               ↑               ↑               ↑
  取消指令 → → → → → → → → → → → → → → → 取消处理

4. Action 的核心组成 🧩

一个 Action 包含三部分：

Goal（目标）：要执行的任务（比如"导航到 x, y 位置"）
Feedback（反馈）：执行过程中的进度更新（比如"已完成 50%"）
Result（结果）：最终的执行结果（比如"成功到达"或"失败原因"）

5. 与 Service、Topic 的对比 📋

| 方面 | Action | Service | Topic | |------|---------|---------|-------| | 通信模式 | 异步，有反馈 | 同步，请求-响应 | 异步，发布-订阅 | | 持续时间 | 长时间运行 | 瞬时完成 | 持续数据流 | | 交互性 | 可取消，有进度反馈 | 不可取消，无反馈 | 无交互 | | 适用场景 | 导航、机械臂控制 | 计算、查询 | 传感器数据 |

6. 常用命令 🛠️

查看 Action 信息

# 列出所有活跃的Action
ros2 action list

# 列出Action并显示类型
ros2 action list -t

# 查看Action信息
ros2 action info /turtle1/rotate_absolute

# 查看Action类型
ros2 action type /turtle1/rotate_absolute

发送 Action 目标

# 发送Action目标
ros2 action send_goal /turtle1/rotate_absolute turtlesim/action/RotateAbsolute "{theta: 1.57}"

# 发送目标并显示反馈
ros2 action send_goal /turtle1/rotate_absolute turtlesim/action/RotateAbsolute "{theta: 3.14}" --feedback

# 取消Action目标（需要先知道goal_id）
ros2 action cancel_goal <goal_id>

7. Action 消息结构 📝

Action 定义文件 (`RotateAbsolute.action`)

# Goal - 目标
float32 theta
---
# Result - 结果
float32 delta
---
# Feedback - 反馈
float32 remaining

8. Params

1. 核心概念：什么是参数（Params）？

在 ros2 中，参数是节点在运行时可配置的配置值。

你可以把它们想象成一个节点的“设置”或“选项”。与通过主题（Topic）和服务（Service）进行的动态、频繁的通信不同，参数通常用于设置那些在节点启动后不经常改变，但又需要灵活配置的变量。

一个简单的类比： 将节点比作一个电视，主题和服务就像是遥控器，用于实时切换频道和调整音量。而参数则像是电视后背的物理旋钮或菜单设置，用于配置屏幕亮度、色彩、语言等，你通常不会在观看时频繁调整它们，但在初次 setup 或偶尔优化时非常重要。

2. 参数的核心特性

动态配置性：参数可以在节点运行时（online）通过命令行、API 或图形化工具动态地读取和修改，而无需重启节点。这极大地提高了系统的灵活性和可调试性。
由节点管理：每个节点都拥有自己独立的参数空间。一个节点的参数与另一个节点的参数是隔离的，即使参数名相同也不会冲突。
具有类型：每个参数都有一个明确的数据类型，例如 integer、double、string、boolean、byte arrays 以及这些类型的列表（arrays）。
可被监控：节点可以设置回调函数，当某个参数的值被外部修改时，该回调函数会被触发，节点可以据此执行相应的操作（例如，应用新的配置）。

3. 参数的使用场景

参数非常适合用于以下情况：

配置硬件设置：例如，配置相机节点的分辨率、帧率。
算法参数调优：例如，配置机器人导航算法中的最大速度、安全距离、PID 控制器增益等。
设置节点行为模式：例如，通过一个 string 类型的参数选择不同的策略模式（如 "aggressive" 或 "cautious"）。
初始化设置：例如，设置机器人的名称、模拟模式还是真实模式等。

4. 参数的工作机制：服务与动作

参数系统并非基于主题（Pub/Sub），而是基于一套服务（Services）和动作（Actions） 的架构。

每个支持参数的节点内部都会自动创建以下几个服务：

~/describe_parameters：获取参数描述。
~/get_parameter_types：获取参数类型。
~/get_parameters：读取一个或多个参数的值。
~/set_parameters：设置一个或多个参数的值。
~/set_parameters_atomically：原子性地设置多个参数的值（要么全部成功，要么全部失败，防止出现中间状态）。
~/list_parameters：列出节点中的所有参数。

此外，还有一个动作（Action）：

~/parameter_events：这是一个发布者，当参数发生变化时，节点会通过这个动作发布一个“参数事件”消息，通知系统其他部分参数发生了更改。

当你使用 ros2 param set 这样的命令行工具时，该工具实际上是在幕后调用目标节点的 ~/set_parameters 服务。

5. 如何使用参数（代码层面）

以下是一个在 Python 节点中声明和使用参数的简单示例：

import rclpy
from rclpy.node import Node
from rclpy.parameter import Parameter

class MyNode(Node):
    def __init__(self):
        super().__init__('my_node')
        
        # 1. 声明参数并设置默认值
        self.declare_parameter('my_string_param', 'default_value')
        self.declare_parameter('my_int_param', 10)
        self.declare_parameter('my_bool_param', True)
        
        # 2. 获取参数值
        my_string = self.get_parameter('my_string_param').value
        my_int = self.get_parameter('my_int_param').value
        my_bool = self.get_parameter('my_bool_param').value
        
        self.get_logger().info(f'String param: {my_string}')
        self.get_logger().info(f'Int param: {my_int}')
        self.get_logger().info(f'Bool param: {my_bool}')
        
        # 3. （可选）设置参数变更回调函数
        # 当任何参数被外部修改时，此函数都会被调用
        self.add_on_set_parameters_callback(self.parameter_change_callback)
    
    def parameter_change_callback(self, params):
        """参数变更回调函数"""
        for param in params:
            self.get_logger().info(f'Parameter {param.name} changed to {param.value}')
            
            # 你可以在这里检查特定参数并做出反应
            if param.name  'my_int_param' and param.type_  Parameter.Type.INTEGER:
                self.get_logger().info(f'New int value is: {param.value}')
                # 这里可以触发重新配置算法等操作
        
        # 返回一个成功的状态对象，表示参数接受更改
        # 你也可以在这里验证参数值，如果值非法，可以返回一个不成功的状态来拒绝此次更改。
        return SetParametersResult(successful=True)

def main(args=None):
    rclpy.init(args=args)
    node = MyNode()
    rclpy.spin(node)
    rclpy.shutdown()

if __name__  '__main__':
    main()

在 C++ 中也有类似的 API。

6. 如何使用参数（命令行工具）

ros2 提供了一系列强大的命令行工具来管理参数：

ros2 param list <node_name>：列出某个节点的所有参数。

ros2 param list /my_node
# 输出： /my_node:
#   my_bool_param
#   my_int_param
#   my_string_param

ros2 param get <node_name> <param_name>：获取某个参数的当前值和类型。
```
ros2 param get /my_node my_int_param
# 输出： Integer value is: 10
```

ros2 param set <node_name> <param_name> <value>：设置某个参数的值。

ros2 param set /my_node my_int_param 42
# 输出： Set parameter successful

ros2 param dump <node_name>：将节点的所有当前参数值导出到一个 YAML 文件中。

ros2 param dump /my_node > my_node_params.yaml

生成的 YAML 文件内容类似：

/my_node:
  ros__parameters:
    my_bool_param: true
    my_int_param: 42
    my_string_param: "default_value"

ros2 param load <node_name> <parameter_file>：从一个 YAML 文件中加载参数值并应用到节点。
```
ros2 param load /my_node my_node_params. Yaml
```

启动时加载参数：更常见的做法是在启动节点时直接通过启动文件（Launch File）加载参数文件。

# 在 Python launch 文件中
From launch_ros. Actions import Node

Node = Node (
    Package='my_package',
    Executable='my_node_executable',
    Name='my_node',
    Parameters=['path/to/my_node_params.Yaml'] # 关键在这里
)

9. 分布式通信

简单的说，如果不设置群组 id，那么所有的节点都会收到消息

如果是设定了群组 id，那么只有相同群组 id 的节点才会收到消息

设置方法

# .bashrc
export ROS_DOMAIN_ID=0 # yourid

10. DDS

好的，我们来详细阐述 ROS 2 中的 DDS（Data Distribution Service）。这是一个核心且基础的概念，理解了 DDS，就理解了 ROS 2 通信机制的基石。

1. 核心概念：什么是 DDS？

DDS（数据分发服务） 是一个由对象管理组织（OMG） 发布的国际标准（v 1.4），它是一种以数据为中心的、跨语言的、跨平台的通信中间件协议和 API 标准。

其核心设计理念是：

以数据为中心（Data-Centric）：传统的通信方式（如 TCP/IP）是以“节点/设备”为中心的（我知道要跟谁说话）。而 DDS 是以“数据”为中心的。应用程序只关心它需要“发布”或“订阅”什么“主题”的数据，而不需要关心数据来自哪里或发送到哪里。DDS 中间件负责自动发现和高效路由数据。
发布-订阅模式（Publish-Subscribe）：DDS 严格遵循发布-订阅模型，这与 ROS 的 Topic 通信模型天然契合。
实时系统（Real-Time Systems）：DDS 的设计目标之一就是满足硬实时和软实时系统的需求，提供可预测的性能和低延迟。
可靠性（Reliability）：DDS 提供了丰富的服务质量（QoS）策略，可以灵活配置通信的可靠性、持久性、寿命、截止时间等，以适应从关键任务控制到非关键监控的各种场景。

2. 为什么 ROS 2 要采用 DDS？

ROS 1 的通信层是自定义的，基于 TCPROS/UDPROS 协议。虽然工作良好，但存在一些固有缺陷：

发现机制：采用集中式的 Master 节点进行发现，单点故障问题严重。
跨平台性：主要支持 Linux，在其他操作系统上支持不佳。
实时性：难以满足严格的实时控制需求。
安全性：原生缺乏安全通信机制。
复杂性：与外部非 ROS 系统集成相对复杂。

DDS 完美地解决了这些问题：

去中心化发现：DDS 使用基于广播或组播的分布式发现协议，无需中心节点，更加健壮。
原生跨平台：DDS 是标准，有各种语言和操作系统的商业和开源实现。
强大的实时性：许多 DDS 实现专为实时和嵌入式系统设计。
内置安全模型：DDS 标准包含一个安全规范（DDS-Security），提供认证、加密和访问控制。
系统集成：DDS 是工业界广泛使用的标准（尤其在航空、国防、医疗领域），ROS 2 节点可以直接与其它 DDS 应用程序通信，无缝集成。

因此，ROS 2 选择不重新发明轮子，而是将 DDS 作为其默认的中间件（Middleware），在其之上构建 ROS 的抽象层（如 Nodes, Topics, Services, Actions）。

3. ROS 2 与 DDS 的架构关系：RCL 和 RMW

ROS 2 的软件栈被设计为可插入中间件的架构，其与 DDS 的关系可以通过以下分层模型来理解：

+---------------------+ (Your Code)
|    ROS 2 Client     |    (e.g., rclcpp, rclpy)
|     Library (RCL)   |
+---------------------+
|  ROS 2 Middleware   |  <--- 这是抽象接口层
|   Interface (RMW)   |
+---------------------+
|   DDS Implementation |  <--- 这是具体的实现层 (e.g., Cyclone DDS, Fast DDS)
+---------------------+

ROS 客户端库（RCL - ROS Client Library）：
- 这是你编写 ROS 2 代码时直接调用的库，例如 C++ 的 rclcpp 或 Python 的 rclpy。
- 它提供了熟悉的 Node, Publisher, Subscriber, Service, Client 等接口。
ROS 中间件接口（RMW - ROS Middleware Interface）：
- 这是一个抽象层，它定义了一套通用的 API（用 C 语言实现），用于所有底层中间件实现的通信功能（如发布消息、订阅主题、请求服务等）。
- RCL 调用 RMW 接口，RMW 再将调用转换给具体的 DDS 实现。这实现了解耦：ROS 2 的上层代码不依赖于任何特定的 DDS 供应商。
DDS 实现层（DDS Implementation）：
- 这是具体的 DDS 库，它实现了 DDS 标准的所有功能。
- ROS 2 通过一个对应的 RMW 适配器包（例如 rmw_cyclonedds_cpp) 来使用这个库。
- 你可以通过设置环境变量 RMW_IMPLEMENTATION=rmw_cyclonedds_cpp 来轻松切换使用的 DDS 实现。

总结一下数据流：你的 C++/Python 代码 -> rclcpp / rclpy -> rcl (C API) -> rmw (Middleware Interface) -> 具体的 DDS 库（如 Cyclone DDS） -> 网络传输。

5. DDS 带给 ROS 2 的核心特性：QoS（服务质量）

这是 DDS 带给 ROS 2 最强大、最独特的特性。QoS 策略允许你精细地控制通信行为。

在 ROS 2 中，你可以在创建 Publisher 和 Subscriber 时指定它们的 QoS 策略。只有当发布者和订阅者的 QoS 配置兼容时，它们才能建立连接并进行通信。

如何指定 QoS

发布 topic 等的时候加入命令行选项即可

如

ros2 topic echo /chatter --qos-reliability best_effort

注意，发送者和接受者需要用相同的 qos

或者在代码中

class PublisherNode(Node):
    
    def __init__(self, name):
        super().__init__(name)  # ROS2节点父类初始化
        
        qos_profile = QoSProfile(  # 创建一个QoS原则
            # reliability=QoSReliabilityPolicy.BEST_EFFORT,
            reliability=QoSReliabilityPolicy.RELIABLE,
            history=QoSHistoryPolicy.KEEP_LAST,
            depth=1
        )
        # 创建发布者对象（消息类型、话题名、QoS原则）
        self.pub = self.create_publisher(String, "chatter", qos_profile)  
         
        # 创建一个定时器（单位为秒的周期，定时执行的回调函数）
        self.timer = self.create_timer(0.5, self.timer_callback)

11. launch

核心概念：什么是 Launch？

在 ROS 2 中，Launch 系统是一个用于启动和管理多个 ROS 2 节点（Nodes）以及相关进程的框架。一个复杂的机器人系统通常由数十个甚至上百个相互协作的节点组成（例如，传感器驱动、感知、定位、规划、控制等）。手动在每个终端里用 ros2 run 命令来启动每一个节点是非常繁琐且容易出错的。

Launch 系统允许你通过一个** launch 文件**，来声明式地配置和启动一整套节点系统，并可以设置参数、重映射（Remapping）、包含其他 launch 文件、响应事件等。

为什么需要 Launch 文件？

自动化复杂系统：一键启动所有必要的组件。
配置管理：集中管理节点的参数、命名空间、重映射规则。
可维护性和可复用性：将启动逻辑写成文件，便于版本控制和在不同机器人或场景下复用。
健壮性：可以配置规则，在某个节点失败时自动重启或其他节点。

ROS 2 Launch 的演进：Python 作为一等公民

与 ROS 1 主要使用 XML 格式的 .launch 文件不同，ROS 2 的 Launch 系统是用 Python 编写的，并且鼓励用户使用 Python 来编写 launch 文件（文件扩展名通常是 .py）。

优势：
- 强大灵活：你可以利用 Python 的全部功能（条件判断、循环、函数、导入模块等）来动态生成复杂的启动逻辑。
- 可编程性：可以轻松地编写逻辑来响应启动过程中发生的事件（例如，一个节点退出时执行某些操作）。
- 可读性：对于熟悉 Python 的开发者来说，Python 代码比 XML 更易读和维护。

当然，ROS 2 也支持通过 XML 和 YAML 来编写 launch 文件，以实现与 ROS 1 的兼容性或满足简单需求，但 Python 方式是官方推荐且功能最强大的方式。

Launch 文件的核心组成部分

一个典型的 Python launch 文件通常包含以下元素：

1. 导入（Imports）

从 launch 和 launch_ros 模块中导入所需的类和方法。

from launch import LaunchDescription
from launch_ros.actions import Node
from launch.actions import DeclareLaunchArgument, IncludeLaunchDescription
from launch.substitutions import LaunchConfiguration, PathJoinSubstitution

2. 生成 Launch 描述的函数

定义一个函数（通常是 generate_launch_description()）来创建并返回一个 LaunchDescription 对象。

def generate_launch_description():
    # ... 在这里配置启动内容 ...
    return LaunchDescription([
        # ... 将配置好的动作（Actions）放在这里 ...
    ])

3. 动作（Actions）

Actions 是 Launch 系统执行的具体操作，最常见的包括：

Node：启动一个 ROS 2 节点。

talker_node = Node(
    package='demo_nodes_cpp',        # 功能包名
    executable='talker',             # 可执行文件的名字
    name='my_talker',                # 覆盖节点名（可选）
    namespace='my_ns',               # 设置命名空间（可选）
    parameters=[{'rate': 1.0}],      # 设置参数（可选）
    remappings=[('chatter', 'my_chatter')] # 重映射话题（可选）
)

DeclareLaunchArgument：声明一个启动参数，允许用户从命令行传入值。

use_sim_time_arg = DeclareLaunchArgument(
    'use_sim_time',
    default_value='false',
    description='Use simulation (Gazebo) clock if true'
)

LaunchConfiguration：引用一个已声明的启动参数的值。

# 在Node的parameters中使用启动参数
parameters=[{'use_sim_time': LaunchConfiguration('use_sim_time')}]

IncludeLaunchDescription：包含并执行另一个 launch 文件，实现模块化。

include_another_launch = IncludeLaunchDescription(
    PathJoinSubstitution([get_package_share_directory('another_pkg'), 'launch', 'other.launch.py'])
)

4. Substitutions（替换）

允许动态地构建字符串，常用于构建路径或使用启动参数。

from launch.substitutions import PathJoinSubstitution, FindPackageShare

# 动态查找功能包路径并拼接文件路径
config_file = PathJoinSubstitution([
    FindPackageShare('my_robot_bringup'),
    'config',
    'robot_params.yaml'
])

一个完整的示例

假设我们想启动一个话题发布者（talker）和一个话题订阅者（listener），并为 talker 设置一个参数。

my_launch_file.py:

from launch import LaunchDescription
from launch_ros.actions import Node
from launch.actions import DeclareLaunchArgument
from launch.substitutions import LaunchConfiguration

def generate_launch_description():

    # 1. 声明一个启动参数
    rate_arg = DeclareLaunchArgument(
        'publish_rate',
        default_value='1.0',
        description='Publishing rate (Hz) for the talker node'
    )
    
    # 当然也可以通过yaml加载
    '''
    config = os.path.join(              # 找到参数文件的完整路径
      get_package_share_directory('learning_launch'),
      'config',
      'turtlesim.yaml'
      )
    '''

    # 2. 配置要启动的节点
    talker_node = Node(
        package='demo_nodes_cpp',
        executable='talker',
        name='my_talker',
        parameters=[{
            'rate': LaunchConfiguration('publish_rate') # 使用启动参数
        }],
        remappings=[('chatter', 'my_chatter_topic')] # 将/chatter重映射为/my_chatter_topic
    )

    listener_node = Node(
        package='demo_nodes_cpp',
        executable='listener',
        name='my_listener',
        remappings=[('chatter', 'my_chatter_topic')] # 也必须重映射，才能听到talker
    )

    # 3. 将所有的Actions加入到LaunchDescription中
    return LaunchDescription([
        rate_arg,
        talker_node,
        listener_node
    ])

Launch 调用 launch

def generate_launch_description():                # 自动生成launch文件的函数
   parameter_yaml = IncludeLaunchDescription(     # 包含指定路径下的另外一个launch文件
      PythonLaunchDescriptionSource([os.path.join(
         get_package_share_directory('learning_launch'), 'launch'),
         '/parameters_nonamespace.launch.py'])
      )
  
   parameter_yaml_with_namespace = GroupAction(   
   # 对指定launch文件中启动的功能加上命名空间
      actions=[
         PushRosNamespace('turtlesim2'), # 防止冲突，主动加ns
         parameter_yaml]
      )

   return LaunchDescription([            # 返回launch文件的描述信息
      parameter_yaml_with_namespace
   ])

准备 setup

(os.path.join('share', package_name, 'launch'), glob(os.path.join('launch', '*.launch.py'))),

(os.path.join('share', package_name, 'config'), glob(os.path.join('config', '*.*'))),

(os.path.join('share', package_name, 'rviz'), glob(os.path.join('rviz', '*.*'))),

如何运行 Launch 文件

使用 ros2 launch 命令：

# 基本用法
ros2 launch <package_name> <launch_file_name>.py

# 运行上面的示例（假设文件在 my_package 功能包中）
ros2 launch my_package my_launch_file.py

# 在启动时覆盖参数的值
ros2 launch my_package my_launch_file.py publish_rate:=2.0

我来详细解释一下这个 remapping 的作用，这是 ROS 中一个非常重要且强大的概念。

Remapping（重映射）

重映射就是在运行时改变节点的通信资源名称（话题、服务、参数等）。简单说，就是给通信通道起个别名或者重新定向。

为什么需要重映射？

在这个具体的例子中，有三个节点：

turtlesim1/sim - 第一个乌龟模拟器
turtlesim2/sim - 第二个乌龟模拟器
mimic - 模仿节点

问题分析：

mimic 节点的设计：
- 它默认订阅 /input/pose 话题来获取姿势信息
- 它默认发布 /output/cmd_vel 话题来发送速度指令
实际需求：
- 我们希望 mimic 读取第一个乌龟的姿势（/turtlesim1/turtle1/pose）
- 然后控制第二个乌龟运动（向 /turtlesim2/turtle1/cmd_vel 发布指令）
名称不匹配：
- mimic 想订阅的是 /input/pose，但数据在 /turtlesim1/turtle1/pose
- mimic 想发布到 /output/cmd_vel，但需要发布到 /turtlesim2/turtle1/cmd_vel

重映射如何解决这个问题？

remappings=[
    ('/input/pose', '/turtlesim1/turtle1/pose'),        # 输入重定向
    ('/output/cmd_vel', '/turtlesim2/turtle1/cmd_vel'), # 输出重定向
]

效果相当于：

对于 mimic 节点内部：

当它尝试订阅 /input/pose 时，系统自动让它订阅 /turtlesim1/turtle1/pose
当它尝试发布到 /output/cmd_vel 时，系统自动让它发布到 /turtlesim2/turtle1/cmd_vel

对于其他节点：

它们看到的是 mimic 在正常地与 /turtlesim1/turtle1/pose 和 /turtlesim2/turtle1/cmd_vel 通信

可视化理解

mimic节点内部             重映射后实际连接
-------------           -------------------
订阅 /input/pose    →   订阅 /turtlesim1/turtle1/pose
发布 /output/cmd_vel →  发布 /turtlesim2/turtle1/cmd_vel

重映射的通用语法

remappings=[
    ('原话题名', '新话题名'),      # 话题重映射
    ('原服务名', '新服务名'),      # 服务重映射
    ('__ns', '新的命名空间'),      # 特殊：重映射节点自身命名空间
    ('__node', '新的节点名'),      # 特殊：重映射节点自身名称
]

其他常见使用场景

避免名称冲突：两个相同功能的节点需要同时运行
接口标准化：让不同节点遵循统一的接口命名规范
测试调试：在不修改代码的情况下改变通信路径
系统集成：连接来自不同开发者的节点

12. 坐标系管理

机器人中的坐标系

在机器人学中，一切都是相对于某个参考系而言的。

1. 为什么需要多个坐标系？

想象一个简单的移动机器人：

它的激光雷达检测到正前方 1 米处有一个障碍物。
这个“1 米”是相对于谁的？是相对于激光雷达自身的光学中心。
如果我们要让机械臂去触碰这个障碍物，或者让底盘绕开它，机械臂和底盘的控制器需要知道这个障碍物相对于它们自己的位置。
因此，我们需要知道激光雷达坐标系、底盘坐标系、机械臂坐标系之间的变换关系。

2. 常见的坐标系类型

基坐标系 (base_link)：通常固定在机器人的中心（例如，底盘的中心）。它是机器人本体上最核心的参考系，其他所有机器人本体上的坐标系都直接或间接地与它相连。
里程计坐标系 (odom)：一个世界固定的坐标系。它的原点通常是机器人启动时的位置。odom 坐标系是通过里程计信息（如轮式编码器、视觉里程计）累积得到的，虽然短期内精确，但长期会有漂移，不会跳变。
地图坐标系 (map)：一个世界固定的坐标系。它通过传感器（如激光雷达、GPS）融合建图算法（如 SLAM）得到，是全局一致、无漂移的。但可能会发生跳变（例如，当算法修正位姿时）。
传感器坐标系：如 laser_frame, camera_depth_optical_frame, imu_link。这些坐标系定义了传感器相对于 base_link 的安装位置和方向。
工具坐标系：如机械臂末端的 tool0 坐标系。

3. 坐标系变换 (Transform)

坐标系之间的关系由变换来描述。一个变换包含两部分：

平移 (Translation)：一个坐标系的原点在另一个坐标系中的 (x, y, z) 坐标。
旋转 (Rotation)：一个坐标系的姿态相对于另一个坐标系的旋转，通常用四元数 (Quaternion) 来表示（比欧拉角更稳定，无万向锁问题）。

一个变换可以完美地回答：“在 laser_frame 中看到的点 (x, y, z)，在 base_link 坐标系中是多少？”

TF 2 - 坐标变换管理神器

TF 2 (Transform Library version 2) 是 ROS 2 中用于跟踪多个坐标系关系的库和工具集。它是 ROS 1 TF 库的升级版，更高效、更安全。

1. TF 2 的核心功能

TF 2 维护着一个随时间变化的坐标系树。

树状结构：所有坐标系通过变换连接成一棵树。每个坐标系只有一个父坐标系，但可以有多个子坐标系。例如：map -> odom -> base_link -> laser_frame。
时间旅行：TF 2 不仅存储最新的变换，还会缓存一段时间的历史变换。这意味着你可以查询“5 秒前的 laser_frame 相对于 map 的变换是什么？”，这对于处理不同时间戳的传感器数据至关重要。

2. TF 2 的工作流程：广播与监听

TF 2 采用“发布-订阅”模型：

广播 (Broadcast)：节点计算出一个坐标系相对于另一个坐标系的变换，然后将其发布到 /tf_static（对于静态的、不变的变换，如传感器安装位置）或 /tf（对于动态的、变化的变换，如移动的底盘）话题上。
监听 (Listen)：需要用到坐标变换的节点（例如，需要将激光点云数据转换到 map 坐标系中进行建图），会向 TF 2 库查询特定的变换。

3. 核心工具和命令

ROS 2 提供了一系列强大的命令行工具来调试和可视化 TF：

ros2 run tf2_ros tf2_echo <source_frame> <target_frame>
- 功能：在终端中实时打印两个坐标系之间的变换（平移和旋转）。
- 示例：ros2 run tf2_ros tf2_echo map base_link 查看机器人当前位置。
ros2 run rviz2 rviz2
- 功能：最强大的可视化工具。添加 TF 显示插件，可以看到所有坐标系的相对位置和姿态的 3 D 可视化。
ros2 run tf2_tools view_frames.py
- 功能：生成一个当前坐标系树的 PDF 图示，清晰地显示所有坐标系之间的连接关系。
ros2 topic echo /tf 和 ros2 topic echo /tf_static
- 功能：直接查看发布到话题上的原始变换消息。

在代码中使用 TF 2 (Python 示例)

1. 广播一个静态变换（例如，激光雷达坐标系）

静态变换只需要广播一次。

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from tf2_ros import StaticTransformBroadcaster
from geometry_msgs.msg import TransformStamped

class StaticTFBroadcaster(Node):
    def __init__(self):
        super().__init__('static_tf_broadcaster')
        self.tf_broadcaster_ = StaticTransformBroadcaster(self)
        
        transform = TransformStamped()
        
        # 设置头信息
        transform.header.stamp = self.get_clock().now().to_msg()
        transform.header.frame_id = 'base_link'  # 父坐标系
        transform.child_frame_id = 'laser_frame' # 子坐标系
        
        # 设置变换：激光雷达安装在 base_link 前方 0.2m，高 0.1m 的位置
        transform.transform.translation.x = 0.2
        transform.transform.translation.y = 0.0
        transform.transform.translation.z = 0.1
        # 没有旋转，所以使用单位四元数
        transform.transform.rotation.x = 0.0
        transform.transform.rotation.y = 0.0
        transform.transform.rotation.z = 0.0
        transform.transform.rotation.w = 1.0
        
        # 发布静态变换
        self.tf_broadcaster_.sendTransform(transform)
        self.get_logger().info('Published static transform from base_link to laser_frame')

def main(args=None):
    rclpy.init(args=args)
    node = StaticTFBroadcaster()
    rclpy.spin(node)
    rclpy.shutdown()

if __name__  '__main__':
    main()

2. 监听/查询一个变换

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from tf2_ros import TransformException
from tf2_ros.buffer import Buffer
from tf2_ros.transform_listener import TransformListener

class TFListener(Node):
    def __init__(self):
        super().__init__('tf_listener')
        self.tf_buffer = Buffer()
        self.tf_listener = TransformListener(self.tf_buffer, self)
        
        # 创建一个定时器，定期查询变换
        self.timer = self.create_timer(1.0, self.on_timer)
        
    def on_timer(self):
        try:
            # 查找最新的从 laser_frame 到 base_link 的变换
            # target_frame, source_frame
            transform = self.tf_buffer.lookup_transform(
                'base_link',
                'laser_frame',
                rclpy.time.Time()) # 获取最新时间的变换
            self.get_logger().info(f'Transform is: {transform}')
        except TransformException as ex:
            self.get_logger().error(f'Could not get transform: {ex}')

def main(args=None):
    rclpy.init(args=args)
    node = TFListener()
    rclpy.spin(node)
    rclpy.shutdown()

if __name__  '__main__':
    main()

3. 转换一个点

这是最常见的应用：将一个点从一个坐标系转换到另一个坐标系。

from tf2_geometry_msgs import do_transform_point
from geometry_msgs.msg import PointStamped

# 假设我们有一个在 laser_frame 中的点
point_in_laser = PointStamped()
point_in_laser.header.frame_id = 'laser_frame'
point_in_laser.point.x = 1.0
point_in_laser.point.y = 0.5
point_in_laser.point.z = 0.0

try:
    # 先查询变换
    transform = self.tf_buffer.lookup_transform('base_link', 'laser_frame', rclpy.time.Time())
    # 转换点
    point_in_base = do_transform_point(point_in_laser, transform)
    self.get_logger().info(f'Point in base_link: {point_in_base.point}')
except TransformException as ex:
    self.get_logger().error(f'Could not transform point: {ex}')

13. urdf

1. URDF 是什么？

URDF 的全称是 统一机器人描述格式。它是一种基于 XML 的文件格式，用于在机器人领域中描述一个机器人的模型。

您可以把它想象成机器人的“蓝图”或“解剖图”，它定义了：

机器人的物理结构：有哪些部件（连杆、关节）以及它们如何连接。
机器人的几何属性：每个部件的大小、形状（长方体、圆柱体、球体等）。
机器人的运动学属性：关节的类型（旋转、平移、固定等）以及它们如何运动（旋转轴、移动方向）。
机器人的动力学属性：质量、惯性矩、摩擦系数等。
视觉属性：每个部件的颜色、纹理。
碰撞属性：用于碰撞检测的简化几何模型。

2. 为什么需要 URDF？

URDF 文件是许多高级功能的基石：

仿真：在 Gazebo、PyBullet 等仿真环境中，需要 URDF 来生成和模拟机器人。
可视化：在 Rviz 等工具中，需要 URDF 来显示机器人模型。
运动规划：MoveIt! 等规划框架需要知道机器人的运动链结构，这来自于 URDF。
控制：控制器管理器需要 URDF 来理解关节之间的关系。

简单来说，没有 URDF，ROS 中的机器人就像没有身体的灵魂，无法被看到、模拟或控制。

3. 核心概念与 XML 标签

一个 URDF 文件总是以 <robot> 标签作为根元素，里面包含两种最核心的元素：<link> 和 <joint>。

3.1 连杆：`<link>`

连杆代表机器人的一个刚体部分，是机器人的基本构成块。例如：机器人底座、轮子、激光雷达、机械臂的每一个臂杆、摄像头顶盖等。

一个典型的 <link> 包含以下子元素：

<visual>：定义连杆的外观，用于可视化（如在 Rviz 中显示）。
- <geometry>：形状。可以是 <box>（长方体）、<cylinder>（圆柱体）、<sphere>（球体）或 <mesh>（网格文件，如 .dae 或 .stl）。
- <origin>：几何体的参考坐标系相对于世界坐标系的位姿（xyz 偏移和 rpy 旋转）。
- <material>：材质。可以指定颜色 (<color>) 或纹理 (<texture>)。
<collision>：定义连杆的碰撞属性，用于物理仿真中的碰撞检测。为了计算效率，碰撞模型通常比视觉模型更简单（例如，用一个长方体近似一个复杂的机械臂连杆）。
- 包含 <geometry> 和 <origin>，与 <visual> 中的类似。
<inertial>：定义连杆的动力学属性，用于物理仿真。
- <mass>：质量（千克）。
- <origin>：质心位置。
- <inertia>：惯性张量（一个 3 x 3 矩阵）。

示例：定义一个名为 “base_link” 的长方体连杆

<link name="base_link">
  <visual>
    <geometry>
      <box size="0.2 0.1 0.05"/> <!-- 长宽高 -->
    </geometry>
    <origin rpy="0 0 0" xyz="0 0 0"/>
    <material name="blue">
      <color rgba="0 0 0.8 1"/> <!-- RGBA，A为透明度 -->
    </material>
  </visual>
  <collision>
    <geometry>
      <box size="0.2 0.1 0.05"/>
    </geometry>
  </collision>
  <inertial>
    <mass value="0.5"/>
    <origin xyz="0 0 0"/>
    <inertia ixx="0.001" ixy="0" ixz="0" iyy="0.001" iyz="0" izz="0.001"/>
  </inertial>
</link>

3.2 关节：`<joint>`

关节描述了两个连杆之间的连接方式，即一个连杆（子连杆）如何相对于另一个连杆（父连杆）运动。

一个 <joint> 的关键属性：

name: 关节的名称（如 “wheel_joint”）。
type: 关节的类型：
- revolute：旋转关节（绕单一轴旋转，有位置极限，如机械臂关节）
- continuous：连续旋转关节（绕单一轴无限旋转，如轮子）
- prismatic：平移关节（沿单一轴移动，有位置极限，如伸缩杆）
- fixed：固定关节（不允许任何运动，子连杆牢牢固定在父连杆上，如传感器固定在底座上）
- planar：平面关节（在垂直于轴的平面内运动）
- floating：浮动关节（完全不受约束的运动，6 自由度）

一个 <joint> 包含以下子元素：

<parent>：父连杆的名字 (<link name=”...”>)。
<child>：子连杆的名字。
<origin>：从父连杆坐标系到子连杆坐标系的变换。这定义了子连杆在“零位”时的位置和姿态。
<axis>：关节运动所围绕的轴（在子连杆坐标系中）。对于旋转关节，这是旋转轴；对于平移关节，这是移动方向。默认是 (1, 0, 0)。
<limit>（仅用于 revolute 和 prismatic 关节）：运动极限。
- lower：下限（弧度或米）
- upper：上限（弧度或米）
- effort：最大 effort（力或扭矩）
- velocity：最大速度（ rad/s 或 m/s）

示例：定义一个连接 “base_link” 和 “wheel” 的连续旋转关节

<joint name="left_wheel_joint" type="continuous">
  <parent link="base_link"/>
  <child link="left_wheel"/>
  <origin xyz="0 0.05 0" rpy="0 0 0"/> <!-- 轮子安装在底座旁边 -->
  <axis xyz="0 1 0"/> <!-- 绕Y轴旋转 -->
</joint>

4. 一个完整的简单 URDF 示例

下面是一个简单的机器人模型，它有一个底座和两个轮子。

<?xml version="1.0"?>
<robot name="my_first_robot">

  <!-- 底座 LINK -->
  <link name="base_link">
    <visual>
      <geometry>
        <box size="0.2 0.1 0.05"/>
      </geometry>
      <material name="blue">
        <color rgba="0 0 0.8 1"/>
      </material>
    </visual>
    <collision>
      <geometry>
        <box size="0.2 0.1 0.05"/>
      </geometry>
    </collision>
    <inertial>
      <mass value="0.5"/>
      <inertia ixx="0.001" ixy="0" ixz="0" iyy="0.001" iyz="0" izz="0.001"/>
    </inertial>
  </link>

  <!-- 左轮 LINK -->
  <link name="left_wheel">
    <visual>
      <geometry>
        <cylinder length="0.02" radius="0.05"/>
      </geometry>
      <material name="black">
        <color rgba="0 0 0 1"/>
      </material>
    </visual>
    <collision>
      <geometry>
        <cylinder length="0.02" radius="0.05"/>
      </geometry>
    </collision>
    <inertial>
      <mass value="0.1"/>
      <inertia ixx="0.0001" ixy="0" ixz="0" iyy="0.0001" iyz="0" izz="0.0001"/>
    </inertial>
  </link>

  <!-- 右轮 LINK -->
  <link name="right_wheel">
    <visual>
      <geometry>
        <cylinder length="0.02" radius="0.05"/>
      </geometry>
      <material name="black"/>
      <!-- 复用名为black的material -->
    </visual>
    <collision>
      <geometry>
        <cylinder length="0.02" radius="0.05"/>
      </geometry>
    </collision>
    <inertial>
      <mass value="0.1"/>
      <inertia ixx="0.0001" ixy="0" ixz="0" iyy="0.0001" iyz="0" izz="0.0001"/>
    </inertial>
  </link>

  <!-- 连接底座和左轮的 JOINT -->
  <joint name="left_wheel_joint" type="continuous">
    <parent link="base_link"/>
    <child link="left_wheel"/>
    <origin xyz="0 0.06 -0.03" rpy="1.5707 0 0"/> 
    <!-- 
    xyz: 安装在底座右侧(y方向)和略下方(z方向)
    rpy: 将圆柱体绕X轴旋转90度（π/2≈1.5707），使其立起来
    -->
    <axis xyz="0 1 0"/>
  </joint>

  <!-- 连接底座和右轮的 JOINT -->
  <joint name="right_wheel_joint" type="continuous">
    <parent link="base_link"/>
    <child link="right_wheel"/>
    <origin xyz="0 -0.06 -0.03" rpy="1.5707 0 0"/>
    <axis xyz="0 1 0"/>
  </joint>

</robot>

5. 超越基础：URDF 的局限性及解决方案

URDF 非常流行，但它也有明显的局限性：

是单体的：URDF 只能描述一个完整的、不可分割的机器人。你不能在 URDF 中定义两个独立的机器人并让它们互动。
是树形结构：URDF 模型必须是一棵树，每个子连杆只能有一个父连杆。这意味着它不能描述闭环结构（例如，一个四杆机构，一个连杆同时被两个关节连接）。
缺乏可扩展性：对于复杂的机器人，一个巨大的 URDF 文件难以维护。

为了解决这些问题，ROS 引入了其他工具和格式作为补充：

Xacro (XML Macros)：这是最重要的实践！ Xacro 是一种宏语言，允许你编写更短、更可读、更模块化的 URDF 文件。它支持：
- 属性（变量）：<xacro:property name=”width” value=”0.2”/>，然后用 ${width} 引用。
- 宏（函数）：<xacro:macro name=”create_wheel” params=”name”> ... </xacro:macro>，然后用 <xacro:create_wheel name=”left”/> 调用。
- 文件包含：<xacro:include filename=”$(find my_robot)/urdf/common.xacro”/>
- 条件判断：<xacro:if value=”${use_mesh}"> ... </xacro:if>
- 最终，Xacro 文件会被预处理成一个纯粹的、扁平的 URDF 文件。强烈建议始终使用 Xacro 来编写机器人模型。
SDF (Simulation Description Format)：被 Gazebo 原生使用的格式。它比 URDF 更强大，支持多个机器人、闭环、插件、大气效果等。当你把 URDF 放入 Gazebo 时，Gazebo 会将其转换为 SDF。
<joint> 标签的巧用：虽然 URDF 本身是树形结构，但通过巧妙定义虚拟的、零质量的连杆和固定关节，有时可以“模拟”出闭环结构，但这很繁琐。

6. 工具与工作流程

编写：使用你喜欢的文本编辑器（如 VSCode）编写 .urdf 或 .xacro 文件。
检查语法：check_urdf my_robot.urdf
可视化：
- urdf_to_graphiz my_robot.urdf：生成一个 PDF，显示连杆和关节的树状图。
- Rviz：启动 Rviz，添加 RobotModel 显示类型，并设置 Description 参数指向你的 URDF 文件路径（例如 robot_description）。
在 Gazebo 中仿真：需要为你的 URDF 添加 Gazebo 特定的标签（如 <gazebo>）来定义仿真属性（颜色、摩擦、传感器插件等）。

CUDA 线程模型与内存优化

Mon, 15 Jun 2026 00:00:00 GMT

CUDA 笔记整理

按截图顺序整理。能抽象重画的图已经改为流程图、表格或公式；代码和索引规则单独整理，方便之后复习。

01. 线程模型与物理结构

CUDA 的线程模型是软件层面的逻辑划分，常见层级为：

Grid -> Block -> Thread

GPU 的物理结构是硬件层面的执行资源，常见层级为：

Device / GPU -> SM -> CUDA Core

左侧线程模型是在逻辑角度分析程序；右侧物理结构是在硬件角度分析执行资源。线程模型可以定义成千上万个线程，但真正同时活跃的线程数量会受到 SM 资源限制。

线程块是调度到 SM 的基本单位。一个 grid 中的所有线程块都需要被分配到 SM 上执行；同一个线程块中的所有线程会被分配到同一个 SM 中执行。一个 SM 可以同时容纳多个线程块，但一个线程块一旦被分配到某个 SM，就不会再被拆分到其他 SM。

线程块分配到 SM 后，会继续以 32 个线程为一组划分成线程束（warp）。

02. 一维线程模型

一维线程模型中，只使用 x 维度来组织 grid 和 block。例如：

kernel_fun<<<2, 4>>>();

含义如下：

gridDim.x = 2：一共有 2 个线程块。
blockDim.x = 4：每个线程块有 4 个线程。
blockIdx.x 的取值范围是 0 ~ 1。
threadIdx.x 的取值范围是 0 ~ 3。

每个线程在整个 grid 中的全局一维编号可以这样计算：

int idx = threadIdx.x + blockIdx.x * blockDim.x;

对应关系如下：

| blockIdx.x | threadIdx.x | 全局编号 idx | |---:|---:|---:| | 0 | 0 | 0 | | 0 | 1 | 1 | | 0 | 2 | 2 | | 0 | 3 | 3 | | 1 | 0 | 4 | | 1 | 1 | 5 | | 1 | 2 | 6 | | 1 | 3 | 7 |

03. 线程束

CUDA 使用 SIMT（Single Instruction Multiple Threads，单指令多线程）模型管理线程执行。线程进入 SM 后，会以 32 个线程为一组组成一个线程束，即 warp。

在同一个线程块中，相邻的 32 个线程构成一个 warp。例如：

第 0 ~ 31 个线程属于 warp 0。
第 32 ~ 63 个线程属于 warp 1。
依此类推。

线程束不会跨线程块组成。也就是说，每个 warp 中只包含同一个 block 中的线程。

常用的线程束内编号计算方式：

int thread_id_in_block = threadIdx.x;
int warp_id = thread_id_in_block / 32;
int lane_id = thread_id_in_block % 32;

04. 流多处理器 SM

GPU 的并行性主要依赖 SM（Streaming Multiprocessor，流多处理器）完成。一个 GPU 通常由多个 SM 构成。

以 Fermi 架构为例，SM 中的关键资源包括：

CUDA 核心（CUDA Core）
共享内存 / L1 缓存（Shared Memory / L1 Cache）
寄存器文件（Register File）
加载和存储单元（Load / Store Units）
特殊函数单元（Special Function Unit，SFU）
Warp 调度器（Warp Scheduler）

SM 内部资源有限，所以同一时刻能驻留的线程块、线程束和线程数量会受到寄存器、共享内存、最大线程数等资源限制。

05. SM 上的并发与并行

GPU 中每个 SM 都可以支持数百个线程并发执行。调度时以线程块 block 为单位向 SM 分配任务，多个线程块可以同时分配到一个可用的 SM 上。

需要注意：

线程块是分配到 SM 的基本单位。
多个线程块可以驻留在同一个 SM。
一个线程块一旦分配到某个 SM，就不会再分配到其他 SM。

并发与并行的区别：

并发：多个任务在时间上交错推进，不一定同时执行。
并行：多个任务在硬件上真正同时执行。

06. 线程束与线程块大小

线程束是 GPU 硬件上非常重要的执行单位：

每个线程束只包含同一个线程块中的线程。
每个线程束包含 32 个线程。
SM 通常以 warp 为单位调度和发射指令。

如果一个线程块的线程数不是 32 的整数倍，最后一个 warp 会存在不满 32 个有效线程的情况，剩余 lane 会处于非活跃状态。

线程块中 warp 数量的计算方式：

int warp_num = (threads_per_block + 31) / 32;

示例：

| 线程块大小 | warp 划分 | 说明 | |---:|---:|---| | (128, 1, 1) | 4 个 warp | 128 / 32 = 4，全部为满 warp | | (112, 1, 1) | 4 个 warp | 前 3 个满 warp，最后一个 warp 只有 16 个有效线程 |

07. 内存分配

主机端内存使用 C / C++ 的内存分配方式，例如 malloc：

float *fpHost_A;
fpHost_A = (float *)malloc(nBytes);

设备端内存使用 CUDA Runtime API 中的 cudaMalloc：

float *fpDevice_A;
cudaMalloc((void **)&fpDevice_A, nBytes);

cudaMalloc 的函数原型：

cudaError_t cudaMalloc(void **devPtr, size_t size);

参数含义：

devPtr：指向设备端已分配内存地址的指针，因此需要传入二级指针。
size：申请的字节数。

返回值类型为 cudaError_t。常见返回结果包括：

cudaSuccess
cudaErrorInvalidValue
cudaErrorMemoryAllocation

08. 内存管理

CUDA 的内存管理主要包括：

内存分配
数据传递
内存初始化
内存释放

标准 C 语言内存管理函数与 CUDA 内存管理函数的对应关系如下：

| 标准 C 函数 | CUDA C 函数 | 作用 | |---|---|---| | malloc | cudaMalloc | 分配内存 | | memcpy | cudaMemcpy | 拷贝数据 | | memset | cudaMemset | 初始化内存 | | free | cudaFree | 释放内存 |

CPU 和 GPU 通常有不同的内存空间。主机端数组不能直接当作设备端数组使用，通常需要用 cudaMemcpy 在 Host 和 Device 之间传递数据。

09. 指定真实架构计算能力

PTX 指令最终会被转换为二进制 cubin 代码，而 cubin 与具体 GPU 架构相关。

指定真实架构计算能力的编译选项：

-code=sm_XY

其中：

X：计算能力主版本号。
Y：计算能力次版本号。
sm_XY：真实 GPU 架构。

注意事项：

二进制 cubin 代码与具体架构相关，不同大版本架构之间通常不能直接兼容。
如果同时指定虚拟架构和真实架构，真实架构计算能力必须大于或等于虚拟架构计算能力。
例如 -arch=compute_61 -code=sm_60 不合理，因为真实架构 sm_60 小于虚拟架构 compute_61。

更合理的写法示例：

nvcc helloworld.cu -o helloworld -arch=compute_61 -code=sm_61

或者降低虚拟架构：

nvcc helloworld.cu -o helloworld -arch=compute_60 -code=sm_60

10. nvcc 编译流程

nvcc 会把 .cu 源代码分离成两类代码：

主机代码（Host code）
设备代码（Device code）

主机代码使用普通 C / C++ 语法编写，由主机编译器处理。设备代码使用 CUDA C / C++ 扩展语法编写，由 nvcc 处理。

设备代码的编译大致分为两步：

先将设备代码编译为 PTX（Parallel Thread Execution）伪汇编代码。
再将 PTX 编译为二进制 cubin 目标代码。

11. 三维网格与三维线程块

CUDA 可以定义三维 grid 和三维 block：

dim3 grid_size(2, 2, 2);
dim3 block_size(4, 4, 2);

kernel_fun<<<grid_size, block_size>>>(...);

在这个例子中：

blockIdx.x、blockIdx.y、blockIdx.z 的取值范围都是 0 ~ 1。
threadIdx.x、threadIdx.y 的取值范围都是 0 ~ 3。
threadIdx.z 的取值范围是 0 ~ 1。

三维 block 编号可以线性化为：

int blockId = blockIdx.x
            + blockIdx.y * gridDim.x
            + gridDim.x * gridDim.y * blockIdx.z;

三维 block 内部的线程编号可以线性化为：

int threadId = threadIdx.z * (blockDim.x * blockDim.y)
             + threadIdx.y * blockDim.x
             + threadIdx.x;

整个 grid 中的全局线性编号为：

int id = blockId * (blockDim.x * blockDim.y * blockDim.z) + threadId;

12. 推广到多维线程

多维网格和多维线程块本质上仍然是逻辑组织方式。GPU 物理执行时并不会真的把线程按二维或三维空间摆放，而是通过索引计算把多维结构映射成线性编号。

示例：

dim3 grid_size(3, 2, 1);
dim3 block_size(5, 3, 1);

这个配置表示：

grid 有 3 * 2 * 1 = 6 个线程块。
每个 block 有 5 * 3 * 1 = 15 个线程。
整个 kernel 启动了 6 * 15 = 90 个线程。

二维情况下常见的线性化方式：

int tid = threadIdx.y * blockDim.x + threadIdx.x;
int bid = blockIdx.y * gridDim.x + blockIdx.x;
int id = bid * (blockDim.x * blockDim.y) + tid;

13. 内建索引变量 `blockIdx` 和 `threadIdx`

CUDA 可以组织三维网格和三维线程块。对应地，blockIdx 和 threadIdx 都是三维结构体类型，具有 x、y、z 三个成员。

blockIdx 和 threadIdx 的类型是 uint3：

blockIdx.x;
blockIdx.y;
blockIdx.z;

threadIdx.x;
threadIdx.y;
threadIdx.z;

三个成员都是无符号整数类型。

14. `dim3` 定义多维网格和线程块

多维 grid 和 block 可以用 dim3 定义。dim3 是 CUDA 中常用的三维尺寸类型，支持 C++ 构造函数语法。

通用写法：

dim3 grid_size(Gx, Gy, Gz);
dim3 block_size(Bx, By, Bz);

示例：定义一个 2 x 2 x 1 的 grid 和一个 5 x 3 x 1 的 block：

dim3 grid_size(2, 2);   // 等价于 dim3 grid_size(2, 2, 1);
dim3 block_size(5, 3);  // 等价于 dim3 block_size(5, 3, 1);

如果省略第三个维度，默认值为 1。

15. 内建尺寸变量 `gridDim` 和 `blockDim`

gridDim 和 blockDim 是 dim3 类型的内建变量，也具有 x、y、z 三个成员：

gridDim.x;
gridDim.y;
gridDim.z;

blockDim.x;
blockDim.y;
blockDim.z;

它们对应 kernel 启动配置中的 grid 尺寸和 block 尺寸。

索引变量的取值范围：

| 变量 | 取值范围 | |---|---| | blockIdx.x | [0, gridDim.x - 1] | | blockIdx.y | [0, gridDim.y - 1] | | blockIdx.z | [0, gridDim.z - 1] | | threadIdx.x | [0, blockDim.x - 1] | | threadIdx.y | [0, blockDim.y - 1] | | threadIdx.z | [0, blockDim.z - 1] |

注意：这些内建变量用于设备端执行上下文，主机端代码不能直接访问它们。

16. 一维线程模型中的内建变量

一维情况下，每个线程在 kernel 中都有唯一身份标识。这个唯一标识由 kernel 启动配置决定：

kernel<<<grid_size, block_size>>>(...);

在设备端，配置值会保存在内建变量中：

gridDim.x：等于启动配置中的 grid_size。
blockDim.x：等于启动配置中的 block_size。

线程索引也保存在内建变量中：

blockIdx.x：当前线程所在 block 在 grid 中的索引，范围为 0 ~ gridDim.x - 1。
threadIdx.x：当前线程在线程块中的索引，范围为 0 ~ blockDim.x - 1。

因此，一维全局线程编号为：

int idx = blockIdx.x * blockDim.x + threadIdx.x;

17. 自定义设备函数

CUDA 中常见函数修饰符包括 __device__、__global__ 和 __host__。

设备函数

设备函数（device function）只能在 GPU 设备上执行，用 __device__ 修饰。

特点：

只能在设备端执行。
只能被 kernel 函数或其他设备函数调用。

示例：

__device__ float add_device(float a, float b) {
    return a + b;
}

核函数

核函数（kernel function）用 __global__ 修饰。它通常由主机端调用，在设备端执行。

特点：

调用时需要使用 <<<grid_size, block_size>>> 配置执行维度。
__global__ 不能和 __host__ 同时使用，也不能和 __device__ 同时使用。

示例：

__global__ void kernel_fun(float *out) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    out[idx] = add_device(out[idx], 1.0f);
}

主机函数

主机函数（host function）在 CPU 端执行，可以用 __host__ 修饰。普通 C++ 函数默认就是主机函数，因此 __host__ 通常可以省略。

同一个辅助函数也可以同时用 __host__ 和 __device__ 修饰，表示编译器分别生成主机端和设备端版本：

__host__ __device__ float add_common(float a, float b) {
    return a + b;
}

18. nvcc 即时编译

即时编译（JIT）指的是：在运行可执行文件时，CUDA Runtime 可以从可执行文件中保留的 PTX 代码临时编译出适配当前 GPU 的 cubin 代码。

如果希望在可执行文件中保留 PTX 代码，可以使用：

-gencode arch=compute_XY,code=compute_XY

注意：

这里的两个计算能力都是虚拟架构计算能力。
两个虚拟架构计算能力必须一致。

常见写法示例：

-gencode arch=compute_35,code=sm_35
-gencode arch=compute_50,code=sm_50
-gencode arch=compute_61,code=sm_61
-gencode arch=compute_61,code=compute_61

其中前三行生成指定真实架构的二进制代码，最后一行保留 compute_61 的 PTX，供运行时 JIT 编译。

简化写法：

-arch=sm_XY

通常可以理解为同时生成当前 sm_XY 的机器码，并保留对应 compute_XY 的 PTX，以便运行时进行兼容处理。

19. CUDA 事件计时

程序执行时间计时是分析 CUDA 程序性能的重要方式。CUDA 中可以使用 event 进行计时。

基本流程：

创建开始事件和结束事件。
在待计时代码前记录 start。
执行待计时代码。
在待计时代码后记录 stop。
同步 stop，确保 GPU 端工作完成。
使用 cudaEventElapsedTime 计算两个事件之间的时间。
销毁事件。

示例代码：

cudaEvent_t start, stop;

cudaEventCreate(&start);
cudaEventCreate(&stop);

cudaEventRecord(start);

// 待计时的 CUDA 代码，例如 kernel 调用
// kernel_fun<<<grid_size, block_size>>>(...);

cudaEventRecord(stop);
cudaEventSynchronize(stop);

float elapsed_time = 0.0f;
cudaEventElapsedTime(&elapsed_time, start, stop);

printf("Time = %g ms.\n", elapsed_time);

cudaEventDestroy(start);
cudaEventDestroy(stop);

由于 kernel 启动通常是异步的，记录结束事件后需要同步，才能得到可靠的 GPU 执行时间。

20. CUDA 内存模型

CUDA 内存模型中常见的内存类型包括：

寄存器（register）
共享内存（shared memory）
本地内存（local memory）
常量内存（constant memory）
纹理内存（texture memory）
全局内存（global memory）

抽象关系如下：

核心理解：

寄存器和本地内存属于单个线程。
共享内存属于单个线程块。
全局内存、常量内存、纹理内存对整个设备上的线程可见。
主机端需要通过 CUDA API 与设备端全局内存交换数据。

21. CUDA 内存的主要特征

CUDA 内存可以从四个角度理解：

物理位置
访问权限
可见范围
生命周期

| 内存类型 | 物理位置 | 访问权限 | 可见范围 | 生命周期 | |---|---|---|---|---| | 全局内存 | 芯片外 | 可读可写 | 所有线程和主机端 | 由主机分配与释放 | | 常量内存 | 芯片外 | 只读 | 所有线程和主机端 | 由主机分配与释放 | | 纹理和表面内存 | 芯片外 | 一般只读 | 所有线程和主机端 | 由主机分配与释放 | | 寄存器内存 | 芯片内 | 可读可写 | 单个线程 | 所在线程 | | 本地内存 | 芯片外 | 可读可写 | 单个线程 | 所在线程 | | 共享内存 | 芯片内 | 可读可写 | 单个线程块 | 所在线程块 |

从性能角度看，芯片内资源通常更快，但容量更有限；芯片外内存容量更大，但访问延迟更高。

22. 不同 CUDA 内存层次的具体使用方法

CUDA 内存层次的选择，本质上是在三个目标之间做平衡：

让访问尽量靠近计算单元。
让同一份数据被尽量多的线程复用。
让 warp 中相邻线程的访问尽量规则、连续、合并。

寄存器

寄存器是每个线程私有的最快存储资源。设备端函数中的普通标量局部变量通常会被编译器放入寄存器。

适合放在寄存器中的数据：

当前线程频繁使用的临时变量。
循环中的累加器。
不需要与其他线程共享的小规模标量。

示例：

__global__ void saxpy(float *y, const float *x, float a, int n) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < n) {
        float xi = x[idx];        // 通常进入寄存器
        float yi = y[idx];        // 通常进入寄存器
        y[idx] = a * xi + yi;
    }
}

使用寄存器时要注意寄存器压力。每个线程使用的寄存器越多，同一个 SM 上能同时驻留的线程束可能越少，进而影响 occupancy 和延迟隐藏能力。

常用检查方式：

nvcc -Xptxas -v kernel.cu

编译输出中可以看到每个 kernel 使用的 register 数量、shared memory 数量和 local memory 数量。

本地内存

本地内存（local memory）名字里有“本地”，但它通常位于芯片外的设备内存中，只是访问范围属于单个线程。

本地内存常见来源：

单个线程里的大数组。
下标无法在编译期确定的数组访问。
寄存器不够时发生 register spilling。

示例：

__global__ void example(float *out) {
    float tmp[128];  // 可能进入 local memory
    int idx = threadIdx.x;
    tmp[idx] = 1.0f;
    out[idx] = tmp[idx];
}

本地内存的使用原则：

尽量避免在单个线程中定义过大的局部数组。
如果数据会被同一个 block 内多个线程复用，优先考虑共享内存。
如果只是少量标量，尽量保持为普通局部变量，让编译器放入寄存器。
通过 nvcc -Xptxas -v 或 Nsight Compute 观察是否出现较多 local memory 访问。

共享内存

共享内存位于 SM 上，由同一个 block 内的线程共享，生命周期为该 block 的执行期间。

适合使用共享内存的场景：

同一个 block 内多个线程会重复使用同一批全局内存数据。
需要在线程块内部进行协作，例如规约、扫描、矩阵分块计算。
需要把非连续的全局内存访问重排为更规则的访问。

静态共享内存声明：

__global__ void kernel(float *out, const float *in) {
    __shared__ float tile[256];

    int tid = threadIdx.x;
    int idx = blockIdx.x * blockDim.x + tid;

    tile[tid] = in[idx];
    __syncthreads();

    out[idx] = tile[tid] * 2.0f;
}

动态共享内存声明：

__global__ void kernel(float *out, const float *in) {
    extern __shared__ float tile[];

    int tid = threadIdx.x;
    int idx = blockIdx.x * blockDim.x + tid;

    tile[tid] = in[idx];
    __syncthreads();

    out[idx] = tile[tid];
}

启动动态共享内存 kernel 时，第三个配置参数表示每个 block 动态分配的共享内存字节数：

int threads = 256;
int shared_bytes = threads * sizeof(float);
kernel<<<grid_size, threads, shared_bytes>>>(out, in);

共享内存使用要点：

写入共享内存后，如果其他线程要读取这些数据，需要使用 __syncthreads()。
__syncthreads() 是 block 级同步，不能同步不同 block。
不要在部分线程进入、部分线程不进入的分支中随意调用 __syncthreads()，否则可能死锁。
共享内存容量有限，使用过多会降低每个 SM 可驻留的 block 数。

共享内存 bank conflict

共享内存被分成多个 bank。一个 warp 中多个线程如果访问落在同一个 bank 的不同地址，就可能产生 bank conflict，访问会被串行化。

常见规避方法：

让相邻线程访问相邻地址。
对二维 tile 增加 padding。
访问转置数据时尤其注意 bank conflict。

二维 tile padding 示例：

#define TILE_DIM 32

__shared__ float tile[TILE_DIM][TILE_DIM + 1];

这里多出的 + 1 可以改变每一行的起始 bank 分布，常用于减少转置访问时的 bank conflict。

全局内存

全局内存位于芯片外，容量大、生命周期由主机端分配和释放，所有线程都可以访问。它是 GPU 上最常用的数据存储位置，但访问延迟也较高。

设备端全局内存分配：

float *d_x = nullptr;
cudaMalloc((void **)&d_x, n * sizeof(float));

主机和设备之间传输数据：

cudaMemcpy(d_x, h_x, n * sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy(h_x, d_x, n * sizeof(float), cudaMemcpyDeviceToHost);

释放设备内存：

cudaFree(d_x);

全局内存访问最重要的性能原则是合并访问（coalesced access）。理想情况下，一个 warp 中相邻线程访问连续地址：

int idx = blockIdx.x * blockDim.x + threadIdx.x;
float v = x[idx];  // 相邻线程读取相邻元素

应尽量避免大跨度访问：

int idx = (blockIdx.x * blockDim.x + threadIdx.x) * stride;
float v = x[idx];  // stride 较大时，访存效率通常较差

常量内存

常量内存适合保存所有线程只读的小型数据，例如模型参数、滤波器系数、查找表和配置常量。

声明常量内存：

__constant__ float c_coeff[64];

主机端写入常量内存：

float h_coeff[64];
cudaMemcpyToSymbol(c_coeff, h_coeff, sizeof(h_coeff));

设备端读取：

__global__ void kernel(float *out, const float *in) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    out[idx] = in[idx] * c_coeff[0];
}

常量内存的最佳使用场景是：同一个 warp 中很多线程读取同一个常量地址。此时硬件可以广播读取结果。若 warp 中每个线程读取不同常量地址，效果通常会变差。

纹理内存和表面内存

纹理内存和表面内存适合图像、二维数组、空间局部性明显或访问模式不完全连续的数据。

常见用途：

图像处理中的二维邻域访问。
访问具有空间局部性的只读数据。
利用纹理硬件支持的地址模式、过滤模式和缓存行为。

简单的一维数组计算通常优先使用全局内存加合并访问；只有当访问模式、缓存特征或图像语义适合时，再考虑纹理或表面对象。

页锁定主机内存

普通主机内存是 pageable memory。CUDA 数据传输时，如果主机内存是页锁定内存（pinned memory），通常可以获得更高的主机和设备传输带宽，也可以配合异步拷贝使用。

分配页锁定主机内存：

float *h_x = nullptr;
cudaMallocHost((void **)&h_x, n * sizeof(float));

释放：

cudaFreeHost(h_x);

异步拷贝示例：

cudaStream_t stream;
cudaStreamCreate(&stream);

cudaMemcpyAsync(d_x, h_x, n * sizeof(float),
                cudaMemcpyHostToDevice, stream);

kernel<<<grid_size, block_size, 0, stream>>>(d_x);

cudaStreamSynchronize(stream);
cudaStreamDestroy(stream);

注意：页锁定内存会减少操作系统可分页内存，分配过多会影响系统整体性能。一般只对频繁传输的大块缓冲区使用。

统一内存

统一内存（Unified Memory）用 cudaMallocManaged 分配，主机和设备可以通过同一个指针访问。

float *x = nullptr;
cudaMallocManaged(&x, n * sizeof(float));

for (int i = 0; i < n; ++i) {
    x[i] = 1.0f;        // Host 访问
}

kernel<<<grid_size, block_size>>>(x);
cudaDeviceSynchronize();

cudaFree(x);

统一内存适合：

快速原型开发。
数据结构复杂、手动管理 Host / Device 副本成本较高的场景。
不想显式写大量 cudaMemcpy 的场景。

性能敏感代码中，建议配合预取使用：

int device = 0;
cudaMemPrefetchAsync(x, n * sizeof(float), device);
kernel<<<grid_size, block_size>>>(x);
cudaDeviceSynchronize();

统一内存简化了编程模型，但并不等于没有数据移动成本。页面迁移、缺页和访问位置变化仍然会影响性能。

不同内存层次的选择表

| 使用场景 | 优先考虑的内存 | |---|---| | 单个线程频繁使用的小标量 | 寄存器 | | 单个线程私有但较大的临时数组 | 尽量避免，必要时为本地内存 | | 同一 block 内线程共享和复用数据 | 共享内存 | | 大数组、输入输出张量、跨 block 可见数据 | 全局内存 | | 所有线程只读且很多线程读同一地址的小表 | 常量内存 | | 图像、二维空间局部性强的只读访问 | 纹理内存 | | 图像或二维数据写入，有专门 surface 语义 | 表面内存 | | 频繁 Host / Device 传输的大缓冲区 | 页锁定主机内存 | | 需要简化内存管理或快速原型 | 统一内存 |

23. CUDA 内存访问最佳实践

优先优化全局内存访问

很多 CUDA kernel 的瓶颈不是计算，而是全局内存带宽。优化时应先检查：

相邻线程是否访问相邻地址。
是否存在 stride 很大的访问。
是否存在重复读取但没有复用。
是否有不必要的 Host / Device 数据传输。

好的访问模式：

int idx = blockIdx.x * blockDim.x + threadIdx.x;
y[idx] = x[idx] * 2.0f;

较差的访问模式：

int idx = (blockIdx.x * blockDim.x + threadIdx.x) * stride;
y[idx] = x[idx] * 2.0f;

如果算法天然需要跨步访问，可以考虑先用共享内存做 tile 缓存和重排。

使用共享内存提高数据复用

共享内存适合把全局内存中会被多次使用的数据搬到 SM 上。典型例子是矩阵乘法中的 tile：

#define TILE 16

__global__ void matmul_tiled(const float *A, const float *B, float *C, int N) {
    __shared__ float As[TILE][TILE];
    __shared__ float Bs[TILE][TILE];

    int tx = threadIdx.x;
    int ty = threadIdx.y;
    int row = blockIdx.y * TILE + ty;
    int col = blockIdx.x * TILE + tx;

    float sum = 0.0f;

    for (int t = 0; t < N; t += TILE) {
        As[ty][tx] = A[row * N + (t + tx)];
        Bs[ty][tx] = B[(t + ty) * N + col];
        __syncthreads();

        for (int k = 0; k < TILE; ++k) {
            sum += As[ty][k] * Bs[k][tx];
        }
        __syncthreads();
    }

    C[row * N + col] = sum;
}

实际代码还需要处理 N 不能整除 TILE 的边界情况。这里重点是模式：全局内存加载一次，block 内多个线程在共享内存中重复使用。

减少 Host 和 Device 之间的数据传输

PCIe 或 NVLink 传输通常比 GPU 内部带宽慢。实践中应尽量：

把多个小传输合并成大传输。
数据能留在 GPU 上就不要频繁拷回 CPU。
使用页锁定主机内存提升传输带宽。
用 cudaMemcpyAsync 和 stream 尝试重叠传输与计算。

常见流程：

Host 初始化数据
-> 一次性拷贝到 Device
-> 多个 kernel 在 Device 上连续处理
-> 最后只把必要结果拷回 Host

区分缓存、复用和同步

共享内存不是越多越好。它真正有价值的前提是：

数据从全局内存读入后会被复用。
复用发生在同一个 block 内。
__syncthreads() 的同步成本小于减少的全局内存访问成本。

如果每个数据只读一次，且访问本来就是合并的，把它搬进共享内存可能没有收益，甚至会变慢。

控制寄存器压力

过多寄存器会降低 SM 上可同时驻留的 warp 数量。优化时需要在“每个线程更快”和“更多 warp 隐藏延迟”之间平衡。

常见方法：

拆分过大的 kernel。
减少过长的临时变量生命周期。
避免单线程维护过多中间结果。
查看编译器报告中的 register 和 local memory 使用量。

可以辅助使用：

nvcc -Xptxas -v kernel.cu

必要时也可以尝试 __launch_bounds__ 或 -maxrregcount，但这类手段可能导致 register spilling，需要结合 profiling 判断。

使用 `const` 和 `restrict`

如果输入指针只读，可以声明为 const。如果能保证多个指针不指向同一片内存，可以使用 __restrict__ 帮助编译器优化访存。

__global__ void add_kernel(const float *__restrict__ a,
                           const float *__restrict__ b,
                           float *__restrict__ c,
                           int n) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < n) {
        c[idx] = a[idx] + b[idx];
    }
}

__restrict__ 需要程序员保证别名关系正确。如果实际上传入了重叠内存，结果可能不符合预期。

注意二维数据的布局

二维数据如果按行主序存储，相邻线程最好沿 x 方向访问连续元素：

int x = blockIdx.x * blockDim.x + threadIdx.x;
int y = blockIdx.y * blockDim.y + threadIdx.y;
int idx = y * width + x;

对于二维数组分配，可以考虑 cudaMallocPitch，让每一行满足更合适的对齐：

float *d_img = nullptr;
size_t pitch = 0;
cudaMallocPitch((void **)&d_img, &pitch,
                width * sizeof(float), height);

访问时要用 pitch 计算行起始地址：

char *row_ptr = (char *)d_img + y * pitch;
float *row = (float *)row_ptr;
float value = row[x];

先测量再优化

内存优化不要只凭直觉。建议使用 profiling 工具观察：

全局内存 load / store efficiency。
是否存在非合并访问。
shared memory bank conflict。
register 数量和 occupancy。
Host / Device memcpy 时间。
kernel 是否被内存带宽限制。

常用工具：

Nsight Systems：看 CPU、GPU、数据传输和 kernel 时间线。
Nsight Compute：看单个 kernel 的访存效率、occupancy、warp stall 原因等细节。

内存优化检查清单

写 CUDA kernel 时可以按下面顺序检查：

全局内存访问是否合并。
Host / Device 拷贝是否最少化。
数据是否能在 GPU 上连续处理，避免频繁拷回 CPU。
block 内重复使用的数据是否适合放入共享内存。
共享内存访问是否存在明显 bank conflict。
__syncthreads() 是否必要，是否所有线程都会到达。
常量数据是否适合放入 __constant__。
单线程局部数组是否导致 local memory 访问。
寄存器数量是否过多，是否影响 occupancy。
是否用 profiling 结果验证优化确实有效。

24. 延迟隐藏的概念

指令延迟指一条指令从发出到完成之间经历的时钟周期数。

如果每个时钟周期中，所有 warp 调度器都有一个满足条件、可以发射的线程束，那么计算资源就可以保持较高利用率。

GPU 会通过调度其他线程束的计算来隐藏当前线程束的指令延迟，这种机制称为延迟隐藏。

典型情况：

某个 warp 因为等待内存访问或数据依赖而停顿。
SM 的 warp scheduler 切换到另一个已经准备好的 warp。
只要可调度 warp 足够多，硬件执行单元就不容易空闲。

指令可以粗略分为两种基本类型：

算术指令
内存指令

内存指令通常延迟更高，因此充足的活跃 warp 数量对隐藏内存访问延迟尤其重要。

25. 参考资料

最优化笔记

Tue, 13 Jan 2026 00:00:00 GMT

import PdfViewer from '@/components/blog/PdfViewer.astro'

import optimizationNoteUrl from './optimization-note.pdf?url'

最优化笔记

数学分析（下）

Sat, 30 Nov 2024 00:00:00 GMT

数学分析（下）

广义积分

P46

无穷限

定义为定积分的极限
积分第二中值定理P54
判断敛散性
- 可以积分的直接积分来观察极限是否存在
- 柯西收敛
- 比较判别法（记得绝对值）
- 与$1/x^p$比较（p>1 收敛，$p \leq 1$发散）
- 迪利克雷判别法P57
  - 被积函数=$f(x)*g(x)$
  - f 积分有界
  - g单调趋于零
- 阿贝尔判别法
  - 被积函数=$f(x)*g(x)$
  - f收敛
  - g单调有界

瑕积分

P61

判断敛散性
- 柯西收敛
- 比较判别法
- 与$1/(x-a)^p$比较（$p<1$ 收敛，$p \geq 1$发散）
- 迪利克雷判别法
  - 被积函数=$f(x)*g(x)$
  - f 积分有界
  - g单调趋于零
- 阿贝尔判别法
  - 被积函数=$f(x)*g(x)$
  - f收敛
  - g单调有界

函数项级数

P70

函数序列
- 一串函数
函数项级数
- 函数序列对于每个确定x组成的数列
极限函数
- $\lim_{n \to \infty} f_n(x) = f(x)$
部分和序列
- 部分和
- 是n的函数
和函数
- 部分和序列的极限
一致收敛
- 级数极限=极限函数在x的取值
- 放心地交换极限次序（$x \to x_0$ / $n \to +\infty$）
- 放心地交换积分和极限的次序
- 放心地交换极限与微商的顺序
判断敛散性（部分和的思想）
- 可以积分的直接积分
- 达朗贝尔判别法
  - 前后两项相除
- 柯西收敛
- 维尔斯特拉斯判别法（M判别法）
  - $|u_k(x)| \leq M_k$
  - $M_k$收敛
  - 迪利克雷判别法
    - $a_n b_n$
    - a一致有界
    - b单调趋于零
  - 阿贝尔判别法
    - $a_n b_n$
    - a一致收敛
    - b一致有界，每个b都单调
分析性质
- 逐项可积
  - 求和和积分可交换
- 逐项求导
- 做题：求和函数
  1. 求收敛域2~3‘
  2. 看模板
  3. 有分母先导后积，无分母先积后导
  4. 写出和函数，记得结合实际情况把收敛域写出来

幂级数

P96

阿贝尔引理
- 收敛点之内收敛
- 发散点之外发散
收敛半径唯一
求收敛半径
- 相邻系数之比的极限
  - 达朗贝尔判别法
  - 求极限确定r
  - 考虑边界
阿贝尔第二引理P101
幂级数的和函数S在收敛区域内
- 逐项微商
- 逐项积分
函数的幂级数展开

傅里叶级数

P114

三角函数系
- 正交性（任意两个不同函数的乘积在[-\pi, \pi]积分为0）
收敛到傅里叶级数的条件
- 逐段可微
计算傅里叶系数(考题基本上都来自这里P142)
- 对称的2\pi区间上的
  - 判断奇偶——简化
  - $a_0 = \frac{1}{\pi} \int_{-\pi}^{\pi} f(x) , dx$
  - $a_n = \frac{1}{\pi} \int_{-\pi}^{\pi} f(x) \cos(nx) , dx$
  - $b_n = \frac{1}{\pi} \int_{-\pi}^{\pi} f(x) \sin(nx) , dx$
  - $f(x) = a_0 + \sum_{n=1}^{\infty} (a_n \cos(nx) + b_n \sin(nx))$
- 非对称的
  - 周期为2L——变量代换x = \frac{l}{x}t
  - 记住延拓完之后，要把x代入回原来的f(x)当中
  - 没有周期
    - 奇延拓
    - 偶延拓

平面点集与多元函数

P158

平面点集

概念明确
- 内点：存在邻域在E内
- 外点：存在邻域不在E内
- 边界点：任意邻域都有E的点也有E外的点
- 聚点：任意空心邻域有E内的点
关系
- 内点一定是聚点
- 边界点可能是聚点，也可能是孤立点
常见平面点集
- 开集：所有点都是内点
- 闭集：所有聚点都属于E
- 连通集：任意两点用有线条直线段相连
- （开）区域：连通的开集
- 闭区域：连通的闭集
关系
- 区域总是开集，反之不一定
- 闭区域总是闭集，反之不一定
（威尔斯特拉斯）W.T定理
- 如果点列{(P_n)}有界，那必有收敛子列
- 证明：连续用两次实数的致密性定理来证明（注意下标）
- $P_n = (x_n, y_n)$ 有界，$x_n, y_n$ 都有界。$x_n$ 有收敛子列 $x_{n_k} \rightarrow x_0$，那么 $y_{n_k}$ 也有界，有收敛子列 $y_{n_{k_l}} \rightarrow y_0$，那么 $x_{n_{k_l}}$ 是 $x_{n_k}$ 的子列，也收敛于 $x_0$。所以有收敛子列
矩形套定理
- 一直缩小，最后所有的矩形交于一点
- 证明：对两个坐标方向分别用区间套定理
有限覆盖定理
- 如果有界闭集F被无限个开区间的集合\sum所覆盖，那么必可从\sum中选取有限个开区间所组成的\sum^*也覆盖F。
- 将无限转化为有限

二元函数

二元函数的极限问题（全面极限）
- 证明的时候要用极限的定义来证明
- 可以用三角换元，但是要满足保证在所有方向上趋近于原点（角度要取完）
- 证明极限不存在只需要找一个特例
累次极限
- 全面极限和两个累次极限的存在性并无必然联系
- 但当它们存在的时候，极限值有一定的关系
  - 如果三个都存在，那么三者必相等
  - 如果两个累次极限存在但是不相等，那么全面极限必不存在（沿着特殊方向的极限值不同）
二元函数的连续性
- 对于一个二元函数，如果对于任意固定的y是x的一元连续函数，同理，对于任意固定的x是y的一元连续函数，并不能推出这个二元函数是连续的
- 讨论连续性的问题
  - 对于一般点，用定义，初等函数直接带入极限值
  - 对于特殊点（没有定义的点），则要计算在该点的极限，然后看看要不要补充定义
- 复合函数的连续性（同时连续才算连续）
有界闭区域上的连续函数
- 有界
  - 用反证法，假设无界
- 有最大值和最小值
- 一致连续
  1. 设D是一个有界闭集，f(x,y)是定义在D上的二元连续函数。
  2. 根据有界闭集的性质，我们知道D上的任意点列都有收敛的子列，并且子列的极限点仍然在D
  3. 假设 $f(x,y)$ 在 $D$ 上不一致连续，那么存在 $\epsilon_0 > 0$，以及点列 ${(x_n, y_n)}$ 和 ${(x_n', y_n')}$（$n=1,2,3,\ldots$），满足
  $\lim_{n \to \infty} \sqrt{(x_n - x_n')^2 + (y_n - y_n')^2} = 0$，但
  
  $|f(x_n, y_n) - f(x_n', y_n')| \geq \epsilon_0。$
  1. 由于 $D$ 是有界闭集，点列 ${(x_n, y_n)}$ 和 ${(x_n', y_n')}$ 都有收敛的子列。设 ${(x_{n_k}, y_{n_k})}$ 和 ${(x_{n_k}', y_{n_k}')}$ 是收敛的子列，且它们的极限分别为 $(x_0, y_0)$ 和 $(x_0', y_0')$。
  2. 根据极限的性质，我们有
  $\lim_{k \to \infty} \sqrt{(x_{n_k} - x_{n_k}')^2 + (y_{n_k} - y_{n_k}')^2} = 0$，即 $(x_0, y_0) = (x_0', y_0')$。
  1. 由于f(x,y)在D上连续，根据连续函数的性质，我们有
  $\lim_{k \to \infty} f(x_{n_k}, y_{n_k}) = f(x_0, y_0) = f(x_0', y_0') = \lim_{k \to \infty} f(x_{n_k}', y_{n_k}')$。
  1. 但是这与第三步中的结论 $|f(x_n, y_n) - f(x_n', y_n')| \geq \epsilon_0$ 矛盾，因为当 $k$ 足够大时，$|f(x_{n_k}, y_{n_k}) - f(x_{n_k}', y_{n_k}')|$ 应该小于 $\epsilon_0$。
  2. 因此，我们的假设——f(x,y)在D上不一致连续——是错误的，所以f(x,y)在D上一致连续。
- 介值定理

偏导数与全微分

P180

偏导数

本质：把曲面取一个截面变成曲线，来研究曲线在某个方向的导数

注意：

与一元函数可导就连续不同，二元函数偏导数存在不能完全反映曲面性质
与一元函数可导即可微不同，二元函数必须偏导数连续，才可微

全微分

$\Delta z = f(x_0 + \Delta x, y_0 + \Delta y) - f(x_0, y_0) = A \Delta x + B \Delta y + o(\rho)$

$dz = f_x(x_0, y_0) \Delta x + f_y(x_0, y_0) \Delta y$

二元函数的全微分是函数全该变量的线性主部（这后面在证明的时候有很大用，看变化量与全微分之差是不是距离的无穷小量）

dz其实是关于x, y, dx, dy的四元线性函数

而四者是独立的

所以在求二阶全微分的时候，有d(dx) = d(dy) = 0

题型：判断函数在某一点的可微性
1. 用定理：偏导数存在且在这一点连续
2. 用定义：（用定义）先求出偏导数，注意区分x_0, \Delta x，用全变化减去微分，看是不是o(\rho)
题型：求近似值
1. 确定x_0, y_0, \Delta x, \Delta y
2. 根据微分的定义，写出 $f(x_0 + \Delta x, y_0 + \Delta y) = f(x_0, y_0) + f_x(x_0, y_0) \Delta x + f_y(x_0, y_0) \Delta y$

高阶全微分

画出树状图

若f_{xy}与f_{yx}都连续则相等

$d^n u = \left( \frac{\partial}{\partial x} dx + \frac{\partial}{\partial y} dy \right)^n f(x, y)$

复合函数与隐函数微分

题型：直接考察求导
- 画出树状图，用链式法则，注意区分乘法的求导法则
- $du = \frac{\partial u}{\partial s} ds + \frac{\partial u}{\partial t} dt = \left( \frac{\partial f}{\partial x} \frac{\partial x}{\partial s} + \frac{\partial f}{\partial y} \frac{\partial y}{\partial s} \right) ds + \left( \frac{\partial f}{\partial x} \frac{\partial x}{\partial t} + \frac{\partial f}{\partial y} \frac{\partial y}{\partial t} \right) dt$
题型：复合函数
- 例如 $F(xy, y+z, xz) = 0$，求 $\frac{\partial z}{\partial x}, \frac{\partial z}{\partial y}$
  1. 假设确定隐函数z = z(x, y)
  2. 方程两边对x和y分别求偏导
  3. 联立方程

几何应用

求切向量法向量

曲线
- 曲线只有切向量和法平面
- 切向量 $\overrightarrow{\gamma} = (x'(t_0), y'(t_0), z'(t_0)) = (A, B, C)$
- 如果曲线由两个曲面 $F, G$ 的交线来定义，那么 $\overrightarrow{\gamma} = \left( \frac{\partial(F, G)}{\partial(y, z)}, \frac{\partial(F, G)}{\partial(z, x)}, \frac{\partial(F, G)}{\partial(x, y)} \right)$
曲面
- 曲面只有切平面和法向量
- 法向量 $\overrightarrow{n} = (F_x, F_y, F_z) = (A, B, C)$
- 特别的，如果z = f(x, y)那么
共同的部分
- 由一个向量求所在直线方程和垂直的平面方程
- 直线方程（自由度为1，所以要两个方程来限定）：$\frac{x - x_0}{A} = \frac{y - y_0}{B} = \frac{z - z_0}{C}$
- 平面方程（自由度为2，所以只需要一个方程）：$A(x - x_0) + B(y - y_0) + C(z - z_0) = 0$

方向导数

沿着 $l$ 方向的方向余弦 $l_0 = (\cos \alpha, \cos \beta, \cos \gamma)$

梯度 $\nabla = \left( \frac{\partial f}{\partial x}, \frac{\partial f}{\partial y}, \frac{\partial f}{\partial z} \right)$

方向导数就是给梯度赋权，权值就是方向余弦

所以 $\frac{\partial f}{\partial l} = \nabla \cdot (\cos \alpha, \cos \beta, \cos \gamma)$

泰勒展开

$f(x_0 + \Delta x, y_0 + \Delta y) = \sum_{k=0}^n \frac{1}{k!} \left( \frac{\partial}{\partial x} dx + \frac{\partial}{\partial y} dy \right)^k f(x_0, y_0) + R$

隐函数存在定理

P225

单个方程的形式

如果 $F(x, y)$ 在某一点 $P_0(x_0, y_0)$ 附近满足

$F_x, F_y$ 连续
$F(P_0) = 0$（通常为初始条件）
$F_y(P_0) \ne 0$，那么在 $P_0$ 点附近存在唯一的隐函数 $y = f(x)$，且在 $x_0$ 邻域连续，且有连续的导数

方程组的形式

$F(x, y, u, v), G(x, y, u, v)$ 满足

对各变元有一阶连续偏导,
$F(P_0) = G(P_0) = 0,$
$J|_{P_0} = \frac{\partial(F, G)}{\partial(u, v)} \ne 0$，那么在 $P_0$ 附近唯一确定连续的隐函数 $u = u(x, y), v = v(x, y)$，且有连续的导数

$\frac{\partial(x, y)}{\partial(u, v)} \cdot \frac{\partial(u, v)}{\partial(x, y)} = 1$

极值与条件极值

P241

多元函数的极值

稳定点——所有偏导数都为0
极值的必要条件
- 所有偏导数都为0
- 注意不是充分条件（z = xy在(0, 0)偏导数都为0，但是在该点附近都有异号的函数值）
D的定义：
- $a_{11} = f_{xx}(x_0, y_0), \space a_{12} = f_{xy}(x_0, y_0), \space a_{22} = f_{yy}(x_0, y_0), \space \ D = \left| \begin{matrix} a_{11} & a_{12} \ a_{12} & a_{22} \end{matrix} \right|$
极值的判别（考察）
- （在该点的领域内有二阶连续偏导数）$f_x(x_0, y_0) = f_y(x_0, y_0) = 0$
  - 若 $D > 0$，当 $a_{11}(a_{22}) > 0$ 取得极小值；当 $a_{11}(a_{22}) < 0$ 取得极大值。
  - 若D < 0 不是极值点
  - 若D = 0 不能判断
- 证明：用泰勒公式
- 做题：
  1. 求一阶偏导，令偏导为0得到稳定点（注意在求解方程的时候，可能会得到两个未知数之间的关系，这个时候一定要带回方程里完全解出来）
  2. 求二阶偏导，算D
  3. 看$a_{11}$的符号

最小二乘法

本质上就是给了一个误差函数，求这个误差函数的极小值

$f(a, b) = \sum_{i=1}^{n} (ax_i + b - y_i)^2$
1. 对他求一阶导，令一阶导数为0，得到方程组
2. 用克拉默法则解方程（注意a和b才是未知数）

多元函数的最值

一句话：可能的最值点包括可能的极值点和边界点

所以先求出极值点，以及边界值，然后做对比即可

条件极值

什么叫条件极值
- 在整个空间里的叫做无条件极值
- 有方程约束范围的叫做条件极值
  - 每个（方程）条件就相当于一个隐函数，可以带入消元
  - 思想：化为无条件极值求解

拉格朗日乘数法

对于上面提到的条件极值

假设 $f(x, y, u, v)$ 在约束条件

$$ \begin{cases} F(x, y, u, v) = 0,\ G(x, y, u, v) = 0\ (F, G \text{ 不重}) \end{cases} $$

下在 $P_0(x_0, y_0, u_0, v_0)$ 点取极值，那么存在唯一的 $\lambda_1, \lambda_2$，使得

$$ \begin{cases} L_x(P_0) = L_y(P_0) = L_u(P_0) = L_v(P_0) = 0,\ F(P_0) = G(P_0) = 0 \end{cases} $$

其中 $L = f + \lambda_1 F + \lambda_2 G$

做题
1. 写出拉格朗日函数
2. 求导，令导函数为0
3. 解方程得到稳定点
4. 通过极值的判断条件来判断
  1. 求二阶导数（求之前要用隐函数存在定理确定导数存在）
  2. D
  3. $a_{11}$

含参变量的积分

P270

一般情况

首先我们要理解什么叫含参变量的积分

每一个 $[a, b]$ 上固定的 $x_0$，对应的 $\int_c^d f(x_0, y) dy$ 都是一个【数】；当 $x$ 变动的时候，就定义了一个【函数】

$$I(x) = \int_c^d f(x, y) dy, \quad x \in [a, b]$$

参变量为 $x$

性质
- f 连续，I 就连续
- 放心交换积分和极限
- 只要偏导数连续就放心求导I'(x) = \int_c^d f_x(x, y) dy
题型：给你一个含参变量的函数，要求把其他变量消掉
- 大胆对内求导
- 把关于y的积分算出来（消掉y）
- 求x的积分
- 确定常数C
题型：要求主动引入参变量的积分（压轴题）
- 引入参变量\alpha \in [0, 1]，原来的I = I(1)，最好保证I(0) = 0（有利于后面构造积分）
- 对内求导数
- 把关于x的积分算出来
- $I = I(1) = I(1) - I(0) = \int_0^1 I'(\alpha) d\alpha$
- 求出积分即可

积分上下限也依赖于参数x P265

$I(x, u) = \int_c^u f(x, y) dy$

请尤其关注这个式子

$$\frac{d \left(\int_c^x f(t) dt\right)}{dx} = f(x)$$

变上限积分的导数为原函数

性质：
- f连续则I连续，放心求导，导函数存在且连续
- 不用担心连续问题：
- $f$ 在 $[a, b] \times [c, d]$ 连续，且 $c(x), d(x)$ 也在 $[a, b]$ 连续，有导数，$c < c(x), d(x) < d$，则
$$F(x) = \int_{c(x)}^{d(x)} f(x, y) dy$$

连续，且

$$F'(x) = \int_{c(x)}^{d(x)} f_x(x, y) dy + f(x, d(x)) d'(x) - f(x, c(x)) c'(x)$$

（链式法则：分别对 $x$，$c$，$d$ 求导 + 复合函数求导）
做题：求正常求不出来的积分的导数
性质：放心积分交换次序
- $\int_a^b dx \int_c^d f(x, y) dy = \int_c^d dy \int_a^b f(x, y) dx$

重积分

P292

三重积分交换次序

对于 $\int_a^b dx \int_c^d dy \int_e^f f(x, y, z) dz$ 的两种理解
- $\int_a^b \left[\iint_{D_z} dx dy\right] dz$，即先对特定 $z$ 求切片面积，再对 $z$ 求积分
- $\left[\iint_{D} dx dy\right] \int_{\psi(x, y)}^{\varphi(x, y)} f(x, y, z) dz$，即在 $xOy$ 平面投影，作垂线，两个交点，做差，再对投影面积积分
不需要在意原理，只需知道两两可以交换次序（变成二重积分）
- $(\int_a^b dx \int_c^d dy) \int_e^f dz$
- $\int_a^b dx (\int_c^d dy \int_e^f dz)$

三重积分的换元

关键是雅可比行列式 $\frac{\partial(x, y)}{\partial(u, v)}$

曲线与曲面积分

第一型曲线积分

可以理解成线密度质量的模型

由于微分转化的时候用的是平方，无方向

做计算题，一般给出的形式为 $\int_L f(x, y, z) ds$
- 用参数来表示
- $ds = \sqrt{x'^2(t) + y'^2(t) + z'^2(t)} dt$
- 转化为普通定积分

第二型曲线积分

可以理解成变力做功的模型

dx/dy/dz给定了方向

做计算题，一般给出的形式为 $\int_{L_{ab}} (x^2 + y^2) dx + 4xy dy$
- 寻找参数（可以是极坐标也可以是曲线方程）
- 对参数求导，转化微分
- 带入，转化为普通定积分求解

第一型曲面积分

最显著的特征在于，积分区域变了，原来是XoY平面，现在变成了某一曲面

可以将函数看作是曲面的面密度（与方向没有任何关系）

思想：将曲面投影到XoY平面，曲面上的一点唯一对应XoY上的一点，面积之比为这个点的梯度。从而转化为熟知的二重积分。

做计算题，一般给出的形式为 $\iint_S xyz ds$
- $\iint_S f(x, y, z) ds = \iint_D f(x, y, z(x, y)) \sqrt{1 + z_x^2(x, y) + z_y^2(x, y)} dx dy$
- 转化为重积分解决
如果用参数表示，只需要
- $r_u = \left( \frac{\partial x}{\partial u}, \frac{\partial y}{\partial u}, \frac{\partial z}{\partial u} \right) \ r_v = \left( \frac{\partial x}{\partial v}, \frac{\partial y}{\partial v}, \frac{\partial z}{\partial v} \right)$
- $E = r_u \cdot r_u, F = r_u \cdot r_v, G = r_v \cdot r_v$
- $ds = \sqrt{EG - F^2} dx dy$
- 转化为重积分解决
特别地，如果三维的积分区域退化到二维，偏导数项为0，$\iint_S f(x, y, z) ds = \iint_D f(x, y, z(x, y)) dx dy$，也就是一个普通的二重积分

第二型曲面积分

本质上是通过法向量 $\overrightarrow{n} = (\cos \alpha, \cos \beta, \cos \gamma)$ 来链接，$\overrightarrow{n} \cdot d\overrightarrow{s} = (dy dz, dz dx, dx dy)$

做计算题，一般给出的形式为 $I = \iint_S x dy dz + y dz dx + z dx dy$
- 看有无对称性
- 投影到对应平面
- 消元（用已知量或者方程带入）
- 转化为重积分解决

各种积分之间的联系

格林公式

由逐段光滑的曲线围成的单连通区域，$P$、$Q$ 有一阶连续偏导数

$$\iint_D \left( \frac{\partial Q}{\partial x} - \frac{\partial P}{\partial y} \right) dx dy = \oint_L P dx + Q dy$$

补充

补充克拉默法则
- 对于一个二元一次方程组：
$$a_1 x + b_1 y = c_1$$ $$a_2 x + b_2 y = c_2$$

其中 $a_1$、$b_1$、$c_1$、$a_2$、$b_2$、$c_2$ 都是已知的常数，而 $x$ 和 $y$ 是未知数。根据克拉默法则，方程组的解可以通过以下公式来表示：

$$x = \frac{D_1}{D}, \quad y = \frac{D_2}{D}$$

其中 $D$ 是方程组的系数行列式，$D_1$ 是将方程组的常数列替换掉 $x$ 的系数列所得到的行列式，$D_2$ 是将方程组的常数列替换掉 $y$ 的系数列所得到的行列式。
处理$\int \sec^3 x dx$
- 我们用分部积分，可以实现降次
$$\int \sec^3 x dx = \int \sec x , d(\tan x) = \sec x \tan x - \int \tan x , d(\sec x)$$

而

$$\int \tan x , d(\sec x) = \int \tan^2 x \sec x , dx = \int (\sec^2 x - 1) \sec x , dx = \int (\sec^3 x - \sec x) dx$$
- 接下来移项即可

期末考试押题

2*广义积分
- 迪利克雷/Abel
函数项级数的收敛域
- 根值法
- 达朗贝尔
幂级数的和函数（展开）
1. 收敛域
2. 看模板
3. 有分母微分，无分母积分
4. 结合实际情况写出收敛域（否则扣分
傅里叶级数的展开
- 延拓
求偏导数
- 链式法则
- 方程组
- 隐函数求解法
极值与条件极值
- 拉格朗日乘数法
二元的微分中值定理
重积分
第一、二型曲线积分
- 参数化表示
格林公式
- 积分与路径无关
- 求原函数
第一型曲面积分

GDB常用指令

Sat, 30 Nov 2024 00:00:00 GMT

GDB（GNU Debugger）提供了丰富的调试命令，涵盖代码运行、断点管理、变量查看、堆栈分析等多个方面。以下是 GDB 的所有主要调试命令，按类别分类：

1. 启动和退出

| 命令 | 说明 | | ------------------------------ | ----------------- | | gdb program | 调试可执行文件 program | | gdb --args program arg1 arg2 | 传递参数给 program | | gdb -p PID | 附加到进程 PID | | q / quit | 退出 GDB |

2. 运行程序

|命令|说明| |---|---| |r / run [args]|运行程序，可传递参数| |start|启动程序并停在 main() 之前| |kill|终止正在调试的程序|

3. 断点（Breakpoints）

|命令|说明| |---|---| |b / break func_name|在函数 func_name 处设置断点| |b line_number|在当前源文件的 line_number 处设置断点| |b file:line|在指定文件 file 的 line 行处设置断点| |b *address|在内存地址 address 处设置断点| |info breakpoints|显示所有断点| |delete [num]|删除编号为 num 的断点（默认删除所有断点）| |clear func_name|清除函数 func_name 的断点| |clear file:line|清除 file 文件 line 行的断点| |enable [num]|启用编号为 num 的断点| |disable [num]|禁用编号为 num 的断点| |condition num expr|仅当 expr 为真时，触发编号为 num 的断点|

4. 观察点（Watchpoints）

|命令|说明| |---|---| |watch var|监视变量 var 变化时暂停| |rwatch var|变量 var 被读取时暂停| |awatch var|变量 var 被读/写时暂停| |info watchpoints|显示所有监视点| |delete watch num|删除编号为 num 的监视点|

5. 单步执行（Stepping）

|命令|说明| |---|---| |s / step|单步执行代码（进入函数内部）| |n / next|单步执行代码（不进入函数内部）| |finish|运行到当前函数返回| |until|运行到当前代码块结束|

6. 继续执行

|命令|说明| |---|---| |c / continue|继续执行到下一个断点| |jump line|跳转到 line 行执行|

7. 堆栈（Stack）

|命令|说明| |---|---| |bt / backtrace|显示当前调用栈| |bt full|显示完整的调用栈（包含参数和变量）| |frame num|切换到编号 num 的栈帧| |up|向上移动一层栈帧| |down|向下移动一层栈帧|

8. 打印变量

|命令|说明| |---|---| |p / print expr|打印表达式 expr 的值| |ptype var|显示变量 var 的类型| |whatis var|显示变量 var 的类型| |x addr|以十六进制格式查看 addr 处的内存| |x/4x addr|以十六进制显示 addr 处的 4 个单位数据|

9. 寄存器

|命令|说明| |---|---| |info registers|显示所有寄存器的值| |p $eax|打印寄存器 eax 的值|

10. 信号（Signals）

|命令|说明| |---|---| |handle SIGSEGV stop|在 SIGSEGV 信号触发时暂停| |handle SIGINT nostop|忽略 SIGINT 信号|

11. 调试共享库

|命令|说明| |---|---| |info sharedlibrary|显示加载的共享库| |set solib-search-path path|设置共享库搜索路径|

12. 修改变量

|命令|说明| |---|---| |set var = value|修改变量值| |set $eax = 0x1234|修改寄存器值|

13. 附加进程

|命令|说明| |---|---| |attach PID|附加到进程 PID| |detach|断开调试进程|

14. 线程调试

|命令|说明| |---|---| |info threads|显示所有线程| |thread num|切换到 num 号线程| |thread apply all cmd|对所有线程执行 cmd|

15. 脚本

|命令|说明| |---|---| |source file|运行 file 中的 GDB 命令| |define cmd|自定义命令| |document cmd|添加自定义命令的文档| |save breakpoints file|将断点信息保存到 file|

16. GDB 调试 TUI 模式

|命令|说明| |---|---| |layout src|显示源码窗口| |layout asm|显示汇编窗口| |layout regs|显示寄存器窗口| |tui enable|启用 TUI 模式| |tui disable|禁用 TUI 模式|

离散数学

Sat, 30 Nov 2024 00:00:00 GMT

第一章：略

第二章：命题逻辑

自然语言符号化

什么叫逆命题、否命题和逆否命题

基本等值式

什么叫做等值式

称命题逻辑公式A和B逻辑等值(logically equivalent)，简称等值，记为A=B，如果
对任意真值赋值函数$\sigma:Var→2$，A和B在下的真值都相同，即都有$\sigma(A）=\sigma(B)$

如何证明呢？
- 证明方法
- 非形式化
模式与实例

题型：
- 判断命题逻辑公式类型（永真式、矛盾式、可满足式）
  - 利用等值演算来证明逻辑等值式

析取、合取范式

==单个的文字可以看做是一个合取式或一个析取式，单个的合取式可看做是析取范式，单个的析取式也可看做是合取范式==
易错！

注意：上例子只给出了一个或两个的合、析取范式，但实际上也可以有多个，不要没见过大蛇o屎

范式中==只出现与、或、非运算，且否定只出现在命题变量的前面==

题型：给出一个公式，让你求合取、析取范式
- 求与公式逻辑等值的析取范式
  先通过蕴涵等值式和双蕴涵等值式转换为不含→和↔的公式
  然后用德摩尔根律将所有否定运算符移到命题变量的前面
  最后用分配律将合取运算符放到括号里的文字间，析取运算符放到括号外的合取式之间

极小项、极大项

合取会变小，析取会变大

超级易错点：极大项是成假赋值

也就是说，命名的下标是通过成真和成假赋值的二进制值来确定的

只是我们在写出对应最大项公式的时候，要反过来

题型
- 给一个公式求主合取范式和主析取范式
- 方法：
  - 真值表
    - 画出真值表，1的就是$m_i$，0的就是$M_i$
    - 如果要写出具体的字母，对m成真赋值，对M成假赋值
  - 等值演算法
    - 先求出主析取范式，遇到不是的，拓展（与一个1，然后用排中律，再用分配律）
    - 然后成真赋值
    - 得到主析取范式（m表示）
    - 不是最小项的就是极大项
    - 例子

推理系统

首先需要注意的是，推理有效与否与公式真假没有关系

题型一：形式化证明

附加前提法

归谬法

题型二：自然语言的证明

易错点：

置换和替换

替换就是完全替代，所以要全部换掉。置换弱一点

第三章：一阶逻辑

谓词逻辑命题符号化

全称量词和存在量词

易错点！！

谓词逻辑命题符号化

谓词逻辑公式及其解释

更多的，只要自由出现了一次，就是自由出现的

改名

约束变量改名

注意：不能换约束出现的，如H中的x

自由变量改名

量词消去和真值

求公式在一定解释下的真值

一阶逻辑的等值演算

前束范式

替换实例

为什么单独放出来呢，是因为我觉得：

他其实就是告诉你
命题逻辑公式那些等值式
全都可以替换
也就是告诉你，全都可以继续用
从而把第二章一下子联系起来了

推理系统

推理系统和命题逻辑的类似

量词引入和消除

易错点！！！

量词例化规则只能针对辖域是整个公式的量词使用

必须先使用存在例化规则引入个体常量c，然后使用全称例化规则时可使用个体常量c

第五章：集合

181定义集合的方法
183重要的定义集合的定义
187交的定义

集合并保持子集关系

192差和补

一些定理

集合运算及其元素定义法

幂集

195空集的幂集相关的易错点、保持子集关系

证明的方法
- 通过定义证明
- 通过集合等式
- 子集的包含关系

集合的容斥原理

==基本集合等式表==

记住以下这些可以加快选择题做题的速度

证明题的时候，优先从有减号的一边入手，将减号化成交

==203集合运算与子集关系==

第六章：关系

211有序对笛卡尔积的定义（用笛卡尔积的定义来证明简单的集合等式）

特殊的关系

212关系的定义
214关系图和关系矩阵

关系的运算

关系逆的定义，关系复合的定义

注意记住符合的定义，本质上是在找中介

218关系的运算，关系矩阵的运算
219关系逆的基本性质
- 逆的逆等于自身
- 关系逆保持子集关系
- 逆和与或是可交换的（谁先谁后）
- 关系逆和关系复合交换次序，括号内要反转
什么叫做保持子集关系呢，就是

这在许多证明中很有用

例题
220-221关系复合的基本性质
- 交换律❌
- 结合律✅
- 恒等关系是单位元
- 关系复合保持子集关系
- 关系复合对并分配，对与不分配（本质上是存在量词对析取分配而对合取不分配）
  - 复合在外，或在括号内

关系的性质

要明确定义：元素定义法，还有性质：集合运算法
自反
- 223自反的定义
- 224上面，易错点，自反与非自反的互斥但非对立关系
- 224下面定理6.8定理的充分必要条件（集合运算）
对称
- 225对称的定义
- 226下面定理6.9对称的充分必要条件（集合运算）
传递
- 228传递的定义
- 229下面定理6.10传递的充分必要条件（集合运算）
汇总
- 231关系定义和性质
注意如果只有一个元素，那么前件为假，蕴含式为真，所以只含有一个元素的关系也是传递的
- 231关系运算与关系性质之间的联系
做题技巧，用关系图来判断关系的性质
- 画出一个关系的关系图，如果每个点都有自回路，那么就是自反的
- 如果每两个点之间，要么没有直接通路，要么有双向直接通路，那么就是对称的
- 如果能形成自闭环，那么是传递的
易错点——下面的都是✔
1. 一个==非空==关系如果是自反的，那它一定不是反自反的
2. 存在既不是自反，也不是反自反的关系——存在某些<x, x>成立，也有些不成立
3. 存在既是对称也是反对称的关系——ΔA
4. 存在既不是对称也不是反对称的关系
5. 恒等关系除了不是反自反的，其他都是
给出参与运算的关系都有列对应的性质，那么运算的结果关系是否也有列对应的性质

| | | | | | | |---|---|---|---|---|---| |关系运算|自反性|反自反性|对称性|反对称性|传递性| |==关系逆运算R^(-1)==|是|是|是|是|是| |==集合交运算R∩S==|是|是|是|是|是| |集合并运算R∪S|是|是|是|否|否| |集合差运算R-S|否|是|是|是|否| |关系复合运算R∘S|是|否|否|否|否|

可以分别用元素法和集合法证明a

关系的闭包

所谓闭包，就是要用最少的元素补充我们的集合，使其满足基本的性质（自反，对称，传递）

闭包的定义和性质
- 233关系闭包的定义
- 234定理，若R为XX，则XX闭包是自己
- 234定理，闭包保持子集关系
例题

ABD都在考察同一件事情，也就是定义里的“包含R”

C的话考察的是闭包的最小性

闭包的运算

236定理：如何补充以变成自反和对称闭包
237关系的幂运算
237定理：传递如何补充成为闭包

| | | |---|---| |关系代数中的概念|图论中的概念| |二元关系 R|有向图的边集 E| |关系的传递性|图中节点间的路径可达性| |关系幂 Rn|从一个节点到另一个节点的长度为 n 的路径| |传递闭包 R∗|图的传递闭包（所有可能路径）|

如何补充以变成传递闭包
- 通过逻辑积计算关系矩阵
  - 求幂
  - 所有幂的并
- Warshall算法
  - 每次画出第x行为1的列和第x列为1的行，然后这些线的交点置为一
等价关系
- 242定义
  - 满足自反、对称、传递
- 等价类
  - 244定义
    - 记作$[a]_R$
  - 性质
    - 总有$a∈[a]_R$
  - 理解
    - 就他妈求连通分量，画出图来，圈就行了
    - 也可以直接看跟x有关系的所有值，这些值构成的集合就是x的等价类
    - $[a]_R= [b]_R当且仅当⟨a, b⟩∈R$
    - 以一个模7同余为例子
    - 我们可以将整数集拆分成这样子7组
    - 每一组里面的元素，都是彼此之间满足模7同余的
    - 任意不同组别的元素都是不满足模7同余的
    - 这样的一组就叫一个等价类
    - 所有的等价类构成这个全集的一个划分
    - 把每个等价类作为一个元素，那么这个集合就是👇
- 商集
  - 所有等价类的集合$A/R$
偏序关系
- 247定义
  - 满足自反、反对称、传递
- 偏序集
  - 偏序集（Partially Ordered Set，简称 poset）描述了一个集合中元素之间的一种“部分”顺序关系。与完全排序的集合（例如自然数集合上的大小关系）不同，偏序集中的元素==不一定能够比较大小==，也就是说，==有些元素==之间没有明确的顺序关系。
  - 可比
    - 虽然是用<符号来表示，但其实表达的还是满足偏序关系
  - 全序（链）
    - 全都可比
  - 偏序
    - 部分不可比
- 覆盖
  - $a<b$且不存在c使得$a < c, c < b$（两个不等式都要满足才行）
  - 也就是紧紧挨着，中间不再有更多的元素满足偏序关系
- 哈斯图（用来找极大元和极小元）
  - 去掉自环
  - 只保留覆盖的边（无第三边）
  - 从下往上
- 最大元、最小元
  - 与所有元素都可比才行，不一定存在
  - 就是哈斯图上，连接所有分叉的唯一最高点
  - 例子
  12和8、10、9、11都不可比，所以不存在最大元
- 极大元、极小元
  - 没有元素可以a更大/小了
  - 可能有元素和它不可比
  - 可能也不存在，如整数集$\Z$，四个都不存在
  - 例子—同上
    - 8、12、10、9、11、7都是极大元
    - 就是哈希图上面没有分叉了的
- 上界、下界
  - 对象是S的子集
  - 上界b不一定在S中
  - 但是b>S中任意元素，==都要能够比较==才行
  - 可以有很多个
- 上确界、下确界
  - 最小的上界
  - 最大的下界
  - 如果对于全集
    - 上确界就是最大元
    - 下确界就是最小元
  - 对于空集
    - 上确界就是最小元
    - 下确界就是最大元

关系证明题

第一步考虑能不能用集合语言来叙述，因为集合语言是一阶逻辑语言更高级的抽象

如果集合语言行不通，不要傻傻发呆，可以尝试符号语言，老老实实抓住定义去做

第七章函数

260函数的定义

注意是对==所有==的A中的元素，B中都有==唯一==的元素与其对应
260定义域、陪域的定义

260像集和逆像集的定义
- 像集就是给出定义域的子集求值域
- 逆像集就是给出值域范围反求定义域
262性质
- $f$ 保持子集关系$S\subseteq U→f(S)\subseteq f(U)$
- 函数与集合交可以交换次序

单函数、满函数、双函数的定义

单函数
- B中每个元素==至多==有一个A中的元素与其对应
- 可以没有对应
- 做题的时候带入$f(x)=f(y$) 看有无 $x=y$
满函数
- B中每个元素==至少==有一个A中的元素与其对应
- 必须要囊括值域的每一个元素
双函数
- 既是单函数也是满函数
- B中每个元素有==唯一==一个A中的元素与其对应

266函数的复合
- 其实就是关系的复合
- 保持子集关系
- 保持单满性
- 满足结合律

267逆函数的定义
- 注意前提是双函数
集合基数的基本
- 这一部分不会出题考试
- 但是面试的时候可能会问到

函数增长和算法效率分析

281定义大O记号
- 存在k和C当 $x>k$ 有$|f(x)| ≤ C|g(x)|$
- 这一部分出题：证明某个函数是$O(x^3)$而不是$O(x^2)$
- 只需要找到对应的k和C即可
大O记号的传递性
O的加法定理
- $f_1(x) + f_2(x) \in O(max(g_1, g_2))$
O的乘法定理
- $f_1(x). f_2(x) \in O(g_1 . g_2)$
284定义大$\Omega$记号
- $存在k和C当x>k有|f(x)| ≥ C|g(x)|$
O的除法定理
- $f_1(x)是O(g_1), f_2是\Omega (g_2) 那么f_1/f_2 是O(g_1/g_2)$

第八章：计数组合

计数

302加法原理乘法原理
- 独立性
  - 无论前面选择什么，后面的==方法数==（注意仅仅是数字，究竟是什么方法不care）==不变==
  - 也可以理解成，如果可以==直接用乘法原理==的，那就是有独立性
- 相关性
  - 前面的选择就对后面有影响
  - 易错
    - 可以同时有相关性和独立性
    - 不相关→独立
    - 独立 !→ 不相关
- 305减法原理
  - 正难则反
- 306除法原理（不是重点）
  - 必须保证是满射
  - 例子：圆桌排列、苯环取代
- 306一一对应原理
  - 提供了一种通过建立两个集合之间的一一对应关系来计算集合大小的方法。具体来说，如果两个集合之间存在一个一一对应（双射）关系，那么这两个集合的元素个数必然相等。
- 308容斥原理
- 集合差计数公式
- 两集合容斥原理
- 三集合容斥原理
- 鸽笼原理
  - 很容易指导什么是鸽子
  - 但是什么是鸽笼才是最重要的
  - [[组合计数|组合计数]] 例题
  - 不会是考试重点

排列组合

==不允许重复的==
316全排列
- 从n个里选择 r 排列，与顺序有关
- 记作$P_n^r$
318组合数
- 从n个里选择 r 与顺序无关
318证明方法
- 组合证明
  - 举一个针对同一集合的不同计数例子
  - 通常可以举例：学生选学生会，学生会选主席、长度为n的字符串
- 代数证明
  - 通过数学归纳法和组合数计算公式证明
技巧
- 至少有一名男生——全集减去一名男生都没有的
- 奇数偶数、是否重复，注意判断
323二项式定理
- $(x + 1)^n = \Sigma_{i= 0}^n(^n_i)x^i$
- 令$x=1$可得所有项之和
- 令$x=-1$，结合上面，得到奇偶项关系
325帕斯卡等式
- $\binom{n}{k} = \binom{n-1}{k-1} + \binom{n-1}{k}$
- 在用数学归纳法证明一些等式，归纳递推的时候很好用
326经常用到的公式
==328允许重复的排列组合==
328$每类物体分别有m_1、m_2…m_n个的n类物体的重复度为m_1+m_2+…+m_n=r的排列数为\\binom{r}{m_1}\binom{r-m_1}{m_2}...\binom{r - m_1 - m_2 - ...-m_{n-1}}{m_n} = \frac{r!}{m_1!m_2!...m_n!}$
- 理解1：多次分步来选择
- 理解2：先全排列，即$r！$然后每个类里面都是无关次序的，所以分别除以他们的阶乘
331物体个数不限的n类物体允许重复地选择r个的方案数——$\binom{n+r-1}{r}$
- 理解：
  - 首先可以理解为不定方程的解
  - 和高中的隔板法很像，但是高中的隔板法至少要有一个
  - 而这里可以一个都没有，所以要把隔板也考虑占一个位置
  - 理解1：二进制串，用0来分隔开
  - 理解2：不定方程，那就相当于用n - 1个加号隔开r个数
- trick
  - x的≥限定
    - 如：苹果至少要a个，香蕉至少b个
    - 令$x = x + a$，那么$x>0$，只需要转化为物体个数不限的n类物体允许重复地选择$r - a - b$个的方案数
  - r的 ≤ 限定
    - 例如：$x1+x2+x3+x4 ≤ 15$
    - 等价于$x1+x2+x3+x4+x5 = 15$
    - 添加一个未知数即可
  - x的≤限定
    - 例如：$x1+x2+x3+x4 ≤ 15 且 x1≤ 5, x2≤ 3$
    - 方法：容斥原理
    - 定义事件：
      - U为没有限制$\binom{4+15-1}{15}$
      - $P1为x1 ≥ 6\ r= r- 6\ N(P1) = \binom{4+9-1}{9}$
      - $P2为x2 ≥ 4\ r= r-4\ N(P2) = \binom{4+11-1}{11}$
      - $P1P2为x1≥6,x2 ≥ 4\ r= r-10\ N(P1P2) = \binom{4+5-1}{5}$
    - $由容斥原理\N(\overline{P1}\overline{P2}) = U - N(P1∪ P2) = U - N(P1) - N(P2) + N(P1P2)$
==338排列组合生成算法==
- 339在字典序下覆盖a的全排列
  - 例如63285741
  - 从右往左找到第一个不是递增的，即5
  - 与他右边的换 5 和 7 换
  - 剩下的升序排列（保证字典序）
  - 得到63287145
- 341给定集合S求S的r组合
  - 由于组合的无序性，所以要求生成的数组严格单调递增
  - 例如S={1,2,…,8} a = 13478
  - 从右往左找到第一个可以变大的数字（8、7不能了，但是4可以变大为5、6）
  - 将这个数字变为能变大的最小值，即5
  - 后面同理
  - 13567
  - 继续
  - 13568
  - 13578
==342递推关系式==
- 递推关系：必须由==前面==的项推出来
- 通项公式
- 封闭公式解
  - $a_n$能使用==不包含序列中任意项==的通项公式表示
  - 给出一个即可，不明确初始特解的情况下可能有很多封闭公式解
- 分类的递推，类似于动态规划，一定要相信它满足条件
- 注意最后写出递归式的时候说明n的范围，特殊情况，如n=0、1要单独说明
- 注意分情况讨论，要充分，然后再加起来的时候合并
==349线性递推关系式求解==
- 常系数线性齐次递推关系式
  
  $\sum {i = 1}^{t} (r_i^n.\sum{j = 0}^{m_i - 1}\beta_{ij}n^j)$
- 常系数线性非齐次递推关系式
  - 解的形式定理——这个定理给出了解是由齐次解+一个特解的结构组成的，所以关键是要找到一个特解
  - 特解构造定理
  - 总结：做题步骤
    1. 求解伴随齐次特征多项式得到特征根r
    2. 将F(n)写成上图标黄的形式
    3. 确定最高次数和s
    4. 根据s是否是特征根分情况讨论得到特解
    5. 将特解带入递推式
    6. 用特殊值带入求解方程
- ==分治算法及其效率分析==
  - 主定理

第九章：图与树

图

基本概念

362无向图的定义
363有向图的定义
- 有向图的==基图==是不考虑方向得到的无向图
364
- n阶图：顶点数为n
- 平凡图：顶点数为1
- 空图：顶点数为0
- 零图：边数为0
364环、简单图的定义
365度的定义
- 注意记号$d(G)$
- 出度是$d^+(G)$入度是$d^-(G)$
- ==图与简单图中对于顶点度的要求==

==365握手定理==

总度数为顶点数的两倍，入度等于出度等于顶点数

这在后面的证明中非常重要，常常矛盾的情况是用握手定理推出来的
推论：总度数为偶数
- 例题：
推论：任何图的奇度顶点个数是偶数
==推论：简单图的最大度====$\Delta(G)≤ n - 1$==
366正则图和完全图的定义
- k正则图：任意顶点的度数都是k
- n完全图：任意两个顶点之间都有边
  - 边数就是$\frac{n(n - 1)}{2}$
366二部图的定义
- 二部图
  
  其实很像一个神经网络的全连接层
367生成子图和导出子图的定义
- 生成子图：指从原始图中选取部分边，但保留所有顶点，形成的子图。
- 导出子图：从原始图中选取部分顶点，并保留这些顶点之间在原始图中存在的所有边，形成的子图。
367
- 删除顶点集：从图中移除指定的一组顶点及其相关联的边。
- 删除边集：从图中移除指定的一组边，同时==保留所有顶点==。
- 删除子图：顶点集不变，但是删除边

==368图的连通性==

通路、回路、简单（有向）通路、简单（有向）回路的定义
回路、初级回路（没有重点）、简单回路（没有重边）

长度为n的通路、回路条数计算

370
- 可达与连通分支
- 类似于握手定理，下面的引理也可以作为一个反证法的矛盾出发点
- 证明方法
- 以上面定理为例子
371点割集和**边割集——**用于描述破坏图连通性的方法
- **点割集：**一组顶点的集合，若将这些顶点（少一个都不行）及其关联的边移除后，图会被分割成多个连通分量（或不再连通）。
- 割点：如果点割集只有一个顶点，这个点就叫做割点
- **边割集：**一组边的集合，若将这些边（少一条都不行）移除后，图会被分割成多个连通分量（或不再连通）。
- 割边（桥）：如果边割集只包含一条边，这条边就叫做割边或桥
- 点连通度：最少需要删除多少个顶点才能使图不连通或者成为平凡图——顶点数最少的点割集的顶点数
- 边连通度：最少需要删除多少条边才能使图不连通——边数最少的边割集的边数
- 例子：
372强连通和单项连通
- 强连通：在有向图中，任意两个顶点之间都存在双向可达的路径
- 单向连通：在有向图中，从某个顶点出发可以到达其他所有顶点，但不一定存在返回路径
- 强连通分量：有向图中的最大强连通子图

欧拉图

一定要注意！！欧拉图是==对边做讨论==

补充：无向连通图G只有两个度数为奇数的顶点，则G存在欧拉通路，则G是半欧拉图
注意：==欧拉图没有强调是简单图！！==例如一个图如果是欧拉图，然后你添上一条重边，必然会使得他有两个顶点的度变成奇数，那就变成了欧拉通路，半欧拉图。

哈密顿图

一定要注意！！哈密顿图是==对顶点做讨论==

澄清哈密顿回路的定义
1. 哈密顿回路的定义是：
  - 路径必须经过图中的所有顶点一次且仅一次。
2. 由于回路的起点和终点是同一个顶点，因此==起点会在路径中出现====两次==，这是合法的。这并不违背哈密顿回路的定义。

树

无向树
- 无向树没有根这个说法，只包含内部节点和叶子：内部节点就是度为≥2；叶子就是度为1
- 无向树的每一条边都是桥（删掉就不连通了）
- 无向树是简单图
  - 对于3的证明，用反证法+握手定理注意啊手动阀
  - 对于3，如果是又向根树，是不成立的
- ==注意：数据结构中树是有向树，其节点的度的定义是孩子的数量，但是这的度的定义是无向图中的度的定义==
无向树的证明，遇到度数的，往握手定理靠

有向树
- 基图是无向树
+有向树内部只含有两种节点，内部和叶子
根树
- 有向树有且仅有一个顶点的入度为0
- m元树
典型的题型：利用握手定理和树中顶点与边数的关系来列方程求解
- 哈夫曼树
  - 例题

==平面图==

定义
握手定理
欧拉公式（用正方体来记忆）
平面图的边数上界

应用

考试

题型：

单选 15*2 30分

论证题：16 10分

计算题：17-20 34分

证明题：21-23 26分

C++理论题总结

Sat, 30 Nov 2024 00:00:00 GMT

C++理论题总结

By lhr 2024/7/7

第一周

PPT

namespace
- 所有全局变量共享一个命名空间——默认namespace

题目

Question 4 - 单选题

当x = 24, y = 4 时，语句cout<<( x > 23 && x - y <=20) << endl; 的执行结果为：

A.true

B.1

C.0

D.false

Standard Answer: B

只能记住，C++条件运算输出的是1/0

Question 5 - 单选题

在Linux系统下，选择与下述代码输出相同的选项：

cout << "The answer is:" << ends << 3.14 * 4 << endl;

A.double a = 3.14 * 4; printf("The answer is: %f", a);

B.cout << "The answer is: "; cout << 3.14 * 4 << endl;

C.printf("The answer is:"); putchar('\0'); printf("%.2f\n", 3.14 * 4);

D.printf("The answer is: %d\n", 3.14 * 4);

Standard Answer: C

解释：

==std::ends 的主要功能是向输出流中插入一个空字符（null character）==，即 ASCII 码为 0 的字符。
这个空字符通常用于标记 C 风格字符串的结束。在 C 和 C++ 中，字符串通常以空字符结尾。
不同于 std::endl，std::ends 不会刷新输出流的缓冲区。它只是简单地插入一个空字符。

Question 7 - 单选题

下述语句的输出是：

cout << 1 + "20.24" << endl << 20.24;

A.编译错误

B.21.24

20.24

C.120.24 20.24

D.0.24\n20.24

Standard Answer: D

解释：一个整型加一个字符串，其实是地址+1，从0开始输出

Question 8 - 单选题

当输入为x时下面语句的输出是？

int x;
cin>>x;
cout<<x;

A.0

B.x

C.编译错误

D.字符x的ASKII码

Standard Answer: A

解释：

在C++中，如果你运行了上面的代码并尝试输入一个非整数值（如字母x），那么cin >> x;这一行将会失败，因为它期待的是一个整数。当输入流cin遇到它不能解析为整数的字符时，它会停止读取，并设置一个错误状态（failbit），并将x设置为0。

Question 12 - 单选题

下面代码在输入2以后，输出为？

#include<iostream>
using namespace std; 
int main(){
	int cout;
	cin>>cout;
	std::cout<<(cout<<cout);
}

A.2

B.编译错误

C.4

D.8

Standard Answer: D

解释：

注意命名空间之间的嵌套，全局cout覆盖了std的cout，<< 左操作数是整数，所以移位

Question 13 - 单选题

下面代码在输入2以后，输出为？

#include<iostream>
using namespace std; 
int main(){
	int cout;
	cin>>cout;
	cout<<cout;
}

A.没有任何输出

B.编译错误

C.运行错误

D.2

Standard Answer: A

Question 17 - 单选题

判断：引用就是某一变量（目标）的一个别名，对引用的操作与对变量直接操作完全一样。

A.正确

B.错误

Standard Answer: A

第二周

Question 4 - 单选题当输入内容是“ Hello World! ”时（注意开头和结尾处各有一个空格），下列语句的输出结果是？

int main() {
	string str1, str2;
	cin >> str1 >> str2;
	cout << str1 << str2;
	return 0;
}

A.HelloWorld!

B. Hello（开头处有一空格）

C.Hello （结尾处有一空格）

D.Hello World

Standard Answer: A

无论输入多少个空格如“ hello world ”都会输出helloworld

Question 5 - 单选题

问题

当输入内容是“ Hello World! ”时（注意开头和结尾处各有一个空格），下列语句的输出结果是？
```
int main(){
	string str;
	getline(cin, str);
	cout << str;
	return 0;
}
```
A.HelloWorld!

B.Hello World! （注意结尾处有一空格）

C. Hello World!（注意开头处有一空格）

D.Hello World!（注意开头和结尾处各有一个空格）

Standard Answer: D
Question 6 - 单选题

问题

下列选项的操作符中，不属于string对象的比较运算符的是？

A.!=

B.<=

C.=

D.<=>

Standard Answer: C

注意审题：比较运算符，C是赋值运算符

在C++中，<=> 是一个称为“三向比较运算符”（也称为“spaceship operator”）的C++20引入的新特性。这个运算符用于返回一个整数，该整数表示两个操作数之间的相对顺序。

具体来说，对于a <=> b：
- 如果 a 小于 b，则返回负整数。
- 如果 a 等于 b，则返回零。
- 如果 a 大于 b，则返回正整数。
对于std::string，<=>运算符允许你以一种简洁且类型安全的方式比较两个字符串。

例如，如果你有两个std::string对象str1和str2，你可以这样使用<=>：

```cpp
#include <string>
#include <iostream>

int main() {
    std::string str1 = "apple";
    std::string str2 = "banana";

    auto result = str1 <=> str2;

    if (result < 0) {
        std::cout << "str1 is less than str2\n";
    } else if (result == 0) {
        std::cout << "str1 is equal to str2\n";
    } else {
        std::cout << "str1 is greater than str2\n";
    }

    return 0;
}
```

Question 8 - 单选题

问题

现有如下三个string对象：
```
string s1 = "Hello", s2 = ", ", s3 = "C++!";
```
则下列哪个选项的语句中string对象的初始化会出错？

A.string s4 = s1 + ", " + s3;

B.string s5 = s1 + ", " + "C++!";

C.string s6 = "Hello" + s2 + "C++!";

D.string s7 = "Hello" + ", " + s3;

Standard Answer: D

解释：没有定义两个字符串数组的加法，而前面三个选项都有一个字符串跟在运算符的两边，所以可以运算
Question 10 - 单选题

问题

下列语句的执行结果是？
```
int main()
{
	string str = "sysu-computer";
	int pos1 = str.find('u');
	int pos2 = str.find('u', 10);
	int pos3 = str.rfind('u');
	cout << pos1 << " " << pos2 << " " << pos3;
	return 0;
}
```
A.3 9 9

B.3 -1 9

C.3 -1 -4

D.3 -1 3

Standard Answer: B

解释：这个题容易错误的地方在于，无论从左边还是从右边——都是返回他的下标
for(auto &c : str)注意使用你用和不用引用的区别。如果不用引用的话是复制一个拷贝出来，不会改变原来的对象。如果是用引用的话，可以直接修改原来的对象。
Question 12 - 单选题

问题

现有一个长度大于等于 4 的string对象str，需要判断str是否以“Sysu”开头（即，前 4 个字符所构成的子串内容是否为“Sysu”）。

下列选项中的表达式，单独作为判断条件，无法实现上述功能的是？

A.str.find("Sysu") == 0

B.str >= "Sysu"

C.str.substr(0, 4) == "Sysu"

D.str.compare(0, 4, "Sysu") == 0

Standard Answer: B

解释：想要得到答案非常容易。但是想强调的是C选项里面，它是左闭右开区间。
Question 14 - 单选题

问题

下列两段程序的运行情况为：程序一：
```
void func1(const int n){
	array <bool, n> arr;
	arr[0] = true;
}
int main()
{
	func1(2);
	return 0;
}
```
程序二：
```
void func2(){
	const int n = 2;
	array <bool, n> arr;
	arr[0] = true;
}
int main()
{
	func2();
	return 0;
}
```
A.程序一和程序二均可正常运行

B.程序一和程序二均不可正常运行

C.程序一可正常运行，程序二不可正常运行

D.程序一不可正常运行，程序二可正常运行

Standard Answer: D

解释：程序一不可以运行的原因是——他要到运行时传参的时候才可以确定尖括号里面的值。但是程序二，它在编译的时候就可以确定尖括号里面的值是常量。
Question 18 - 单选题

问题

关于下列语句，说法正确的是：
```
const int func1(int arg){
    return 2 * arg;
}
constexpr int func2(int arg){
    return 2 * arg;
}
int main()
{
    array<int, func1(10)> a;
    array<int, func2(10)> b;
    return 0;
}
```
A.a, b 均能完成初始化

B.a 能完成初始化， b 不能完成初始化

C.a 不能完成初始化， b 能完成初始化

D.a, b 均不能完成初始化

Standard Answer: C

解释：同理
在 C++11 标准中，建议按照以下方式将 const 和 constexpr 的功能区分开：
- 凡是表达“只读”语义的场景都使用 const
- 凡是表达“常量”语义的场景都使用 constexpr

Question 16 - 单选题

问题

下列语句的运行结果为：

int main(void) {
    int a = 1;
    const int & const_b = a;
    cout << const_b << endl;
    a = 2;
    cout << const_b << endl;
    return 0;
}

A.1 1

B.1 2

C.2 1

D.2 2

Standard Answer: B

解释：他只是不能通过const_b来改变a

但是注意：是绝对不可以反过来的

变式：

int main() {
	double a = 3.14;
    const double & b = a;
    const int & c = a;
    
    cout << a << b << c << endl;
    // output:3.14, 3.14, 3
    
    a *= 2;
    
    cout << a << b << c << endl;
    // output:6.28, 6.28, 3
}

为什么c不会跟着变呢，因为const int & c必须要指向一个int的变量，所以在第4行的时候，创建了一个临时变量，然后c指向这个临时变量

Question 17 - 单选题

问题

关于下列语句（1）和语句（2），说法正确的是：

（1）const int a = 3 + 6; （2）constexpr int a = 3 + 6;

A.（1）和（2）均合法

B.（1）和（2）均不合法

C.（1）合法，（2）不合法

D.（1）不合法，（2）合法

Standard Answer: A

在C++中，const 和 constexpr 都用于声明常量，但它们之间有一些关键的区别。
1. 编译时和运行时：
  - 使用 const 声明的常量在运行时具有确定的值。这意味着这个值在编译时可能不知道，但在程序执行时它必须有一个确定的值。
  - 使用 constexpr 声明的常量在编译时就有确定的值。编译器在编译阶段就会计算其值，并将其嵌入到生成的代码中。因此，constexpr 常量可以用于那些需要常量表达式的地方，比如数组的大小、模板参数等。
2. 初始化：
  - const 常量可以使用任何在编译时或运行时能够确定的表达式进行初始化。
  - constexpr 常量必须使用常量表达式进行初始化，这通常意味着它只能包含编译时常量、文字值以及只调用其他 constexpr 函数的函数调用。
3. 函数和类构造函数：
  - 除了变量，你还可以将 constexpr 应用于函数或类的构造函数。这表示这些函数或构造函数在编译时就能计算出结果。
  - const 不能这样使用。
4. 内存位置：
  - const 和 constexpr 在内存中的位置没有固定的区别。它们都可能存储在只读数据段中，但这不是由 const 或 constexpr 关键字直接决定的，而是由它们的使用方式和上下文决定的。
对于你给出的两个例子：

（1）const int a = 3 + 6; 这里，a 是一个常量，它的值在运行时是确定的（尽管在这种情况下，编译器可能在编译时就能计算出它的值）。

（2）constexpr int a = 3 + 6; 这里，a 是一个编译时常量。它的值在编译时就被确定为9，并且这个值会被嵌入到生成的代码中。由于它是一个编译时常量，它可以用于那些需要常量表达式的地方。

注意：虽然在这个例子中，const 和 constexpr 的效果看起来是一样的，但在更复杂的场景中，它们之间的区别可能会更加明显。
Question 19 - 单选题

问题

下列关于 auto 关键字的说法，错误的是：

A.使用 auto 声明的变量必须初始化

B.函数和模板参数不能被声明为 auto

C.auto 不能用于类型转换或其他一些操作，如 sizeof 和 typeid 操作

D.定义在一个 auto 序列的变量不必始终推导成同一类型

Standard Answer: D

解释：auto的一些知识点，通过这个题来熟悉

第三周

类内定义的函数一定是内联的
判断：sizeof(引用)是指所指向变量的大小；sizeof(指针)结果为对象地址的大小

A.正确

B.错误

Standard Answer: A

解释：在C++中，sizeof 是一个操作符，用于获取对象或类型在内存中所占用的字节大小。但是，当 sizeof 应用于引用（reference）时，情况有些特殊。

引用本身并不是一个对象，它只是一个别名，或者说是一个已存在对象的另一个名字。因此，你不能直接取一个引用的 sizeof，因为引用本身并不占用额外的内存空间（除了在编译时用于一些内部处理，但这与 sizeof 无关）。

当你写 sizeof(引用) 时，你实际上是在获取该引用所指向的对象类型的大小。

第四周

PPT

默认参数只能在普通参数的右边
析构函数不能直接调用
友元函数没有this指针
static成员没有this指针
只有动态成员才有this指针
this指针是所有成员函数的隐含参数
static成员函数不接收this指针做参数
当成员参数与成员数据重名时，必须用this访问成员数据
在C++中，static 成员（无论是数据成员还是成员函数）都是与类本身关联的，而不是与类的任何特定实例（对象）关联的。因此，它们不需要通过类的实例（即对象）来访问，而是可以直接通过类名来访问。

当你尝试在 static 成员函数中使用 this 指针时，编译器会报错，因为 this 指针是指向调用该函数的对象的指针，而 static 成员函数并不与任何特定对象关联。

以下是一些关于 static 成员的基本点：
1. 静态数据成员：
  - 静态数据成员在类的所有实例之间共享。
  - 静态数据成员需要在类定义之外进行有且只有一次的初始化。注意格式为 Typename ClassName::VarName = 0;(不要再加static)
  - 可以通过类名或对象名来访问静态数据成员，但推荐使用类名。ClassName::VarName = 1;
  - 具有全局生存期，所有对象共享的储存空间
2. 静态成员函数：
  - 静态成员函数只能访问静态数据成员、其他静态成员函数和全局变量。
  - 静态成员函数没有 this 指针。
  - 静态成员函数不能访问非静态数据成员或调用非静态成员函数（没有this指针做参数）（除非它们通过对象名或指针/引用显式传递）。
示例：
```
class MyClass {
public:
    static int staticVar; // 静态数据成员

    static void staticFunc() {
        // this->staticVar; 	 // 错误：静态成员函数不能使用this指针
        MyClass::staticVar = 42; // 正确：使用类名访问静态数据成员
    }

    void nonStaticFunc() {
        MyClass::staticVar = 10; // 正确：也可以在非静态成员函数中通过类名访问静态数据成员
        this->nonStaticVar = 20; // 正确：非静态成员函数可以使用this指针访问非静态数据成员
    }

    int nonStaticVar; // 非静态数据成员
};

int MyClass::staticVar = 0; // 静态数据成员的初始化（不能再加static，否则报错）

int main() {
    MyClass obj;
    MyClass::staticFunc(); // 调用静态成员函数
    std::cout << MyClass::staticVar << std::endl; // 输出：42
    return 0;
}
```
在这个示例中，staticVar 是一个静态数据成员，而 staticFunc 是一个静态成员函数。staticFunc 使用类名 MyClass 来访问和修改 staticVar，而不是使用 this 指针。同样，你也可以通过对象名（如 obj.staticVar）来访问静态数据成员，但这通常不是推荐的做法，因为它可能会导致混淆。

mutable 关键字用于修饰类的非静态成员变量，表示即使该类的对象是 const 的，这个成员变量也可以被修改。这在某些特定的场景下是有用的，比如当你需要在 const 成员函数内部修改某个成员变量的值，但又不希望改变对象本身的逻辑状态时。

==好好学这个，可以偷鸡！==

以下是一个简单的C++示例，展示了 mutable 的用法：

class MyClass {
public:
    int value;
    mutable int mutableValue;

    MyClass(int v, int mv) : value(v), mutableValue(mv) {}

    // 一个const成员函数，可以修改mutableValue但不能修改value
    void printAndIncrementMutable() const {
        std::cout << "Before increment: " << mutableValue << std::endl;
        mutableValue++; // 这是允许的，因为mutableValue是可变的
        std::cout << "After increment: " << mutableValue << std::endl;

        // value++; // 这是不允许的，因为value不是mutable的，且我们在一个const成员函数中
    }
};

int main() {
    const MyClass obj(10, 20);
    obj.printAndIncrementMutable(); // 输出: Before increment: 20, After increment: 21
    // obj.value = 30; // 这是不允许的，因为obj是const的
    obj.mutableValue = 1; // it's ok！
    return 0;
}

在上面的示例中，尽管 obj 是一个 const 对象，我们仍然可以在 printAndIncrementMutable 函数中修改 mutableValue 的值，因为 mutableValue 被声明为 mutable。但是，尝试修改 value 的值会导致编译错误，因为 value 不是 mutable 的，且我们在一个 const 成员函数中。

Question 6 - 单选题

关于构造函数和析构函数的区别，表述正确是

A.它们具有不相同的函数名

B.构造函数不会返回类型，而析构函数会

C.构造函数允许传入函数参数，而析构函数不能

D.构造函数不允许传入函数参数，而析构函数能

Standard Answer: C

解释：A: 根据网上，是同名的

Question 7 - 单选题

下列哪个选项是程序的输出：

#include<iostream>

using namespace std;

class Foo {
public:
    int x;
    int y;
    Foo() {
        x = 1;
        y = 1;
    }
    Foo(int x_ = 10, int y_ = 10) {
        x = x_;
        y = y_;
    }

    void p() {
        int x = 20;  // local variable
        cout << "x is " << x << " ";
        cout << "y is " << y << endl;
    }
};
int main() {
    Foo foo;  //"message": "类 \"Foo\" 包含多个默认构造函数",
    cout << x << " " << y << endl; // x was not declare in this scope
    return 0;
}

A.1 1

B.10 10

C.编译错误

D.无法预期的值

Standard Answer: C

Question 10 - 单选题

下列c++代码的输出是什么
```
#include <iostream>  
using namespace std;
class A{
	A(){
		cout<<"Constructor called";
	}
};
int main(int argc, char const *argv[]){
	A a;
	return 0;
}
```
A.Constructor called

B.程序没有输出

C.编译错误

D.Segmentation fault

Standard Answer: C

解释：一定要小心，默认是private

Question 20 - 单选题

下列c++代码的输出是什么

#include<iostream>
using namespace std;
 
class Test{
private:
  int x;
  int y;
public:
  Test(int x = 0, int y = 0) { this->x = x; this->y = y; }
  static void fun1() { cout << "Inside fun1()"; }
  static void fun2() { cout << "Inside fun2()"; this->fun1(); }
};
 
int main(){
  Test obj;
  obj.fun2();
  return 0;
}

A.Inside fun2() Inside fun1()

B.Inside fun2()

C.Inside fun1() Inside fun2()

D.编译错误

Standard Answer: D

解释：小心！！static成员函数没有this指针

第五周

Question 2 - 单选题

下列说法正确的是
```
#include <iostream>

#include "Circle.h"
using namespace std;
int main()
{
cout << Circle(5).getArea() << endl;
cout << (new Circle(5))->getArea() << endl;

return 0;
}
```
A.Circle(5).getArea() 编译出错

B.new Circle(5).getArea() 编译出错

C.该程序能够编译通过，但不能运行

D.该程序能够通过编译，也能够运行，但 new Circle(5) 在堆上创建了匿名对象，这将导致内存泄漏。

Standard Answer: D
Question 4 - 单选题

删除空指针会发生什么？

A.不会报错

B.不会报错，但必须提前将空指针指定一个类型(例如int * p = nullptr; delete p;)

C.编译错误

D.运行时错误

Standard Answer: B
Question 7 - 单选题
```
int* t = new int(5);
int* p = t;
delete t;
delete p;
cout << *p << endl;
```
该段代码的输出是

A.不确定的脏值

B.0

C.5

D.出现运行时错误

Standard Answer: D

解释：上一题是空指针nullptr，但是这里是有所指但是无法访达的指针，所以runtime error

Question 6 - 单选题

class A
{
public:
	int x;
	A() :x(0) { cout << "A::A() x=" <<x<<endl; }
	~A() { cout << "A::~A() x=" << x << endl; }
};

int main()
{
	A* p = new A[3];
	for (int i = 0; i < 3; i++)
	{
		p[i].x = i;
	}
	delete []p;
	return 0;
}

运行结果为？

A.A::A() x=0

A::A() x=0

A::~A() x=2

A::~A() x=1

A::~A() x=0

就考了一件事情：析构顺序与构造顺序相反

Question 20 - 单选题
```
A* arr[4]={new A(0),NULL,new A(0)};
```
该语句生成了几个A对象

A.1

B.2

C.3

D.4

Standard Answer: B

解释：上一题直接new了3个，这里只new了两个
Question 8 - 单选题

以下程序段的执行结果是
```
class A{
	int x;
public:
	A() :x(0) { cout << "A::A()" << endl; }
	~A() { cout << "A::~A()" << endl; }
};

int main(){
	A* p = new A[10];
	p += 1;
	delete []p;
	return 0;
}
```
A.编译不通过

B.打印10个A::A(), 10个A::~A()

C.打印10个A::A(), 9个A::~A()

D.打印10个A::A()，运行异常终止

Standard Answer: D

解释：因为 p 不再指向数组的起始地址，所以这里的行为是未定义的（Undefined Behavior, UB）。在大多数实现中，这会导致运行时异常终止，因为 delete [] 操作符期望一个指向数组第一个元素的指针，以便正确地释放整个数组的内存并调用每个对象的析构函数。
Question 13 - 不定项选择题

在下列有关类、抽象、封装和数据隐藏的说法中，正确的有？

A.类表示可以通过类方法的公共接口对类对象执行的操作；这是抽象。

B.类隐藏了实现的细节，例如数据表示和方法代码；这就是封装。

C.类可以对数据成员使用私有可见性，这意味着只能通过成员函数访问数据；这是数据隐藏。

D.使用类是C++中可以轻松实现面向对象功能抽象、数据隐藏和封装的方式。

Standard Answer: C, A, B, D

第六周

Question 1 - 单选题

**静态联编(static binding)**是指在运行阶段就能确定调用的动态对象的方法的技术。

A.正确

B.错误

Standard Answer: B

解释：也称为早期联编或编译时联编，是在编译阶段就确定了方法调用与其实现的对应关系。这通常发生在非虚方法（非多态方法）的调用中。

在静态联编中，编译器在编译时会根据调用方法的对象的类型来确定要调用的方法。由于这种确定是在编译时进行的，因此它不会受到运行时对象实际类型的影响。

注意区别

  //已经重写拷贝构造函数
  Test t1;
  Test t2 = t1;// 调用拷贝构造函数
  t2 = t1;	 // 只是调用=

Question 3 - 单选题
```
A func()
{
	A tmp(1);
	return tmp;
}
int main()
{
	A a = func(); 
        A aa(a);
	return 0; 
}
```
A是一个具有拷贝构造函数的类，如果考虑编译优化，该段程序调用了几次拷贝构造函数。

A.0

B.1

C.2

D.3

Standard Answer: B

解释：
1. func() 返回 tmp 时，编译器可能会应用命名返回值优化（NRVO），直接在返回值的位置构造 tmp，避免拷贝构造函数的调用。
2. 在 A a = func(); 这行代码中，如果应用了（NRVO），则不会调用拷贝构造函数。
3. A aa(a); 这行代码会调用拷贝构造函数来初始化 aa。
因此，在考虑编译器优化的情况下，这段程序最少可能调用拷贝构造函数1次。这是因为编译器优化可以消除func()返回时的拷贝构造函数调用，但A aa(a);这行代码中的拷贝构造函数调用无法被优化掉。
Question 4 - 单选题
```
A func1(A a)
{
	return a;
}


A& func2(A& a)
{
	return a;
}



int main()
{
	A a(1); 
	func1(a); 
    func2(a);
	return 0; 
}
```
A是一个具有拷贝构造函数的类，如果不考虑编译优化，该段程序调用了几次拷贝构造函数，几次析构函数。

2， 3 0, 1

解释：注意，不考虑编译优化，返回的时候会先拷贝到一个新的临时对象上
Question 8 - 单选题
```
double a = 3.14;
const int & b = a;
a = 6.28;
cout<<a<<","<<b<<endl;
```
这段代码的输出是？

A.6.28, 6

B.6.28, 3

C.6.28, 6.28

D.6.28, 3.14

Standard Answer: B

解释：由于const int & b必须要指向一个int的变量，所以第二行的时候会生成一个整型临时变量来给b指，所以a改变的时候，b不变
Question 9 - 单选题
```
void func(string& s)
{
    cout << s;
}

int main()
{
    func("123");
    return 0;
}
```
该段代码的输出是

A.编译不通过

B.123

Standard Answer: A

解释：这段代码不能编译通过。原因在于func函数期望的参数是一个string&（非const引用），而在main函数中调用func("123");时，传递的是一个字符串字面量。字符串字面量是一个常量字符数组，它可以被隐式转换为const string，但不能直接绑定到非const引用上。下面的代码同理
```
void func(int& x){
    cout<<x<<endl;
}

int main(){
    int i = 1;
    func(i * 3);
    return 0;
}
```
那反过来是不是就对了呢？
Question 14 - 不定项选择题

关于const引用，以下说法正确的是

A.const引用是一个比较万能的类型，可以初始化为左值，右值，类型转换的左值对象。

B.把const引用作为函数参数，可以防止程序错误修改不该修改的实参。

C.非const的引用可以初始化为右值

D.把const引用作为函数参数，可以提高程序的运行效率

Standard Answer: D, B, A

第八周

Question 1 - 不定项选择题

若定义正常对象的形式为A a(parameter);,那么定义常对象的形式为

A.A const a(parameter);

B.A a(parameter);

C.A a(parameter) const;

D.const A a(parameter);

Standard Answer: A, D

解析：注意！！AD等价

Question 2 - 不定项选择题

如果在一个类中声明以下4个重载函数，有哪两个是互相冲突的？

Point fun1();  // 1
const Point fun1();  // 2
Point fun1() const;  // 3
const Point fun1() const;  // 4

A.1、2

B.1、3

C.2、3

D.3、4

Standard Answer: A, D

解析：

前面那个const只是表示返回值类型括号里的const表示this指针的类型，限定this指针的修改权限分号前的const表示所有成员的修改权限

函数签名：名称，参数类型，不考虑返回值，也即是前面的const不影响重载，后面反之

第九周

下面关于继承说法不正确的是:

A.继承可以使用现有类的所有功能，并在无需重新编写原来类的情况下对这些功能进行扩展。

B.继承体系中派生类应体现出与基类的不同。

C.派生类对象一定比基类对象大。

D.继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。

Standard Answer: C

解析：如果派生类没有新的成员变量，而且没有因为内存对齐而改变存储填充，派生类大小和基类相同；但是，如果派生类添加了新的成员变量或因为内存对齐而增加了额外的填充，那么派生类对象的大小就会比基类对象大。

派生类析构函数的作用是什么？

A.释放派生类新增的资源

B.释放基类的资源

C.释放派生类和基类的所有资源

D.不需要做任何操作

Standard Answer: A

解析：派生类的构造函数和析构函数并不是释放派生类和基类的所有资源

本质上都只是构造/销毁派生的变量 + 调用基类的构造/析构函数

Question 8 - 单选题

在派生类析构函数中，可以如何调用基类的析构函数？

A.直接调用基类的析构函数

B.使用基类的析构函数的名称作为成员初始化列表的一部分调用

C.不需要调用，基类的析构函数会自动被调用

D.只能调用公有基类的析构函数

Standard Answer: C
如果派生类没有定义构造函数和析构函数，会发生什么？

A.编译错误

B.调用基类的默认构造函数和析构函数

C.调用派生类的默认构造函数和析构函数

D.不做任何操作

Standard Answer: C

解析：调用默认构造/析构函数然后在这些默认函数里调用基类的函数

第十周

在C++中，重载（overloading）、覆盖（overriding）和隐藏（hiding）是三种不同的函数处理方式。它们在继承和多态性方面有着各自不同的作用和行为。以下是对这三者的详细解释和区别：

重载（Overloading）

重载指的是在同一个作用域中，定义多个具有相同名字但参数列表不同的函数。这些函数可以是普通函数，也可以是类成员函数。

示例：
```
class Example {
public:
    void func(int x) {
        // 实现1
    }

    void func(double y) {
        // 实现2
    }

    void func(int x, double y) {
        // 实现3
    }
};
```
在这个例子中，func函数被重载了三次，每次都有不同的参数列表。编译器通过参数列表来区分这些函数。

覆盖（Overriding）

覆盖指的是在派生类中重新定义基类中已存在的虚函数。覆盖函数必须具有与基类中被覆盖函数相同的函数签名（参数列表和返回类型）。覆盖通常用于实现多态性。

示例：
```
class Base {
public:
    virtual void show() {
        // 基类实现
    }
};

class Derived : public Base {
public:
    void show() override {
        // 派生类实现
    }
};
```
在这个例子中，Derived类中的show函数覆盖了Base类中的show函数。使用override关键字可以显式地表示该函数是覆盖基类中的虚函数。

隐藏（Hiding）

隐藏指的是在派生类中定义一个与基类中同名的函数，这个函数可能具有不同的参数列表。此时，基类中所有同名的函数都会被隐藏，而不是被重载。

示例：
```
class Base {
public:
    void func(int x) {
        // 基类实现
    }
};

class Derived : public Base {
public:
    void func(double y) {
        // 派生类实现
    }
};
```
在这个例子中，Derived类中的func函数隐藏了Base类中的func函数。在派生类的对象上调用func时，只有Derived类中的func函数是可见的。要调用基类的函数，可以使用作用域解析运算符。

区别总结
1. 重载：在同一个作用域中，定义多个具有相同名字但参数列表不同的函数。
2. 覆盖：在派生类中重新定义基类中的虚函数，必须具有相同的函数签名。
3. 隐藏：在派生类中定义一个与基类同名但参数列表不同的函数，这会隐藏基类中的所有同名函数。
理解这些概念对于正确使用C++中的继承和多态性非常重要。
关于虚继承
- C++在设计虚继承机制时，会提供一个虚表（vtable）和一个虚指针（vptr）。虚指针指向虚表，虚表用于存放虚基类（祖父类）成员的地址。通过虚指针和虚表，可以在使用公共基类时快速找到正确的成员。
- 菱形（钻石）继承的时候，编译器会默认调用父类的默认构造函数（记得提供），左右的类，不再调用父类的构造函数。
- 在类中，如果要使用父类的同名函数，要用域运算符: :
```
Human& Human::operator=(const Human& other) {
    Creature::operator=(other);
    // 基类的指针可以指向继承类——开头的结构是相同的
    delete [] languages;
    languages = new char[strlen(other.languages) + 1];
    strcpy(languages, other.languages);
    return *this;
}
```
virtual的范围只有上下两个
恢复访问方式
- ```
using  Base::data;
```
- 注意是，恢复为原来的访问方式，不受继承的时候的protected和private影响‘
在派生类中显式调用基类构造函数的时候，如果有拷贝构造，可以直接把派生类对象作为参数，如下
- ```
  Derived(const Derived & other) : Base(other), z(other.z) {}
```
- 在C++中，当你在派生类的构造函数中显式调用基类的构造函数时，使用Derived类的引用other作为参数是合法的，原因如下：
  1. 向上转型（Upcasting）：在C++中，派生类的对象可以被隐式地转换（向上转型）为基类的引用或指针。这意味着，当你将派生类的引用或指针传递给需要基类引用或指针的函数或构造函数时，转换是自动进行的。这种转换是安全的，因为派生类对象包含了基类的部分。
  2. 基类部分的初始化：在派生类构造函数中显式调用基类构造函数是初始化派生类对象中基类部分的标准方式。通过将Derived类的引用other传递给基类的拷贝构造函数，你实际上是在告诉编译器：“请使用other对象中的基类部分来初始化当前对象的基类部分。”这样做是必要的，因为基类可能有自己的成员变量需要根据other对象的状态来初始化。
  3. 保持对象状态的一致性：通过这种方式，你可以确保派生类对象的基类部分是通过基类的拷贝构造函数正确初始化的，这有助于保持对象状态的一致性，特别是当基类有自己的资源管理逻辑（如动态分配的内存）时

第十一周

Question 1 - 单选题

什么是多重继承？

A.从派生类派生出基类

B.从基类派生出派生类

C.从多个基类派生出派生类

D.派生出一个派生基类

Standard Answer: C

下面代码输出什么

#include <iostream>
using namespace std;

class Base {
public:
    virtual void print() const = 0;
};

class DerivedOne : public Base {
public:
    void print() const {
        cout << "DerivedOne\n";
    }
};

class DerivedTwo : public Base {
public:
    void print() const {
        cout << "DerivedTwo\n";
    }
};

class Multiple : public DerivedOne, public DerivedTwo {
public:
    void print() const {
        DerivedTwo ::print();
    }
};

int main() {
    int i;
    Multiple both;
    DerivedOne one;
    DerivedTwo two;
    Base *array[3];
    array[0] = &both; // error: 由于没有虚继承，基类的指向不明确
    array[1] = &one;
    array[2] = &two;
    array[i]->print();
    return 0;
}

Question 9 - 单选题

从基类继承了哪些内容？

A.构造函数及其析构函数

B.Operator=() 成员

C.友元

D.以上所有均不是

Standard Answer: D

在C++中，派生类从基类继承时，有几种成员和特性是不会被继承的：
1. 构造函数：基类的构造函数不会被派生类继承。派生类需要定义自己的构造函数。如果需要，派生类的构造函数可以显式地调用基类的构造函数。
2. 析构函数：基类的析构函数不会被派生类继承。派生类需要定义自己的析构函数。析构函数总是按照派生类到基类的顺序被调用。
3. 拷贝构造函数和拷贝赋值运算符：这些用于控制对象如何被复制的特殊成员函数不会被自动继承。派生类需要定义自己的拷贝构造函数和拷贝赋值运算符，如果需要的话，它们可以在其实现中调用基类的对应成员。
4. 友元函数：友元函数是指定的外部函数，它可以访问类的所有私有和保护成员。友元关系不是继承的。如果派生类需要某个函数作为友元，需要在派生类中显式声明。
5. 私有成员：基类的私有成员虽然被派生类继承，但是派生类不能直接访问它们。如果派生类需要访问基类的私有成员，可以通过基类提供的公共或保护的成员函数来实现。
6. 默认参数的使用规则：虽然派生类会继承基类的成员函数，但是成员函数的默认参数是静态绑定的，而不是动态绑定的。这意味着，如果通过基类的指针或引用调用一个继承自基类的函数，使用的默认参数值是基类中定义的值，而不是派生类中可能重新定义的值。
这些限制确保了对象的构造和析构、复制行为可以被适当地控制，并且保护了类的封装性，同时也避免了潜在的多态性相关的问题。
Question 10 - 不定项选择题

c++的类型兼容规则所指的替代包括以下情况:

A.父类指针可以直接指向子类对象

B.子类对象可以直接赋值给父类对象

C.子类对象可以直接初始化父类对象

D.将父类对象直接赋值给子类对象

Standard Answer: A, B, C
Question 11 - 单选题

在C++中，什么是虚拟继承？

A.C++ 中增强多重继承的技术

B.C++ 中确保基类的私有成员可以以某种方式被访问的技术

C.C++ 中避免类的多重继承的技术

D.C++ 中避免基类在子类/派生类中出现多个副本的技术

Standard Answer: D
Question 16 - 单选题

下面叙述不正确的是

A.在单一继承中，基类的构造函数不可被派生类直接继承或调用

B.对基类成员的访问必须是无二义性的

C.赋值兼容规则也适用于多重继承的组合

D.基类的公有成员在派生类中仍然是公有的

Standard Answer: D
Question 20 - 不定项选择题

哪种访问修饰符的成员会被继承？

A.Public

B.Protected

C.Private

D.以上都不会

Standard Answer: A, B，C

其实都能被继承的，只是访问权限上有不同

程序题出现的问题

/*
    private:
        char* sound;
        int age;
 */

//-----------------------------------------------------

/Creature::Creature(const char* _sound, int _age) : sound(_sound), age(_age) {} // error: invalid conversion from 'const char*' to 'char*' [-fpermissive]

Creature::Creature(const char* _sound, int _age) : age(_age) {
    sound = new char[strlen(_sound) + 1];
    strcpy(sound, _sound);
}	//correct

//-----------------------------------------------------

Human& Human::operator=(const Human& other) {
    if (this != &other) {
        // this->Creature = other; // error: invalid use of 'Creature::Creature'
        this->Creature::operator=(other); // 正确地调用基类的赋值运算符
        delete[] languages;
        languages = new char[strlen(other.languages) + 1];
        strcpy(languages, other.languages);
    }
    return *this;
}

第十二周

Question 1 - 单选题

在C++中，多态意味着什么？

A.只具有单一形态的类

B.编译时决定行为的类

C.允许对象表现出多种行为形态的特性

D.仅具备静态行为的类

Standard Answer: C

概念题
第三题

class Object {
private:
    int value;

public:
    Object(int x = 0) : value(x) {}
    void print() {
        cout << "Object::print" << endl;
        add(1);
    }
    virtual void add(int x) {
        cout << "Object::add" << x << endl;
    }
};

class Base : public Object {
private:
    int num;

public:
    Base(int x = 0) : Object(x + 10), num(x) {}
    void show() {
        cout << "Base::show" << endl;
        print();
    }
    virtual void add(int x) {
        cout << "Base::add:" << endl;
    }
};
int main() {
    Base base;
    base.show();
    return 0;
}

在C++中，**构造函数和析构函数中调用虚函数不会发生多态**的原因是为了保证对象状态的安全和一致性。具体来说，有以下几个原因：

构造函数中的虚函数调用：当构造函数被执行时，对象的派生类部分尚未被初始化。如果此时调用虚函数，并且该虚函数被派生类覆盖，那么该虚函数可能会操作派生类的成员变量，但这些成员变量此时还没有被初始化，这可能会导致不可预知的行为或错误。因此，在构造函数中，虚函数调用不会被动态绑定到派生类的实现。
析构函数中的虚函数调用：当析构函数被执行时，派生类的部分已经被销毁，对象被“降级”为其基类的状态。如果此时调用虚函数，并且该虚函数在派生类中有覆盖实现，那么调用派生类的实现就可能操作已经被销毁的成员变量，同样会导致不可预知的行为或错误。因此，在析构函数中，虚函数调用也不会被动态绑定到派生类的实现。

这种设计是为了确保在构造和析构过程中对象的完整性和一致性，避免在对象构造未完成或析构已开始时调用派生类的方法，这些方法可能会错误地操作尚未初始化或已经销毁的成员变量。

第五题

class Object {
public:
    virtual void func(int a = 10) {
        cout << "Object::func:a" << a << endl;
    }
};
//---------------------------------------------
class Base : public Object {
public:
    virtual void func(int b = 20) {
        cout << "Base::fun:b" << b << endl;
    }
};
//---------------------------------------------
int main() {
    Base base;
    Object* op = &base;
    op->func();
    return 0;
}

//out put Base::fun:b10

在这个C++代码中，有几个关键点需要注意来解释为什么输出时b等于10，而不是20。

在C++中，当通过基类指针或引用来调用虚函数时，会发生动态绑定（或晚期绑定）。但是，这里的关键是==默认参数值是在编译时确定的==，基于函数声明的上下文。由于op是Object*类型，编译器只知道Object类中的func函数及其默认参数值（a = 10），而不知道Base类中的默认参数值（b = 20）。

因此，当你执行op->func();时，调用的是Base类中的func函数，但是使用了Object类中定义的默认参数值10。这就是为什么输出是"Base::func:a10"。

在C++中，当通过基类指针调用一个覆盖的虚函数时，会使用派生类的函数实现，这是多态的表现。然而，函数的**默认参数值是静态绑定**的，而不是动态绑定的。这意味着默认参数值的选择是根据指针或引用的静态类型来决定的，而不是对象的实际类型。

在给定的代码中，[op](vscode-file://vscode-app/d:/Microsoft VS Code/resources/app/out/vs/code/electron-sandbox/workbench/workbench.html)是一个指向[Base](vscode-file://vscode-app/d:/Microsoft VS Code/resources/app/out/vs/code/electron-sandbox/workbench/workbench.html)对象的[Object](vscode-file://vscode-app/d:/Microsoft VS Code/resources/app/out/vs/code/electron-sandbox/workbench/workbench.html)类型指针。当调用[op->func()](vscode-file://vscode-app/d:/Microsoft VS Code/resources/app/out/vs/code/electron-sandbox/workbench/workbench.html)时，由于[func](vscode-file://vscode-app/d:/Microsoft VS Code/resources/app/out/vs/code/electron-sandbox/workbench/workbench.html)是一个虚函数，并且在[Base](vscode-file://vscode-app/d:/Microsoft VS Code/resources/app/out/vs/code/electron-sandbox/workbench/workbench.html)类中被覆盖，所以会调用[Base](vscode-file://vscode-app/d:/Microsoft VS Code/resources/app/out/vs/code/electron-sandbox/workbench/workbench.html)类中的[func](vscode-file://vscode-app/d:/Microsoft VS Code/resources/app/out/vs/code/electron-sandbox/workbench/workbench.html)实现。然而，因为[func](vscode-file://vscode-app/d:/Microsoft VS Code/resources/app/out/vs/code/electron-sandbox/workbench/workbench.html)的调用是通过一个类型为[Object*](vscode-file://vscode-app/d:/Microsoft VS Code/resources/app/out/vs/code/electron-sandbox/workbench/workbench.html)的指针[op](vscode-file://vscode-app/d:/Microsoft VS Code/resources/app/out/vs/code/electron-sandbox/workbench/workbench.html)进行的，所以使用的默认参数值是在[Object](vscode-file://vscode-app/d:/Microsoft VS Code/resources/app/out/vs/code/electron-sandbox/workbench/workbench.html)类中声明的[func](vscode-file://vscode-app/d:/Microsoft VS Code/resources/app/out/vs/code/electron-sandbox/workbench/workbench.html)函数的默认参数值10，而不是[Base](vscode-file://vscode-app/d:/Microsoft VS Code/resources/app/out/vs/code/electron-sandbox/workbench/workbench.html)类中的默认参数值20。

第8题

==虚函数不能是静态成员函数。==

这是因为在C++中，虚函数和静态成员函数在语义和设计目的上存在根本的差异。

虚函数：虚函数主要用于实现动态多态性。当通过基类指针或引用调用虚函数时，实际调用的是指针或引用所指向的对象的实际类型（即派生类）中的虚函数版本（如果已经被重写）。这是通过虚函数表（vtable）和虚指针（vptr）实现的。
静态成员函数：静态成员函数与类的一个特定实例无关，而是与类本身相关。它们不能访问类的非静态成员（因为它们不依赖于任何特定的对象实例），并且它们不能是虚函数。静态成员函数主要用于访问静态数据成员或执行与类相关的但与任何特定对象无关的操作。

由于静态成员函数与类的特定实例无关，因此它们没有与对象的动态类型相关的概念。因此，将它们声明为虚函数是没有意义的。

Question 10 - 不定项选择题

以下哪些情况会导致虚函数表的创建？

A.定义至少一个虚函数的类

B.使用虚继承的类

C.包含纯虚函数的类（抽象类）

D.所有类都会自动创建虚函数表

Standard Answer: A, C

解释：好好区分虚继承的概念，虚继承是为了解决菱形继承的过程中出现的多个基类的问题，和虚函数表完全是两码事
13.以下哪些是实现运行时多态的方式？

A.函数重载

B.虚函数

C.重写（Override）

D.模板函数

---standard answer BC

解释：

A. 函数重载（Overloading）虽然是实现多态的一种方式，但它实现的是编译时的多态性，而不是运行时的多态性。函数重载允许在同一个作用域内使用相同的函数名，但具有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）。

B. 虚函数（Virtual Functions）是实现运行时多态的关键机制。当基类中的成员函数被声明为虚函数时，它就可以在派生类中被重写（Override）。这样，通过基类指针或引用来调用虚函数时，就会根据指针或引用所指向的实际对象类型来调用相应的函数实现，从而实现运行时的多态性。

C. 重写（Override）是子类对父类中虚函数的重新实现。通过重写，子类可以改变父类中虚函数的行为。这也是实现运行时多态的一种方式。

D. 模板函数（Template Functions）主要用于实现泛型编程，它与运行时多态没有直接关系。模板函数在编译时根据提供的类型参数生成具体的函数实例，这属于**编译时的多态性**。

Question 14 - 不定项选择题

关于动态类型，以下哪些说法是正确的？

A.动态类型是在运行时确定的

B.动态类型可以通过向下转型来改变

C.动态类型决定了实际调用哪个函数版本

D.动态类型与静态类型总是相同的

Standard Answer: A, C

解释：动态类型和静态类型的概念主要用于指针和引用的上下文中，尤其是在涉及到继承和多态时。
- 静态类型：是变量声明时的类型，或者说是编译时可知的类型。对于指针和引用，静态类型决定了你可以在该指针或引用上调用哪些成员函数，以及这些函数调用是如何被解析的（比如是否发生动态绑定）。
- 动态类型：是指针或引用实际指向的对象的类型。动态类型只有在运行时才能确定，它可能与静态类型相同，也可能是静态类型的派生类类型。在使用虚函数时，动态类型决定了哪个函数实现被调用。
这两个概念是理解和实现多态性的关键。在非指针或引用的情况下，变量的类型在编译时是固定的，不存在动态类型的概念，因此通常不会讨论静态类型和动态类型。

对于B：动态类型是指指针或引用所指向对象的实际类型。动态类型可以在运行时通过向下转型（downcasting）来“改变”，但实际上并不改变对象本身的类型，而是改变我们对该对象类型的解释或访问方式。
17.以下哪种情况会发生动态类型转换？

A.将基类对象赋值给派生类对象

B.使用static_cast进行类型转换

C.通过基类指针调用非虚成员函数

D.显式地使用dynamic_cast进行转换

---answer: D

在C++中，关于动态类型转换的描述，我们来分析这些选项：

A. 将基类对象赋值给派生类对象

这是不允许的，因为基类对象通常不包含派生类可能添加的所有成员，因此无法直接将基类对象转换为派生类对象。这会导致编译错误。

B. 使用static_cast进行类型转换

static_cast 是一种编译时类型转换，它不会进行运行时检查。虽然它可以用于多种类型转换，包括基类和派生类之间的转换（当进行安全的上转型或明确知道转换是安全时），但它本身并不直接代表动态类型转换。

C. 通过基类指针调用非虚成员函数

通过基类指针调用非虚成员函数不会导致动态类型转换。这种调用将总是解析为基类中的函数版本，因为非虚函数是在编译时绑定的。

D. 显式地使用dynamic_cast进行转换

dynamic_cast 是C++中的一种类型转换运算符，它用于安全地执行运行时类型检查。它主要用于在类层次结构中进行向上转型（这通常是不必要的，因为自动转换就足够了）和向下转型（从基类指针或引用到派生类指针或引用）。当使用 dynamic_cast 进行向下转型时，如果转换不安全（即基类指针不指向派生类对象），它将返回空指针（对于指针类型）或抛出异常（对于引用类型）。因此，这是动态类型转换的一个例子。

所以，正确答案是 D：显式地使用dynamic_cast进行转换。
Question 20 - 不定项选择题

下列关于函数重载的规则，哪些是正确的？

A.参数类型或个数不同

B.函数返回类型必须相同

C.函数名称必须相同

D.参数名称可以不同

Standard Answer: A, C, D

补充

虚表
- from C++ 虚函数表剖析 - 知乎 (zhihu.com)
- 虚表是一个指针数组，其元素是虚函数的指针，每个元素对应一个虚函数的函数指针。需要指出的是，普通的函数即非虚函数，其调用并不需要经过虚表，所以虚表的元素并不包括普通函数的函数指针。虚表内的条目，即虚函数指针的赋值发生在编译器的编译阶段，也就是说在代码的编译阶段，虚表就可以构造出来了。（解释上面的第五题）
- 虚表是属于类的，而不是属于某个具体的对象，一个类只需要一个虚表即可。同一个类的所有对象都使用同一个虚表。
- 为了指定对象的虚表，对象内部包含一个虚表的指针，来指向自己所使用的虚表。为了让每个包含虚表的类的对象都拥有一个虚表指针，编译器在类中添加了一个指针，*__vptr，用来指向虚表。这样，当类的对象在创建时便拥有了这个指针，且这个指针的值会自动被设置为指向类的虚表。
- 一个继承类的基类如果包含虚函数，那个这个继承类也有拥有自己的虚表，故这个继承类的对象也包含一个虚表指针，用来指向它的虚表。（解释一旦为虚，永远为虚）
- ==对象的虚表指针用来指向自己所属类的虚表，虚表中的指针会指向其继承的最近的一个类的虚函数==
- 非虚函数的调用不用经过虚表，故不需要虚表中的指针指向这些函数。
- ```
int main() 
{
    B bObject;
    A *p = & bObject;
    p->vfun1();
}

//虽然p是基类的指针只能指向基类的部分，但是虚表指针亦属于基类部分，所以p可以访问到对象bObject的虚表指针。bObject的虚表指针指向类B的虚表，所以p可以访问到B vtbl.

//程序在执行p->vfunc1()时，会发现p是个指针，且调用的函数是虚函数，接下来便会进行以下的步骤。

//首先，根据虚表指针p->__vptr来访问对象bObject对应的虚表。虽然指针p是基类A*类型，但是*__vptr也是基类的一部分，所以可以通过p->__vptr可以访问到对象对应的虚表。

//然后，在虚表中查找所调用的函数对应的条目。由于虚表在编译阶段就可以构造出来了，所以可以根据所调用的函数定位到虚表中的对应条目。对于p->vfunc1()的调用，B vtbl的第一项即是vfunc1对应的条目。

//最后，根据虚表中找到的函数指针，调用函数。
```
- 我们把经过虚表调用虚函数的过程称为动态绑定，其表现出来的现象称为运行时多态。动态绑定区别于传统的函数调用，传统的函数调用我们称之为静态绑定，即函数的调用在编译阶段就可以确定下来了。
- 当对象指针被向上转型为基类指针时，如果没有涉及到多态（即没有使用虚函数机制），调用的是基类的函数，原因在于编译时的静态类型决定了可以调用哪些成员函数。这种行为是基于静态绑定的，意味着函数调用在编译时就已经确定了，而不是在运行时。
  
  在没有多态的情况下，即使派生类隐藏了基类中的同名函数，当通过基类指针调用函数时，编译器只能看到指针的静态类型（即基类），因此它会调用基类中的函数。这是因为在编译时，编译器只能根据指针的类型（而不是指针所指向的对象的实际类型）来解析函数调用。
  
  多态通过虚函数实现，它允许在运行时根据对象的动态类型来决定调用哪个函数。当基类中的函数被声明为 virtual，并且派生类提供了一个覆写版本时，通过基类指针调用该函数将会根据指针所指向的对象的实际类型来调用相应的函数实现，这是动态绑定的结果。
向上转型
- 向上转型是将派生类（或子类）的引用赋值给基类（或父类）的引用。这种转型是安全的，因为派生类是基类的一个特殊化版本，所以基类引用可以安全地引用派生类对象。在向上转型过程中，不需要进行显式转换，因为编译器会自动进行这种转换。
- 收窄
如果派生类中的函数与基类中的函数同名，不管参数列表是否相同，都会导致基类中同名函数的隐藏。这种现象在 C++ 中被称为“隐藏”（不是“覆写”或 overwrite，覆写一词通常用于虚函数的上下文）。隐藏发生在派生类中声明了一个与基类中某个函数同名的函数时，无论这两个函数的参数列表是否相同，基类中的所有同名函数都将在派生类的作用域中被隐藏。

这意味着，如果你想在派生类中调用被隐藏的基类函数，你需要在派生类中显式地引用它们，通常是通过使用基类的作用域解析运算符（::）来实现。

static

**静态成员变量是**C++中类的一个特殊特性，它不属于任何一个类实例，而是属于类本身。以下是使用静态成员变量时需要注意的一些关键事项：

定义与声明：静态成员变量==必须在类定义之外进行定义和初始化==。在类定义中，你只能声明静态成员变量，而不能定义它。例如：

class MyClass {
public:
    static int myStaticVar;  // 声明
};

int MyClass::myStaticVar = 0;  // 定义和初始化

访问方式：你可以通过类名直接访问静态成员变量，而无需创建类的实例。同时，你也可以通过类的对象访问静态成员变量，但这不是推荐的做法，因为这可能会导致混淆。

MyClass::myStaticVar = 10;  // 通过类名访问
MyClass obj;
obj.myStaticVar = 20;  // 通过对象访问，不推荐

初始化顺序：静态成员变量的初始化顺序是按照它们在文件中出现的顺序进行的，而不是按照它们在类定义中的顺序。因此，如果静态成员变量的初始化依赖于其他静态成员变量或全局变量，那么你需要特别小心以确保正确的初始化顺序。
生命周期：静态成员变量的生命周期与整个程序的生命周期相同。它们在程序开始执行时创建，在程序结束时销毁。
线程安全：在多线程环境中，对静态成员变量的访问需要特别注意线程安全。如果没有适当的同步机制，多个线程可能同时修改静态成员变量，导致数据不一致或其他问题。
内存管理：静态成员变量存储在程序的静态存储区，而不是堆或栈上。因此，你不需要（也不能）使用new或delete来管理它们的内存。
继承：如果基类有静态成员变量，那么派生类不会继承这个静态成员变量。每个类都有自己的静态成员变量。但是，通过派生类的名字也可以访问基类的静态成员变量。

**静态成员函数**是C++类中的一种特殊函数，它属于类本身而不是类的实例对象。以下是关于静态成员函数的一些主要特点和注意事项：

声明与定义：静态成员函数在类内部声明时，使用static关键字进行修饰。其定义（实现）通常在类外部完成，且不需要static关键字。
访问方式：静态成员函数可以通过类名直接调用，而不需要创建类的实例。这使得静态成员函数成为执行与类本身相关的操作而非特定于某个对象的操作的理想选择。同时，静态成员函数不能访问类的非静态成员变量和非静态成员函数，因为它们需要依赖于特定的对象实例。但是，静态成员函数可以访问静态成员变量和静态成员函数。
用途：静态成员函数通常用于执行与类相关但不依赖于对象实例的操作。例如，它们可以用于计算类的静态成员变量的值，或者执行一些全局性的操作。
线程安全：在多线程环境中，对静态成员函数的访问需要特别注意线程安全。如果没有适当的同步机制，多个线程可能同时调用静态成员函数，导致数据竞争或其他问题。
继承：如果基类有静态成员函数，派生类可以访问基类的静态成员函数。这是因为静态成员函数属于类本身，而不是类的实例。

请注意，虽然静态成员函数在类定义中声明时使用了static关键字，但在其定义（实现）时==不需要再次使用static关键字==。此外，静态成员函数由于没有隐式的this指针，因此不能访问类的非静态成员。

总的来说，静态成员函数是C++类的一个强大工具，可以在不需要特定对象实例的情况下执行与类相关的操作。然而，在使用它们时，需要注意它们的一些限制和特性，以确保代码的正确性和安全性。

#第十三周

Question 3 - 单选题

以下关于虚函数和多态的说法中错误的是：

A.只要基类的函数被声明为虚函数，则派生类的同名函数就能自动实现对基类函数的覆盖（override）。

B.一般不建议在派生类中把从基类继承来的非虚函数声明为虚函数。

C.当基类的某个成员函数在派生类中被隐藏（overwrite）时，程序将根据引用或指针的类型选择函数方法。

D.关键字virtual只用于类声明的函数原型中，而不会用于类外的函数方法定义中。

Standard Answer: A

这句话的错误之处在于它忽略了函数签名的匹配要求和override关键字的作用。要正确实现对基类虚函数的覆盖（override），派生类中的函数不仅需要与基类中的虚函数同名，还必须具有相同的参数列表（包括参数类型和数量）和兼容的返回类型。此外，C++11引入了override关键字，虽然它不是必需的，但使用它可以让编译器帮助检查派生类的函数确实覆盖了基类的一个虚函数。

因此，更准确的表述应该是：

只要基类的函数被声明为虚函数，且派生类中有一个同名函数，该函数具有相同的参数列表和兼容的返回类型，则派生类的这个函数就能实现对基类函数的覆盖。为了确保这种覆盖是有意为之，可以在派生类的函数声明中使用override关键字，这样如果没有正确覆盖基类的虚函数，编译器将报错。
Question 5 - 不定项选择题

以下关于up/downcasting的说法正确的有：

A.upcasting时必须显式转换；

B.upcasting显隐式转换均合法；

C.downcasting时必须显式转换；

D.downcasting显隐式转换均合法；

Standard Answer: B, C

解释： B.将派生类指针(或引用)转换为基类指针(或引用)的过程称为upcasting

C.将基类指针(或引用)转换为派生类指针(或引用)的过程称为downcasting

往下是危险的，所以要用dynamic_cast保护
不能声明为虚函数的函数
- 1）普通函数。普通函数不属于成员函数，是不能被继承的。普通函数只能被重载，不能被重写，因此声明为虚函数没有意义。因为编译器会在编译时绑定函数。而多态体现在运行时绑定。通常通过基类指针指向子类对象实现多态。
- 2）友元函数。友元函数不属于类的成员函数，不能被继承。对于没有继承特性的函数没有虚函数的说法。
- 3）构造函数。假如子类可以继承基类构造函数，那么子类对象的构造将使用基类的构造函数，而基类构造函数并不知道子类的有什么成员，显然是不符合语义的。从另外一个角度来讲，多态是通过基类指针指向子类对象来实现多态的，在对象构造之前并没有对象产生，因此无法使用多态特性，这是矛盾的。因此构造函数不允许继承。
- 4）内联成员函数。我们需要知道内联函数就是为了在代码中直接展开，减少函数调用花费的代价。也就是说内联函数是在编译时展开的。而虚函数是为了实现多态，是在运行时绑定的。因此显然内联函数和多态的特性相违背。
- 5）静态成员函数。首先静态成员函数理论是可继承的。但是静态成员函数是编译时确定的，无法动态绑定，不支持多态，因此不能被重写，也就不能被声明为虚函数。
Question 3 - 单选题

以下关于虚函数和多态的说法中错误的是：

A.只要基类的函数被声明为虚函数，则派生类的同名函数就能自动实现对基类函数的覆盖（override）。

B.一般不建议在派生类中把从基类继承来的非虚函数声明为虚函数。

C.当基类的某个成员函数在派生类中被隐藏（overwrite）时，程序将根据引用或指针的类型选择函数方法。

D.关键字virtual只用于类声明的函数原型中，而不会用于类外的函数方法定义中。

答案：A

选项分析：

A. 只要基类的函数被声明为虚函数，则派生类的同名函数就能自动实现对基类函数的覆盖（override）。
- 这个说法有误。虽然基类函数被声明为虚函数允许派生类进行覆盖，但并不是派生类的同名函数就能“自动”实现对基类函数的覆盖。派生类中的函数需要有相同的函数签名（包括返回类型、函数名和参数列表），并且需要使用 override 关键字（在C++11及以后的版本中）来显式地表明这是一个覆盖基类的虚函数。所以，A 选项是错误的。
B. 一般不建议在派生类中把从基类继承来的非虚函数声明为虚函数。
- 这个说法通常被认为是正确的。如果基类中的函数不是虚函数，而在派生类中将其声明为虚函数，这可能会导致一些设计上的问题，比如切片问题等。通常，如果一个函数在基类中应当是虚函数，那么它应该在基类中就被声明为虚函数。
C. 当基类的某个成员函数在派生类中被隐藏（overwrite）时，程序将根据引用或指针的类型选择函数方法。
- 这个说法是正确的。当派生类中的函数与基类中的函数同名但签名不同，或者基类中的函数没有被声明为虚函数时，基类的函数将被隐藏。在这种情况下，程序将根据对象的静态类型（即引用或指针的类型）来选择调用的函数。
D. 关键字virtual只用于类声明的函数原型中，而不会用于类外的函数方法定义中。
- 这个说法是正确的。virtual 关键字只在类内部声明虚函数时使用，不需要在类外部的函数定义中重复。
Question 5 - 不定项选择题

以下关于up/downcasting的说法正确的有：

A.upcasting时必须显式转换；

B.upcasting显隐式转换均合法；

C.downcasting时必须显式转换；

D.downcasting显隐式转换均合法；

答案：BC

收窄安全，隐式即可，无强制要求显式；拓宽危险，需要显式

#include <iostream>
#include <string>

using namespace std;

class Cat {
public:
    // three overloaded functions
    virtual void func() const {
        cout << "func default" << endl;
    }

    virtual void func(int a) const {
        cout << "func with int" << endl;
    }

    virtual void func(double x) const {
        cout << "func with double" << endl;
    }

    virtual void func(string str) const {
        cout << "func with string" << endl;
    }
};

class persianCat : public Cat {
public:
    // new redefined functions
    // 有同名函数，不管参数是否相同，都隐藏了基类的函数

    // 同名且参数相同，重写了基类的无参函数
    virtual void func() const {
        cout << "new func default" << endl;
    }

    // 同名且参数相同，重写了基类的int函数
    virtual void func(int a_) const {
        cout << "new func with int" << endl;
    }
};

int main() {
    Cat bai;
    persianCat hei;

    //--------------------------------------------------------

    Cat *c1 = &hei;
    persianCat *c2 = &hei;
    string s("hello");
    // hei.func(s);  // error:找不到这个函数，被隐藏了，强制类型转换又不行（string->int）
    // c2->func(s);  // error:
    c1->func(s);  // correct，输出func with string
    c1->func(2);  // correct, 输出func with int
    /*
    Q:为什么派生对象和派生类指针找不到这个函数？是因为隐藏吗
    A:是的，派生类同名函数隐藏了基类函数

    Q:为什么基类指针就可以调用
    A:基类指针调用的是基类的函数，基类的函数在基类指针的解释下都是可以找到的，再根据动态类型来调用派生类的函数
    */

    //-------------------------------------------------------

    // object of base class
    cout << "12" << endl;
    bai.func(2.1);  // 输出func with double，基类成员调用基类函数

    //-------------------------------------------------------

    cout << "13" << endl;
    hei.func(2.1);  // 输出func with new int，由于隐藏，无法调用基类的int函数，只能强转之后调用派生类的int函数
    // 因为基类的虚表已经被隐藏，只有在派生类中重定义了的函数才会出现在派生类的虚表里面。既然找不到函数，只好强制类型转换后调用int的函数了。

    //-------------------------------------------------------

    // hei.func("adsasd");
    cout << "14" << endl;
    cout << "error" << endl;

    //-------------------------------------------------------

    // pointer to base class
    cout << "15" << endl;
    Cat *p2Cat = &bai;  // 基类指针指向基类对象
    p2Cat->func();      // 输出func default
    p2Cat->func(2);     // 输出func with int
    p2Cat->func(2.1);   // 输出func with double
    // 这仨都是基类指针指向基类对象，动态类型也是基类的，所以都是调用基类的函数

    //-------------------------------------------------------

    // pointer to base class
    cout << "16" << endl;
    // Cat *p2Cat
    p2Cat = &hei;      // 基类指针指向派生类对象
    p2Cat->func();     // 输出new func default
    p2Cat->func(2);    // 输出new func with int
    p2Cat->func(2.1);  // 输出func with double
    // 基类指针指向派生类对象，从基类函数中找匹配参数的函数
    // 如果有，看看有无重写，有则调用派生类的函数，没有则调用基类的函数

    //----------------------------------------------------

    // pointer to derived class
    cout << "17" << endl;
    persianCat *p2persianCat = &hei;  // 派生类指针指向派生类对象
    p2persianCat->func();             // 输出new func default
    p2persianCat->func(2);            // 输出new func with int
    p2persianCat->func(2.1);          // 输出nfunc with int
    // 派生类指针指向派生类对象，基类函数已经被隐藏了，直接调用派生类的函数
    // 如果没有完全匹配的，尝试类型转换

    //---------------------------------------------------

    // reference to base class
    cout << "18" << endl;
    Cat &ref2Cat = bai;  // 基类引用指向基类对象
    ref2Cat.func();      // 输出func default
    ref2Cat.func(2);     // 输出func with int
    ref2Cat.func(2.1);   // 输出func with double
    // 基类引用指向基类对象，动态类型也是基类的，所以都是调用基类的函数

    //----------------------------------------------------

    // reference to base class
    cout << "19" << endl;
    Cat &ref3Cat = hei;  // 基类引用指向派生类对象
    ref3Cat.func();      // 输出new func default
    ref3Cat.func(2);     // 输出new func with int
    ref3Cat.func(2.1);   // 输出func with double
    // 基类引用指向派生类对象，从基类函数中找匹配参数的函数
    // 找到了，看看有无重写，有则调用派生类的函数，没有则调用基类的函数

    //----------------------------------------------------

    // reference to derived class
    cout << "20" << endl;
    persianCat &r2persianCat = hei;  // 派生类引用指向派生类对象
    r2persianCat.func();             // 输出new func default
    r2persianCat.func(2);            // 输出new func with int
    r2persianCat.func(2.1);          // 输出new func with int
    // 派生类引用指向派生类对象，基类函数已经被隐藏了，直接调用派生类的函数
    // 如果没有完全匹配的，尝试类型转换

    system("pause");

    return 0;
}

13周课堂1，要输出类名，注意函数，只有基类或者次基类要用virtual，然后调用的函数，接受的形参必须是引用或者指针

第十四周（模板）

Question 2 - 单选题

模板函数的真正代码是在哪个时期产生的？

A.源程序中声明函数时

B.源程序中定义函数时

C.源程序中调用函数时

D.运行执行函数时

Standard Answer: C

解释：编译器的“调用”过程实际上是一个代码生成过程，而不是像程序运行时那样的函数执行过程。编译器通过分析源代码中的模板函数调用，确定需要生成的具体函数版本。这个过程包括确定模板参数的具体类型，并根据这些类型生成相应的函数实例代码。这一切都发生在编译时，而非运行时。
Question 3 - 单选题

下列关于模板的描述中，错误的是？

A.模板把数据类型作为一个设计参数，称为参数化程序设计

B.使用时，模板参数与函数参数相同，是按位置而不是名称对应的

C.模板参数表中可以有类型参数和非类型参数

D.类模板与模板类是同一个概念

Standard Answer: D

解释：类模板是一个蓝图，不是一个具体的类，但是模板类是一个具体的类
Question 10 - 单选题

关于类模板，描述错误的是?

A.一个普通基类不能派生类模板

B.类模板可以从普通类派生，也可以从类模板派生

C.根据建立对象时的实际数据类型，编译器把类模板实例化为模板类

D.函数的类模板参数需生成模板类并通过构造函数实例化

Standard Answer: A
Question 16 - 不定项选择题

根据如下类模板定义，下列语句中可正常运行的有：
```
template<typename T>
class Point{
    T x,y;
public:
    Point(T x_, T y_):x(x_),y(y_){}
};

template<typename T>
class Circle : public Point<T>{
    T r;
public:
    Circle(T x_, T y_, T r_):Point<T>(x_,y_),r(r_){}
};
```
A.Circle<double>* a = new Circle<int>(4,5,6);

B.Point<int>* a = new Circle<int>(4,5,6);

C.Circle<int> a(4,5,6); Circle<double> b(1,2,3); a=b;

D.Circle<int> a(1,2,2.5); Point<int> b(1,2); b=a;

Standard Answer: B, D

解释：这个语句试图将 Circle<int> 类型的对象赋值给一个指向 Circle<double> 类型的指针。这是类型不匹配的，因为模板参数 T 在两边不一致，导致类型不兼容。因此，这个语句不能正常运行。

一旦实例化，就是不同类的了，如果将不同类非继承关系的指针之间进行直接赋值，是错的，而D选项里，基类和派生类都是int的，因而父类指针可以指向派生类
Question 17 - 单选题

下述关于函数模板和类模板的说法中错误的是：

A.调用函数模板时，编译器允许根据函数调用中所给出的实参类型来确定相应的模板实参

B.调用函数模板时允许显示指定模板实参

C.实例化类模板时，编译器允许不显式提供模板实参而根据构造函数的实参类型来推断模板实参

D.实例化类模板时，必须显式地提供模板实参

Standard Answer: C

解释：对于类模板，当前的 C++ 标准（包括 C++17）要求在实例化类模板时必须显式提供模板实参。这意味着编译器不会尝试根据构造函数的实参类型来推断模板实参。

Question 15 - 单选题

对模板进行实例化时，传递给非类型形参的实参可以是：

A.动态对象

B.局部变量

C.非const的全局变量

D.编译时常量表达式

ans: D 由于模板实例化发生在编译期，所以必须传递编译器常量才能识别，也就是说尖括号里面的内容必须是一个常量表达式。

函数模板调用的是同一个函数吗

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

类函数分离声明与定义的写法

#include "Stack.h"
 
template<class T1>
// 构造函数
Stack<T1>::Stack(int capacity)
	:_a(new T1[capacity])
	,_capacity(capacity)
	,_size(0)
{}
template<class T1>
// 插入函数
void Stack<T1>::Push(T1 data){
	_a[_size] = data;
	_size++;
}
// 析构函数
template<class T1>
Stack<T1>::~Stack(){
	delete[]_a;
	_a = nullptr;
	_capacity = _size = 0;
}

补充

explicit表示不发生隐式类型转换，所以调用失败（注意：explicit只能在构造函数中使用）

程序题

#include <iostream>
#include <string>

using namespace std;

// 函数模板demoPrint
template <typename T>
void demoPrint(const T v1, const T v2) {
    cout << "the first version of demoPrint()" << endl;
    cout << "the arguments: " << v1 << " " << v2 << endl;
}

// 函数模板demoPrint的指定特殊
template <>
void demoPrint(const char v1, const char v2) {
    cout << "the specify special of demoPrint()" << endl;
    cout << "the arguments: " << v1 << " " << v2 << endl;
}

// 函数模板demoPrint重载的函数模板
template <typename T>
void demoPrint(const T v) {
    cout << "the second version of demoPrint()" << endl;
    cout << "the argument: " << v << endl;
}

// 非函数模板demoPrint
void demoPrint(const double v1, const double v2) {
    cout << "the nonfunctional template version of demoPrint()" << endl;
    cout << "the arguments: " << v1 << " " << v2 << endl;
}

int main() {
    string s1("rabbit"), s2("bear");
    char c1('k'), c2('b');
    int iv1 = 3, iv2 = 5;
    double dv1 = 2.8, dv2 = 8.5;
    
    // 调用第一个函数模板
    demoPrint(iv1, iv2);
    
    // 调用第一个函数模板的指定特殊
    demoPrint(c1, c2);
    
    // 调用第二个函数模板
    demoPrint(iv1);
    
    // 调用非函数模板
    demoPrint(dv1, dv2);
    
    // 模板不会发生隐式类型转换，所以隐式转换后调用非函数模板
    demoPrint(iv1, dv2);

    return 0;
}

第十五、十六周（STL）

  //1
  int main() {
      vector<int> vec;
      for (int i = 0; i < 5; i++) {
          vec.push_back(i + 1);
      }
      // 1 2 3 4 5
      auto it2 = vec.begin() + 2; // 3
      auto it = vec.begin() + 3;  // 4
      vec.insert(it2, 5); // 在3的前面插入5
      // 1 2 5 3 4 5
      cout << *(it2) << " " << *(it) << endl; // 5 3（it没有移动）
  }
  
  //2
  int main() {
      vector<int> vec;
      for (int i = 0; i < 5; i++) {
          vec.push_back(i + 1);
      }
      // 1 2 3 4 5
      auto it2 = vec.begin() + 2; // 3
      auto it = vec.begin() + 3;  // 4
      vec.insert(it2, 5);     // 1 2 5 3 4 5
      sort(vec.begin(), vec.end()); // 1 2 3 4 5 5
      cout << *(it2) << " " << *(it) << endl; // 3 4（迭代器不会跟随数据移动而移动，只是指向一个位置）
  }

关于stack，下列哪项描述是正确的？

A.stack是一种先进先出（FIFO）的数据结构

B.stack支持随机访问其中的元素

C.stack提供的主要操作是push、pop和top等

D.stack可以直接使用迭代器进行遍历

Standard Answer: C

解释：
- A：错误。栈是一种后进先出（LIFO）的数据结构，而不是先进先出（FIFO）。先进先出描述的是队列（std::queue）的行为。
- B：错误。栈不支持随机访问其内部元素。栈的操作主要集中在栈顶，你不能直接访问栈中间的元素，这是由栈的设计和目的决定的。
- D：错误。std::stack不提供直接使用迭代器进行遍历的能力。这是因为栈是一种只能从一端（栈顶）访问元素的容器，不支持像数组或链表那样的随机访问模式。如果需要遍历栈中的元素，你需要将元素从栈中移除，这通常不是遍历操作所期望的。
- 请注意：stack，queue等==是一个容器适配器，而不是一个顺序容器==。它提供了一组特定的接口（如 push, pop, front, back 等）来支持先进先出（FIFO）的数据结构模型。std::queue通常使用std::deque或std::list作为其底层容器实现，但它限制了对这些底层容器的直接访问，仅提供了队列操作的接口。这种设计允许std::queue专注于实现队列的行为，而不是容器的存储细节。
- 第二次输出的容量不会因为 resize 调用而减少。即使 vector 的大小被调整为4，其容量仍然保持不变，因为 resize 减少大小不会自动减少容量。
- 这个地方很好地说明了capacity和size的区别

  int main() {
      int n = 16;
      vector<int> a;
      for (int i = 0; i < n; i++) {
          a.push_back(i);
      }
      // 0~15 capacity = 16 size = 16
      cout << a.capacity() << " ";  // 16
  
      int m = 50;
      a.reserve(m);
      cout << a.capacity() << " " << a.size() << endl;
      // capacity = 50 size = 16
      for (int i = 0; i < m; i++) {
          a.push_back(i);
      }
      // capacity = 100 size = 66
      cout << a.capacity() << " " << a.size() << endl;  // 100 66
      return 0;
  }

  int main() {
      int n = 17;
      vector<int> a;
      for (int i = 0; i < n; i++) {
          a.push_back(i);
      }
      // 0~16, size = 17, capacity = 32
      cout << a.capacity() << " ";
      
      a.shrink_to_fit();
      // 0~16, size = 17, capacity = 17
      
      a.push_back(n + 1);
      // 0~17, size = 18, capacity = 34
      cout << a.capacity();
      return 0;
  }

  int main() {
      int n = 3;
      vector<int> a;
      for (int i = 0; i < n; i++) {
          a.push_back(i + 1);
      }
      // 1 2 3
      auto res = accumulate(a.begin(), a.end(), 1, [](int i, int j) { return pow(i, j); });
      // i = i^1 = 1^1 = 1
      // i = i^2 = 1^2 = 1
      // i = i^3 = 1^3 = 1
      cout << res << " ";
      
      auto res = accumulate(a.begin(),a.end(),1,[](int i,int j){return pow(j,i);});
      // i = 1^i = 1^1 = 1
      // i = 2^i = 2^1 = 2
      // i = 3^i = 3^2 = 9
  	cout << res << " ";
      
      sort(a.begin(), a.end(), [](int a, int b) { return a > b; });
      // 3 2 1
      auto res2 = accumulate(a.begin(), a.end(), 1, [](int i, int j) { return pow(i, j); });
      // i = i^3 = 1^3 = 1
      // i = i^2 = 1^2 = 1
      // i = i^1 = 1^1 = 1
      cout << res2;
  }

这里，i 是累积到目前为止的结果（初始值为 1），j 是当前元素的值。lambda 表达式使用 pow(i, j) 计算 i 的 j 次幂，这个结果将被用作下一步的累积值。

因此，对于这个特定的 accumulate 调用：
- 第一个参数 i 表示到目前为止的累积结果。
- 第二个参数 j 表示当前遍历到的元素值。

课堂2中有一个地方

map<string, set<int>> students;

// 在我们试图寻找到。对应的set的时候出现了问题
for(auto c : students.at(name)) {
    sum += c;
    cnt++;
    cout << c << " ";
}

错误示例 1

for(auto c : students[name]) {
    // ...
}

错误原因：students 是一个对 const map<string, set<int>> 的引用，这意味着你不能通过这个引用修改 map 或其内部的元素。在 for 循环中使用 students[name] 实际上会尝试在 map 中查找键 name，如果它不存在，则会插入一个新的键值对（默认构造的 set<int>）。然而，由于 students 是 const 的，这种修改（即使它实际上是因为查找不存在的键而发生的隐式插入）也是不允许的。

错误示例 2

for(auto it = students[name].begin()...; // ...

错误原因：和错误示例 1 类似，这里也是尝试通过 students[name] 访问 map 中的 set，这同样会导致尝试修改 const 对象，因为当 name 不存在于 map 中时，students[name] 会隐式地插入一个新的 set。

正确示例 1

for(auto c : students.find(name)->second) {
    // ...
}

正确原因：students.find(name) 返回一个迭代器，指向键为 name 的元素（如果存在的话），或者指向 map 的 end()。由于它不会尝试修改 map，所以这在 const 上下文中是合法的。->second 用于访问找到的 map 元素的 set 成员。

正确示例 2

for(auto c : students.at(name)) {
    // ...
}

正确原因：students.at(name) 也会返回与键 name 关联的 set，但它会在找不到键时抛出一个异常（而不是像 operator[] 那样隐式地插入一个元素）。由于它不修改 map，所以在 const 上下文中也是安全的。但是，使用 at 时需要确保键确实存在，否则程序会因为未捕获的异常而终止。

总结

在 const 上下文中处理容器时，你必须确保不执行任何可能修改容器的操作。这包括避免使用 operator[] 访问 map 的元素，因为它可能会隐式地插入新元素。相反，应该使用 find 或 at（但要注意处理可能的异常）。

vector（序列式容器）常用函数

C++中的std::vector是一个动态数组，提供了一系列用于管理其存储的元素的函数。以下是一些std::vector的常用函数及其返回值：

容量相关

empty()：检查容器是否为空。返回bool。
size()：返回容器中的元素数。返回size_type。
max_size()：返回容器可能包含的最大元素数。返回size_type。
capacity()：返回在不重新分配的情况下容器可以容纳的元素数量。返回size_type。
resize(n)：调整容器的大小为n个元素。无返回值。
reserve(n)：请求改变容器的容量至少为n个元素。无返回值。
shrink_to_fit()：请求移除未使用的容量。无返回值。

修改器

clear()：移除所有元素。无返回值。
insert(position, value)：在指定位置之前插入元素。==返回指向新插入的元素的迭代器。==

erase(position)：移除指定位置的元素。==返回指向被移除元素之后元素的迭代器==。

注意：erase会自动指向删除元素的下一个，所以这里注意代码规范

  vector<int> v = {1, 2, 3, 4, 5};
  // correct 
  for (auto i = v.begin(); i != v.end(); ) {
      if(*i == 5) {
          v.erase(i);
          cout << *i << endl;
      } else {
          i++;
      }
  }
  
  // error
  for (auto i = v.begin(); i != v.end(); i++) {
      if(*i == 5) {
          i = v.erase(i);
          cout << *i << endl;
      }
  }
  // erase 之后 i 指向 v.end()了，然后又++，导致指针丢失，所以一直循环

push_back(value)：在容器末尾添加一个新元素。无返回值。
pop_back()：移除容器末尾的元素。无返回值。
swap(vector)：与另一个同类型的vector交换内容。无返回值。

元素访问

operator[] (n)：访问指定位置n的元素。返回引用。
at(n)：访问指定位置n的元素，带边界检查。返回引用。
front()：访问第一个元素。返回引用。
back()：访问最后一个元素。返回引用。
data()：返回指向容器中第一个元素的指针。返回T*。

map（关联式容器）常用函数

std::map是C++标准模板库（STL）中的一个关联容器，它存储键值对，并且基于键来自动排序。每个键在std::map中是唯一的。以下是std::map的一些常用成员函数及其返回值：

访问元素

at(const Key& key)：返回给定键对应的值的引用，如果键不存在则抛出std::out_of_range异常。返回类型为mapped_type&。
operator[](const Key& key)：访问给定键对应的值，如果键不存在，则插入一个新的键值对，其中值进行默认初始化。返回类型为mapped_type&。

容量和大小

empty()：检查容器是否为空。返回true如果容器为空，否则返回false。
size()：返回容器中键值对的数量。返回类型为size_type。
max_size()：返回容器可能包含的最大键值对数量。返回类型为size_type。

修改器

clear()：移除容器中的所有键值对。
insert(const value_type& value)：插入一个键值对，如果键已存在，则不进行任何操作。返回一个pair<iterator,bool>，其中iterator指向插入的元素或已存在的元素，bool表示是否插入成功。
erase(const Key& key)：移除指定键的键值对。返回移除的元素数量（0或1）。
swap(map& other)：与另一个map交换内容。

查找

find(const Key& key)：查找给定键的元素。==如果找到，则返回一个指向该元素的迭代器==；否则，返回end()。
count(const Key& key)：返回具有给定键的元素数量（由于map中的键是唯一的，因此返回值为0或1）。

迭代器

begin() / cbegin()：返回指向容器中第一个元素的迭代器。
end() / cend()：返回指向容器末尾的迭代器。

观察者

key_comp()：返回用于键比较的函数对象。
value_comp()：返回用于值比较的函数对象。

第十七周

以下哪个选项描述的是C++中异常处理的正确用法？

A.在try块中使用throw语句抛出一个整数类型的异常

B.在catch块中捕获一个整数类型的异常，并将其赋值给一个字符串变量

C.在catch块中捕获一个整数类型的异常，并将其赋值给一个整数变量

D.在catch块中捕获一个整数类型的异常，并将其赋值给一个指针变量

Standard Answer: C

解释：

A：这个选项是正确的行为，但它不是关于如何捕获异常的描述，而是关于如何抛出异常，属于异常检测。因此，它不是针对问题“描述C++中异常处理的正确用法”的最佳答案。
如何抛出一个标准库中的异常对象？

A.throw new std::exception("error");

B.throw std::exception("error");

C.throw "error";

D.throw std::runtime_error("error");

Standard Answer: D 注意：exception没有含参数的构造函数
在一个try-catch块中，try抛出异常，如果catch块没有匹配到任何异常，程序将会怎样？

A.程序正常继续执行

B.程序崩溃

C.抛出未捕获的异常

D.返回默认值

Standard Answer: C

解释：会输出
```
terminate called after throwing an instance of 'std::exception'
  what():  std::exception
```
在异常处理中，finally 块用于：

A.C++ 没有 finally 块

B.抛出异常

C.捕获异常

D.定义异常

Standard Answer: A

finally是Js里的
throw 关键字后面可以跟随：

A.任何类型的值

B.只有整数

C.只有字符串

D.只有自定义异常类型

Standard Answer: A

第十八周

在C++中，异常机制被用来解决哪种类型的程序错误？

A.语法错误

B.逻辑错误

C.运行时错误

Standard Answer: C
下列关于异常，叙述错误的是（）

A.编译错误属于异常，可以抛出

B.运行错误属于异常

C.硬件故障也可当异常抛出

D.只要是人认为的异常都可被抛出

Standard Answer: A

解释：
- A. 编译错误属于异常，可以抛出：这个叙述是错误的。编译错误是在编译时发生的错误，它们是由编译器检测到的，通常是因为代码不符合语言的语法规则、类型不匹配、缺少必要的定义等原因。编译错误必须在编译阶段被修正，程序才能成功编译成可执行文件。编译错误不能被抛出或捕获，因为它们在程序运行之前就必须被解决。
- B. 运行错误属于异常：这个叙述是正确的。运行时错误是程序执行过程中发生的错误，如除以零、访问无效的内存地址、文件不存在等。这些错误可以通过异常处理机制被抛出和捕获，以便程序可以优雅地处理错误情况。
- C. 硬件故障也可当异常抛出：在某种程度上，这个叙述可以被认为是正确的。虽然硬件故障本身不是通过C++标准异常机制直接抛出的，但是硬件故障（如磁盘读写错误、网络连接中断等）可以通过操作系统或硬件抽象层检测到，并最终通过软件异常或错误码的形式暴露给应用程序。应用程序可以捕获这些软件异常或检查错误码来响应硬件故障。
- D. 只要是人认为的异常都可被抛出：这个叙述是正确的，但需要一定的上下文理解。在C++中，几乎任何类型的对象都可以作为异常被抛出，这意味着程序员可以根据需要定义和抛出自定义的异常类型。因此，从这个角度来看，只要是开发者认为需要特殊处理的情况，都可以通过抛出异常来处理。
当程序遇到一个==没有== noexcept 修饰符的函数，会假设这个函数可能抛出异常，导致额外的代码执行，使用 noexcept 可以优化程序性能。该说法是否正确？

A.正确

B.错误

Standard Answer: A

注意是没有
【多选】下列关于异常传播的说法正确的是（）

A.当在try块内部发生异常时，程序会立即退出当前的try块，并开始搜索匹配的catch块来处理该异常。

B.如果在try块中没有找到匹配的catch块，异常会传播到调用栈的上一层，即调用该try块的函数或方法中

C.过程会继续进行，直到找到匹配的catch块或者异常传播到程序的顶层（通常是main函数外部），此时程序会调用std::terminate并终止执行。

Standard Answer: A, B, C
下列哪项最能描述C++中的异常？

A.一种错误的检测机制

B.一种错误的处理方法

C.一种处理程序中意外情况的方法

D.一种调试工具

Standard Answer: C
在以下代码中，哪一行是重新抛出异常的正确方法？ try { throw std::runtime_error("error"); } catch (std::runtime_error& e) { // 哪行是重新抛出异常？ }

A.throw e;

B.throw std::runtime_error(e);

C.throw;

D.rethrow;

Standard Answer: C
下列关于自定义异常的描述哪个是正确的？

A.自定义异常必须继承自 std::exception

B.自定义异常必须包含一个 what() 方法

C.自定义异常不能包含成员变量

D.自定义异常类可以不继承任何标准异常类

Standard Answer: D
在对象的构造函数中抛出异常时，以下哪项描述是正确的？

A.对象构造完成后抛出异常

B.对象不会被创建，析构函数不会被调用

C.对象会被部分创建，析构函数会被调用以清理已分配的资源

D.构造函数不能抛出异常

Standard Answer: B

文件读写

流
- 流是一种对连接的抽象
- 流入的量等于流出的量
缓存区
- 缓冲区的作用？
- 从命令行向程序输入数据时，实际上是输入到缓冲区里
- 一旦按Enter回车键，缓冲区里的数据才流入程序
- 在按回车键之前，我们可以修改缓冲区（即当前行）的数据
- 但一旦按回车键后，我们就不能修改当前行数据了
- 程序输出时，同样是输出到缓冲区里

C++的文件读写方法

ofstream: 写操作（输出）的文件类 (由ostream继承而来)
ifstream: 读操作（输入）的文件类(由istream继承而来)
fstream: 可同时读写操作的文件类 (由iostream继承而来)
用法和cin、cout完全一样！

  /*样例*/
  #include <fstream>
  #include <iostream>
  
  using namespace std;
  
  // 实现功能：将source.txt中的内容去掉空格后写入result.txt
  
  int main() {
      ifstream infile("source.txt");
      // jkadshf ah fa dfhas dfahsdf ashdf a sdf ads
      ofstream outfile("result.txt");
      while (!infile.eof()) {  // eof()函数用于判断是否到达文件末尾
          char tmp;
          infile >> tmp;  // 从文件中读取一个字符
          if (tmp != ' ') {
              outfile << tmp;  // 将读取的字符写入文件
          }
      }
      infile.close();
      outfile.close();
      // jkadshfahfadfhasdfahsdfashdfasdfsdfads
      return 0;
  }

ios::out 文件以输出(写)方式打开
ios::in 文件以输入(读)方式打开
ios::ate 初始位置：文件尾
ios::app 所有输出附加在文件末尾
ios::trunc 如果文件已存在则先删除该文件
ios::binary 二进制方式
可以用 | 来放入多个参数

随机过程

Sat, 30 Nov 2024 00:00:00 GMT

数学常识

概率论

条件概率

条件概率是指在已知某一事件发生的条件下，另一个事件发生的概率。形式化定义为：

$$ P(A | B) = \frac{P(A \cap B)}{P(B)}, \quad P(B) > 0 $$

全概率公式

全概率公式用于计算一个事件的概率，该事件可以通过多个互斥事件的并集来表示。形式化定义为：

$$ P(A) = \sum_{i} P(A | B_{i}) P(B_{i}) $$

其中，$B_i$ 是一组互斥且完备的事件。

贝叶斯公式

贝叶斯公式用于更新事件的概率，基于新的信息。形式化定义为：

$$ P(A | B) = \frac{P(B | A) P(A)}{P(B)}, \quad P(B) > 0 $$

概率分布和概率密度

离散随机变量

离散随机变量的概率分布函数（Probability Mass Function, PMF）定义为：

$$ P(X = x) = p_X(x) $$

连续随机变量

连续随机变量的概率密度函数（Probability Density Function, PDF）定义为：

$$ f_X(x) = \frac{d}{dx} P(X \leq x) $$

这个定义是需要熟悉的，有些时候往往会通过算一个极限来求出 PDF。

$$ f_X(x) = \lim_{\Delta x \to 0} \frac{P(x \leq X < x + \Delta x)}{\Delta x} $$

这在实际计算中经常用到。

累积分布函数

累积分布函数（Cumulative Distribution Function, CDF）定义为：

$$ F_X(x) = P(X \leq x) $$

联合分布

对于多个随机变量的联合分布，定义为：

$$ P(X_1 = x_1, X_2 = x_2, \ldots, X_n = x_n) = p_{X_1, X_2, \ldots, X_n}(x_1, x_2, \ldots, x_n) $$

对于连续随机变量的联合分布，定义为：

$$ P(X_1 \leq x_1, X_2 \leq x_2, \ldots, X_n \leq x_n) = F_{X_1, X_2, \ldots, X_n}(x_1, x_2, \ldots, x_n) $$

概率密度函数为：

$$ f_{X_1, X_2, \ldots, X_n}(x_1, x_2, \ldots, x_n) = \frac{\partial^n}{\partial x_1 \partial x_2 \cdots \partial x_n} F_{X_1, X_2, \ldots, X_n}(x_1, x_2, \ldots, x_n) $$

如果 $X_1, X_2, \ldots, X_n$ 是独立的，则有：

$$ P(X_1 = x_1, X_2 = x_2, \ldots, X_n = x_n) = P(X_1 = x_1) P(X_2 = x_2) \cdots P(X_n = x_n) $$

概率密度上也有

$$ f_{X_1, X_2, \ldots, X_n}(x_1, x_2, \ldots, x_n) = f_{X_1}(x_1) f_{X_2}(x_2) \cdots f_{X_n}(x_n) $$

当然联合分布也有

$$ F_{X_1, X_2, \ldots, X_n}(x_1, x_2, \ldots, x_n) = F_{X_1}(x_1) F_{X_2}(x_2) \cdots F_{X_n}(x_n) $$

随机变量函数的分布

对于随机变量 $X$ 和函数 $Y=g(X)$，其分布可以通过以下方式计算：

比如 $Z=X+Y$，我们用 $Z$ 和 $X$ 来表示 $Y$，则有： $$ Y = Z - X $$ 然后我们可以通过联合分布来计算：

$$ f_{X+Y}(x, y) = \int_{-\infty}^{+\infty} f(x, z-x) =\int_{-\infty}^{+\infty} f_X(x) f_Y(z - x) , dx $$

数字特征

期望

期望（Expectation）是随机变量的加权平均值，定义为：

对于离散随机变量： $$ \mathbb{E}[X] = \sum_{x} x P(X = x) $$

对于连续随机变量： $$ \mathbb{E}[X] = \int_{-\infty}^{+\infty} x f_X(x) , dx $$

对于高纬度随机变量，可以使用多重积分：

$$ \mathbb{E}[X] = \int_{-\infty}^{+\infty} \cdots\int_{-\infty}^{+\infty} x_1 x_2 \cdots f_X(x_1, x_2, \ldots) , dx_1 , dx_2 \cdots $$

性质

线性性质：对于常数 $a$ 和 $b$，有 $\mathbb{E}[aX + b] = a\mathbb{E}[X] + b$。（对任意随机变量 $X$ 和常数 $a, b$ 成立）
独立性：如果 $X$ 和 $Y$ 独立，则 $\mathbb{E}[XY] = \mathbb{E}[X]\mathbb{E}[Y]$。

全期望公式

对于随机变量 $X$ 和条件 $Y$，全期望公式为：

$$ \mathbb{E}[X] = \mathbb{E}[\mathbb{E}[X | Y]] $$

内层的 $\mathbb{E}[X | Y]$ 是在条件 $Y$ 下对 $X$ 的期望，而外层的 $\mathbb{E}$ 是对 $Y$ 的期望。相当于对 $Y$ 的所有可能值进行枚举，然后加权平均。

方差

方差（Variance）是随机变量与其期望之间的偏离程度，定义为：

$$ \mathrm{Var}(X) = \mathbb{E}[(X - \mathbb{E}[X])^2] = \mathbb{E}[X^2] - (\mathbb{E}[X])^2 $$

协方差

协方差（Covariance）是两个随机变量之间的线性关系，定义为：

$$ COV(X, Y) = \mathbb{E}[(X - \mathbb{E}[X])(Y - \mathbb{E}[Y])] = \mathbb{E}[XY] - \mathbb{E}[X]\mathbb{E}[Y] $$ 其实方差是协方差的特例，即 $COV(X, X) = \mathrm{Var}(X)$。

他们与期望有着密切的关系：

记忆：协方差=乘积的期望 - 期望的乘积

协方差矩阵

对于多维随机变量 $\mathbf{X} = (X_1, X_2, \ldots, X_n)$，协方差矩阵定义为：

$$ \Sigma = \begin{pmatrix} \mathrm{Var}(X_1) & COV(X_1, X_2) & \cdots & COV(X_1, X_n) \ COV(X_2, X_1) & \mathrm{Var}(X_2) & \cdots & COV(X_2, X_n) \ \vdots & \vdots & \ddots & \vdots \ COV(X_n, X_1) & COV(X_n, X_2) & \cdots & \mathrm{Var}(X_n) \end{pmatrix} $$

这在高维高斯过程中非常重要。

自相关函数

随机过程的自相关函数定义为 $$ R_X(t_1, t_2) = \mathbb{E}[X(t_1) X(t_2)] $$

协方差函数

随机过程的协方差函数定义为 $$ C_X(t_1, t_2) = \mathbb{E}[(X(t_1) - \mathbb{E}[X(t_1)])(X(t_2) - \mathbb{E}[X(t_2)])] $$

平稳性

宽平稳

定义：

$X (t)$ 对于任意的 $t_1, t_2$，都有 $$ \mathbb{E}[X(t_1)] = \mathbb{E}[X(t_2)] $$ 且 $$ R_X(t_1, t_2) = R_X(t_1 + \tau, t_2 + \tau) $$ 即自相关函数只与时间差 $\tau = t_2 - t_1$ 有关。即 $$ R_X(t_1, t_2) = R_X(\tau) = R_X(t_2 - t_1)) $$ 也就是说，要证明是宽平稳的，只需要证明自相关函数只与时间差 $\tau$ 有关。

严平稳

定义：

$X(t)$ 对于任意的 $t_1, t_2$，都有 $$ F_{X(t_1), X(t_2)}(x_1, x_2) = F_{X(t_1 + \tau), X(t_2 + \tau)}(x_1, x_2) $$ 即联合分布函数不随时间平移而改变。

母函数

定义：

令 $X$ 是取值为非负整数的随机变量，已知 $P(X = k) = p_k$ 是对应的概率，则称一个 $X$ 型如

$$ G_X(s) = \mathbb{E}[s^X] = \sum_{k=0}^{\infty} p_k s^k $$

的函数为概率母函数（Probability Generating Function）。

也有别名加生成函数和形式级数。

性质

已知随机变量 $X$ 的概率母函数为：

$$ G_X(s) = \mathbb{E}[s^X] = \sum_{k=0}^{\infty} p_k s^k $$

则有以下性质：

归一性

$$ G_X(1) = 1

期望公式

$$ \mathbb{E}[X] = G_X'(1)

方差公式

$$ \mathrm{Var}(X) = G_X''(1) + G_X'(1)\left(1 - G_X'(1)\right)

$$ 概率母函数的性质：计算两个离散随机变量和的分布

概率母函数除了描述单个随机变量的分布外，还有一个非常有用的性质 —— 可用于计算两个独立离散随机变量之和的分布。

定理：

设 $X_1$ 和 $X_2$ 是两个相互独立的、取非负整数值的随机变量，分别具有概率母函数：

$$ G_{X_1}(t) = \mathbb{E}[t^{X_1}], \quad G_{X_2}(t) = \mathbb{E}[t^{X_2}] $$

则它们之和 $X = X_1 + X_2$ 的概率母函数为：

$$ G_X(t) = G_{X_1 + X_2}(t) = G_{X_1}(t) \cdot G_{X_2}(t) $$

也就是说：独立随机变量的和的概率母函数，等于各自概率母函数的乘积。

特征函数

定义

特征函数（Characteristic Function）是随机变量分布的一个重要工具，定义为：

$$ \phi_X(\omega) = \mathbb{E}[e^{j\omega X}] = \int_{-\infty}^{\infty} e^{j\omega x} f_X(x) , dx $$ 其中，$j$ 是虚数单位，$\omega$ 是频率变量。

其实就是对随机变量 $X$ 的概率密度函数 $f_X(x)$ 进行傅里叶逆变换。

性质

特征函数与概率分布一一对应
若 $X_1, X_2 ... X_n$ 相互独立，则它们的特征函数满足 $$ \phi_{X_1 + X_2 + ... + X_n}(\omega) = \phi_{X_1}(\omega) \cdot \phi_{X_2}(\omega) \cdots \phi_{X_n}(\omega)

高数

Gamma 积分公式

📌 定义（欧拉积分形式）

对于复数 ( z )，实部大于 0：

$$ \Gamma(z) = \int_0^{\infty} t^{z-1} e^{-t} , dt \quad \text{Re}(z) > 0 $$

注意，很多时候去凑形式的时候，往往忘记了 $t^{z-1}$ 中的 $t$ 也要凑。

🎯 特殊值

当 $z = n \in \mathbb{N}^+$ 时：

$$ \Gamma(n) = (n - 1)! $$

例子：

$$ \Gamma(1) = 0! = 1, \quad \Gamma(2) = 1! = 1, \quad \Gamma(3) = 2! = 2 $$

特别地：

$$ \Gamma\left(\frac{1}{2}\right) = \sqrt{\pi} $$

🔁 变形与代换形式

代换 $t = x^2$，可以得到：

$$ \Gamma\left(\frac{1}{2}\right) = \int_0^{\infty} x^{-1/2} e^{-x} , dx = \sqrt{\pi} $$

🔗 与 Beta 函数关系

Beta 函数定义为：

$$ B(x, y) = \int_0^1 t^{x-1}(1 - t)^{y - 1} , dt $$

与 Gamma 函数的关系：

$$ B(x, y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x + y)} $$

📉 斯特林近似（当 ( z \to \infty ) 时）

$$ \Gamma(z) \approx \sqrt{2\pi} , z^{z - \frac{1}{2}} e^{-z} $$

高斯积分

高斯积分（Gaussian Integral）

1. 基本高斯积分

最基础的高斯积分形式为：

$$ \int_{-\infty}^{+\infty} e^{-x^2} , dx = \sqrt{\pi} $$

2. 带参数的高斯积分

对于带参数的高斯积分：

$$ \int_{-\infty}^{+\infty} e^{-a x^2} , dx = \sqrt{\frac{\pi}{a}}, \quad a > 0 $$

3. 奇函数高斯积分

对于奇函数乘以高斯函数的积分：

当 $k$ 为奇数时： $$ \int_{-\infty}^{+\infty} x^k e^{-x^2} , dx = 0 $$

4. 偶函数高斯积分

对于偶函数乘以高斯函数的积分： $$ \int_{-\infty}^{+\infty} x^{2n} e^{-x^2} , dx = \frac{(2n-1)!!}{2^n} \sqrt{\pi}, \quad n \in \mathbb{N} $$

平方展开式

对于任意 $a_1, a_2, \dots, a_n$，平方和的展开公式为：

$$ \left(\sum_{k=1}^n a_k\right)^2 = \sum_{k=1}^n a_k^2 + 2 \sum_{1 \leq k < l \leq n} a_k a_l. $$

线性代数

特征值和特征向量

设 $A$ 是一个 $n \times n$ 的矩阵，$\lambda$ 是一个标量，$v$ 是一个非零向量。如果满足以下方程：

$$ A v = \lambda v $$ 则称 $\lambda$ 是矩阵 $A$ 的特征值，$v$ 是对应的特征向量。

具体如何计算呢

特征值和特征向量的计算可以通过求解以下特征方程来完成：

$$ \text{det}(\lambda I - A) = 0 $$ 其中 $I$ 是单位矩阵，$\text{det}$ 表示行列式。特征值 $\lambda$ 的求解就是求解这个方程的根。

解关于 $\lambda$ 的多项式方程后，可以得到特征值 $\lambda_1, \lambda_2, \ldots, \lambda_n$。

对应的特征向量可以通过将特征值代入以下方程求解：

$$ (A - \lambda_i I)v = 0 $$ 这个方程一定是线性相关的，求到最后用某一个 $x$ 来表示其他的 $x$，然后就可以得到特征向量。

对角化

一个矩阵 $A$ 可以被对角化，如果存在一个可逆矩阵 $P$ 和一个对角矩阵 $D$，使得：

$$ A = P D P^{-1} $$ 其中 $D$ 的对角线元素是 $A$ 的特征值。

对角化的过程通常包括以下步骤：

计算特征值：求解特征方程 $\text{det}(\lambda I - A) = 0$。
计算特征向量：对于每个特征值 $\lambda_i$，求解方程 $(A - \lambda_i I)v = 0$。
构造矩阵 $P$ 和 $D$：将特征向量按列排列形成矩阵 $P$，将特征值按对角线排列形成对角矩阵 $D$。

对角化的好处在于可以简化矩阵的运算，特别是在计算矩阵的幂或指数时。

对称

一个矩阵 $A$ 是对称的，如果它等于它的转置，即：

$$ A = A^T $$ 对称矩阵具有以下性质：

实特征值：所有特征值都是实数。
正交特征向量：对应不同特征值的特征向量是正交的。
可对角化：对称矩阵总是可以被对角化，且可以通过正交矩阵对角化。

正交对角化

对于对称矩阵 $A$，一定可以找到一个正交矩阵 $Q$ 和一个对角矩阵 $D$，使得：

$$ A = Q D Q^T $$ 其中 $D$ 的对角线元素是 $A$ 的特征值，$Q$ 的列向量是 $A$ 的正交特征向量。

与一般的对角化不同，我们这里多一步，对特征向量做正交归一化

随机过程

定义

你现在知道 随机变量（random variable） 是啥了，它表示一个“值不确定”的量，比如投一次骰子，结果是个离散随机变量；温度计测一次温度，是个连续随机变量。

但这些都是一次性的不确定。

随机过程（stochastic process） = 多次 + 时变 + 不确定

换句话说，随机过程就是一组随时间变化的随机变量序列。你把时间引入随机变量，就是随机过程。

离散时间马尔科夫链

定义

设有可数样本空间的 $\mathcal{S}$，如果随机过程 ${X_n}_{n=0}^{\infty}$ 满足：

$$ P(X_{n+1} = i_{n+1} | X_n = i_n, X_{n-1} = i_{n-1}, \ldots, X_0 = i_0) = P(X_{n+1} = i_{n+1} | X_n = i_n) $$

对任意的 $n \geq 0$，则称 ${X_n}_{n=0}^{\infty}$ 是一个离散时间马尔科夫链（DTMC）。

定义告诉我们，马尔科夫链的未来状态只与当前状态有关，而与过去的状态无关。这种性质称为无后效性（Markov property）。

状态转移概率

对于马尔科夫链 $X_n$ 的 $n$ 步转移概率定义为：

$$ P(X_{k+n} = j | X_k = i) = P_{ij}^{(n)} $$

得到一个矩阵 $P^{(n)}$

在我们的课程中，认为转移概率不依赖于 $k$ ，因此是齐次的

特别地当 $n=1$ 时，称为一步转移概率：

$$ P_{ij} = P(X_{k+1} = j | X_k = i) $$

C-K 方程

C-K 方程（Chapman-Kolmogorov 方程）是描述马尔科夫链状态转移的基本方程。它表明从状态 $i$ 到状态 $j$ 的 $n$ 步转移概率可以通过中间状态的转移概率来计算： $$ P_{ij}^{(n + m)} = \sum_{k} P_{ik}^{(n)} P_{kj}^{(m)} $$ 矩阵形式为 $$ P^{(n + m)} = P^{(n)} P^{(m)} $$ 这意味着，$n$ 步转移矩阵可以通过一步转移矩阵的乘积来计算。

$$ P^{(n)} = P^n $$ 有括号表示 $n$ 步转移概率矩阵，没有括号表示 $n$ 次矩阵乘积。

这里通常会用到矩阵的幂运算，即将转移矩阵 $P$ 自身乘以 $n$ 次。为了简化计算，我们可以使用矩阵的特征分解或对角化方法。

表示方法

转移矩阵法

对于马尔科夫链 ${X_n}_{n=0}^{\infty}$，可以用转移矩阵 $P$ 来表示状态转移概率：

$$ P = \begin{pmatrix} p_{00} & p_{01} & \cdots & p_{0n} \ p_{10} & p_{11} & \cdots & p_{1n} \ \vdots & \vdots & \ddots & \vdots \ p_{n0} & p_{n1} & \cdots & p_{nn} \end{pmatrix} $$ 其中 $P_{ij}$ 表示从状态 $i$ 到状态 $j$ 的一步转移概率。

状态转移图

状态转移图是马尔科夫链的图形表示方法，其中每个状态用节点表示，转移概率用有向边表示。边上的权重表示从一个状态到另一个状态的转移概率。

递推函数

$$ X_{n+1} = f(X_n, Z_{n+1}) $$ 其中 $Z_k$ 是一个随机变量序列，只需要满足下列条件之一：

$Z_k$ 独立同分布，且与 $X_0$ 独立
$Z_k$ 同分布，且给定 $X_n$ 的条件下，$Z_k$ 独立于 $X_0$

这是我们==最常用到的证明方法==，特别是当状态空间有限时。

状态分类

可达性

状态 $j$ 从状态 $i$ 可达，当且仅当存在一个正整数 $n$，使得 $P_{ij}^{(n)} > 0$。这意味着从状态 $i$ 可以通过若干步转移到达状态 $j$。

传递性

状态 $i$ 是传递的，若 $i \rightarrow j, j\rightarrow k$，则 $i \rightarrow k$。即如果从状态 $i$ 可以到达状态 $j$，并且从状态 $j$ 可以到达状态 $k$，则从状态 $i$ 也可以到达状态 $k$。

相通性

状态 $i$ 和状态 $j$ 是相通的，当且仅当 $i \rightarrow j$ 且 $j \rightarrow i$。这意味着从状态 $i$ 可以到达状态 $j$，并且从状态 $j$ 也可以到达状态 $i$。

相同是一种等价关系！因此，==等价类具有相同的类性质==。这是很有用的，意味着当我们==确定了一个状态的性质后，可以直接推广到整个等价类==。

闭集

状态集合 $C$ 是闭集，当且仅当对于任意的状态 $i \in C$ 和 $j \notin C$，都有 $P_{ij} = 0$。这意味着从闭集中的状态无法转移到闭集外的状态，是一种"进得去，出不来"的吸收态。

不可约性

如果闭集 $C$ 没有闭的真子集，则称 $C$ 是不可约的。（$C$ 中任意两状态都相通）

一个马尔科夫链是 不可约的，如果从任意状态 i 出发，经过有限步转移后能以 正概率 到达任意其他状态 j 如果链是 可约的（Reducible），则存在某些状态子集，一旦进入就无法离开

可以想象成韦恩图

周期性

状态 $i$ 的周期 $d_i$ 定义为： $$ d_i = \gcd{n : P_{ii}^{(n)} > 0} $$ 讲人话，即状态 $i$ 回到自身的步数的最大公约数。如果 $d_i = 1$，则称状态 $i$ 是非周期的（aperiodic）；如果 $d_i > 1$，则称状态 $i$ 是周期的（periodic）。

判断周期性，画图即可

如果两个状态 $i$ 和 $j$ 相通，则它们的周期相同，即 $d_i = d_j$。

其实先前提到过，如果两个状态是相通的，那么他们属于同一个类，共享类性质，周期当然相同。

长时间特性

人们往往关注马尔科夫链长时间后的统计特性，比如哪些状态会被频繁访问，哪些状态会被忽略。为了描述这种长期行为，我们引入了常返性（recurrence）和瞬时性（transience）的概念。

首达概率

状态 $j$ 从状态 $i$ 经过 $n$ 步的首达概率定义为： $$ f_{ij}^{(n)} = P(X_n = j, X_{n-1} \neq j, \ldots, X_1 \neq j | X_0 = i) $$ 通常这个概率可以通过状态转移图，然后一个个去计算。然后得到规律，即得到 $n$ 的一般表达式。

常返性与瞬时性

如果 $$ f_{ii}=\sum_{n=1}^{\infty} f_{ij}^{(n)} = 1 $$ 那么状态 $i$ 是常返的（recurrent），否则是瞬时的（transient）。

另外的判断定理

$$ \sum_{n=0}^{+\infty} p_{ii}^{(n)}=\frac{1}{1-f_{ii}} $$

如果 $$ \sum_{n=1}^{\infty} p_{ii}^{(n)} = \infty $$ 则状态 $i$ 是常返的；如果 $$ \sum_{n=1}^{\infty} p_{ii}^{(n)} < \infty $$ 则状态 $i$ 是瞬时的。

直观理解

常返状态：像一个“黑洞”，一旦进入，就会无限次返回（如随机游走在一维整数格点上的原点）。
非常返状态：像一个“临时站点”，最终可能会被抛弃（如随机游走在三维空间中的点，几乎不会返回原点）。

首达时间

对于常返状态，我们可以定义他的首达时间。

常返态 $i$ 的首达时间定义为：

$$ T_i = \min{n \geq 1 : X_n = i | X_0 = i} $$ 根据首达时间，可以定义平均首达时间：

$$ \mu_i = E[T_i] = \sum_{n=1}^{\infty} n f_{ii}^{(n)} $$ 如果 $\mu_i < \infty$，则称状态 $i$ 是正常返的（positive recurrent），否则是零返的（null recurrent）。

如何理解呢？

正常返状态：平均返回时间是有限的，意味着状态会被频繁访问 (会回来，而且回来得比较勤快)

典型例子：有限状态不可约马尔科夫链的所有状态（如天气预报模型中的“晴天”“雨天”）

零返状态：平均返回时间是无限的，意味着状态会被稀疏访问 (会回来，但可能要等很久很久)

典型例子：一维对称随机游走（醉汉左右晃悠，最终会回家，但平均等待时间无限）

推论：常返性对转移概率极限的影响

对于瞬时态和零常返态，有

$$ \lim_{n \to \infty} p_{ii}^{(n)} = 0 $$ 对于非周期正返态，有 $$ \lim_{n \to \infty} p_{ii}^{(n)} = \frac{f_{ii}}{\mu_i} $$ 其中 $\mu_i$ 是状态 $i$ 的平均返回时间。

常返态存在定理

对于有限状态马尔科夫链，一定存在正常返态。
对于不可约的马尔科夫链，所有状态都是正常返的。

这个定理告诉我们，各状态的常返性可以一眼看出！只需要判断是否有限状态或不可约即可。对找到的不可约状态，直接认为是正常返的。别 tm 再去死算计算首达概率了！

极限行为与平稳分布

这里考虑的问题是，当马尔科夫链运行足够长时间后，状态分布是否会趋向于某个稳定的分布，极限是否存在，如果存在，如何求解。

极限分布

如果存在一个概率分布 $\pi$，使得对于任意状态 $i$，都有： $$ \lim_{n \to \infty} P(X_n = i) = p_i $$ 则称 $\pi$ 是马尔科夫链的极限分布（stationary distribution）。

又 $$ P(X_n=j)) = \sum_{i} p_{ij}^{(n)} P(X_0=i) $$ 可以知道：

极限分布依赖于初始分布 $P(X_0=i)$ 和转移概率 $p_{ij}^{(n)}$。

由[[

##推论：常返性对转移概率极限的影响]]可知，当是非常返态或者零常返态的，极限分布概率为 0，所以马尔科夫链最终形态由正常返态决定。

可约->有正常返的->极限随初值周期->极限可能不存在

平稳分布

如果存在一个概率分布 $\pi=(p_1, p_2, \ldots, p_n)$，满足平衡方程 $$ \pi = \pi P $$ 则称 $\pi$ 是马尔科夫链的平稳分布（stationary distribution）。

平稳分布是马尔科夫链长期行为的一个重要特征，它描述了在长时间运行后，状态分布的稳定性。

通常列出平衡方程之后，还需要加上 $\sum \pi_i=1$ 来确保 $\pi$ 是一个概率分布。

注意：

有时候极限尽管不存在，但仍然可以找到平稳分布。
平稳分布和极限存在没有必然联系
平稳分布不一定是唯一的，可能存在多个平稳分布。

平稳分布存在定理

存在的充要条件是链中存在正常返态

存在且唯一的充要条件是链中存在唯一的不可约正常返子集

泊松过程

定义

随机过程 $N(t)$ 表示时间段 $[0, t]$ 内发生事件数目的总和，则称其为计数过程。

把满足下面的条件的计数过程称为标准泊松过程：

$N(0) = 0$，即在时间 $0$ 时刻没有发生事件。
平稳增量性，对于任意的 $0 \leq s < t$，事件发生的次数 $N(t) - N(s)$ 只与时间间隔 $t - s$ 有关
独立增量性，对于任意的 $0 \leq s < t$，事件发生的次数 $N(t) - N(s)$ 与 $N(s)$ 独立。
微元时间内发生多于一个事件的概率是刚好发生一次的概率的无穷小量。

对于某类题，要你证明是泊松过程，严格按照定义，证明每一个条件

概率分布

$$ P(N(t)=k) = \frac{(\lambda t)^k e^{-\lambda t}}{k!}, \quad k = 0, 1, 2, \dots $$

$\lambda$ 的含义

$\lambda$ 是单位时间内事件发生的平均次数，称为到达率（arrival rate）。它描述了事件发生的频率。 $$ \lambda = \lim_{t \to 0} \frac{N(t)}{t} $$

期望和方差

其期望和方差分别为： $$ E[N(t)] = Var[N(t)] = \lambda t $$

母函数

泊松过程的母函数（生成函数）为： $$ M(t) = E[e^{tN(t)}] = e^{\lambda t(e^t - 1)} $$

性质

联合分布

为了求解泊松过程的联合分布，我们可以利用泊松过程的平稳增量性和独立增量性

设 $N(t)$ 是强度为 $\lambda$ 的泊松过程，则对于任意的 $0 \leq t_1 < t_2 < \cdots < t_n$，$0 \leq k_1, k_2, \ldots, k_n$，有： $$ P(N(t_1) = k_1, N(t_2) = k_2, \ldots, N(t_n) = k_n) = \prod_{i=1}^n P(N(t_i) - N(t_{i-1}) = k_i - k_{i-1}) $$

条件分布

设 $N(t)$ 是强度为 $\lambda$ 的泊松过程，$0 \leq s < t$，则有： $$ P(N(t) = m | N(s) = k) = \frac{\lambda^{m-k} (t-s)^{m-k} e^{-\lambda(t-s)}}{(m-k)!} $$ 这说明在已知 $N(s) = m$ 的条件下，$N(t) - N(s)$ 仍然服从泊松分布，实际上就是 $N(t-s)$

到达时刻

概率密度

对于强度为 $\lambda$ 的泊松过程，设 $S_n$ 是第 $n$ 次到达的时刻服从于 Gamma 分布，概率密度为： $$ f_{S_n}(t) = \lambda e^{-\lambda t} \frac{(\lambda t)^{n-1}}{(n-1)!}, \quad t \geq 0 $$ 证明：用微元法，第 $n$ 次到达时刻 $S_n$ 可以看作是前 $n-1$ 次到达时刻 $S_{n-1}$ 加上一个独立的指数分布随机变量 $X_n$，即：

$$ f_{S_n}=\lim_{\Delta t \to 0} \frac{P(t \le S_n \le t + \Delta t)}{\Delta t}= \lim_{\Delta t \to 0}\frac{P(N(t)=n - 1)P(N(t+\Delta t) - N(t) = 1)}{\Delta t} = e^{-\lambda t} \frac{(\lambda t)^{n-1}}{(n-1)!}\lambda $$

联合密度

任意 $n$ 次事件的到达时刻的联合概率密度为 $$ f_{S_1 \ldots S_n}(t_1, t_2, \ldots, t_n) = \lambda^ne^{-\lambda t_n} $$ 证明思路同上面微元法，这里不给了

条件密度

已知 $[0, t]$ 内发生了 $n$ 次事件，设 $S_1, S_2, \ldots, S_n$ 是这些事件的到达时刻，则它们的条件密度为 $$ f_{S_1, S_2, \ldots, S_n | N(t) = n}(t_1, t_2, \ldots, t_n) = \frac{n!}{t^n}, \quad 0 \leq t_1 < t_2 < \cdots < t_n \leq t $$

事件间隔

对于强度为 $\lambda$ 的泊松过程，事件间隔 $S_n$ 服从指数分布，概率密度为： $$ f_{S_n}(t) = \lambda e^{-\lambda t}, \quad t \geq 0 $$ 指数分布具有无记忆性。这意味着泊松过程的事件间隔（注意不是到达时刻）是独立的，并且每个间隔的分布不受前一个间隔的影响。从任意一个时间点开始重新观察，得到的新过程在概率意义上与原过程相同。

可加性

两个泊松过程 $N_1(t)$ 和 $N_2(t)$ 的事件间隔之和仍然服从泊松分布，且参数为 $\lambda_1 + \lambda_2$。即： $$ P(N_1(t) + N_2(t) = k) = \frac{(\lambda_1 t + \lambda_2 t)^k e^{-(\lambda_1 + \lambda_2)t}}{k!}, \quad k = 0, 1, 2, \ldots $$ 但是！做差不成立！

顺序统计量

注意，以下定义是独立于泊松过程的概率论的知识

定义

设 $X_1, X_2, \ldots, X_n$ 是从同一分布中独立抽取的随机变量，则它们的顺序统计量定义为：

第 $i$ 个顺序统计量 $X_{(i)}$ 是这 $n$ 个随机变量中第 $i$ 小的值。记作 $X_{(i)}$

概率密度

对于第 $k$ 个顺序统计量 $X_{(k)}$，其期望为： $$ E[X_{(k)}] = \frac{k}{n+1} $$

联合分布

对于 $n$ 个独立同分布的随机变量 $X_1, X_2, \ldots, X_n$，它们的顺序统计量 $X_{(1)}, X_{(2)}, \ldots, X_{(n)}$ 的联合分布为：

$$ f_{X_{(1)}, X_{(2)}, \ldots, X_{(n)}}(x_1, x_2, \ldots, x_n) = n! f_X(x_1) f_X(x_2) \cdots f_X(x_n)
$$ 其中 $f_X(x)$ 是单个随机变量的概率密度函数。

$n!$ 是因为每个顺序统计量的排列方式有 $n!$ 种可能。

与泊松过程的关系

对于泊松过程的事件到达时刻 $S_1, S_2, \ldots, S_n$，它们与 $n$ 个独立的 $(0,t)$ 上的均匀分布随机变量 $U_1, U_2, \ldots, U_n$ 的顺序统计量有相同的分布。 $$ (S_1, S_2, \ldots, S_n) \overset{d}{=} (U_{(1)}, U_{(2)}, \ldots, U_{(n)}) $$ 因此有

推论

如果 $S_1, S_2, \ldots, S_n$ 是泊松过程的事件到达时刻，对任意函数 $g(x)$

$$ E[\sum_{k=1}^n g(S_k)|N(t)=n] = nEg(U) $$ 其中 $U$ 是均匀分布在 $(0,t)$ 上的随机变量。

这一推论是很有用的，用一道例题来说明：

等待时间总和

设乘客按照参数为 $\lambda$ 的泊松过程到达机场，飞机起飞时间为 $t$。求在飞机起飞前到达的乘客的等待时间总和的期望。

解

设在飞机起飞前到达的乘客数为 $N(t)$，则他们的到达时刻为 $S_1, S_2, \ldots, S_{N(t)}$。每个乘客的等待时间为 $t - S_i$，因此到达乘客的等待时间总和为：

$$ \sum_{i=1}^{N(t)} (t - S_i) $$

注意这里 $N(t)$ 是随机变量，我们需要将他固定下来，因此要使用条件期望： $$ E(\sum_{i=1}^{N(t)} (t - S_i))= E_{N(t)}(E(\sum_{i=1}^{N(t)} (t - S_i)|N(t))) $$ 利用[[

##推论]]，有 $$ E(\sum_{i=1}^{N(t)} (t - S_i)|N(t)=n) = n E_U(t - U)= n(t - \frac{t}{2}) = \frac{nt}{2} $$

因此带回有 $$ E(\sum_{i=1}^{N(t)} (t - S_i)) = E_{N(t)}(\frac{N(t)t}{2}) = \frac{t}{2} E(N(t)) = \frac{t}{2} \lambda \lambda t = \frac{\lambda t^2}{2} $$

泊松过程的拓广

泊松过程的托管本质上就是在放松它的各种限制条件

非齐次泊松过程

定义

非齐次泊松过程是指到达率 $\lambda(t)$ 随时间变化的泊松过程。其定义与齐次泊松过程类似，但增量的分布依赖于时间。

$$ \lambda(t) = \lim_{\Delta t \to 0} \frac{N(t + \Delta t) - N(t)}{\Delta t} $$

需要格外注意的是，这里的 $\lambda(t)$ 是一个确定性的函数，而不是随机变量。这一点将与后面的条件泊松过程区分开来。

概率分布

对于非齐次泊松过程，事件在时间 $[0, t]$ 内发生的次数 $N(t)$ 的概率分布为：

$$ P(N(t) = k) = \frac{[\int_0^t \lambda(s) ds]^k }{k!}e^{-\int_0^t \lambda(s) ds}, \quad k = 0, 1, 2, \ldots $$

可以看到，只是原来的 $\lambda t$ 换成了 $\int_0^t \lambda (s) ds$，即在时间 $[0, t]$ 内的总到达率。若 $\lambda(t)$ 是常数 $\lambda$，则退化为齐次泊松过程。

例如，在 $[t_1, t_2]$ 上出现 $k$ 个事件的概率为：

$$ P(N(t_2)-N(t_1)=k)=\frac{[\int_{t_1}^{t_2} \lambda(s) ds]^k }{k!}e^{-\int_{t_1}^{t_2} \lambda(s) ds} $$

期望和方差都为

$$ \int_{t_1}^{t_2}\lambda(t)dt $$

其实

只需要把标准泊松过程的 $\lambda t$ 换成 $\int_0^t \lambda(s) ds$ 即可。剩余的一样，仅仅失去平稳增量性。

复合泊松过程

定义

复合泊松过程是指在泊松过程的基础上，放宽了每次到达事件的数量限制。即在每个时间间隔内，可能发生多个事件，每个事件的数量服从某种分布。

所以复合的意思就是，标准泊松，每次事件数不是 1，而是另一个分布

设 $N(t)$ 是泊松过程，$Y_i$ 是每次到达事件的数量，则复合泊松过程 $Y{(t)}$ 定义为：

$$ Y(t) = \sum_{i=1}^{N(t)} Y_i $$

特征函数定理

$$ \phi_Y(t) = exp\left(\lambda t [\phi_{Y_1}(u) - 1] \right) $$ 这意味着，复合泊松过程的分布由泊松过程的参数 $\lambda$ 和每次到达事件数量的分布决定。

条件泊松（随机参数泊松）

放宽独立增量性，允许到达率 $\lambda(t)$ 是一个随机变量，这样的泊松过程称为条件泊松过程（或随机参数泊松过程）。

定义

条件泊松过程是指在给定某些条件下，泊松过程的到达率 $\lambda(t)$ 是一个随机变量。即在某些条件下，泊松过程的到达率是随机的。

概率分布

条件泊松过程的参数 $\Lambda$ 为连续随机变量时（概率密度函数为 $f_\Lambda(\lambda)$），则条件泊松过程的概率分布为：
$$ P(N(t) = k)=\int_0^\infty P(N(t) = k | \Lambda = \lambda) f_\Lambda(\lambda) d\lambda =\int_0^\infty \frac{[\lambda t]^k e^{-\lambda t}}{k!} f_\Lambda(\lambda) d\lambda
$$ 这其实就是个全概率公式，利用了条件泊松过程的定义。

更新过程

定义

与标准泊松对比，更新过程的事件间隔是独立同分布的随机变量。

概率分布

设更新过程的事件间隔的分布为 $F_T(t)$，概率密度为 $f_T(t)$，$S_n=\sum_{i=1}^n T_i$ 是第 $n$ 次事件发生的时间，则更新过程的概率分布为： $$ P(N(t) = n) = F_{S_n}(t)-F_{S_{n+1}}(t) $$ 其中 $F_{S_n}(t)$ 是第 $n$ 次事件发生的时间的分布函数。

这里 $F_{S_n}(t)$ 可以通过卷积得到，设 $F_{k}(t) = F_{S_k}(t)$，则有

$$ F_n(t) = \int_0^t f_T(s) \cdot F_{n-1}(t-s) , ds $$

也就是 $f_T(s)$ 的 $n$ 重卷积。

为了理解这个公式，我们需要==将次数转化到时间轴==上，$t$ 时刻发生了 $n$ 个事件，那么等价于 $S_n$ 这个事件发生在 $t$ 时刻前，而 $S_{n+1}$ 这个事件发生在 $t$ 时刻后，因此 $F_{S_n}(t)-F_{S_{n+1}}(t)$ 就是在 $t$ 时刻发生了 $n$ 个事件的概率。

$n$ 重卷积难做？那就用拉普拉斯变换转为频域上的乘法运算吧

$$ \mathcal{L}{F_{S_n}(t)} = \mathcal{L}{f_T(t)}^n $$

连续时间马尔科夫链

定义

设可数状态空间的连续时间随机过程 $X(t)$, 对所有$k\in \mathbb{N}$, $s, s_1, \ldots, s_k, s$ 且 $s \ge s_k \ge \ldots \ge s_1 \ge 0$ , 有 $$ P(X(t+s) = j | X(t) = i, X(t+s_1) = i_1, \ldots, X(t+s_k) = i_k) = P(X(t+s) = j | X(t) = i) $$ 则称 $X(t)$ 为连续时间马尔科夫链。

我们所讨论的马尔科夫链都为齐次的，满足 $$ P(X(t+s) = j | X(s) = i) = P(X(t) = j | X(0) = i) $$

与离散时间马尔科夫链的区别

区别

离马的状态转移发生在离散的时间点上，而连马的状态转移可以发生在任意时刻。
离马的转移概率矩阵是一个固定的矩阵，而连马的转移概率矩阵是一个函数，依赖于时间。

状态转移概率

状态转移概率矩阵 $P(t)$ 定义为： $$ P_{ij}(t) = P(X(t) = j | X(0) = i) $$

矩阵形式为： $$ P(t) = \begin{pmatrix} P_{00}(t) & P_{01}(t) & P_{02}(t) & \cdots \ P_{10}(t) & P_{11}(t) & P_{12}(t) & \cdots \ P_{20}(t) & P_{21}(t) & P_{22}(t) & \cdots \ \vdots & \vdots & \vdots & \ddots \end{pmatrix} $$ 一定满足行和为一： $$ \sum_{j} P_{ij}(t) = 1, \quad \forall i $$

和离散的一样，也满足C-K方程： $$ P(t+s) = P(t)P(s) $$

Q矩阵

标准连续时间马尔科夫链

标准连续时间马尔科夫链的转移概率矩阵 $P(t)$ 满足 $$\lim_{t \to 0} P(t) = I $$ 其中 $I$ 是单位矩阵。

这意味着当时间趋近于零时，转移概率矩阵趋近于单位矩阵，即在极短的时间内，状态不会发生变化。

Q矩阵

如果满足标准条件，那么可以定义极限 $$ Q = \lim_{t \to 0} \frac{P(t) - I}{t} $$ 其中 $Q$ 称为转移率矩阵或速率矩阵。 $Q$ 的元素 $q_{ij}$ 表示从状态 $i$ 到状态 $j$ 的瞬时转移率，即在极短时间内从状态 $i$ 转移到状态 $j$ 的速率。

补充

后面我们经常会计算$q_{ij}$。需要注意：

如果 $i = j$，则 $q_{ii} = \lim_{t \to 0} \frac{P_{ii}(t) - 1}{t}$
如果 $i \neq j$，则 $q_{ij} = \lim_{t \to 0} \frac{P_{ij}(t)}{t}$

保守性

对于标准有限状态连续时间马尔科夫链，$Q$ 矩阵的每一行的和为零，即 $$ \sum_{j} q_{ij} = 0, \quad \forall i $$ 这表示在任意时刻，系统必须处于某个状态。

停留时间定理

设连续时间马尔科夫链满足标准性和保守性条件，$\tau = \inf{t \ge 0: X(t) \neq X(0)}$ 表示从状态 $X(0)$ 开始到达其他状态的时间。则有

$\tau$ 的分布是参数为 $q_{ii}$ 的指数分布, 即 $P(\tau > t) = e^{-q_{ii} t}$。
条件分布 $P(X(\tau) = j | X(0) = i)$ = $\frac{q_{ij}}{q_{ii}}$，即在状态 $i$ 停留时间结束后，转移到状态 $j$ 的概率与速率矩阵的元素有关。
$\tau$ 与 $X(t)$ 在给定 $X(0)$ 的条件下是独立的。

嵌入链

从连马中只抽出跳转了和跳去哪了的信息，形成一个离散时间马尔科夫链，称为嵌入链它的转移概率为 $$ p_{ij} = \begin{cases} \frac{q_{ij}}{-q_{ii}}, & i \neq j \ 0, & i = j \end{cases} $$

Kolmogorov方程

Kolmogorov方程描述了连续时间马尔科夫链的状态转移概率矩阵 $P(t)$ 的演化。它有两种形式：前向和后向。

前向Kolmogorov方程

$$ \frac{dP(t)}{dt} = P(t)Q $$

后向Kolmogorov方程

$$ \frac{dP(t)}{dt} = QP(t) $$

转移概率的收敛级数形式

如果 $Q$ 是一个有限矩阵，则可以将转移概率矩阵 $P(t)$ 表示为 $$ P(t) = I + tQ + \frac{t^2}{2!}Q^2 + \frac{t^3}{3!}Q^3 + \cdots $$ 这个级数形式可以用于计算转移概率矩阵，尤其在 $t$ 较小的情况下。

极限行为

平稳分布

平稳分布是指当时间趋近于无穷大时，马尔科夫链的状态分布趋于一个固定的分布。设 $\pi$ 是平稳分布，则满足 $$ \pi = \pi P(t) $$ 这表示在平稳分布下，状态的分布不随时间变化。

同样也可以用速率矩阵 $Q$ 来描述平稳分布：

$$ \pi Q = 0 $$ 这表示在平稳分布下，状态的转移率矩阵 $Q$ 的每一行和为零。

定理

对于不可约的连续时间马尔科夫链

如果$\pi Q = 0$有解，则存在唯一的平稳分布 $\pi$，且满足 $$ \lim_{t \to \infty} P_{ij}(t) = \pi_j
$$

如果无解，则不存在平稳分布。 $$ \lim_{t \to \infty} P_{ij}(t) = 0 $$

应用

纯生过程

纯生过程是一种特殊的连续时间马尔科夫链，其中状态空间为非负整数，且状态只能增加或保持不变。其在$[t, \Delta t]$内的转移概率为 $$ P_{ij}(\Delta t) = \begin{cases} \lambda_i \Delta t + o(\Delta t), & j = i+1 \ o(\Delta t), & j = i \ 0, & \text{others} \end{cases} $$

根据定义可以算出$Q$矩阵为 $$ Q_{ij} = \begin{cases} \lambda_i, & j = i+1 \ -\lambda_i, & j = i \ 0, & \text{otherwise} \end{cases} $$

$$ Q = \begin{pmatrix} -\lambda_0 & \lambda_0 & 0 & 0 & \cdots \ 0 & -\lambda_1 & \lambda_1 & 0 & \cdots \ 0 & 0 & -\lambda_2 & \lambda_2 & \cdots \ \vdots & \vdots & \vdots & \ddots & \ddots
\end{pmatrix} $$

可验证 $$ \pi Q = 0 $$

只有平凡解，即 $\pi = 0$。因此纯生过程没有平稳分布。

生灭过程

生灭过程是一种连续时间马尔科夫链，其状态空间为非负整数 ${0, 1, 2, \ldots}$，且从状态 $i$ 只能转移到相邻状态 $i-1$（死亡）或 $i+1$（出生）。

设生灭过程的出生率为 $\lambda_i$（从状态 $i$ 到状态 $i+1$ 的速率），死亡率为 $\mu_i$（从状态 $i$ 到状态 $i-1$ 的速率）。

其在 $[t, t+\Delta t]$ 内的转移概率为： $$ P_{ij}(\Delta t) = \begin{cases} \lambda_i \Delta t + o(\Delta t), & j = i+1 \ \mu_i \Delta t + o(\Delta t), & j = i-1 \ 1 - (\lambda_i + \mu_i) \Delta t + o(\Delta t), & j = i \ o(\Delta t), & \text{others} \end{cases} $$

其中 $\mu_0 = 0$（状态 0 不能再减少）。

根据定义，$Q$ 矩阵为： $$ Q_{ij} = \begin{cases} \lambda_i, & j = i+1 \ \mu_i, & j = i-1 \ -(\lambda_i + \mu_i), & j = i \ 0, & \text{others} \end{cases} $$

矩阵形式为： $$ Q = \begin{pmatrix} -\lambda_0 & \lambda_0 & 0 & 0 & \cdots \ \mu_1 & -(\lambda_1 + \mu_1) & \lambda_1 & 0 & \cdots \ 0 & \mu_2 & -(\lambda_2 + \mu_2) & \lambda_2 & \cdots \ \vdots & \vdots & \vdots & \ddots & \ddots \end{pmatrix} $$

平稳分布

设平稳分布为 $\pi = (\pi_0, \pi_1, \pi_2, \ldots)$，则需满足 $\pi Q = 0$，即：

对于 $i = 0$：$-\lambda_0 \pi_0 + \mu_1 \pi_1 = 0$

对于 $i \geq 1$：$\lambda_{i-1} \pi_{i-1} - (\lambda_i + \mu_i) \pi_i + \mu_{i+1} \pi_{i+1} = 0$

这可以简化为细致平衡条件： $$ \lambda_i \pi_i = \mu_{i+1} \pi_{i+1}, \quad i \geq 0 $$

递推可得： $$ \pi_n = \pi_0 \prod_{k=0}^{n-1} \frac{\lambda_k}{\mu_{k+1}}, \quad n \geq 1 $$

由归一化条件 $\sum_{n=0}^{\infty} \pi_n = 1$，得到： $$ \pi_0 = \frac{1}{1 + \sum_{n=1}^{\infty} \prod_{k=0}^{n-1} \frac{\lambda_k}{\mu_{k+1}}} $$

当且仅当级数 $\sum_{n=1}^{\infty} \prod_{k=0}^{n-1} \frac{\lambda_k}{\mu_{k+1}}$ 收敛时，存在平稳分布。

高斯过程

定义

设随机过程$X(t)$，如果$\forall n, \forall t_1, t_2, \ldots, t_n \in [0, T]$，都有 $$ (X(t_1), X(t_2), \ldots, X(t_n)) $$ 服从$n$元高斯分布，则称$X(t)$为高斯过程。

单元高斯分布

设随机变量 $X$ 服从单元高斯分布，记作 $$ X \sim \mathcal{N}(\mu, \sigma) $$ 其中 $\mu$ 是均值，$\sigma$ 是标准差。则其概率密度函数为： $$ f_X(x) = \frac{1}{\sqrt{2\pi}\sigma} \exp\left(-\frac{(x - \mu)^2}{2\sigma^2}\right) $$

多元高斯分布

设随机变量$X = (X_1, X_2, \ldots, X_n)$服从多元高斯分布，记作 $$ X \sim \mathcal{N}(\mu, \Sigma) $$ 其中 $\mu$ 是均值向量，$\Sigma$ 是协方差矩阵。则其概率密度函数为： $$ f_X(x) = \frac{1}{(2\pi)^{n/2}|\Sigma|^{1/2}} \exp\left(-\frac{1}{2}(x - \mu)^T \Sigma^{-1} (x - \mu)\right) $$

特征函数

多元高斯过程的特征函数为： $$ \phi_X(\omega) = \exp\left(j \omega^T \mu - \frac{1}{2} \omega^T \Sigma \omega\right) $$ 当结论记下来就好

性质

线性性

设 $X \sim \mathcal{N}(\mu, \Sigma)$，$A$ 是常数矩阵，则 $AX + b \sim \mathcal{N}(A\mu + b, A\Sigma A^T)$。

这意味着对一个多元高斯分布它的线性组合以及它的任何一个子向量均服从高斯分布

独立性

设 $X \sim \mathcal{N}(\mu, \Sigma)$，$Y \sim \mathcal{N}(\nu, \Lambda)$

有 $$ \Sigma_{11} = \text{Cov}(X_1, X_1) = E((X_1-\mu_1)(X_1-\mu_1)^T) $$ $$ \Sigma_{22} = \text{Cov}(X_2, X_2) = E((X_2-\mu_2)(X_2-\mu_2)^T) $$ $$ \Sigma_{12} = \text{Cov}(X_1, X_2) = E((X_1-\mu_1)(X_2-\mu_2)^T) = \Sigma_{21}^T $$

如果 $\Sigma_{12} = 0$，则 $X_1$ 和 $X_2$ 独立。

例子

设 $X = (X_1, X_2)^T$，求一个常系数矩阵 $A$ 使得 $Y=AX$ 的各组分.

解设 $$ A = \begin{pmatrix} I & A' \ 0 & I \end{pmatrix} $$ 其中 $I$ 是单位矩阵，$A'$ 是任意矩阵。则 $$ Y = AX = \begin{pmatrix} X_1 + A'X_2 \ X_2 \end{pmatrix} $$ 要使得$Y$ 的各组分独立，则需要满足 $$ \text{Cov}(X_1 + A'X_2, X_2) = Cov(X_1, X_2) + A' \text{Cov}(X_2, X_2) = 0 $$ 这意味着 $$ A' \Sigma_{22} + \Sigma_{12} = 0 $$ 因此 $$ A' = -\Sigma_{12} \Sigma_{22}^{-1} $$

布朗运动

定义

标准布朗运动（Brownian motion）是一个特殊的高斯过程，满足以下条件

$B(0) = 0$，即初始位置为零。
平稳增量，即 $B(t) - B(s) \sim B(t-s)$
对任意$t$，$B(t)$ 服从正态分布

性质

期望 $$ E[B(t)] = 0 $$
方差 $$ \text{Var}(B(t)) = t $$
协方差 $$ \text{Cov}(B(t), B(s)) = \min(t, s) $$

这里尤其需要注意协方差的计算，有一个常用的技巧 $$ \text{Cov}(B(t), B(s)) = E[B(t)B(s)] - E[B(t)]E[B(s)] = E[B(t)B(s)] $$ 因为 $E[B(t)] = E[B(s)] = 0$。

然后我们可以利用技巧得到 $$ E[B(t)B(s)] = E(B(t)[B(s)-B(t)+B(t)]) = E[B(t)[B(s)-B(t)]] + E[B(t)^2] $$

这就让我们可以用独立增量的性质来计算协方差。

$$ \text{Cov} = E(B(t))E(B(s-t)) + E(B(t)^2) = 0 + t = t $$

布朗运动几乎处处连续，但是几乎处处不可微。

Haoran Liao | 廖浩然

并行程序设计复习题库

并行程序设计复习题库

题量概览

目录

第一章 为什么要并行计算

填空题

1-填空-1

1-填空-2

1-填空-3

1-填空-4

1-填空-5

1-填空-6

1-填空-7

1-填空-8

1-课本填空-1

1-课本补充-填空-1

1-课本补充-填空-2

1-课本补充-填空-3

1-课本概念-填空-1

1-课本概念-填空-2

1-课本概念-填空-3

1-课本概念-填空-4

判断题

1-判断-1

1-判断-2

1-判断-3

1-判断-4

1-判断-5

1-判断-6

1-课本判断-1

1-课本补充-判断-1

1-课本补充-判断-2

1-课本概念-判断-1

1-课本概念-判断-2

1-课本概念-判断-3

选择题

1-选择-1

1-选择-2

1-选择-3

1-选择-4

1-选择-5

1-选择-6

1-课本选择-1

1-课本补充-选择-1

1-课本补充-选择-2

1-课本概念-选择-1

1-课本概念-选择-2

1-课本概念-选择-3

大题

1-大题-1

1-大题-2

1-大题-3

1-课本大题-1

1-课本补充-大题-1

1-课本补充-大题-2

1-课本补充-大题-3

第二章 并行硬件和软件

填空题

2-填空-1

2-填空-2

2-填空-3

2-填空-4

2-填空-5

2-填空-6

2-填空-7

2-填空-8

2-课本填空-1

2-课本补充-填空-1

2-课本补充-填空-2

2-课本补充-填空-3

2-课本概念-填空-1

2-课本概念-填空-2

2-课本概念-填空-3

2-课本概念-填空-4

判断题

2-判断-1

2-判断-2

2-判断-3

2-判断-4

第一章为什么要并行计算

第二章并行硬件和软件