inasayang's blog

Rust | LTO和Thin LTO编译器

xiayangzzw@gmail.com (inasayang) — Tue, 15 Apr 2025 00:00:00 Z

# LTO (Link Time Optimization)

链接时优化是一种编译器优化技术，它在程序的链接阶段而非传统的编译阶段执行代码优化。

## LTO 的工作原理

编译阶段：编译器在编译单个源文件时，不仅生成机器代码，还保存中间表示（IR，Intermediate Representation）到目标文件中
链接阶段：链接器收集所有模块的IR，将它们合并为一个统一的程序表示
全局优化：对整个程序执行优化，基于对所有代码的完整视图

## LTO 的主要优势

跨模块优化：可以进行跨越多个源文件的优化
内联函数：更强大的函数内联能力，包括跨编译单元边界
死代码消除：更有效地移除未使用的代码
更精确的别名分析：改进指针分析和内存访问优化
代码大小减少：通过移除不必要的代码减小二进制大小

## LTO 的缺点

内存消耗大：处理大型程序时需要大量内存
编译时间长：链接过程变得更加复杂和耗时

# Thin LTO (轻量级链接时优化)

Thin LTO 是 LLVM 编译器基础设施引入的 LTO 变种，旨在解决传统 LTO 的性能和扩展性问题。

## Thin LTO 的工作原理

索引生成：每个目标文件都独立生成索引，包含符号和引用信息
并行优化：基于索引信息，将全局优化工作分解成多个可并行执行的任务
模块级优化：在各个模块上并行执行优化，而不是合并所有IR

## Thin LTO 的主要优势

减少内存使用：不需要加载整个程序的IR到内存
并行编译：通过并行化加速编译过程
增量编译支持：更好地支持增量构建
保留大部分传统LTO的优化效果：仍能执行跨模块优化

特性	LTO	Thin LTO
优化效果	最大化	接近LTO但略低
内存使用	高	中等
编译速度	慢	快（尤其在多核系统）
并行度	有限	高
适用场景	最终发布构建	日常开发和发布

# Rust 中使用

[profile.release]
# lto = "off"
# lto = "fat"   
# lto = "thin"

LTO 通常与其他优化标志一起使用。

Rust | Clone vs Copy

xiayangzzw@gmail.com (inasayang) — Wed, 13 Sep 2023 00:00:00 Z

## Copy的含义

Copy的全名是std::marker::Copy

std::marker模块里面所有的trait都是特殊的trait

它们是跟编译器密切绑定的，impl这些trait对编译器的行为有重要影响。在编译器眼里，它们与其他的trait不一样。这几个trait内部都没有方法，它们的唯一任务是给类型打一个“标记”，表明它符合某种约定——这些约定会影响编译器的静态检查以及代码生成

那么，Copy这个trait在编译器的眼里代表的是什么意思呢？

简单点总结就是，如果一个类型impl了Copy trait，意味着任何时候，我们都可以通过简单的内存复制（在C语言里按字节复制memcpy）实现该类型的复制，并且不会产生任何内存安全问题。

一旦一个类型实现了Copy trait，那么它在变量绑定、函数参数传递、函数返回值传递等场景下，都是copy语义，而不再是默认的move语义。

最简单的赋值语句x = y来说明move语义和copy语义的根本区别

move语义是“剪切、粘贴”操作，变量y把所有权递交给了x之后，y就彻底失效了，后面继续使用y就会出编译错误
copy语义是“复制、粘贴”操作，变量y把所有权递交给了x之后，它自己还留了一个副本，在这句赋值语句之后，x和y依然都可以继续使用

在Rust里，move语义和copy语义具体执行的操作，是不允许由程序员自定义的。

move语义或者copy语义都是执行的memcpy，无法更改，这个过程中绝对不存在其他副作用。

如果考虑后端优化，在许多情况下，不必要的内存复制实际上已经彻底优化掉了，不必担心执行效率的问题。没有必要每次都把move或者copy操作与具体的汇编代码联系起来，因为场景不同，优化结果不同，生成的代码也是不同的。只需记住的是语义。

## Copy的实现条件

并不是所有的类型都可以实现Copy trait。Rust规定，对于自定义类型，只有所有成员都实现了Copy trait，这个类型才有资格实现Copy trait。

常见的数字类型、bool类型、共享借用指针&，都是具有Copy属性的类型
Box、Vec、可写借用指针&mut等类型都是不具备Copy属性的类型
对于数组类型，如果内部的元素类型是Copy，那么这个数组也是Copy类型
对于元组tuple类型，如果每一个元素都是Copy类型，那么这个tuple也是Copy类型
struct和enum类型不会自动实现Copy trait。只有当struct和enum内部的每个元素都是Copy类型时，编译器才允许我们针对此类型实现Copy trait
```
    struct T(i32);
    fn main() {
        let t1 = T(1);
        let t2 = t1;
        println! ("{} {}", t1.0, t2.0);
    }
```
编译错误。原因是在let t2 = t1；这条语句中执行的是move语义。但是可以手动为它impl Copy trait，这样它就具备了copy语义

Rust中只有POD（C++语言中的Plain Old Data）类型才有资格实现Copy trait。

在Rust中，如果一个类型只包含POD数据类型的成员，并且没有自定义析构函数，那它就是POD类型。

比如：整数、浮点数、只包含POD类型的数组等，都属于POD类型；而Box String Vec等不能按字节复制的类型，都不属于POD类型。

并不是所有满足POD的类型都应该实现Copy trait，是否实现Copy取决于业务需求。

## Clone的含义

Clone的全名是std::clone::Clone

    pub trait Clone : Sized {
        fn clone(&self) -> Self;
        fn clone_from(&mut self, source: &Self) {
            ＊self = source.clone()
        }
    }

两个关联方法，分别是clone_from和clone

clone_from是有默认实现的，依赖于clone方法的实现
clone方法没有默认实现，需要手动实现

clone方法一般用于“基于语义的复制”操作。所以，跟具体类型的作用息息相关。比如，对于Box类型，clone执行的是“深复制”；而对于Rc类型，clone做的事情就是把引用计数值加1。

虽然Rust中的clone方法一般是用来执行复制操作的，但是如果在自定义的clone函数中做点别的什么工作，编译器也没办法禁止。可以根据需要在clone函数中编写任意的逻辑。

对于实现了copy的类型，它的clone方法应该跟copy语义相容，等同于按字节复制

## 自动derive

绝大多数情况下，实现Copy Clone这样的trait都是一个重复而无聊的工作。因此，Rust提供了一个attribute，可以利用编译器自动生成这部分代码。示例如下：

    #[derive(Copy, Clone)]
    struct MyStruct(i32);

derive会让编译器自动生成impl Copy和impl Clone这样的代码。自动生成的clone方法，会依次调用每个成员的clone方法。

通过derive方式自动实现Copy和手工实现Copy有微小的区别。当类型具有泛型参数的时候，比如struct MyStruct<T>{}，通过derive自动生成的代码会自动添加一个T:Copy的约束。

## 总结

Copy内部没有方法，Clone内部有两个方法
Copy trait是给编译器用的，告诉编译器这个类型默认采用copy语义，而不是move语义。Clone trait是给程序员用的，我们必须手动调用clone方法，它才能发挥作用
Copy trait不是想实现就能实现的，它对类型是有要求的，有些类型不可能impl Copy。而Clone trait则没有什么前提条件，任何类型都可以实现（unsized类型除外，因为无法使用unsized类型作为返回值）
Copy trait规定了这个类型在执行变量绑定、函数参数传递、函数返回等场景下的操作方式。即这个类型在这种场景下，必然执行的是“简单内存复制”操作，这是由编译器保证的，程序员无法控制。Clone trait里面的clone方法究竟会执行什么操作，则是取决于程序员自己写的逻辑。一般情况下，clone方法应该执行一个“深复制”操作，但这不是强制性的，如果你愿意，在里面启动一个人工智能程序都是有可能的
如果确实不需要Clone trait执行其他自定义操作（绝大多数情况都是这样），编译器提供了一个工具，我们可以在一个类型上添加#[derive(Clone)]，来让编译器自动生成那些重复的代码。编译器自动生成的clone方法非常机械，就是依次调用每个成员的clone方法
Rust语言规定了在T: Copy的情况下，Clone trait代表的含义。即：当某变量t: T符合T: Copy时，它调用t.clone() 方法的含义必须等同于“简单内存复制”。也就是说，clone的行为必须等同于let x = std::ptr::read(&t);，也等同于let x = t;。当T: Copy时，不要在Clone trait里面乱写逻辑。所以，当需要指定一个类型是Copy的时候，最好使用#[derive(Copy,Clone)]方式，避免手动实现Clone导致错误。

深入浅出Rust

Rust | Ownership

xiayangzzw@gmail.com (inasayang) — Tue, 20 Jun 2023 00:00:00 Z

# 一段不安全的代码

int* foo() {
    int a;          // 变量a的作用域开始
    a = 100;
    char *c = "xyz";   // 变量c的作用域开始
    return &a;
}                   // 变量a和c的作用域结束

变量 a 和 c 都是局部变量，函数结束后将局部变量 a 的地址返回，但局部变量 a 存在栈中，在离开作用域后，a 所申请的栈上内存都会被系统回收，从而造成了 悬空指针(Dangling Pointer) 的问题。

虽然编译可以通过，但是运行的时候会出现错误。

变量 c常量字符串，存储于常量区， "xyz" 只有当整个程序结束后系统才能回收这片内存。

# 栈(Stack)与堆(Heap)

栈中的所有数据都必须占用已知且固定大小的内存空间
对于大小未知或者可能变化的数据，需要存储在堆上
- 当向堆上放入数据时，需要请求一定大小的内存空间。操作系统在堆的某处找到一块足够大的空位，把它标记为已使用，并返回一个表示该位置地址的指针, 该过程被称为在堆上分配内存，有时简称为 “分配”(allocating)
- 接着，该指针会被推入栈中，因为指针的大小是已知且固定的，在后续使用过程中，你将通过栈中的指针，来获取数据在堆上的实际内存位置，进而访问该数据
写入
- 入栈比在堆上分配内存要快
- 入栈时操作系统无需分配新的空间，只需要将新数据放入栈顶即可
- 在堆上分配内存则需要更多的工作，这是因为操作系统必须首先找到一块足够存放数据的内存空间，接着做一些记录为下一次分配做准备
读取
- 得益于 CPU 高速缓存，使得处理器可以减少对内存的访问，高速缓存和内存的访问速度差异在 10 倍以上
- 栈数据往往可以直接存储在 CPU 高速缓存中，而堆数据只能存储在内存中
- 访问堆上的数据比访问栈上的数据慢，因为必须先访问栈再通过栈上的指针来访问内存

# 所有权原则

Rust 中每一个值都被一个变量所拥有，该变量被称为值的所有者
一个值同时只能被一个变量所拥有，或者说一个值只能拥有一个所有者
当所有者(变量)离开作用域范围时，这个值将被丢弃(drop)

# 变量绑定背后的数据交互

### 转移所有权

let x = 5;
let y = x;

两个值都是通过自动拷贝的方式来赋值的，都被存在栈中，完全无需在堆上分配内存

let s1 = String::from("hello");
let s2 = s1;

对于基本类型（存储在栈上），Rust 会自动拷贝，但是 String 不是基本类型，而且是存储在堆上的，因此不能自动拷贝。

String 类型是一个复杂类型，由存储在栈中的堆指针、字符串长度、字符串容量共同组成，其中堆指针是最重要的，它指向了真实存储字符串内容的堆内存，至于长度和容量，如果你有 Go 语言的经验，这里就很好理解：容量是堆内存分配空间的大小，长度是目前已经使用的大小。

String 类型指向了一个堆上的空间，这里存储着它的真实数据, 下面对上面代码中的 let s2 = s1 分成两种情况讨论：

拷贝 String 和存储在堆上的字节数组如果该语句是拷贝所有数据(深拷贝)，那么无论是 String 本身还是底层的堆上数据，都会被全部拷贝，这对于性能而言会造成非常大的影响
只拷贝 String 本身这样的拷贝非常快，因为在 64 位机器上就拷贝了 8字节的指针、8字节的长度、8字节的容量，总计 24 字节，但是带来了新的问题：一个值只允许有一个所有者，而现在这个值（堆上的真实字符串数据）有了两个所有者：s1 和 s2。

当变量离开作用域后，Rust 会自动调用 drop 函数并清理变量的堆内存。

当 s1 和 s2 离开作用域，它们都会尝试释放相同的内存。这是一个叫做 二次释放（double free） 的错误。

所以，Rust 这样解决问题：当 s1 赋予 s2 后，Rust 认为 s1 不再有效，因此也无需在 s1 离开作用域后 drop 任何东西，这就是把所有权从 s1 转移给了 s2，s1 在被赋予 s2 后就马上失效了。

看看在所有权转移后再来使用旧的所有者

let s1 = String::from("hello");
let s2 = s1;
println!("{}, world!", s1);

Rust 会禁止你使用无效的引用

move occurs because `s1` has type `std::string::String`, which does not implement the `Copy` trait

fn main() {
    let x: &str = "hello, world";
    let y = x;
    println!("{},{}",x,y);
}

x 只是引用了存储在二进制中的字符串 "hello, world"，并没有持有所有权。

因此 let y = x 中，仅仅是对该引用进行了拷贝，此时 y 和 x 都引用了同一个字符串。

### 克隆(深拷贝)

Rust 永远也不会自动创建数据的 “深拷贝”。任何自动的复制都不是深拷贝。

如果确实需要深度复制 String 中堆上的数据，而不仅仅是栈上的数据，可以使用一个叫做 clone 的方法。

let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {}, s2 = {}", s1, s2);

s2 完整的复制了 s1 的数据

### 拷贝(浅拷贝)

浅拷贝只发生在栈上

Rust 有一个叫做 Copy 的特征，可以用在类似整型这样在栈中存储的类型。如果一个类型拥有 Copy 特征，一个旧的变量在被赋值给其他变量后仍然可用。

任何基本类型的组合可以 Copy ，不需要分配内存或某种形式资源的类型是可以 Copy 的。如下是一些 Copy 的类型：

所有整数类型
布尔类型
所有浮点数类型
字符类型
元组，当且仅当其包含的类型也都是 Copy 的时候
不可变引用 &T

# 引用与解引用

常规引用是一个指针类型，指向了对象存储的内存地址。

fn main() {
    let x = 5;
    let y = &x;

    assert_eq!(5, x);
    assert_eq!(5, *y);
}

# 不可变引用

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len);
}
fn calculate_length(s: &String) -> usize {
    s.len()
}

通过 &s1 语法，我们创建了一个指向 s1 的引用，但是并不拥有它。因为并不拥有这个值，当引用离开作用域后，其指向的值也不会被丢弃。

# 可变引用

fn main() {
    let mut s = String::from("hello");
    change(&mut s);
}
fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

s 是可变类型，其次创建一个可变的引用 &mut s 和接受可变引用参数 some_string: &mut String 的函数。

可变引用同时只能存在一个

fn main() {
   let mut s = String::from("hello");
    let r1 = &s;
    let r2 = &s;
    println!("{} and {}", r1, r2);
    // 新编译器中，r1,r2作用域在这里结束
    let r3 = &mut s;
    println!("{}", r3);
} // 老编译器中，r1、r2、r3作用域在这里结束
  // 新编译器中，r3作用域在这里结束

引用作用域的结束位置从花括号变成最后一次使用的位置，因此 r1 借用和 r2 借用在 println! 后，就结束了，此时 r3 可以顺利借用到可变引用。

## 悬垂引用(Dangling References)

指针指向某个值后，这个值被释放掉了，而指针仍然存在，其指向的内存可能不存在任何值或已被其它变量重新使用。

fn dangle() -> &String { // dangle 返回一个字符串的引用
    let s = String::from("hello"); // s 是一个新字符串
    &s // 返回字符串 s 的引用
} // 这里 s 离开作用域并被丢弃。其内存被释放。
  // 危险！

解决方法是直接返回 String：

fn no_dangle() -> String {
    let s = String::from("hello");
    s
}

String 的 所有权被转移给外面的调用者