memscope-rs 0.2.4

A memory tracking library for Rust applications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

// Test reallocation warning logs
use memscope_rs::event_store::{EventStore, MemoryEvent, MemoryEventType};
use memscope_rs::snapshot::engine::SnapshotEngine;
use std::sync::Arc;

#[test]
fn test_reallocation_without_old_size_logs_warning() {
    let event_store = EventStore::new();

    // Create a reallocation event without old_size or previous allocation
    let ptr = 0x1000;
    event_store.record(MemoryEvent {
        timestamp: 1,
        event_type: MemoryEventType::Reallocate,
        ptr,
        size: 2000,
        old_size: None,
        thread_id: 1,
        var_name: None,
        type_name: None,
        call_stack_hash: None,
        thread_name: None,
        source_file: None,
        source_line: None,
        module_path: None,
        clone_source_ptr: None,
        clone_target_ptr: None,
        stack_ptr: None,
        task_id: None,
    });

    let engine = SnapshotEngine::new(Arc::new(event_store));
    let snapshot = engine.build_snapshot();

    // The snapshot should still be created, but a warning should have been logged
    assert_eq!(snapshot.stats.total_reallocations, 1);
    assert_eq!(snapshot.stats.total_deallocated, 0); // Should be 0, no phantom deallocation
    assert_eq!(snapshot.stats.current_memory, 2000);
}

#[test]
fn test_reallocation_with_old_size() {
    let event_store = EventStore::new();

    // Create a reallocation event with old_size
    let ptr = 0x1000;
    event_store.record(MemoryEvent {
        timestamp: 1,
        event_type: MemoryEventType::Reallocate,
        ptr,
        size: 2000,
        old_size: Some(1000),
        thread_id: 1,
        var_name: None,
        type_name: None,
        call_stack_hash: None,
        thread_name: None,
        source_file: None,
        source_line: None,
        module_path: None,
        clone_source_ptr: None,
        clone_target_ptr: None,
        stack_ptr: None,
        task_id: None,
    });

    let engine = SnapshotEngine::new(Arc::new(event_store));
    let snapshot = engine.build_snapshot();

    assert_eq!(snapshot.stats.total_reallocations, 1);
    assert_eq!(snapshot.stats.total_deallocated, 1000);
    assert_eq!(snapshot.stats.current_memory, 2000);
}

#[test]
fn test_reallocation_with_previous_allocation() {
    let event_store = EventStore::new();

    let ptr = 0x1000;

    // First allocation
    event_store.record(MemoryEvent {
        timestamp: 1,
        event_type: MemoryEventType::Allocate,
        ptr,
        size: 1000,
        old_size: None,
        thread_id: 1,
        var_name: None,
        type_name: None,
        call_stack_hash: None,
        thread_name: None,
        source_file: None,
        source_line: None,
        module_path: None,
        clone_source_ptr: None,
        clone_target_ptr: None,
        stack_ptr: None,
        task_id: None,
    });

    // Reallocation without old_size but with previous allocation
    event_store.record(MemoryEvent {
        timestamp: 2,
        event_type: MemoryEventType::Reallocate,
        ptr,
        size: 2000,
        old_size: None,
        thread_id: 1,
        var_name: None,
        type_name: None,
        call_stack_hash: None,
        thread_name: None,
        source_file: None,
        source_line: None,
        module_path: None,
        clone_source_ptr: None,
        clone_target_ptr: None,
        stack_ptr: None,
        task_id: None,
    });

    let engine = SnapshotEngine::new(Arc::new(event_store));
    let snapshot = engine.build_snapshot();

    assert_eq!(snapshot.stats.total_allocations, 1);
    assert_eq!(snapshot.stats.total_reallocations, 1);
    assert_eq!(snapshot.stats.total_deallocated, 1000); // Should use previous allocation size
    assert_eq!(snapshot.stats.current_memory, 2000);
}