如何理解 C/C++ 中的 指针别名(pointer alias)、restrict、const 的关系呢?

背景

最近在写点 C,发现以前一直没注意到 指针别名(pointer alias)restrict 这些东西。

初步看了看,感觉以后碰指针要更烧脑了,否则动不动就会遇到 UB 代码。。想来讨论讨论,弄弄清楚。

比如,这个快速求平方根的代码,居然是 UB 的。。

float Q_rsqrt( float number ) {
  long i;
  float x2, y;
  const float threehalfs = 1.5F;

  x2 = number * 0.5F;
  y  = number;
  i  = * ( long * ) &y;                       // evil floating point bit level hacking
  i  = 0x5f3759df - ( i >> 1 );               // what the fuck?
  y  = * ( float * ) &i;
  y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
  y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

  return y;
}

个人理解

按我目前理解,一个指针经 restrict 修饰后,它(可能经过指针运算后)指向的对象不会有其它别名。

修改一个对象,会污染它所有相同/兼容/字符类型的别名,使得下一次使用它们时,需要重新读取。

疑惑

  1. const int * restrict p 有意义吗?

    cppreference - restrict 类型限定符(大意,个人理解)

    每次执行声明有 restrict 的指针 P的代码块时(如 int func (int * restrict P) {...},如果通过 P (直接或间接地)修改了某个对象,后续都必须通过 P 来读写该对象,否则行为未定义。

    由于只读的 p 无法被写入,所以 restrict 体现不出作用?

  2. 两个预计不会重叠的内存块,可以只指定一次 restrict 来达到目的吗?

    比如,memcpy 的原型:

    void* memcpy( void *restrict dest, const void *restrict src, size_t count )
    

    可以去掉 srcrestrict,只保留 dest 的吗?若如此,似乎也能表达出:

    dest 的内存块是独占的,src 自然不会与 dest 有重叠

  3. restrict 指针 realloc 时,需要有什么特殊处理吗?

回复列表(80|显示机器人聊天)
  • @Ta / 2023-01-26 / /

    先 @ 万能的 @老虎会游泳

  • @Ta / 2023-01-27 / /

    @无名啊volatilerestrict是编译器优化指示标记,其中volatile阻止对该标识符进行优化,restrict建议编译器对该标识符进行优化。

    volatile的语义:小心,这个变量的用途很复杂,优化这个变量很可能会导致程序出问题!

    restrict的语义:我保证我只通过这个变量访问它指向的内存区域,你随便优化它,绝对不会出问题!

    这些都只是给编译器的提示,编译器不一定会遵循指示。比如,使用-O0编译时,加不加volatilerestrict参数都没有任何区别。只有-O1-O2-O3等有区别。

    对于VC++编译器,Debug模式应该体现不出区别,只有Release模式才有区别。

    const与它们不一样,它不仅是编译器优化指示标记,还进行了语法上的限制。如果不通过强制类型转换去除const标记,则无法对变量进行写入。

    不过,因为const也是编译器优化指示标记,它的语义是:我保证不会对该变量进行写入,你放心优化。所以如果后续通过强制类型转换去掉const并写入变量,则Release版程序可能会出问题。注意只是可能,编译器会尽量给出不出问题的代码,所以真想遇到问题也需要碰运气。

  • @Ta / 2023-01-27 / /

    @无名啊,此外,Q_rsqrt()函数中没有未定义行为,IEEE 754 标准已经精确的定义了单精度浮点数(float)的二进制表示,所以把它的二进制表示做为long使用不是未定义行为,结果应该是很明确的:符号位依然是符号位,指数和尾数则被拼接在一起做为整数的值。

    反向操作(把整数的二进制表示做为单精度浮点数使用)结果也很明确:符号位依然是符号位,然后接下来8位成为指数,最后23位成为尾数。

    所以,这只是一个“用户定义浮点数算法”,它与GMP等其他用户定义数学库中的自定义浮点数算法没有本质区别。代码中的每次类型转换在C中都有明确的定义。在所有使用IEEE754单精度浮点数的计算机中,结果都应该是一致的。

  • @Ta / 2023-01-27 / /

    一个指针经 restrict 修饰后,它(可能经过指针运算后)指向的对象不会不能有其它别名。

    并非不会,而是不能

    不会意味着编译器会阻止你为它创建别名,创建别名会导致编译错误。

    但实际上只是不能,创建别名最多产生警告,程序还是能运行,而且还可能完全无错(因为编译器优化后程序出问题只是概率事件)。

    所以,restrict体现的是你的自信,你得首先保证你的代码没有对该变量创建别名,然后才能给它加上restrict

    就像volatile,是你不自信,觉得优化这个变量会出问题,才给它加上volatile。至于不加会不会出问题,得具体问题具体分析。

  • @Ta / 2023-01-27 / /

    其实无论是const,还是volatilerestrict,都是为了解决内存空间的所有权问题。

    因为C/C++可以操作原始指针,所以内存空间的所有权可以在多个线程、函数、变量之间以任意方式共享和转移,导致编译器优化很容易出问题,所以才需要这些标记加以指示。

    其他编程语言不能直接操作原始指针,所以内存空间的所有权是明确的,不需要这些编译器优化限定符。

    当然const也有语法上的含义,表明你希望编译器帮你阻止对该变量的修改,所以其他编程语言里也存在该关键字。但是volatilerestrict在语法上没有任何含义,所以在内存空间所有权明确的编程语言中完全不存在。不能对原始指针解引用的语言都是所有权明确的,带GC的语言通常属于此类。

    所谓原始指针解引用,就是类似这样的代码:

    y  = * ( float * ) &i;
    

    它在语法上提供了无限的灵活性,实际上可以用于读写任意内存地址:

    int main() {
        long i = 1;
        float y = -1;
        const int x = 12306;
    
        // 以下代码没有语法错误,可以编译通过。
    
        // 读取原始指针
        y  = * ( float * ) (&i + 10086);
        y  = * ( float * ) 10086;
    
        // 写入原始指针
        * ( float * ) (&i + 10086) = y;
        * ( float * ) 10086 = y;
    
        // 写入 const 变量
        * (int *) &x = 10010;
    
        return 0;
    }
    

    因为这种灵活性,所以在C/C++中跟踪内存空间所有权变得不可能,于是需要对所有权进行人工标记。而constvolatilerestrict正是这样的标记。

    const:我保证不写入这块内存空间。如果我通过原始指针解引用实现了写入,结果是未定义的。
    restrict:我保证不把内存空间的所有权转移给其他变量(也就是创建别名)。如果我确实转移了,结果是未定义的。
    volatile:我对该内存空间的使用不进行任何保证,请不要假设它可以被优化。至于到底能阻止哪些优化,由实现定义。

    需要说明的是:volatile不是线程同步措施,它不能提供多核CPU间的内存一致性。想实现多线程内存一致性必须使用同步原语(比如互斥锁 mutex)。

  • @Ta / 2023-01-27 / /

    @无名啊,这是这个函数的PHP版本,有助于理解为什么没有未定义行为:

    <?php
    function Q_rsqrt(float $number) {
        $threehalfs = 1.5;
        $x2 = $number * 0.5;
        $y = $number;
    
        $i = unpack("l", pack("f", $y))[1];
        $i = 0x5f3759df - ($i >> 1);
        $y = unpack("f", pack("l", $i))[1];
        $y = $y * ( $threehalfs - ($x2 * $y * $y) );
        $y = $y * ( $threehalfs - ($x2 * $y * $y) );
    
        return $y;
    }
    
    printf("%0.7f\n", Q_rsqrt(3.14));
    printf("%0.7f\n", Q_rsqrt(1024.0));
    printf("%0.7f\n", Q_rsqrt(10086.0));
    printf("%0.7f\n", Q_rsqrt(2147483647.0));
    
    printf("%0.14f\n", Q_rsqrt(3.14));
    printf("%0.14f\n", Q_rsqrt(1024.0));
    printf("%0.14f\n", Q_rsqrt(10086.0));
    printf("%0.14f\n", Q_rsqrt(2147483647.0));
    

    在给定的定义域和有效数字范围内,它和C版本的结果一致。如果继续增加输出的位数,结果就开始不一致了,因为PHP在内部使用64位整数和双精度浮点数,而非C代码的32位整数和单精度浮点数,只在packunpack时才转换为32位单精度,所以两者会有精度差异。

    此外32位和64位在处理符号位上可能也有差异,所以C版给出负数解的情况下PHP给出的是正数解。当然两者都是正确的解,因为负数的平方也是正数。

    Screenshot_20230127_144400.jpg(159.56 KB)

    C版本:

    #include <stdio.h>
    
    float Q_rsqrt( float number ) {
      long i;
      float x2, y;
      const float threehalfs = 1.5F;
    
      x2 = number * 0.5F;
      y  = number;
      i  = * ( long * ) &y;                       // evil floating point bit level hacking
      i  = 0x5f3759df - ( i >> 1 );               // what the fuck?
      y  = * ( float * ) &i;
      y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
      y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed
    
      return y;
    }
    
    int main() {
      printf("%0.7f\n", Q_rsqrt(3.14));
      printf("%0.7f\n", Q_rsqrt(1024.0));
      printf("%0.7f\n", Q_rsqrt(10086.0));
      printf("%0.7f\n", Q_rsqrt(2147483647.0));
    
      printf("%0.14f\n", Q_rsqrt(3.14));
      printf("%0.14f\n", Q_rsqrt(1024.0));
      printf("%0.14f\n", Q_rsqrt(10086.0));
      printf("%0.14f\n", Q_rsqrt(2147483647.0));
    
      return 0;
    }
    
  • @Ta / 2023-01-27 / /

    至于 i = 0x5f3759df - ( i >> 1 ) 到底意味着什么,其实也可以有纯数学的解释。

    0x5f3759dfi 其实都是浮点数,但是使用整数规则进行了运算,这些运算同时操作了浮点数的指数和尾数部分。

    比如 i >> 1 也就是把指数和尾数同时向后挪动一位,两者的最后一位都被抛弃,然后指数的最后一位变成尾数的第一位。

    0x5f3759df - $x 也就是把指数和尾数同时减小,并且尾数减到小于0时向指数借位。

    这些操作都可以写成数学公式,从而让运算具有数学上的解析表达——也就是说,运算结果是确定的,没有未定义行为。

  • @Ta / 2023-01-27 / /

    @老虎会游泳,回复好多啊,我刚看到第一条:

    此外,Q_rsqrt()函数中没有未定义行为

    未定义行为是:* ( long * ) &y

    cppreference - 严格别名 说:

    某左值表达式,是某个对象的[cvr修饰][有/无符号]兼容类型/含有第一项的结构体或联合体/字符类型,才能赋值访问,否则为未定义行为。

    long 不是 float 的兼容类型,也不是字符类型,所以是未定义行为。

    严重时,会产生结果错误/性能低下等后果(见 知乎 - 严格别名(Strict Aliasing)规则是什么? - 严格别名(strict aliasing)为什么讨厌 中的三个例子)

  • @Ta / 2023-01-27 / /

    @无名啊i = * ( long * ) &y不含未定义行为,因为long i,所以* ( long * )long显然是它的兼容类型。当赋值发生时,类型已经是long了。而把一个float指针转换为long指针显然也不是未定义行为,因为实际上只是绕过了编译器的类型检查,对于代码生成来说相当于什么也没有发生,指针的值没有任何变化。

  • @Ta / 2023-01-27 / /

    @无名啊,把这段代码拆分成多个部分,应该有助于理解为什么没有未定义行为:

    long i;  long *p_i;
    float y; float *p_y;
    
    p_y = &y; // 只是一个简单的取地址操作,不是未定义行为
    p_i = (long *) p_y; // 对指针进行类型转换不是未定义行为,所有指针类型都是互相兼容的
    i = *p_i; // i 和 *p_i 类型一致,没有未定义行为
    

    操作的每一步都不含未定义行为,所以整体不含未定义行为。

  • @Ta / 2023-01-27 / /

    @老虎会游泳,我比较怕的是未定义行为导致的结果错误,所以想弄清楚别名规则。

    看到知乎那篇文章中的第三个例子,我又觉得 restrict 有助于减少性能损耗(修改 char * 导致编译器认为 this 可能被修改,进而没法重复利用缓存好的 this),所以顺便想弄清楚 restrict

  • @Ta / 2023-01-27 / /

    @无名啊,我已经对上述问题进行了回答。

  • @Ta / 2023-01-27 / /

    @老虎会游泳,你看下 cppreference - 指针 - 注解 说的:

    尽管任何指向对象的指针能被转型成指向其他类型对象的指针,解引用指向类型异于对象声明类型的指针几乎总是未定义行为。细节见严格别名使用。

  • @Ta / 2023-01-27 / /

    需要注意的是,错误行为不是未定义行为

    char c;
    long i;
    
    // 这个行为非常不恰当,会导致紧接着`c`后面的3个字节被访问,这3个字节不属于`c`。
    // 但它只是错误行为,不是未定义行为。
    // 这个行为会发生什么具有明确的定义,就是`c`所指向的内存地址及其后方3个字节一同被赋值给`i`,在所有平台上都会发生同样的事情。
    // 所以,这里不含未定义行为,只含编程错误。
    i = * ( long * ) &c;
    
  • @Ta / 2023-01-27 / /

    @老虎会游泳,如果按 cppreference 所说,应该是未定义行为

    转换指针类型没问题,只要不访问就行。(但不访问,转了也没用。可认为不能转)

    比如:

    float a = 1.0;
    long * b = (long *)&a;
    
    *b = 1;
    return a;
    

    按照标准,编译器可认为,a 未被修改(因为 *b 不是 a 的兼容类型,所以修改 *b 不应该污染 a),所以优化掉 b,直接返回 1.0。。。

  • @Ta / 2023-01-27 / /

    @无名啊,我还是要说,错误行为不是未定义行为。

    解引用指向float值的long指针具有明确的定义,因为float的内存表示在IEEE754定义,long的内存表示在C中定义。在特定的实现中,两者的长度可能相同,也可能不同,但当两者长度不同时,错误一定会以规定好的方式发生:float及其后不属于它的4字节会被访问。这只是编程错误,不是未定义行为。

    watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1bkNoZXJyeURyZWFt,size_16,color_FFFFFF,t_70.jpg(11.22 KB)

  • @Ta / 2023-01-27 / /

    @老虎会游泳,按照标准,可能根本不会发生解引用指向float值的long指针,因为可能已经被优化掉了。。也就没有你后面说的浮点定义如何如何……

  • @Ta / 2023-01-27 / /

    @无名啊,这里没有未定义行为,因为取地址操作会阻止优化。因为&a,所以a必须在内存,不能优化到寄存器。所以该代码没有未定义行为,但存在出现编程错误的风险(如果float和long长度不同)。

    float a = 1.0;
    long * b = (long *)&a;
    
    *b = 1;
    return a;
    
  • @Ta / 2023-01-27 / /

    @老虎会游泳,你看下知乎上的 一个回答

添加新回复
回复需要登录