为什么Valgrind不会为Rust程序显示任何分配?

问题描述

限时删除！！

我正在学习Rust，并且正在玩Box，所以我尝试使用valgrind检查泄漏，但是它表明堆上没有分配空间:

 $ rustc -C opt-level=0 raii.rs
$ valgrind ./raii
==3850== Memcheck, a memory error detector
==3850== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==3850== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==3850== Command: ./raii
==3850==
5
Changed:10
==3850==
==3850== HEAP SUMMARY:
==3850==     in use at exit: 0 bytes in 0 blocks
==3850==   total heap usage: 0 allocs, 0 frees, 0 bytes allocated
==3850==
==3850== All heap blocks were freed -- no leaks are possible
==3850==
==3850== For counts of detected and suppressed errors, rerun with: -v
==3850== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
 

valgrind --leak-check=full ./raii显示相同的结果.

这是Rust代码:

fn main() {
    let mut _box2 = Box::new(5i32);

    println!("{}", _box2);
    *_box2 = 10i32;
    println!("Changed:{}", _box2);

    {
        let _box3 = Box::new(4i32);
    }
}

其他一些信息:

 $ rustc -V
rustc 1.8.0 (db2939409 2016-04-11)

$ valgrind --version
valgrind-3.10.1

$ uname -a
Linux 3.19.0-59-generic #65~14.04.1-Ubuntu SMP Tue Apr 19 18:57:09 UTC 2016 x86_64 x86_64 x86_64 GNU/Linux
 

那是为什么?我以为Box在堆上分配变量.另外，此示例显示几乎相同的代码，而Valgrind显示那里的分配.

如果我添加以下代码:

let _stack = (1u64, 2u64, 3u64);
let _heap = Box::new((4u64, 5u64, 6u64));
println!("Memory used by stack: {} bytes", std::mem::size_of_val(&_stack));
println!("Memory used by heap: {} bytes", std::mem::size_of_val(&_heap));

它完全打印出我期望的样子:

 $ ./raii
Memory used by stack: 24 bytes
Memory used by heap: 8 bytes
 

• 在第二种情况下，将元组放置在堆上，并将指针(8个字节)压入堆栈.
• 在第一种情况下，元组被放置在堆栈上，因此需要24个字节.

Valgrind似乎能够计算其他程序中的堆分配:

 $ valgrind echo "test"
==4575== Memcheck, a memory error detector
==4575== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==4575== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==4575== Command: echo test
==4575==
test
==4575==
==4575== HEAP SUMMARY:
==4575==     in use at exit: 0 bytes in 0 blocks
==4575==   total heap usage: 30 allocs, 30 frees, 3,681 bytes allocated
==4575==
==4575== All heap blocks were freed -- no leaks are possible
==4575==
==4575== For counts of detected and suppressed errors, rerun with: -v
==4575== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
 

解决方案

Rust 1.32

从Rust 1.32开始，可执行文件的默认分配器为现在是系统分配器，因此您无需默认设置任何内容.

以前的版本

在构建二进制文件时，Rust使用jemalloc作为分配器.当前编译jemalloc的方式不包含所需的Valgrind钩子. /p>

如果您需要使用Valgrind跟踪分配的功能，那么如果您使用每晚的Rust，则可以切换到系统分配器.

另请参阅:

• 为什么Valgrind使用每晚1.29.0无法在Rust程序中检测到内存泄漏?

I'm learning Rust and I was playing with Box, so I tried checking leaks with valgrind but it shows that there are no allocations on the heap:

$ rustc -C opt-level=0 raii.rs
$ valgrind ./raii
==3850== Memcheck, a memory error detector
==3850== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==3850== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==3850== Command: ./raii
==3850==
5
Changed:10
==3850==
==3850== HEAP SUMMARY:
==3850==     in use at exit: 0 bytes in 0 blocks
==3850==   total heap usage: 0 allocs, 0 frees, 0 bytes allocated
==3850==
==3850== All heap blocks were freed -- no leaks are possible
==3850==
==3850== For counts of detected and suppressed errors, rerun with: -v
==3850== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

valgrind --leak-check=full ./raii shows exaclty the same result.

Here's the Rust code:

fn main() {
    let mut _box2 = Box::new(5i32);

    println!("{}", _box2);
    *_box2 = 10i32;
    println!("Changed:{}", _box2);

    {
        let _box3 = Box::new(4i32);
    }
}

Some other info:

$ rustc -V
rustc 1.8.0 (db2939409 2016-04-11)

$ valgrind --version
valgrind-3.10.1

$ uname -a
Linux 3.19.0-59-generic #65~14.04.1-Ubuntu SMP Tue Apr 19 18:57:09 UTC 2016 x86_64 x86_64 x86_64 GNU/Linux

Why is that? I thought Box allocates the variable on the heap. Also, this example shows almost the same code and Valgrind shows allocations there.

If I add the following code:

let _stack = (1u64, 2u64, 3u64);
let _heap = Box::new((4u64, 5u64, 6u64));
println!("Memory used by stack: {} bytes", std::mem::size_of_val(&_stack));
println!("Memory used by heap: {} bytes", std::mem::size_of_val(&_heap));

It prints exactly what I expected:

$ ./raii
Memory used by stack: 24 bytes
Memory used by heap: 8 bytes

• In the second case, the tuple was placed on the heap and a pointer (8 bytes) was pushed to the stack.
• In the first case tuple was placed on the stack, so it takes 24 bytes.

Valgrind seems to be able to count heap allocations from other programs:

$ valgrind echo "test"
==4575== Memcheck, a memory error detector
==4575== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==4575== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==4575== Command: echo test
==4575==
test
==4575==
==4575== HEAP SUMMARY:
==4575==     in use at exit: 0 bytes in 0 blocks
==4575==   total heap usage: 30 allocs, 30 frees, 3,681 bytes allocated
==4575==
==4575== All heap blocks were freed -- no leaks are possible
==4575==
==4575== For counts of detected and suppressed errors, rerun with: -v
==4575== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

解决方案

Rust 1.32

As of Rust 1.32, the default allocator for an executable is now the system allocator, so you don't need to set anything by default.

Previous versions

Rust uses jemalloc as the allocator when you build a binary. The way that jemalloc is currently compiled does not contain the Valgrind hooks needed.

If you need the ability to track allocations with Valgrind, you can switch to the the system allocator if you are using nightly Rust.

See also:

• Why does Valgrind not detect a memory leak in a Rust program using nightly 1.29.0?

这篇关于为什么Valgrind不会为Rust程序显示任何分配?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！

1403页，肝出来的..