Rust中的精确内存布局控制？


Precise memory layout control in Rust?

据我所知，Rust编译器可以打包，重新排序以及向结构的每个字段添加填充。 如果需要，如何指定精确的内存布局？

在C＃中，我具有StructLayout属性，在C / C ++中，我可以使用各种编译器扩展。 我可以通过检查期望值位置的字节偏移量来验证内存布局。

我想使用自定义着色器编写OpenGL代码，这需要精确的内存布局。 有没有办法在不牺牲性能的情况下做到这一点？

如FFI指南中所述，您可以向结构添加属性以使用与C相同的布局：

1
2
3
4
5
#[repr(C)]
struct Object {
    a: i32,
    // other members
}

并且您还可以打包该结构：

1
2
3
4
5
#[repr(C, packed)]
struct Object {
    a: i32,
    // other members
}

为了检测内存布局是否正常，您可以初始化一个结构并通过将指针转换为整数来检查偏移量是否正常：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#[repr(C, packed)]
struct Object {
    a: u8,
    b: u16,
    c: u32, // other members
}

fn main() {
    let obj = Object {
        a: 0xaa,
        b: 0xbbbb,
        c: 0xcccccccc,
    };
    let a_ptr: *const u8 = &obj.a;
    let b_ptr: *const u16 = &obj.b;
    let c_ptr: *const u32 = &obj.c;

    let base = a_ptr as usize;

    println!("a: {}", a_ptr as usize - base);
    println!("b: {}", b_ptr as usize - base);
    println!("c: {}", c_ptr as usize - base);
}

输出：

1
2
3
a: 0
b: 1
c: 3

不再有to_uint。 在Rust 1.0中，代码可以是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#[repr(C, packed)]
struct Object {
    a: i8,
    b: i16,
    c: i32, // other members
}

fn main() {
    let obj = Object {
        a: 0x1a,
        b: 0x1bbb,
        c: 0x1ccccccc,
    };

    let base = &obj as *const _ as usize;
    let a_off = &obj.a as *const _ as usize - base;
    let b_off = &obj.b as *const _ as usize - base;
    let c_off = &obj.c as *const _ as usize - base;

    println!("a: {}", a_off);
    println!("b: {}", b_off);
    println!("c: {}", c_off);
}

您也可以像这样为"数据承载enum"设置内存布局。

1
2
3
4
5
6
7
#[repr(Int)]
enum MyEnum {
    A(u32),
    B(f32, u64),
    C { x: u32, y: u8 },
    D,
}

详细信息在手册和RFC2195中进行了描述。

  • https://rust-lang.github.io/unsafe-code-guidelines/layout/enums.html
  • https://rust-lang.github.io/rfcs/2195-really-tagged-unions.html#motivation