主页 / user-7204912

ChrisB's questions

Martin Hope
ChrisB
Asked: 2024-04-23 23:59:49 +0800 CST
  • 12

查看以下简单 C++ 函数的汇编输出：

#include <memory>
int square(std::unique_ptr<int> num) {
    return *num * *num;
}

Gcc 和 clang 发出以下程序集 ( -O2)：

square(std::unique_ptr<int, std::default_delete<int> >):
        mov     rax, QWORD PTR [rdi]
        mov     eax, DWORD PTR [rax]
        imul    eax, eax
        ret

这对我来说非常出乎意料：析构函数在哪里被调用？

另一方面，MSVC 执行了我所期望的操作，并调用析构函数。

这是 Godbolt 重现：https://godbolt.org/z/e66xh9Yos

我还尝试使用更大的类型来int查看是否是一些小尺寸优化，但情况似乎并非如此。

有人能解释一下这是怎么回事吗？

c++
Martin Hope
ChrisB
Asked: 2024-04-11 19:42:46 +0800 CST
  • 4

我知道 Rust 结构中的字段会自动重新排序以节省内存（除非#[repr(C)]指定了eg）。

我假设枚举也是如此。今天我正在创建一个简单的辅助类型（示例的语义并不重要，这是关于内存布局的）：

pub enum LazyRwLockGuardVersionA<'a, T> {
    Unlocked(&'a RwLock<T>),
    Read {
        lock: &'a RwLock<T>, // still neccessary for promoting to write lock
        guard: RwLockReadGuard<'a, T>,
    },
    Write(RwLockWriteGuard<'a, T>),
}

原始读/写防护使用16 个字节，而此类型使用32 个字节。为了让编译器使用利基优化，我尝试了这个版本：

pub enum LazyRwLockWriteGuard<'a, T> {
    Unlocked(&'a RwLock<T>),
    Write(RwLockWriteGuard<'a, T>),
}

pub enum LazyRwLockGuardVersionB<'a, T> {
    Read {
        guard: RwLockReadGuard<'a, T>,
        lock: &'a RwLock<T>,
    },    
    NonRead(LazyRwLockWriteGuard<'a, T>),
}

这成功地将内存使用量降低到24字节。

但是，我注意到一些奇怪的事情：当反转变体中的字段顺序时Read：

pub enum LazyRwLockGuardVersionC<'a, T> {
    Read {
        lock: &'a RwLock<T>, // order of fields reversed
        guard: RwLockReadGuard<'a, T>,
    },
    NonRead(LazyRwLockWriteGuard<'a, T>),
}

这个类型突然又使用了32字节。

我的 Rust 版本是 1.77，这里是 godbolt 重现：https://godbolt.org/z/svE5v6Tr8

  • 规范不允许枚举字段重新排序，还是编译器在这里只是“懒惰”？
  • 对于编译器当前用于布局枚举的算法是否有一个粗略的直觉，以便我可以理解这个结果，并防止将来我的代码意外悲观？
rust
Martin Hope
ChrisB
Asked: 2024-02-04 19:32:07 +0800 CST
  • 6

我有一个带有凸面分解碰撞器的网格，使用bevy_rapier3d.

我怎样才能算出剑杆为该对撞机计算的质量？

我的代码看起来像这样：

fn asset_loaded(
    mut commands: Commands, 
    my_object: Query<(Entity, &Handle<Mesh>), With<MyObjectMarker>>,
    meshes: Res<Assets<Mesh>>,
    asset_server: Res<AssetServer>,
    loaded: Local<bool>,
){
     if *loaded{
         return;
     }
     let (my_entity, my_mesh) = my_object.single();
     if asset_server.load_state(my_mesh) != LoadState::Loaded {
         return;
     }
     let collider = Collider::from_bevy_mesh(
         meshes.get(my_mesh).unwrap(),
         &ComputedColliderShape::ConvexDecomposition(VHACDParameters::default()),
     ).unwrap();

     // ??: how can i get the computed mass of the object here? 

     commands.get_entity(my_entity).unwrap().insert(collider);
     *loaded = true;
}
rust
Martin Hope
ChrisB
Asked: 2024-01-25 07:20:33 +0800 CST
  • 6

rustnomicon包含以下示例：

#[no_mangle]
extern "C" fn assert_nonzero(input: u32) {
    assert!(input != 0)
}

如果assert_nonzero使用参数 调用0，则运行时保证（安全）中止进程，无论是否使用panic=abort.

另一方面，Rust Reference声称：

行为被视为未定义：[...] 使用错误的调用 ABI 调用函数或从具有错误的展开 ABI 的函数展开。

这两种说法对我来说似乎是矛盾的。assert_nonzero拥有CABI，但摆脱了 Rust 恐慌。那么这是否保证（安全）中止或UB？不可能两者兼而有之。

Chayim Friedman 在另一个问题上善意地表示这确实是 UB。

那么 Rustnomicon 是否已经过时了，或者我是否误解了什么？

更一般地说：跨越 FFI 边界的 Rust 恐慌何时被视为未定义行为？

rust
Martin Hope
ChrisB
Asked: 2023-12-02 22:08:41 +0800 CST
  • 10

Rust 中的结构体std::cell::Ref定义如下：

pub struct Ref<'b, T: ?Sized + 'b> {
    // NB: we use a pointer instead of `&'b T` to avoid `noalias` violations, because a
    // `Ref` argument doesn't hold immutability for its whole scope, only until it drops.
    // `NonNull` is also covariant over `T`, just like we would have with `&T`.
    value: NonNull<T>,
    borrow: BorrowRef<'b>,
}

评论// NB（我假设 Nota bene / Nasty Bug 或其他什么？）暗示以下定义不起作用，因为这会违反noalias（它们是否意味着后端的 LLVM 属性？）：

pub struct Ref2<'b, T: ?Sized + 'b> {
    value: &'b T,
    borrow: BorrowRef<'b>,
}

我不明白这一点，因为我的印象是非词汇生命周期语义在代码生成中得到了正确的保留。否则下面的简单示例（当然可以编译）也是非法的，对吗？：

struct Foo<'a> {
    v: &'a i32,
}
fn foo(x: &mut i32) {
    let f = Foo { v: x };
    *x = 5; // value modified while the `noalias` f.v pointer is still in scope
}

对内部结构有更多了解的人可以为我阐明这一点吗？我担心我在这里误解了一些关键的东西，导致我自己的不安全代码出现潜在问题。

rust