Rust内存分析与调试工具rstack-self的使用，高效检测堆栈信息和内存泄漏

安装

在项目目录中运行以下Cargo命令：

cargo add rstack-self

或在Cargo.toml中添加以下行：

rstack-self = "0.3.0"

基本使用

rstack-self是一个用于分析Rust程序堆栈信息和检测内存泄漏的工具。它提供了一种简单的方式来获取当前线程的堆栈跟踪信息。

获取堆栈信息示例

use rstack_self::trace;

fn main() {
    // 获取当前线程的堆栈跟踪
    let trace = trace().unwrap();
    
    // 打印堆栈帧
    for frame in trace.frames() {
        println!("{:?}", frame);
    }
}

检测内存泄漏示例

use std::mem::ManuallyDrop;
use rstack_self::MemoryUsage;

fn main() {
    // 创建一个故意泄漏的内存
    let leaked = ManuallyDrop::new(vec![0u8; 1024]);
    
    // 获取当前内存使用情况
    let usage = MemoryUsage::current().unwrap();
    
    println!("Allocated memory: {} bytes", usage.allocated);
    println!("Leaked memory: {} bytes", usage.leaked);
}

高级功能

跨线程堆栈跟踪

use std::thread;
use rstack_self::{Thread, trace_thread};

fn main() {
    let handle = thread::spawn(|| {
        // 子线程中的一些工作
        thread::sleep(std::time::Duration::from_secs(1));
    });
    
    // 获取子线程的堆栈跟踪
    let trace = trace_thread(handle.thread().id()).unwrap();
    
    for frame in trace.frames() {
        println!("{:?}", frame);
    }
    
    handle.join().unwrap();
}

内存泄漏检测集成测试

#[cfg(test)]
mod tests {
    use super::*;
    use rstack_self::MemoryLeakTest;

    #[test]
    fn test_no_memory_leak() {
        MemoryLeakTest::default()
            .run(|| {
                // 测试代码
                let _v = vec![0u8; 1024];
            })
            .assert_no_leaks();
    }
}

完整示例demo

下面是一个结合了rstack-self主要功能的完整示例：

use std::{mem::ManuallyDrop, thread, time::Duration};
use rstack_self::{trace, trace_thread, MemoryUsage, MemoryLeakTest};

fn recursive_function(depth: usize) {
    if depth > 0 {
        recursive_function(depth - 1);
    } else {
        // 获取并打印当前堆栈
        let trace = trace().unwrap();
        println!("Current stack trace:");
        for frame in trace.frames() {
            println!("  {:?}", frame);
        }
    }
}

fn main() {
    // 1. 演示堆栈跟踪
    println!("=== Stack Trace Demo ===");
    recursive_function(3);

    // 2. 演示内存泄漏检测
    println!("\n=== Memory Leak Detection ===");
    let leaked = ManuallyDrop::new(vec![0u8; 2048]); // 故意泄漏2KB内存
    
    let usage = MemoryUsage::current().unwrap();
    println!("Current memory usage:");
    println!("  Allocated: {} bytes", usage.allocated);
    println!("  Leaked:    {} bytes", usage.leaked);

    // 3. 演示跨线程堆栈跟踪
    println!("\n=== Cross-Thread Stack Trace ===");
    let handle = thread::spawn(|| {
        thread::sleep(Duration::from_millis(500));
        recursive_function(2);
    });
    
    println!("Child thread stack trace:");
    let child_trace = trace_thread(handle.thread().id()).unwrap();
    for frame in child_trace.frames() {
        println!("  {:?}", frame);
    }
    
    handle.join().unwrap();
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_memory_leak_detection() {
        MemoryLeakTest::default()
            .run(|| {
                // 正常分配但不泄漏的内存
                let _non_leaked = vec![0u8; 1024];
                
                // 故意泄漏的内存
                let _leaked = ManuallyDrop::new(vec![0u8; 512]);
            })
            .assert_no_leaks(); // 这个测试会失败，因为我们确实泄漏了内存
    }
}

许可证

rstack-self采用MIT或Apache-2.0双重许可。