1. 参考

白栎旸. 数字IC设计入门（微课视频版）[M]. 北京: 清华大学出版社，2023-09-01:第2章.

2. 数字器件与Verilog语法

虽然 Foundry 提供的可用元器件种类较多，但数字设计师并不特别在意这些元器件，在其头脑中，只存在 10 种简单元器件：

• 与门、或门、非门、异或门、
• 加法器、乘法器、移位器、
• 选择器、比较器、
• 触发器

注意，虽然加法器、乘法器、比较器等元器件可以由逻辑门生成，但是从Verilog常用的表达式来看，一般直接用“+”这个符号表示加法，而很少用门电路去直接搭建。因为现代芯片规模庞大，功能复杂，工程师应该将主要精力投入到重点难题的实现中，而对于如何实现加法器等最底层的问题，应该交给综合步骤自动完成。

基本元器件中不包括除法，因为除法的实现不同于乘法，它受到被除数、除数、商的数值范围限制，有时需要用到迭代等复杂方法实现，还有分母为 0 等异常情况需要报告，所以不属于Verilog中常用的直接运算方式。

务必注意，数字前端写的Verilog仅仅是代码，而非程序，其代码是代替电路图的一种文本语言描述。与或非加乘等指的是元器件。写Verilog时要有电路概貌和时序。

10种数字器件的符号表示及Verilog表示方法见表格：

真正的元器件库中有很多复杂的元器件，如图所示：

但是这些元器件都可以看作以上10种基础元器件的组合，不会超出原有的功能范围。所以设计时，头脑中只需要有以上10种元器件。

数字IC设计又称为数字逻辑设计，因为其本身就是逻辑的，只有0和1两种逻辑。

• 组合逻辑：电平输入和电平输出。元器件结构简单，但问题是如果输入含有毛刺，输出就有毛刺。

• 时序逻辑：以时钟为驱动源。一个触发器，在时钟的驱动（边沿触发）下，将 D 输入端的信号送到 Q 端输出。

触发器也可以叫寄存器(register, reg)，因为如果没有时钟驱动，那么Q端会保持原有状态不变，也就寄存了上一次触发时的D端信息。而组合逻辑，输出端是无法寄存信息的。

时序逻辑是数字电路的基础。10 种元器件中，只有触发器属于时序逻辑器件，所以触发器是整个数字电路的基础。从 RTL 的名称可以知晓，RTL 意为寄存器传输层，直译过来就是：从一个触发器的输出到另一个触发器的输入，通过触发器的层层传递，最终实现了一个功能完整的数字电路。

数字电路的时序分析，主要是分析两个触发器之间的路径延迟。

进行前仿时，看到的仿真波形会和本图一样，是理想的，而使用版图网表进行后仿时，仿真波形是带延迟的。

上图中触发器的符号表示，它共有4个引脚，除输入的D端和输出的Q端外，三角形位置表示时钟，下方的rst_n表示复位，其上的圆圈表示0电平有效，即rst_n等于0时，寄存器处于复位状态。此时，Q端保持0，即使时钟和D端有动作，Q端也不会变化，只有当rst_n等于1时，才解除复位状态，寄存器方能正常工作。

3. 可综合的Verilog设计语法

能变成电路的Verilog表达叫做可综合，在设计电路时，只能使用可综合的语法表述。而在仿真时，由于只在计算机上运行，不留片，可使用不能综合的高级语法，以增加语言表达的灵活度和复杂度。

可综合的电路表述只有两种：

• assign
• always

与门：

1

assign z = a & b;

触发器：

1
2
3
4
5
6
7

always @(posedge clk or negedge rst_n)
begin
    if (!rst_n)
        Q <= 0;
    else
        Q <= D;
end

符号说明：

• <=: 非阻塞赋值，凡是时序逻辑，都用非阻塞赋值；
• =: 阻塞赋值，凡是组合逻辑，都用阻塞赋值；
• @(...): 括号中的列表叫敏感列表，意思是，always块输出的Q对列表中信号保持敏感，如果敏感信号动，则Q也会动。
• posedge clk: 意思是时钟的上升沿；
• negedge rst_n: 意思是时钟的下降沿。
• begin / end: 相当于 C 语言中的 {} ，如果语句只有一条，可以不写 begin / end 。

always不仅可以表示时序逻辑，也可以表示组合逻辑。如下是与门的另一种表示：

1
2
3
4

always @(*)
begin
    z = a & b;
end

其中，@(*)中的*是省略表述的敏感列表，综合器会自动在always块中寻找与输出z相关的输入信号，自动填入敏感列表中。本例中，会自动将a和b作为输入填入。这种让工具自动填入的方式是可靠且推荐的。

Verilog的语法规律：

1. 时序逻辑，必须使用always块，并同时使用<=非阻塞赋值。在其敏感列表中，必须出现时钟信号的边沿和复位信号的边沿。
2. 组合逻辑，可以使用assign，也可以使用always块，但是它们的赋值是=阻塞赋值。若使用always块，则敏感列表中使用*。若遇到敏感列表中带有*，则可以直接判定为组合逻辑。

再次强调，Verilog的语法表达，描述的都是电路，因此例子中的 z、a、b、clk、rst_n、Q、D 都称为信号，在电路中都是实实在在的金属连线，切勿称为变量。

4. 对寄存器的深度解读

一般会使用时钟上升沿来驱动寄存器。对于同样的功能需求，双沿触发需要的时钟慢，但要求时钟是50%占空比，而单沿触发，对时钟的要求快一倍，但对时钟形状的要求降低很多。

复位信号rst_n，以0电平作为复位电平，1电平解复位，是通用标准，很少有反过来使用的。原因是，数字电路的复位信号是模拟电路给的，通常，模拟电路将其命名为POR(Power On Reset)，即上电复位信号。芯片刚通电时，电压小，逐渐上升到要求的电压，例如1.8V，POR本质上是一个电压上升的标志，模拟电路放一个比较器，将输入电压与0.9V比较，电压小于0.9V，POR为0，电压大于0.9V，POR为1。因而复位信号上电时总是先0后1，数字寄存器需要在复位信号为0的阶段保持复位态，不能运行，因为此时芯片电压不足，不能保证正常运行，而复位信号变成1，说明上电完毕，电压充足，寄存器解除复位进行正常运行是安全的。

需要特别澄清的是语句negedge rst_n，但是经过仿真和与模拟工程师确认，复位信号对寄存器的作用不是通过信号沿来驱动的，而是通过电平来驱动，也就是 0 信号具有绝对控制权，只要 rst_n 为 0 ，那么立即复位。

5. 非阻塞赋值和阻塞赋值的区别

非阻塞赋值的意思是该句表达不会阻塞后续表达的执行。如下例中，X <＝ 0的执行，不会阻碍到Y <＝ 0的执行，它们是同时发生的：

1
2
3
4
5
6
7
8
9
10
11
12
13

always @(posedge clk or negedge rst_n)
begin
    if (!rst_n)
    begin
        X <= 0;
        Y <= 0;
    end
    else
    begin
        X <= A;
        Y <= B;
    end
end

而阻塞赋值，意思是如果前一句不执行，后一句就无法执行，前一句会阻塞后一句。对于可综合的Verilog来讲，其实并不会阻塞。在下例中， always 块的目的是创造 z 和 k 两个信号。 k ＝ 3 * z 和 z ＝ a & b 是两个不同的电路， k ＝ 3 * z 电路不会被 z ＝ a & b 阻塞。

1
2
3
4
5

always @(*)
begin
    z = a & b;  // 与门
    k = 3 * z;  // 乘法器
end

本例对应的原理图如图所示：

可见，对于电路描述来讲，语法只是表示一种连接关系，并没有执行先后顺序的说法，但如果本例使用非阻塞赋值，语法检查会报错，因此，这是一种惯用方法。阻塞赋值在Verilog中真正体现阻塞，是在仿真使用的不可综合语法中，到第3章再做解释。

6. 组合逻辑的表达式

对于一个组合逻辑电路，应该在什么情况下用assign，在什么情况下用always呢？

比较简单的逻辑适合使用assign方式，较为复杂的逻辑应使用always块。下例给出了一个适合用always块的较复杂例子：

1
2
3
4
5
6
7
8
9
10
11

always @(*)
begin
    if (s1)
        a = 1;
    else if (s2)
        a = 2;
    else if (s3)
        a = 3;
    else
        a = 0;
end

同样的功能若改用assign，则为下例所示。很明显，用always块表达意思更加清晰。

1

assign a = s1 ? 1 : (s2 ? 2 : (s3 ? 3 : 0));

前面解释了敏感列表中的 * 在组合逻辑 always 块中的作用。如果读者使用过一些老IP，则可能还会看到下例所示的表达，这种表达已随着综合器的进步渐渐被淘汰了，不建议初学者使用。

1
2
3
4
5
6
7
8
9
10
11

always @(s1 or s2 or s3)
begin
    if (s1)
        a = 1;
    else if (s2)
        a = 2;
    else if (s3)
        a = 3;
    else
        a = 0;
end

7. 组合逻辑中的选择器

7.1. 二选一 MUX 如何表达？

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 第 1 种表达， assign 完整表达
assign z = (s == 1) ? b : a;

// 第 2 种表达， assign 简化表达
assign z = s ? b : a;

// 第 3 种表达， always 块表达
always @(*)
begin
    if (s)
        z = b;
    else
        z = a;
end

7.2. 多选一MUX，又该如何表示呢？

因为使用 assign 表示显然会过于复杂，所以需要用 always 块表示。表示方法有两种，注意两种表达综合出来的电路是不同的。

其一如下例所示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

always @(*)
begin
    if (s == 0)
        z = a;
    else if (s == 1)
        z = b;
    else if (s == 2)
        z = c;
    else if (s == 3)
        z = d;
    else if (s == 4)
        z = e;
    else if (s == 5)
        z = f;
    else
        z = a; // 默认值
end

综合出来的电路如图所示：

可见，使用 if 表述的选择关系，综合的电路是一层一层逐渐展开的，写在 if 最前面的语句，掌握着最终的选择权，因而优先级最高，再往后优先级逐层下降，而使用 case 表述的MUX，每个选择都是并列的，优先级相同，见下文。

其二如下例所示。

1
2
3
4
5
6
7
8
9
10
11

always @(*)
begin
    case (s)
        0: z = a;
        1: z = b;
        2: z = c;
        3: z = d;
        4: z = e;
        5: z = f;
        default: z = a; // 默认值
end

所综合的电路如图所示：

使用 if 表述，有可能出现隐藏逻辑，即设计者没有考虑到，但实际会被综合出来的逻辑门。隐藏逻辑是设计的隐患，设计者在写代码时应该清楚其逻辑含义，尽量避免出现隐藏逻辑。为了避免设计中出现隐藏逻辑，在实际项目中往往会提倡使用 case 语句来表达。

下例中反映出 if 的优先级特征，条件 s < 5 包含 s ＝＝ 4 的情况，因为 s < 5 优先，因而当 s＝＝4 时， z 的赋值是 a 而不是 b 。如果设计意图是要在 s ＝＝ 4 时使 z ＝ b ，则应当将其写在 s < 5 之前。

1
2
3
4
5
6
7
8
9

always @(*)
begin
    if (s < 5)
        z = a;
    else if (s == 4)
        z = b;
    else
        z = c;
end

case有一种变体是 casez ，它可以拓展case的使用范围：

1
2
3
4
5
6
7
8
9

always @(*)
begin
    casez(s)
        16'b00011???????????: z = a;
        16'b10111111????0000: z = b;
        16'b1111?001000?????: z = c;
        default: z = d;
    endcase
end

其中，问号的意思是0或1都能匹配，类似计算机语言中的通配符。

虽然很多项目提倡使用 case 或 casez 来表述选择器，但究竟是使用 if 还是 case ，仍然取决于表达的需要。总体而言， case 便于判断是否相等的情况，而 if 适合判断大于或小于关系，不同情况用不同的表达，可以使Verilog逻辑更加清晰，也更便于维护。

注意组合逻辑中的 if 和 else if ，最后必须跟一句 else ，使整体逻辑完整。若没有else，则该电路会综合出一个锁存器(Latch)。锁存器不属于10种基本元器件之一。在设计中，凡有寄存需求，应尽量使用触发器，避免使用锁存器，特别要避免不写 else 引起的隐藏逻辑。

8. Verilog中的for循环

关键字：

• for
• generate / endgenerate / genvar
• integer: 是编译时的变量，不是信号，不会被综合成电路或金属连线。如果变量 ii 声明为 wire 或 reg ，然后用 a[ii] 表示一个信号，则语法不能综合为电路。但是 ii 声明为 integer ，那么 a[ii] 将被综合成信号。

9. Verilog中的数值表示方法

数值一般不直接写，如果直接写，则工具会理解为十进制32比特数，但实际中的信号位宽多种多样，选用哪种进制表示数值也有多种选择，因此需要将这两方面予以规定。

特殊的数值表示方法：

{5{1'b0}} 表示5个比特0，再如 {4{1'b1}} 表示4个比特1。这种表示一般不用，但是它有优点，上例中的比特数量5和4可以用参数替代，若Verilog中有一个参数 kkk ，则可以写为 {(kkk){1'b0}} ，甚至可以写成用计算式表示的位宽，如 {(kkk＋2){1'b0}} 。注意，kkk是参数，不是信号，它不是电路，而是一种编译时使用的变量。

这种表示方法还可以写为 {常数{逻辑表达式}} 的形式，如

1

assign int_clr = {2{(apb_addr = = 4'd7) & wr_en}} & apb_wdat[1 : 0];

此例的目的是使用APB总线配置两个只写信号（write-only信号）​，这两个信号合称为 int_clr ，等式的右边，仅当地址 apb_addr 等于7，并且在APB总线上发生写操作时，APB写入的两比特数据 apb_wdat[1:0] 才会被配置到int_clr中，否则int_clr就是0。问题在于， (apb_addr＝＝4'd7)&wr_en 是一比特，不能跟 apb_wdat[1:0] 按位求与，因而需要将一比特复制为两比特，即 {2{(apb_addr＝＝4'd7)&wr_en}} 。

对于其他辅助变量，可以直接写数字，例如在for循环中讲述的 genvar ii ，ii只是个变量，没有对应的电路，那么for循环赋值就不需要带位宽 和进制了，可以像下面这样写

1

for(ii = 0;ii<100;ii = ii + 1)

注意Verilog中，如果单写a、b、c、d、e、f、x、z，表示的是信号名，不能作为数值，如果想表示十六进制的数值，则可写为4’ha等，1’bx表示未知态，1’bz表示高阻态。

10. 信号的状态类型

1

0 1 x z

其中，

• 0和1是数字电路本身的状态，它的本源是零电平和VDD电平。

  VDD， Voltage Drain, 其中 Drain 表示漏极，是一个电源引脚，用来提供正电压给电路中的元件。由于晶体管的设计通常包含两个漏极（源极和漏极），所以在一些命名规则中，为了区分正电源和负电源，使用了两个 D，并且VDD 代表正电源电压，VSS（Voltage Source）代表地线或负电源。 整个芯片的电源常称为VCC，芯片的地常标注为VSS。

  不同工艺和元器件库需要的VDD不同，例如0.9V、1.8V、3.3V等，而同一个元器件库中的所有元器件，其需要的供电电压VDD一般相同的，只有I/O器件等少数元器件，其输入端和控制端是比较低的电压，而输出端口却是较高的电压。

  数字0和1对应的电平不会特别严格，而是有一个浮动范围，通常信号电平低于VDD的30%，就被认为是0，高于VDD的70%，就被认为是1。

• z态是高阻态。

  如果一颗芯片不通电，则它所有的引脚就都是高阻态。可见，高阻态的实际意义就是不会干扰到其他信号传输的状态，例如某信号A是高阻态，某信号B不是高阻态，那么信号A叠加到信号B上（可以想象为两根信号线被拧在一起）​，结果仍然是B，而A没有任何效果。

  一般来讲，一个有着双向传输功能的引脚，如果设置为输入模式，就可以认为这个引脚处于高阻态，意思是它对电路板上与它相连的元器件没有任何影响，这些相连元器件如果要对本芯片输出0或1，就可以直接顺着该高阻态引脚输入，而不会被干扰或阻挡。

  在FPGA的Verilog表述中，可以很形象地将FPGA的引脚描述为如下语句，其中b是FPGA的引脚，所以声明为inout类型，oe是该引脚的方向选择，若oe为1，则b为输出模式，将信号a输出到FPGA外面，而当oe为0时，是高阻态，即输入模式，外面的信号从b引脚可以进来后与信号c形成了组合逻辑，代码如下：

  1 2 3 4

  inout b; assign b = oe ? a : 1'bz assign d = b ^ c;

  注意上例中引用FPGA的语法只是为了说明z态的含义。IC设计中对引脚的设计不像FPGA这么简单，需要例化一个引脚模块，在代码中不会出现1’bz数值。

  博主注1：

  在集成电路（IC）中，高阻态（High Impedance State，简称 Hi-Z）是指一个电路输出引脚处于没有输出驱动信号的状态，即该引脚既不提供高电平（VDD）也不提供低电平（GND），而是处于一种“悬空”状态，几乎不消耗电流，像是断开了。高阻态通常用于多路复用（bus）或三态总线（tri-state bus）等应用中，允许多个设备共享同一条总线而不会相互干扰。

  高阻态的实现
  高阻态通常通过 三态门（Tri-state Gate） 来实现。三态门是一种特殊类型的逻辑门，它具有三个输出状态：

  高电平（逻辑 1）
  低电平（逻辑 0）
  高阻态（Hi-Z）
  具体来说，高阻态是通过在输出端增加一个高阻抗的电路来实现的，这个高阻抗值通常非常大，以至于该引脚对外部电路几乎没有影响。三态门的工作原理可以分为以下几种方式：

  开关型设计：

  P-Channel MOSFET（PMOS） 和 N-Channel MOSFET（NMOS） 组成的电路可以根据控制信号决定是否接通输出。如果三态门处于“高阻态”时，MOSFET 们并不会导通，从而使输出引脚处于高阻抗状态。
  控制信号：

  三态门的输出通常由一个控制信号来控制。当控制信号为“使能”状态时，输出引脚会驱动高或低电平；而当控制信号为“禁用”状态时，输出引脚进入高阻态，基本与外部电路断开连接。
  双向总线：

  在多路复用的场景中，多个设备可能需要共享同一条数据总线。为了避免多个设备同时驱动总线产生冲突，设备在不输出数据时会进入高阻态，不影响其他设备的信号传输。
  高阻态的作用
  多路复用：高阻态允许多个电路共享同一总线。只有一个电路在某个时间点输出数据，其他电路进入高阻态，防止冲突。

  总线冲突保护：通过将不参与通信的设备置于高阻态，避免了多个设备在同一时间尝试驱动总线的冲突。

  节省电力：通过在不需要输出信号时将输出置于高阻态，可以降低功耗，因为在高阻态下输出引脚几乎不消耗电流。

  举例说明
  一个常见的例子是在 Tri-state Bus（三态总线）中，多个设备通过控制信号来决定是否驱动总线。如果设备不需要发送数据，它会将输出置于高阻态，允许其他设备使用总线。

  总结来说，高阻态的实现依赖于三态门（Tri-state Gate），它通过控制MOSFET开关来使输出处于非驱动状态，从而让其他电路可以共享同一个引脚或总线。

  博主注2：

  在数字电路中，inout 引脚是指一个既可以作为输入端口，也可以作为输出端口的引脚。它通常用于多路复用（bus）或双向数据传输的场合，允许一个引脚在不同时间根据需要在输入和输出之间切换。为了在同一引脚上同时支持输入和输出，通常使用 三态逻辑（Tri-state logic）来控制数据的流向。

  inout 引脚的实现方式
  inout 引脚的实现依赖于几个关键的设计原则和组件

  三态缓冲器（Tri-state Buffer）：

  在 inout 引脚上，通常使用 三态缓冲器（Tri-state buffer）来控制该引脚是处于输入、输出还是高阻态。三态缓冲器的作用是通过控制信号来决定该引脚的状态。
  当引脚作为 输出 时，缓冲器将数据传递到引脚。
  当引脚作为 输入 时，缓冲器将引脚上的电压信号传送到内部电路。
  当引脚处于 高阻态（Hi-Z）时，缓冲器断开与引脚的连接，使得该引脚对外部电路“透明”，即不影响电路。
  控制信号：

  inout 引脚的切换通常由控制信号（例如，方向控制信号）来决定，指示该引脚是作为输入使用还是作为输出使用。
  控制信号一般是由逻辑电路生成，当电路需要输出数据时，控制信号会使引脚成为输出；而当电路需要接收数据时，控制信号会使引脚成为输入。
  双向总线设计：

  inout 引脚常用于总线设计，其中多个设备共享同一条总线。每个设备可以在需要时向总线发送数据，而在不需要时通过将输出设为高阻态来避免与其他设备的冲突。
  例如，数据总线（Data Bus）可能由多个设备共享。当一个设备不在发送数据时，它会将其 inout 引脚设为高阻态，确保只有发送设备影响总线信号。

  工作原理

  输出模式：

  当inout 引脚作为输出时，相关的三态缓冲器连接到该引脚，并驱动电平（高或低）。此时，控制信号将引脚设置为输出模式，并且其他连接到该引脚的电路会处于断开状态。

  输入模式：

  当 inout 引脚作为输入时，缓冲器进入高阻态（Hi-Z），即引脚的状态不再由输出逻辑驱动，转而接收外部信号。此时，只有连接到引脚的其他设备会驱动该引脚的电平。
  高阻态：

  当引脚不需要输出数据时，三态缓冲器将进入 高阻态，使该引脚对其他电路没有影响。这样，多个设备就可以共享同一个引脚或总线而不会发生电平冲突。
  应用示例
  双向数据总线：

  假设有多个设备共享一条数据总线。每个设备的 inout 引脚可以作为数据的输入端或输出端。在某个时刻，只有一个设备向总线发送数据，其他设备则将其引脚设为高阻态，避免干扰。
  双向信号传输：

  在通信协议中，inout 引脚可用于双向信号传输。例如，I²C总线就使用 inout 引脚，其中一个设备在某个时刻发送信号，而另一个设备则接收信号。
  芯片间通信：

  在多芯片系统中，inout 引脚可用于芯片之间的数据交换，允许不同芯片在不同时刻控制同一引脚的输入和输出行为。
  总结
  inout 引脚通过三态缓冲器和控制信号的组合，实现了同一引脚可以在输入和输出之间切换的功能。通过将输出置于高阻态，可以使得该引脚不会干扰其他电路或设备，使其适用于总线系统或双向通信的设计中。

• x态的含义是未知态。

  有4种情况会产生未知态：

  • 其一是芯片已上电但复位信号未进行复位的情况；
  • 其二是双向引脚信号冲突，因为没控制好，导致有一路信号通过引脚输入，另一路信号通过相同的引脚输出；
  • 其三是芯片中一个元器件的某个输入端为x态，于是输出就跟着变成了x态，这就是所谓x态的传播；
  • 第四是触发器的时序不满足，产生了亚稳态，从而表示为x态。

  上述4种情况在仿真中都能看到，但实际中，第1种情况基本不会出现，除非模拟电路设计有误，其他3种在数字设计有缺陷时会出现，实际在测量其电压时会出现不稳定或非预期的问题。在可综合的Verilog中，不会出现1’bx数值，因为没有一个设计会故意将一个错误引入RTL中，所有的错误都是意外发生的。该符号在仿真脚本和仿真波形中可能出现。

电平信号与脉冲信号

电平信号也叫Latch信号，即一个信号持续多个时钟周期都一直保持为1的信号。

脉冲信号就是只持续一个时钟周期的信号。

工程师在交流时，对于电平信号a常用的说法是“将a给Latch住”​，对于脉冲信号b常用的说法是“打一个脉冲b”​。

1. 参考

白栎旸. 数字IC设计入门（微课视频版）[M]. 北京: 清华大学出版社，2023-09-01:第1章.

2. 数字IC设计流程

2.1. 三个主要流程：

1. 前端设计: 用 Verilog 编写 RTL 设计文件（Register Transfer Level，RTL，寄存器传输层）。

2. 综合（Synthesis）：将 RTL 转换位实际电子元器件的连接。输出文件称为网表（netlist），也是纯文本文件。

3. 后端布局布线（PR）：将网表变为实际电路图，类似 PCB 图，称为版图（Layout）。版图是晶圆厂（Foundry）能识别的通用格式。

   版图的绘制：

   • 布局（Place）：元器件如何摆放；
   • 布线（Route）：元器件如何连接。

   数字版图的绘制大部分由计算机自动完成，称为自动布局布线（Automatic Place and Route，APR），很多时候也称为 PR 。

   流片（TapeOut）：Foundry 根据版图制造芯片。

2.2. 验收和验证（SignOff）：

对质量进行把控和最终验收。

前仿真：检查 RTL 设计文件；用测试平台（Testbench）文件对实际应用环境仿真。这是在版图成型之前，称为前仿。一旦发现错误，验证人员会反馈给设计者修改，如此反复迭代，直至交付到综合阶段的 RTL 文件都是合格的。

SignOff 检查：检查版图设计；对时序和功耗检查。如果检查不过，首先是数字后端工程师自己努力，重新绘制版图或微调元器件位置，若无法达到目的，再修改综合策略，重新综合。若仍无法达到目的，则反馈到前端 IC 设计，在 RTL 上调整。

后仿真：在 SignOff 合格后，需要将网表和延迟信息提交给验证人员，进行后仿。对成型版图的时序进行最后验证和验收。后仿就是版图成型之后的仿真。

2.3. 可测性设计（Design For Test，DFT）

一个附属工序，原理是在芯片中加入与主要功能无关的附属电路，用于在芯片的生产过程中使用 TestBench 快速判断芯片功能的完好行、内部结构的正常性。

如果芯片中包含 DFT 电路，则 TestBench 可以向芯片的某些引脚发送事先准备好的测试向量，在芯片的另一些引脚上采样芯片对测试向量的反应。将事先准备好的预期效果与实际采样到的结果进行对比，从而判断内部功能是否正常。

DFT 功能也常常被称为扫描（Scan），即用 TestBench 扫描芯片内部之意。DFT 的检查对象是生产差错造成的芯片损坏，它不能检查设计问题。设计问题应该交给验证工序。

DFT 对芯片来说不是必需的，一些低成本的芯片没有插入 DFT 电路，在设计流程中，直接从电路综合过渡到后端设计。

2.4. 前端设计 VS 后端设计

• 前端设计：抽象电路，只描述功能，不是具体电路。
• 后端设计：具体电路，不仅要知道哪些元器件，还要确认这些元器件的摆放位置。

综合是前端和后端的分界线，综合之前没有元器件而只有功能；综合之后，设计才有了具体化的元器件。

当然，前端工程师往往强调心中有电路，并非实际电路，而是心中有功能相似的概念性电路。这样可以认清设计架构，并避免潜在的设计隐患。

3. 模拟IC设计流程

1. 绘制原理图（Schematic）

   手动绘制。

2. 原理图仿真

   一般由原理图设计者亲自完成。原因是模拟电路的设计参数选择范围宽泛，需要验证的场景也复杂，仿真验收标准不十分明确。这就需要设计者搭建关键的应用环境和场景，对电路上产生的反应做出判断，随时调整电路结构和参数。

3. 绘制版图（根据原理图）

   手动绘制。

   模拟版图工程师和模拟IC设计师一般是分开的两个职业。

   模拟IC设计师一般也都掌握一些绘制版图的方法，单熟练程度以及对一些物理问题的处理方面，需要求助专业的版图工程师。

   模拟版图工程师可以根据原理图及通用的绘图规则直接绘制。但是对诸如社评电路及高功率管之类有着特殊要求的设计，版图工程师需要与模拟IC设计师进行充分沟通，在模拟IC设计师的协助下进行绘制。

4. 抽取寄生参数

5. 版图后仿

6. 设计规则检查（Design Rule Check，DRC）

7. 版图和原理图的一致性检查（Layout Versus Schematics，LVS）

8. 流片

模拟IC设计没有那么多自动化成分，需要手动绘制原理图、版图，电阻、电容等元器件需要人工确定。

模拟IC仿真，无法像数字IC那样通过仿真验证和FPGA验证两种方法来相互印证设计效果。模拟仿真速度慢、情况多，很难覆盖真是使用中可能遇到的全部情况，因此，模拟设计具有很高的不确定，芯片的实际效果与仿真结果存在明显差距是经常发生的。

但是模拟电路也有一些无法被数字电路取代的特性。

可以想象，数字电路只需要处理 0 和 1 两种信号，但是模拟电路的数值域是实数域，包括所有连续的整数、浮点数、正负数，数据有无穷个。因此，即使是很小的电路，元器件数量不多，也需要设计者和仿真者从数值域中挑选一部份值作为设计和仿真中用到的值，绝对不可能覆盖所有情况。

4. 芯片整体规划

版图布局规划（FloorPlan）：将芯片整体规划，以及内部数字、模拟电路的位置、面积、形状等特征的规划。

• Pad: FloorPlan的周围是芯片引脚(Pad)。Pad实际指的是芯片引脚之外的一块金属。
• IO: 包括Pad和内部逻辑在内的整个引脚设计。

一个完整的引脚设计如图：

• 封装: 芯片外面的塑料壳子称为芯片的封装，大体分为两种：插针式（引脚如针）、表贴式（引脚扁平）。

5. IC设计工具

EDA 公司：电子设计自动化（Electronic Design Automation）公司，粗略来说，数字设计常用 Synopsys ，模拟设计常用 Cadence ， Mentor 在一些细分领域有优势。

仿真加速器： Palladium (Cadence) 、 ZeBu (Synopsys) 。

5.1. 数字IC设计工具

RTL 仿真工具：有 Synopsys 的 VCS ，Cadence 的 Incisive （也叫 irun ）。这些工具可以胜任前仿、后仿、UVM 架构（Universal Verification Methodology，通用验证方法学）的仿真。Cadence 的 irun 与模拟设计工具 Virtuoso 工具中集成的 AMS 仿真工具相结合，支持数字模拟电路混合仿真。

波形查看工具：一般集成在仿真工具中。VCS 的波形软件叫 DVE ， Incisive 的波形软件叫 SimVision 。但在这个领域，一家名为 Novas 的公司的软件，以其明快的界面、方便的功能、快捷的操作，异军突起，得到了广泛的认可，它就是 Verdi （以音乐家威尔第的名字命名，前身叫 Debussy ，以音乐家德彪西的名字命名）。 Verdi 现已被 Synopsys 收购。 Mentor 的仿真和看波形软件叫 ModelSim ，主要用于 FPGA 功能的仿真。

RTL 语法检查工具： Atrenta 公司的 Sypyglass ，可以检查语法、跨时钟域处理方案的可靠性，甚至可以在内部执行综合、功耗评估和简单的布局布线，使它能全方位地给出设计建议。现已被 Synopsys 收购。 Cadence 的对应检查工具是 nLint 。

综合工具：即将 RTL 转化为实际电路的工具，常用的的有 Synopsys 的 Design Compiler (DC) ，该工具内部还有一些 Synopsys 开发的库，能够帮助设计者减小面积，提高性能，例如加法器、乘法器等，这些设计好的子模块在 DC 中被称为 DesignWare (DW) 。可以是让工具自动从 RTL 中识别出可用 DW 替换的代码，也可以是设计者手动例化 DW 模块。 Cadence 相应的工具叫 Genus （原名叫 RTL Compiler ）。

版图自动布局布线软件： Synopsys 有 ICC2 （旧版为 ICC ）， Cadence 有 Innovus （原名 Encounter ），两个软件都被广泛使用。由于两个软件的操作命令不同，后端工程师往往只掌握其中一种。 Synopsys 为了增强客户的黏性，开发了一个银河（ MilkyWay ）流程，从前端到后端，通过专用的二进制文件 (db) 传输，占用空间小，处理效率高，但也有许多公司使用 DC 综合，再将网表导入 Innovus 进行布局布线。

SignOff 工具：即对整个设计的时序、功耗评估。 Synopsys 的 Prime Time (PT) ， Cadence 的 Tempus 。目前， PT 已经称为业内 SignOff 的标准。实际上，时序分析在 DC 中也能做，但两者在分析方法、细节考虑全面度、分析速度等方面存在差异。在综合时使用 DC 检查，而在 SignOff 时，使用 PT 检查。

形式验证工具：也称为逻辑等效行检查（ Logic Equivalece Check, LEC ），将 RTL 和网表进行一一对照。因为从 RTL 到综合网表，以及从综合网表到后端网表的过程，可能意外地改变原有功能和设计意图，所以需要进行检查。 Synopsys 的工具时 Formality ， Candence 的工具是 Conformal 。

寄生参数的提取工具：进入设计版图阶段，可以确定走线的延迟。该值受信号负载、线路长短、粗细、周围线路等多重影响，需要用模型和查表进行计算，才能得到确切的值。该过程称为寄生参数的提取。一般使用 Synopsys 的 StarRC 。提取出来的信息可用于 PT 进行 SignOff 。

上述工具，最主要的控制语法是 TCL 语言， EDA 工具大多以该语言为基础，扩展出各种专用命令。

除了以上数字设计工具，还有一些更加细分的工具类型，比如仿真加速器，有 Cadence 的 Palladium 、 Synopsys 的 ZeBu 。

5.2. 模拟IC设计工具

主要是 Cadence 的 Virtuoso 。与数字设计中繁多的工具不同， Virtuoso 能满足大部分设计需求，例如绘制并仿真原理图、绘制并仿真版图、数模混合仿真等。实际上， Virtuoso 更像集成开发环境（ Integrated Development Environment, IDE ），它包含很多独立的设计工具，如仿真工具 Spectre 等。

SignOff 工具：Mentor 的 Calibre 可以用来提取寄生参数、进行 DRC 和 LVS 检查。

5.3. 职位、分工与工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

管理
├── 研发
│   ├── 数字IC设计
│   ├── 数字IC验证
│   └── 数字后端
│   └── 模拟IC设计
│       └── 模拟版图
├── 测试
│   ├── 研发类测试
│   │   ├── 方案测试
│   │   └── 量产测试
│   └── 客户测试
├── 销售
└── 方案
    ├── 硬件方案
    └── 软件方案

5.4. EDA 与 Foundry 的关系

普通软件公司无力开发 EDA 软件。因为 EDA 厂商需要和 Foundry 厂商紧密合作，才能获得有关的生产细节数据，从而帮助用户进行更加准确的仿真、寄生参数的提取、规则的检查。不同的 EDA 工具抽取的寄生参数可能不同，原因可能是不同的工具获得的工艺数据不同。

国内 EDA 厂商要想打破垄断，不仅要靠软件技术，还要与各大 Foundry 厂达成战略合作，共享工艺数据，才能做出有实用价值的 EDA 工具。

6. 概念

6.1. 寄存器：

register，这是对功能强调的名称，其物理实体很多，比如触发器 (Flip-Flop, FF)和锁存器(Latch)等等。在数字设计中，主要提倡触发器。

寄存器是受控于时钟沿的元器件， Foundry 会在标准单元库中提供多种寄存器。

触发器是由边沿信号而非电平信号导致数据存储的。触发源一般是时钟信号。

锁存器较少使用，它一般以非时钟信号为存储控制，靠电平触发。一般不连接时钟，只是连接一根普通的信号线。这种锁存器一般很少被纳入时钟计算中，因为它既不属于组合逻辑，又无法像触发器一样作为时序路径的起终点，所以时序上无法通过工具保证，只能通过工程师来保证。

本书说的寄存器，基本可以替换为触发器。在数字芯片 EDA 工具链中，两个概念也是混用的，一个 reg 既可以指寄存器，也可以指触发器。另外，所谓时序逻辑门电路，也基本等同于触发器。

6.2. 设计(Design)的边界

• Pad：芯片（封装）之外的引脚。

• 元器件：指芯片内的组合逻辑门电路及时序逻辑门电路。这些标准的元器件也被称为标准单元(Standard Cell)。元器件也称为逻辑门。

• 标准单元库/工艺库：元器件的集合。

• I/O: 如前“FloorPlan”对IO的解释，I/O是包括Pad和内部逻辑在内的整个引脚设计。在标准单元库中是一种标准单元，但是它比较特殊，可能与其他标准单元不放在同一个标准单元库中。驱动电平也可能不同。

• 通用单元库: 在综合时，有一个中间步骤是将 RTL 抽象逻辑先映射为通用单元(Generic Boolean)，然后映射到标准单元。通用单元与工艺无关，也不包含物理特性，只有功能属性，与 RTL 描述类似。而标准单元既有功能属性，又有延迟、电压等工艺属性，与工艺和 Foundry 相关。

• lef文件: Library Exchange Format. 描述特定流片工艺下元器件的物理属性。

• lib文件: Library. 描述特定流片工艺下元器件的功能属性。lib文件常常要被编译为二进制的db文件才能在某些EDA工具上使用。 lef 和 lib 文件都是技术库。

  数字设计只能在 Foundry 提供的已有的选项中挑选元器件。

• def文件: Design Exchange Format. 设计除了 RTL 外，也可以带有物理信息，保存为 def 文件，基础内容是设计的形状和尺寸，扩展内容包括端口的分布位置、RAM和ROM等硬核的放置位置、内部元器件的放置和布线位置等。 RTL 和 def 统称为设计。

自己写的模块可以称为设备(Device)或模块(Module)。

用设备一词主要强调它具备相对独立的功能，在介绍SoC架构等上层逻辑时较为常用，设备也经常被替换为单元(Unit)一词，它指人为设计的单元，而非标准单元。一个设计可以包含很多个设备。

用模块一词，主要强调它在设计文件结构上的独立性，在介绍通用设计和底层逻辑时较为常用。

VMWare 的 Linux 虚拟机共享 Windows 主机的 VPN

方案 2：NAT 模式 + Windows 网络共享
另一种方式是保持 VMware 使用 NAT 模式，并通过 Windows 主机的网络共享功能，将 VPN 流量共享给虚拟机。

步骤：
在 Windows 上启用网络共享：

确保 Clash 在 Windows 主机上运行，并已连接到 VPN。
打开 控制面板 > 网络和共享中心 > 更改适配器设置。
右键点击你的 VPN 连接（通常是一个以 Ethernet 开头的适配器），选择 属性。
在 共享 标签页，勾选 允许其他网络用户通过此计算机的 Internet 连接连接。
选择虚拟机使用的网络适配器（例如 VMware 的 VMnet8 适配器），然后点击确定。
配置虚拟机网络为 NAT：

在 VMware 中，确保虚拟机的网络适配器设置为 NAT（这通常是默认设置）。
在 NAT 模式下，虚拟机会通过 Windows 主机访问网络，但流量会被路由到共享的网络适配器。
验证虚拟机是否可以通过 VPN 访问网络：

启动虚拟机，测试网络连接。
如果虚拟机连接成功并通过 VPN 访问互联网，那么配置就完成了。

WSL1 通过主机的 clash 客户端访问网络

方法一：配置环境变量（适用于普通网络请求）

适合 curl、wget、apt、pip、git 等命令行工具走代理。

1
2
3
4

echo 'export http_proxy=http://127.0.0.1:7890' >> ~/.bashrc
echo 'export https_proxy=http://127.0.0.1:7890' >> ~/.bashrc
echo 'export all_proxy=socks5://127.0.0.1:7890' >> ~/.bashrc
source ~/.bashrc

验证代理是否有效：

1

curl cip.cc

这个网站会返回你的公网 IP。

1

curl https://www.google.com

应该会返回网页。

临时开启：

如果你只想暂时走代理一次，不想改 .bashrc，你可以直接这样运行：

1
2
3
4
5
6

# 方法1
http_proxy=http://127.0.0.1:7890 https_proxy=http://127.0.0.1:7890 curl https://www.google.com
# 方法2
curl -I https://www.google.com -x http://127.0.0.1:7890
# 方法3：走socks5代理
curl -I --socks5 127.0.0.1:7890 https://www.google.com

方法二：使用 proxychains 全局转发（适用于所有程序，包括二进制）

安装 proxychains，让任意程序走 Clash 的代理。

1. 安装 proxychains

1
2

sudo apt update
sudo apt install proxychains -y

2. 编辑配置 /etc/proxychains.conf

1

sudo vim /etc/proxychains.conf

在文件末尾加一行或修改为：

1

socks5  127.0.0.1 7890

注意：不要改成 http，要用 socks5。

使用 proxychains（只代理你想代理的程序）：

1

proxychains curl https://www.google.com

优点：

• 精准控制哪些程序走代理。
• 不影响系统其他设置。

缺点：

• 每次都要手动加 proxychains。

方法三：为单独的程序配置代理

1. 配置 git 使用代理

执行以下命令设置全局代理（只设置一次即可）：

1
2

git config --global http.proxy http://127.0.0.1:7890
git config --global https.proxy http://127.0.0.1:7890

若你之后想关闭 git 代理，可运行：

1
2

git config --global --unset http.proxy
git config --global --unset https.proxy

2. 配置 pip 使用代理

在主目录创建 pip 配置文件：

1
2

mkdir -p ~/.config/pip
vim ~/.config/pip/pip.conf

添加内容：

1
2

[global]
proxy = http://127.0.0.1:7890

3. 配置 apt 使用代理

编辑 apt 的配置文件：

1
2

sudo mkdir -p /etc/apt/apt.conf.d
sudo nano /etc/apt/apt.conf.d/99proxy

粘贴以下内容（假设 HTTP 代理端口是 7890）：

1
2

Acquire::http::Proxy "http://127.0.0.1:7890";
Acquire::https::Proxy "http://127.0.0.1:7890";

方法四：配置 iptables + redsocks（实现真正的全局转发）

适合高级用户，WSL2 使用 TUN 模式实现系统级全局代理。这比较复杂，建议在需要所有流量强制走代理时使用。TODO

线段树（Segment Tree）是一种将数组区间存储为树的数据结构 ^1。

时间复杂度

查询连续子数组 或 查询范围内的最小元素：O(logn)

最简单形式的线段树

高阶版本的线段树

TODO

参考

OI wiki

参考源码

/usr/include/c++/11/bits/shared_ptr_base.h
/usr/include/c++/11/bits/shared_ptr.h

博客：https://zhiqiang.org/coding/std-shared-ptr.html

std::shared_ptr 的性质

1. 复制构造、析构是线程安全的。

标准库使用原子操作实现无锁的线程安全性。

2. 写操作（例如 reset 、 赋值 operator= ）是线程不安全的。

写操作和复制构造、析构的主要区别是：

• 复制构造、析构函数中，单个线程只处理一个对象，复制构造函数将其他对象复制过来之后，不会改动其他对象的资源（引用计数、所管理的内存）。
• 但是写操作可能多个线程都在处理该 shared_ptr 。例如多个线程都对同一个 shared_ptr 进行赋值：

1
2
3

shared_ptr<int> sp1 = make_shared<int>(1);
sp1 = sp2; // 线程 1
sp1 = sp3; // 线程 2

对比源码分析：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

     __shared_count&
     operator=(const __shared_count& __r) noexcept
     {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != _M_pi)
  {
    if (__tmp != nullptr)
      __tmp->_M_add_ref_copy();
    if (_M_pi != nullptr)
      _M_pi->_M_release(); // 注意：线程 1 和线程 2 持有相同的 _M_pi！
    _M_pi = __tmp; // 注意：线程 1 和线程 2 持有相同的 _M_pi！
  }
return *this;
     }

以上代码中两个“注意”可能同时在发生，例如：
线程 1 release 的时候，线程 2 在给 _M_pi 赋值；
或者两个线程同时在 release 或同时在给 _M_pi 赋值。

要点

1. 管理的内存和引用计数都应该动态分配到堆（ heap ）上，这样多个 shared_ptr 对象才能更新同一份数据。
2. 需要同时维护强引用计数和弱引用计数。
3. 引用计数本身应该是一个控制块类，使用 delete this 来自动删除（析构）引用计数。

永远不要手动 delete use_count，因为其他线程可能此时正在使用该资源，例如解引用 *use_count。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

template<_Lock_policy _Lp = __default_lock_policy>
    class _Sp_counted_base
    : public _Mutex_base<_Lp>
    {
      void
      _M_add_ref_copy()
      { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }

      void
      _M_release() noexcept
      {
        // Be race-detector-friendly.  For more info see bits/c++config.
        _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
	if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
	  {
            _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
	    _M_dispose();
	    // There must be a memory barrier between dispose() and destroy()
	    // to ensure that the effects of dispose() are observed in the
	    // thread that runs destroy().
	    // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
	    if (_Mutex_base<_Lp>::_S_need_barriers)
	      {
		__atomic_thread_fence (__ATOMIC_ACQ_REL);
	      }

            // Be race-detector-friendly.  For more info see bits/c++config.
            _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
	    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
						       -1) == 1)
              {
                _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
	        _M_destroy();
              }
	  }
      }

    private:
      _Sp_counted_base(_Sp_counted_base const&) = delete;
      _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;

      // using _Atomic_word = int;
      _Atomic_word  _M_use_count;     // #shared
      _Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
    };

  template<_Lock_policy _Lp>
    class __shared_count
    {
      _Sp_counted_base<_Lp>*  _M_pi; // 引用计数的指针

      __shared_count(const __shared_count& __r) noexcept
      : _M_pi(__r._M_pi)
      {
	if (_M_pi != nullptr)
	  _M_pi->_M_add_ref_copy(); // TODO: 有没有可能此时的 _M_pi 所引对象已经被释放了呢
      }

      ~__shared_count() noexcept
      {
	if (_M_pi != nullptr)
	  _M_pi->_M_release(); // 没有直接 delete _M_pi，
                           // 而是使用 _M_pi 的成员函数来释放它。
      }

      __shared_count&
      operator=(const __shared_count& __r) noexcept
      {
	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
	if (__tmp != _M_pi)
	  {
	    if (__tmp != nullptr)
	      __tmp->_M_add_ref_copy();
	    if (_M_pi != nullptr)
	      _M_pi->_M_release(); // 没有直接 delete _M_pi，
                               // 而是使用 _M_pi 的成员函数来释放它。
	    _M_pi = __tmp;
	  }
	return *this;
      }
    };

参考

https://gcc.gnu.org/onlinedocs/libstdc++/manual/ext_concurrency.html

在测试leetcode的 815.公交路线 一题时，发现一个现象，当我使用vector<vector<bool>>作为图的邻接矩阵的类型时，运行速度比使用vector<vector<int>>慢了近1倍。使用bool运行速度为600ms左右，使用int时运行速度为300ms左右。

以下是ChatGPT的回答：

在C++中，bool类型并不一定比int类型慢，但在某些情况下，它们的性能表现可能有所不同。以下是一些与性能差异相关的考虑：

1. 内存大小
   bool类型在标准中只需要表示 true（非0）和 false（0），通常占用1个字节（8位），而 int 通常占用4个字节（32位）。因此，bool类型可以节省内存，在某些情况下会带来缓存效率的提升，尤其是在处理大量布尔值时（例如布尔数组）。
2. 对齐和内存访问
   在某些架构上，处理单字节的bool类型时，可能会有额外的开销，因为处理器通常优化对齐访问。如果内存没有正确对齐，处理器可能需要额外的操作来处理非对齐的字节，导致性能下降。相比之下，int的对齐通常与系统的内存总线对齐更好（如32位或64位系统上），因此读取和写入可能更高效。
3. 指令集和操作
   现代处理器在处理布尔值时通常会将其扩展为完整的寄存器大小（例如32位或64位）。因此，虽然bool类型的存储可能更小，但在实际操作中，处理器可能将它提升为int或更大的类型来执行逻辑操作。处理布尔值可能涉及隐式类型转换，这在某些极端情况下可能带来开销。
4. 寄存器使用
   int 类型可以直接映射到处理器寄存器中进行操作，而 bool 类型的操作有时可能会涉及额外的逻辑运算（如掩码操作）以确保布尔值的正确性。
5. 编译器优化
   现代编译器在优化时会考虑到bool与int的差异，并尽量优化代码，因此在大多数应用场景下，你不会感受到显著的性能差异。但在一些特定的场合（如大规模数组、频繁内存访问等），bool类型的使用确实可能带来性能影响，尤其是在处理器需要对齐或执行额外的操作时。
   总结
   bool类型通常并不会比int慢，实际的性能差异取决于平台、内存对齐、编译器优化以及应用场景。在大多数情况下，差异是微不足道的，但在对性能非常敏感的程序中，这种差异可能会显现。

启用调试模式

1. 命令行启用调试：

1
2

#使用 -x 和 -v 选项运行 main.sh 脚本。
bash -xv main.sh

注意：调试输出是通过 stderr ，在试图重定向时要注意。

2. 在脚本中启用调试：

1

set -xv

参考链接

其他选项：

• set +e：忽略错误继续运行（bash）。
• set -e：遇错停止执行（bash）。

3. 环境变量 PS4

1

PS4='+ ${LINENO}: '

可以搭配使用 PS4 环境变量，以在调试输出中打印命令所在的文件行号。

PS4 是一个 Bash 环境变量，用于定义调试模式下的提示符格式。
当你启用调试模式（通过 set -x）时，Bash 会在每一行执行之前打印调试信息，而 PS4 决定了这些调试信息的格式。
$LINENO表示打印行号。

trap DEBUG

设置DEBUG陷阱，该陷阱在每一条“简单语句”执行完毕之后会被调用一次。

1
2
3
4
5
6
7
8
9
10
11

set -o functrace
track_var="my_var"
old_value=""
check_var_change() {
    new_value="${!track_var}"
    if [[ "$new_value" != "$old_value" ]]; then
        echo "$track_var changed to \"$new_value\" at $BASH_LINENO"
        old_value="$new_value"
    fi
}
trap check_var_change DEBUG

说明：监控my_var变量的变化，如果变化，则打印新值。

注意：实际测试中，我们发现trap监控变量变化似乎会延迟，而set -x打印的信息是可靠的。

特殊变量

参考：https://www.gnu.org/software/bash/manual/html_node/Bash-Variables.html

• BASH_LINENO: 这是一个数组变量，‌用于表示当前执行的脚本或函数中每一行的行号。‌它特别适用于调试，‌因为它可以追踪到函数调用栈中每一层的行号。‌通过访问BASH_LINENO数组的不同索引，‌可以获取到不同函数调用层级对应的行号信息‌。
• LINENO: 获取当前脚本行号‌，‌而不涉及函数调用栈的追踪‌。
• FUNCNAME: 函数名
• BASH_SOURCE

判断文件是否存在

相关函数

• access
• stat
• inotify_node
• opendir
• readdir

注意事项

文件系统并不会实时刷新缓存，尤其是在网络文件系统中。这会导致文件即使已经创建，access或stat函数依然返回”No such file”。
但是ls可以看到文件，这是因为ls和access函数的实现机制不同。

例如：

在NFS文件系统中，创建文件之后立即调用stat命令查看文件，stat会报告“文件不存在”。
删除文件之后立即调用stat命令查看文件，发现stat依然可以看到该文件。

我们可以改用readdir来读取目录，因为目录会被更快地更新缓存。

debug

在当前代码根目录下创建.vscode/launch.json文件，写入如下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

{
    "configurations": [
        {
            "name": "(gdb) Launch",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceFolder}/a.out",
            "args": [],
            "stopAtEntry": true,
            "cwd": "${workspaceFolder}",
            "miDebuggerServerAddress": "<remote host>:<remote port>",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
        },
        {
            "name": "(gdb) Attach",
            "type": "cppdbg",
            "request": "attach",
            // "program": "/path/to/executable",
            "program": "/proc/self/exe",
            "MIMode": "gdb",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                },
                {
                    "description": "Set Disassembly Flavor to Intel",
                    "text": "-gdb-set disassembly-flavor intel",
                    "ignoreFailures": true
                }
            ]
        }
    ],
    "version": "2.0.0"
}

其中，”(gdb) Launch”可以用来连接gdbserver。用gdbserver启动executable：

1

gdbserver peer_host:local_port prog [args]

如果在点击”Run”按钮之前，在VSCode的Debugger Terminal写上命令（可以不按Enter），那么在程序启动时，该命令会被先执行。

Q & A

1. Q: Configured debug type 'cppdbg' is not supported.
A: Please check if the "c/c++" extension is installed. (ref)
2. Q: VS Code Remote-SSH: The vscode server failed to start SSH
A: https://stackoverflow.com/questions/67976875/vs-code-remote-ssh-the-vscode-server-failed-to-start-ssh
3. Q: Where does VS Code store the data for its Local History feature?
A: https://stackoverflow.com/questions/72610147/where-does-vs-code-store-the-data-for-its-local-history-feature
4. vscode无法跳转到定义
A: when "C_Cpp.intelliSenseEngine" is set to "Tag Parser", Goto definition is working fine.

https://github.com/microsoft/vscode-cpptools/issues/273

Links

• TI-RPC
• RPC language
• XDR Protocol
• PRC Compiler
• rpcgen
• rpcgen programming guide

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

$ which rpcgen
/bin/rpcgen
$ rpcgen
usage: rpcgen infile
        rpcgen [-abkCLNTM][-Dname[=value]] [-i size] [-I [-K seconds]] [-Y path] infile
        rpcgen [-c | -h | -l | -m | -t | -Sc | -Ss | -Sm] [-o outfile] [infile]
        rpcgen [-s nettype]* [-o outfile] [infile]
        rpcgen [-n netid]* [-o outfile] [infile]
options:
-a              generate all files, including samples
-b              backward compatibility mode (generates code for SunOS 4.1)
-c              generate XDR routines
-C              ANSI C mode
-Dname[=value]  define a symbol (same as #define)
-h              generate header file
-i size         size at which to start generating inline code
-I              generate code for inetd support in server (for SunOS 4.1)
-K seconds      server exits after K seconds of inactivity
-l              generate client side stubs
-L              server errors will be printed to syslog
-m              generate server side stubs
-M              generate MT-safe code
-n netid        generate server code that supports named netid
-N              supports multiple arguments and call-by-value
-o outfile      name of the output file
-s nettype      generate server code that supports named nettype
-Sc             generate sample client code that uses remote procedures
-Ss             generate sample server code that defines remote procedures
-Sm             generate makefile template 
-t              generate RPC dispatch table
-T              generate code to support RPC dispatch tables
-Y path         directory name to find C preprocessor (cpp)

For bug reporting instructions, please see:
<http://www.gnu.org/software/libc/bugs.html>.

Note:

% 可以用来转义某行，任何句首带有 % 的行将被视作字符串，直接放入到输出文件中。
注意：rpcgen 可能改变该行的位置，所以应该在输出文件中对这些行进行仔细检查。

rpcgen provides an additional preprocessing feature: any line that begins with a percent sign (%) is passed directly to the output file, with no action on the line’s content. Use caution because rpcgen does not always place the lines where you intend. Check the output source file and, if needed, edit it.

例如

1

#include "abc.h"

当执行 rpcgen infile 命令时，由于 “abc.h” 不存在，可能会报错。

但是如果在句首添加一个 % 符号，则可以绕过检查。

1

%#include "abc.h"