rust中的别名(aliasing)

前言

最近看rust死灵书,讲到了在rust programming languages那本书中没有提到的一些知识,记录下。

什么是别名(aliasing)

提到aliasing就要说到为什么会有这个概念——在死灵书的关于reference(引用)讲到了两个规则:

  1. 一个引用不能存活超过他的引用对象(A reference cannot outlive its referent)
  2. 一个可变引用不能被别名(A mutable reference cannot be aliased)

在rust讨论别名,我们采用如下定义:当某个变量和某个指针表示的内存区域有重叠时,它们互为对方的别名。

ps:c++里面的引用类似于别名的存在,c++里面的引用的概念和rust的引用概念是不一样的。

为什么别名很重要?

我们看一个简单的rust函数:


fn compute(input: &u32, output: &mut u32) {
    if *input > 10 {
        *output = 1;
    }
    if *input > 5 {
        *output *= 2;
    }
}


fn main() {
    let mut input:u32 = 22;
    let mut output:u32 = 32;
    compute(&input, &mut output);

    println!("input {}", input);
    println!("output {}", output);
}

我们可能会这样优化它:



fn compute(input: &u32, output: &mut u32) {
    let cached_input = *input; // 将*input放入缓存
    if cached_input > 10 {
        *output = 2; // x > 10 则必然 x > 5,所以直接加倍并立即退出
    } else if cached_input > 5 {
        *output *= 2;
    }
}

fn main() {
    let mut input:u32 = 22;
    let mut output:u32 = 32;
    compute(&input, &mut input); // 这里会报错,因为不符合引用的第二条规则。按照之前的所有权的规则理解就是,在一个作用域里面只能有一个可变引用。
    
    println!("input {}", input);
    println!("output {}", output);
}

|
|     compute(&input, &mut input);
|     ------- ------  ^^^^^^^^^^ mutable borrow occurs here
|     |       |
|     |       immutable borrow occurs here
|     immutable borrow later used by call


在Rust中,这种优化是正确的。但对于其他几乎所有的语言,都是有错误的(除非编译器进行全局分析)。这是因为优化方案成立的前提是不存在别名,而绝大多数语言并不会限制这一点。看一个c++中的例子:


void compute(const int* input, int* output) {
    if (*input > 10) {
        *output = 1;
    }

    if (*input > 5) {
        *output *= 2;
    }
}

int main()
{

    int input = 20;
    int output = 10;
    compute(&input, &input);  // c++ 不会验证传入参数的别名重复 

    cout << "output " << output << endl;
    cout << "input " << input << endl;
    return 0;
}

上面的执行过程如下: 
                  //  input ==  output == 0xabad1dea
                  // *input == *output == 20
if *input > 10 {  // true (*input == 20)
    *output = 1;  // 同时覆盖了 *input,以为他们是一样的
} 
*input > 5 {      // false (*input == 1)
    *output *= 2;
}
                  // *input == *output == 1

别名分析的好处

有个这个的好处是什么呢?对于开发者来说感知不大,但是对于编译器来说有很大的益处。

  1. 将值放到高速缓存中,因为在一段作用域里面,没有人去修改内存,所以不需要同步。
  2. 省略了读操作,得益于上面的好处。
  3. 省略了一些写回操作,因为在下一次写内存前,内存不会有读取。(我理解是可以直接写到缓存里面,因为在当前的作用域里面,外部的访问,不需要做内存同步,只有在当前作用域结束,才需要写回到内存)
  4. 移动或重排没有依赖的读写顺序

这些优化也可以进一步证明更大程度的优化的可行性,比如循环向量化、常量替换和不可达代码消除等。

总结

因为以前没有做过这么底层的东西,从来没有考虑过类似的事情,这次是涨姿势了。