Valgrind zeigt keine Zuweisungen

Question

Ich lerne Rust und ich spielte mit Box, also versuchte ich Lecks mit valgrind prüft, aber es zeigt, dass es keine Zuweisungen auf dem 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 zeigt exaclty die gleiche Ergebnis.

Hier ist der Rust-Code:

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

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

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

Einige andere 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 

Warum ist das so? Ich dachte, Box weist die Variable auf dem Heap zu. Auch this example zeigt fast den gleichen Code und Valgrind zeigt Zuordnungen dort.

Wenn ich folgenden Code hinzu:

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)); 

Er druckt genau das, was zu erwarten:

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

- in zweiten Fall Tupel wurde auf Heap und Zeiger (8 Byte) wurde auf den Stapel geschoben platziert , während im ersten Fall das Tupel auf den Stack gelegt wurde, benötigt es 24 Bytes.

Valgrind scheint Heapzuweisungen der Lage zu sein, auf andere Programme zu zählen:

$ 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) 

Answer 1

Rust verwendet jemalloc als allocator, wenn Sie eine binäre bauen. Die Art und Weise, wie jemalloc derzeit kompiliert wird does not contain the valgrind hooks needed.

Wenn Sie die Möglichkeit benötigen Zuweisungen mit valgrind zu verfolgen, können Sie switch to the the system allocator, wenn Sie mit nächtlichen Rust:

#![feature(alloc_system)] 
extern crate alloc_system;