memscope-rs 0.2.3

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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

//! Capture types module.
//!
//! This module contains all type definitions for the capture engine,
//! organized into logical submodules for better maintainability.
//!
//! # Organization
//!
//! Types are organized by their functional area:
//! - `allocation`: Memory allocation tracking types
//! - `smart_pointer`: Smart pointer tracking (Rc, Arc, Box)
//! - `error`: Error types for tracking operations
//! - `stats`: Memory statistics and analysis
//! - `scope`: Scope tracking and lifecycle
//! - `memory_layout`: Memory layout analysis
//! - `generic`: Generic type tracking
//! - `dynamic_type`: Dynamic type (trait object) tracking
//! - `runtime_state`: Runtime state information
//! - `fragmentation`: Memory fragmentation analysis
//! - `ownership`: Ownership hierarchy tracking
//! - `drop_chain`: Drop chain analysis
//! - `leak_detection`: Memory leak detection
//! - `timeline`: Timeline visualization types
//! - `access_tracking`: Memory access pattern tracking
//! - `stack`: Stack allocation tracking
//! - `temporary`: Temporary object tracking
//! - `tracking`: Function call tracking

pub mod access_tracking;
pub mod allocation;
pub mod drop_chain;
pub mod dynamic_type;
pub mod error;
pub mod fragmentation;
pub mod generic;
pub mod leak_detection;
pub mod lifecycle;
pub mod memory_layout;
pub mod ownership;
pub mod runtime_state;
pub mod scope;
pub mod smart_pointer;
pub mod stack;
pub mod stats;
pub mod temporary;
pub mod timeline;
pub mod tracking;

// Re-export common types for convenience
pub use access_tracking::{
    AccessPattern, AccessPatternType, AddressRange, BandwidthBottleneck,
    BandwidthBottleneckLocation, BandwidthUtilization, CacheAccessInfo, CacheLatencyBreakdown,
    ImplementationDifficulty, LocalityMetrics, MemoryAccessEvent, MemoryAccessPerformanceImpact,
    MemoryAccessStatistics, MemoryAccessTrackingInfo, MemoryAccessType,
    MemoryOptimizationRecommendation, MemoryOptimizationType, StridePattern,
};
pub use allocation::{
    AllocationInfo, BorrowInfo, BottleneckType, CloneInfo, ContextPerformanceMetrics, ContextType,
    HotPath, ImpactLevel, ImplementationDifficulty as AllocImplDifficulty,
    OptimizationRecommendation, PerformanceBottleneck, PerformanceSnapshot, Priority,
    RecommendationType, TypePerformanceImpact, TypeUsageInfo, UsageContext, UsageTimePoint,
};
pub use drop_chain::{
    CleanupAction, CleanupActionType, DropBottleneckType, DropChainAnalysis, DropChainNode,
    DropChainPerformanceMetrics, DropImplementationType, DropPerformanceBottleneck,
    DropPerformanceCharacteristics,
};
pub use dynamic_type::{
    DispatchOverhead, DynamicTypeInfo, PerformanceImpact, TypeErasureInfo, VTableInfo, VTableMethod,
};
pub use error::{TrackingError, TrackingResult};
pub use fragmentation::{
    BlockSizeRange, EnhancedFragmentationAnalysis, FragmentationCause, FragmentationCauseType,
    FragmentationMetrics, FragmentationSeverity,
};
pub use generic::{
    BranchPredictionImpact, CacheImpact, CodeBloatLevel, CompilationImpact, ConcreteTypeParameter,
    ConstraintType, GenericConstraint, GenericInstantiationInfo, GenericTypeInfo, MemoryImpact,
    MonomorphizationInfo, OptimizationDifficulty, PerformanceCharacteristics, SourceLocation,
    TypeCategory, TypeParameter,
};
pub use leak_detection::{
    EnhancedPotentialLeak, LeakEvidence, LeakEvidenceType, LeakImpact,
    LeakPreventionRecommendation, LeakPreventionType, LeakRiskLevel, LeakType,
    ResourceLeakAnalysis, ResourcePatternType, ResourceUsagePattern,
};
pub use lifecycle::{
    BorrowState, EventPerformanceMetrics, LifecycleEfficiencyMetrics, LifecycleEvent,
    LifecycleEventType, LifecyclePattern, LifecyclePatternType, LifecycleStageDurations,
    MemoryLocationType, MemoryState, ObjectLifecycleInfo, ResourceWasteAssessment,
    SimpleLifecyclePattern,
};
pub use memory_layout::{
    AccessEfficiency, CapacityUtilization, ContainerAnalysis, ContainerEfficiencyMetrics,
    ContainerType, FieldLayoutInfo, GrowthPattern, LayoutEfficiency, MemoryLayoutInfo,
    OptimizationPotential, PaddingAnalysis, PaddingLocation, PaddingReason, ReallocationFrequency,
    ReallocationPatterns, UtilizationEfficiency,
};
pub use ownership::{
    ChildTypeInfo, CircularReferenceInfo, CircularReferenceType, ComposedTypeInfo, CompositionType,
    OwnershipHierarchy, OwnershipNode, OwnershipTransferEvent, OwnershipTransferType,
    OwnershipType, ParentTypeInfo, RelationshipType, TypeRelationshipInfo, WeakReferenceInfo,
    WeakReferenceType,
};
pub use runtime_state::{
    AllocatorStateInfo, CachePerformanceInfo, CpuUsageInfo, GcInfo, MemoryAccessPattern,
    MemoryPressureInfo, MemoryPressureLevel, RuntimeStateInfo,
};
pub use scope::{
    AllocationEventType, BorrowEvent, GrowthEvent, GrowthReason, MoveEvent, PotentialLeak,
    RiskDistribution, ScopeAnalysis, ScopeEventType, ScopeHierarchy, ScopeInfo,
    ScopeLifecycleMetrics, TypeLifecyclePattern, VariableRelationship,
};
pub use smart_pointer::{RefCountSnapshot, SmartPointerInfo, SmartPointerType};
pub use stack::{ScopeType, StackAllocationInfo, StackScopeInfo};
pub use stats::{
    ConcurrencyAnalysis, FragmentationAnalysis as StatsFragmentationAnalysis, LibraryUsage,
    MemoryStats, MemoryTypeInfo, SystemLibraryStats, TypeMemoryUsage,
};
pub use temporary::{CreationContext, ExpressionType, TemporaryObjectInfo, TemporaryUsagePattern};
pub use timeline::{
    AllocationEvent, AllocationHotspot, AllocationPattern, HotspotLocation, MemorySnapshot,
    SafetyViolation, StackFrame, StackTraceData, StackTraceHotspot, TimeRange, TimelineData,
};
pub use tracking::{
    CallPattern, CallPatternType, CallSequence, CallStackInfo, ConcurrencyCharacteristics,
    DeadlockRisk, FunctionCallTrackingInfo, FunctionMemoryCharacteristics,
    FunctionPerformanceCharacteristics, IOCharacteristics, LeakPotential, MemoryUsagePattern,
    RecursionPerformanceImpact, RecursiveCallInfo, StackOverflowRisk, ThreadSafetyLevel,
};

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

    #[test]
    fn test_error_reexports() {
        let error = TrackingError::TrackingDisabled;
        assert!(matches!(error, TrackingError::TrackingDisabled));
    }

    #[test]
    fn test_allocation_info_creation() {
        let info = AllocationInfo::new(0x1000, 1024);
        assert_eq!(info.ptr, 0x1000);
        assert_eq!(info.size, 1024);
    }

    #[test]
    fn test_smart_pointer_info_creation() {
        let info = SmartPointerInfo::new_rc_arc(0x1000, SmartPointerType::Rc, 1, 0);
        assert_eq!(info.data_ptr, 0x1000);
        assert!(info.is_data_owner);
    }

    #[test]
    fn test_memory_stats_creation() {
        let stats = MemoryStats::new();
        assert_eq!(stats.total_allocations, 0);
    }
}