memscope_rs/
enhanced_types.rs

1//! Enhanced types for comprehensive memory analysis
2//!
3//! This module contains additional type definitions needed for the enhanced memory analysis system.
4//! These types support advanced memory tracking features including stack/heap distinction,
5//! temporary object optimization, fragmentation monitoring, generic type analysis,
6//! object lifecycle tracking, and memory access pattern analysis.
7
8use serde::{Deserialize, Serialize};
9use std::collections::HashMap;
10use std::time::Duration;
11// Import specific types rather than wildcard to avoid conflicts
12use crate::core::types::{
13    AccessPattern, AllocationInfo, CreationContext, FragmentationAnalysis,
14    LifecycleEfficiencyMetrics, LifecyclePattern, ObjectLifecycleInfo, OptimizationPotential,
15    OptimizationRecommendation, PerformanceCharacteristics, PerformanceImpact, ScopeType,
16    TemporaryUsagePattern,
17};
18
19///  Stack Frame and Boundary Types
20#[derive(Debug, Clone, Serialize, Deserialize)]
21pub struct EnhancedStackFrame {
22    /// Frame ID
23    pub frame_id: u64,
24    /// Function name
25    pub function_name: String,
26    /// Allocations in the frame
27    pub allocations: Vec<usize>,
28    /// Total allocated memory in the frame
29    pub total_allocated: usize,
30    /// Frame size
31    pub frame_size: usize,
32}
33
34/// Stack boundaries
35#[derive(Debug, Clone, Serialize, Deserialize)]
36pub struct StackBoundaries {
37    /// Stack base address
38    pub stack_base: usize,
39    /// Stack top address
40    pub stack_top: usize,
41    /// Stack size
42    pub stack_size: usize,
43}
44
45impl StackBoundaries {
46    /// Detect stack boundaries
47    pub fn detect() -> Self {
48        // Detect stack boundaries using platform-specific methods
49        // This is a simplified implementation
50        let stack_base = 0x7fff_0000_0000; // Typical stack base on x64
51        let stack_size = 8 * 1024 * 1024; // 8MB default stack size
52
53        Self {
54            stack_base,
55            stack_top: stack_base + stack_size,
56            stack_size,
57        }
58    }
59
60    /// Check if a pointer is within the stack boundaries
61    pub fn contains(&self, ptr: usize) -> bool {
62        ptr >= self.stack_base && ptr < self.stack_top
63    }
64
65    /// Get the base address of a stack frame
66    pub fn get_frame_base(&self, frame_id: u64) -> usize {
67        // Estimate frame base from frame ID
68        self.stack_base + (frame_id as usize * 4096)
69    }
70}
71
72/// Heap Boundary Types
73#[derive(Debug, Clone, Serialize, Deserialize)]
74pub struct HeapSegment {
75    /// Start address of the heap segment
76    pub start: usize,
77    /// End address of the heap segment
78    pub end: usize,
79}
80
81impl HeapSegment {
82    /// Check if a pointer is within this heap segment
83    pub fn contains(&self, ptr: usize) -> bool {
84        ptr >= self.start && ptr < self.end
85    }
86}
87
88/// Allocator information
89#[derive(Debug, Clone, Serialize, Deserialize)]
90pub struct AllocatorInfo {
91    /// Allocator name
92    pub name: String,
93    /// Allocator strategy
94    pub strategy: AllocationStrategy,
95    /// Allocator heap segments
96    pub heap_segments: Vec<HeapSegment>,
97}
98
99/// Allocation strategies
100#[derive(Debug, Clone, Serialize, Deserialize)]
101pub enum AllocationStrategy {
102    /// First fit allocation strategy
103    FirstFit,
104    /// Best fit allocation strategy
105    BestFit,
106    /// Worst fit allocation strategy
107    WorstFit,
108    /// Next fit allocation strategy
109    NextFit,
110    /// Buddy system allocation strategy
111    SlabAllocation,
112}
113
114/// Enhanced Temporary Object Types
115#[derive(Debug, Clone, Serialize, Deserialize)]
116pub struct EnhancedTemporaryObjectInfo {
117    /// Allocation information
118    pub allocation: AllocationInfo,
119    /// Temporary pattern classification
120    pub pattern_classification: TemporaryPatternClassification,
121    /// Temporary usage pattern
122    pub usage_pattern: TemporaryUsagePattern,
123    /// Hot path involvement
124    pub hot_path_involvement: bool,
125    /// Elimination feasibility
126    pub elimination_feasibility: EliminationFeasibility,
127    /// Optimization potential
128    pub optimization_potential: OptimizationPotential,
129    /// Creation context
130    pub creation_context: CreationContext,
131    /// Lifetime analysis
132    pub lifetime_analysis: TemporaryLifetimeAnalysis,
133    /// Performance impact
134    pub performance_impact: PerformanceImpact,
135}
136
137/// Temporary pattern classification
138#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
139pub enum TemporaryPatternClassification {
140    /// String concatenation pattern classification
141    StringConcatenation,
142    /// Vector reallocation pattern classification
143    VectorReallocation,
144    /// Iterator chaining pattern classification
145    IteratorChaining,
146    /// Closure capture pattern classification
147    ClosureCapture,
148    /// Async await pattern classification
149    AsyncAwait,
150    /// Error handling pattern classification
151    ErrorHandling,
152    /// Serialization/Deserialization pattern classification
153    SerializationDeserialization,
154    /// Generic instantiation pattern classification
155    GenericInstantiation,
156    /// Trait object creation pattern classification
157    TraitObjectCreation,
158    /// Unknown pattern classification
159    Unknown,
160}
161
162/// Elimination feasibility
163#[derive(Debug, Clone, Serialize, Deserialize)]
164pub enum EliminationFeasibility {
165    /// Highly feasible elimination feasibility
166    HighlyFeasible {
167        /// Suggested approach for elimination
168        suggested_approach: String,
169    },
170    /// Feasible elimination feasibility
171    Feasible {
172        /// Constraints for feasibility
173        constraints: Vec<String>,
174    },
175    /// Difficult elimination feasibility
176    Difficult {
177        /// Blockers for difficulty
178        blockers: Vec<String>,
179    },
180    /// Infeasible elimination feasibility
181    Infeasible {
182        /// Reasons for infeasibility
183        reasons: Vec<String>,
184    },
185}
186
187/// Temporary lifetime analysis
188#[derive(Debug, Clone, Serialize, Deserialize)]
189pub struct TemporaryLifetimeAnalysis {
190    /// Temporary creation time
191    pub creation_time: u64,
192    /// Temporary destruction time
193    pub destruction_time: Option<u64>,
194    /// Temporary estimated lifetime
195    pub estimated_lifetime: Duration,
196    /// Temporary usage frequency
197    pub usage_frequency: usize,
198    /// Temporary scope escape analysis
199    pub scope_escape_analysis: EscapeAnalysis,
200}
201
202/// Analysis of how a variable escapes its scope
203#[derive(Debug, Clone, Serialize, Deserialize)]
204pub enum EscapeAnalysis {
205    /// Variable does not escape its local scope
206    DoesNotEscape,
207    /// Variable escapes to the heap (stored in a heap allocation)
208    EscapesToHeap,
209    /// Variable escapes to the calling function
210    EscapesToCaller,
211    /// Variable escapes to a global scope
212    EscapesToGlobal,
213    /// Escape behavior is unknown or cannot be determined
214    Unknown,
215}
216
217/// Fragmentation Analysis Types
218#[derive(Debug, Clone, Serialize, Deserialize)]
219pub struct AllocationEvent {
220    /// Allocation timestamp
221    pub timestamp: u64,
222    /// Allocation event type
223    pub event_type: EnhancedAllocationEventType,
224    /// Allocation pointer
225    pub ptr: usize,
226    /// Allocation size
227    pub size: usize,
228    /// Allocation type name
229    pub type_name: Option<String>,
230}
231
232/// Types of memory allocation events
233#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
234pub enum EnhancedAllocationEventType {
235    /// Memory allocation event
236    Allocate,
237    /// Memory deallocation event
238    Deallocate,
239    /// Memory reallocation event (resize)
240    Reallocate,
241}
242
243/// Real-time metrics for memory fragmentation analysis
244#[derive(Debug, Clone, Serialize, Deserialize)]
245pub struct RealTimeMetrics {
246    /// Current fragmentation level
247    pub current_fragmentation: f64,
248    /// Allocation rate
249    pub allocation_rate: f64,
250    /// Deallocation rate
251    pub deallocation_rate: f64,
252    /// Memory pressure
253    pub memory_pressure: f64,
254}
255
256impl RealTimeMetrics {
257    /// Create a new instance of RealTimeMetrics
258    pub fn new() -> Self {
259        Self {
260            current_fragmentation: 0.0,
261            allocation_rate: 0.0,
262            deallocation_rate: 0.0,
263            memory_pressure: 0.0,
264        }
265    }
266
267    /// Update metrics based on new allocation
268    pub fn update_allocation(&mut self, _allocation: &AllocationInfo) {
269        // Update metrics based on new allocation
270        self.allocation_rate += 1.0;
271        // Additional metric updates would go here
272    }
273}
274
275impl Default for RealTimeMetrics {
276    fn default() -> Self {
277        Self::new()
278    }
279}
280/// Fragmentation causes
281#[derive(Debug, Clone, Serialize, Deserialize)]
282pub enum FragmentationCause {
283    /// Frequent small allocations cause fragmentation
284    FrequentSmallAllocations,
285    /// Mixed size allocations cause fragmentation
286    MixedSizeAllocations,
287    /// Long-lived allocations cause fragmentation
288    LongLivedAllocations,
289    /// Poor deallocation patterns cause fragmentation
290    PoorDeallocationPatterns,
291    /// Allocator limitations cause fragmentation
292    AllocatorLimitations,
293}
294
295/// Fragmentation mitigation strategy
296#[derive(Debug, Clone, Serialize, Deserialize)]
297pub struct FragmentationMitigationStrategy {
298    /// Mitigation strategy type
299    pub strategy_type: MitigationStrategyType,
300    /// Description of the mitigation strategy
301    pub description: String,
302    /// Expected improvement from the mitigation strategy
303    pub expected_improvement: f64,
304    /// Implementation complexity of the mitigation strategy
305    pub implementation_complexity: ImplementationComplexity,
306}
307
308/// Types of fragmentation mitigation strategies
309#[derive(Debug, Clone, Serialize, Deserialize)]
310pub enum MitigationStrategyType {
311    /// Pool allocation strategy
312    PoolAllocation,
313    /// Size class segregation strategy
314    SizeClassSegregation,
315    /// Generational garbage collection strategy
316    GenerationalGC,
317    /// Compaction garbage collection strategy
318    CompactionGC,
319    /// Custom allocator strategy
320    CustomAllocator,
321}
322
323/// Complexity levels for implementing optimization strategies
324#[derive(Debug, Clone, Serialize, Deserialize)]
325pub enum ImplementationComplexity {
326    /// Low complexity - easy to implement with minimal changes
327    Low,
328    /// Medium complexity - requires moderate changes but straightforward
329    Medium,
330    /// High complexity - requires significant changes and careful planning
331    High,
332    /// Very high complexity - requires extensive changes and deep system knowledge
333    VeryHigh,
334}
335
336/// Stack allocation details
337#[derive(Debug, Clone, Serialize, Deserialize)]
338pub struct StackAllocationDetails {
339    /// Allocation information
340    pub allocation: AllocationInfo,
341    /// Frame information
342    pub frame_info: crate::core::types::StackFrame,
343    /// Stack depth
344    pub stack_depth: usize,
345    /// Scope analysis
346    pub scope_analysis: StackScopeAnalysis,
347}
348/// Heap allocation details
349#[derive(Debug, Clone, Serialize, Deserialize)]
350pub struct HeapAllocationDetails {
351    /// Allocation information
352    pub allocation: AllocationInfo,
353    /// Heap region information
354    pub heap_info: HeapRegionInfo,
355    /// Allocator type
356    pub allocator_type: String,
357    /// Fragmentation impact on memory performance
358    pub fragmentation_impact: FragmentationImpact,
359}
360
361/// Ambiguous allocation details
362#[derive(Debug, Clone, Serialize, Deserialize)]
363pub struct AmbiguousAllocation {
364    /// Allocation information
365    pub allocation: AllocationInfo,
366    /// Reason for ambiguity
367    pub ambiguity_reason: AmbiguityReason,
368    /// Confidence score for the allocation
369    pub confidence_score: f64,
370}
371
372/// Stack scope analysis
373#[derive(Debug, Clone, Serialize, Deserialize)]
374pub struct StackScopeAnalysis {
375    /// Scope type
376    pub scope_type: ScopeType,
377    /// Nesting level of the scope
378    pub nesting_level: usize,
379    /// Estimated lifetime of the scope
380    pub estimated_lifetime: Duration,
381    /// Escape analysis result
382    pub escape_analysis: EscapeAnalysis,
383}
384
385/// Fragmentation impact on memory performance  
386#[derive(Debug, Clone, Serialize, Deserialize)]
387pub struct FragmentationImpact {
388    /// Severity of fragmentation impact
389    pub severity: FragmentationSeverity,
390    /// Affected allocations
391    pub affected_allocations: Vec<usize>,
392    /// Estimated waste due to fragmentation
393    pub estimated_waste: usize,
394    /// Impact level of fragmentation on memory performance
395    pub impact_level: ImpactLevel,
396}
397
398/// Impact level of fragmentation on memory performance
399#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
400pub enum ImpactLevel {
401    /// Low impact - minimal effect on performance
402    Low,
403    /// Medium impact - noticeable effect on performance
404    Medium,
405    /// High impact - significant effect on performance
406    High,
407    /// Critical impact - severe effect on performance, requires immediate attention
408    Critical,
409}
410
411/// Temporary object analysis report
412#[derive(Debug, Clone, Serialize, Deserialize, Default)]
413pub struct TemporaryObjectAnalysisReport {
414    /// Temporary objects detected
415    pub temporary_objects: Vec<EnhancedTemporaryObjectInfo>,
416    /// Optimization candidates
417    pub optimization_candidates: Vec<OptimizationCandidate>,
418    /// Hot temporary patterns
419    pub hot_temporary_patterns: Vec<HotTemporaryPattern>,
420    /// Optimization suggestions
421    pub optimization_suggestions: Vec<OptimizationSuggestion>,
422    /// Pattern statistics
423    pub pattern_statistics: PatternStatistics,
424    /// Performance impact assessment
425    pub performance_impact_assessment: PerformanceImpactAssessment,
426}
427
428/// Optimization candidate
429#[derive(Debug, Clone, Serialize, Deserialize)]
430pub struct OptimizationCandidate {
431    /// Allocation information
432    pub allocation: AllocationInfo,
433    /// Optimization type
434    pub optimization_type: OptimizationType,
435    /// Expected benefit of the optimization
436    pub expected_benefit: f64,
437    /// Implementation difficulty of the optimization
438    pub implementation_effort: ImplementationDifficulty,
439}
440
441/// Types of memory optimization strategies
442#[derive(Debug, Clone, Serialize, Deserialize)]
443pub enum OptimizationType {
444    /// Eliminate temporary object creation entirely
445    EliminateTemporary,
446    /// Reuse existing allocations instead of creating new ones
447    ReuseAllocation,
448    /// Use memory pools for similar-sized allocations
449    PoolAllocation,
450    /// Initialize objects only when needed
451    LazyInitialization,
452    /// Avoid unnecessary copying of objects
453    CopyElision,
454}
455/// Implementation difficulty of memory optimization strategies
456#[derive(Debug, Clone, Serialize, Deserialize)]
457pub enum ImplementationDifficulty {
458    /// Easy implementation difficulty
459    Easy,
460    /// Medium implementation difficulty
461    Medium,
462    /// Hard implementation difficulty
463    Hard,
464    /// Very hard implementation difficulty
465    VeryHard,
466}
467
468/// Hot temporary pattern classification
469#[derive(Debug, Clone, Serialize, Deserialize)]
470pub struct HotTemporaryPattern {
471    /// Temporary pattern classification
472    pub pattern: TemporaryPatternClassification,
473    /// Frequency of the temporary pattern
474    pub frequency: usize,
475    /// Total memory impact of the temporary pattern
476    pub total_memory_impact: usize,
477    /// Optimization priority of the temporary pattern
478    pub optimization_priority: Priority,
479}
480
481/// Priority levels for optimization recommendations
482#[derive(Debug, Clone, Serialize, Deserialize)]
483pub enum Priority {
484    /// Low priority - minimal impact on performance or memory usage
485    Low,
486    /// Medium priority - moderate impact on performance or memory usage
487    Medium,
488    /// High priority - significant impact on performance or memory usage
489    High,
490    /// Critical priority - severe impact on performance or memory usage, should be addressed immediately
491    Critical,
492}
493
494/// Optimization suggestion for memory management
495#[derive(Debug, Clone, Serialize, Deserialize)]
496pub struct OptimizationSuggestion {
497    /// Category of optimization
498    pub category: OptimizationCategory,
499    /// Description of the optimization
500    pub description: String,
501    /// Code example for the optimization
502    pub code_example: Option<String>,
503    /// Expected improvement from the optimization
504    pub expected_improvement: f64,
505}
506
507/// Categories of memory optimization techniques
508#[derive(Debug, Clone, Serialize, Deserialize)]
509pub enum OptimizationCategory {
510    /// Optimizing memory layout of data structures
511    MemoryLayout,
512    /// Reducing temporary object creation and lifetime
513    TemporaryObjectReduction,
514    /// Optimizing for cache efficiency
515    CacheOptimization,
516    /// Improving allocation strategy
517    AllocationStrategy,
518    /// Better management of object lifecycles
519    LifecycleManagement,
520}
521
522/// Statistics about detected temporary object patterns
523#[derive(Debug, Clone, Serialize, Deserialize, Default)]
524pub struct PatternStatistics {
525    /// Total number of patterns detected
526    pub total_patterns_detected: usize,
527    /// Frequency distribution of patterns
528    pub pattern_frequency_distribution: HashMap<TemporaryPatternClassification, usize>,
529    /// Memory impact by pattern
530    pub memory_impact_by_pattern: HashMap<TemporaryPatternClassification, usize>,
531}
532
533/// Assessment of performance impact of memory management
534#[derive(Debug, Clone, Serialize, Deserialize)]
535pub struct PerformanceImpactAssessment {
536    /// Overhead of allocation
537    pub allocation_overhead: f64,
538    /// Overhead of deallocation
539    pub deallocation_overhead: f64,
540    /// Impact on cache performance
541    pub cache_impact: f64,
542    /// Overall performance cost
543    pub overall_performance_cost: f64,
544}
545
546impl Default for PerformanceImpactAssessment {
547    fn default() -> Self {
548        Self {
549            allocation_overhead: 0.0,
550            deallocation_overhead: 0.0,
551            cache_impact: 0.0,
552            overall_performance_cost: 0.0,
553        }
554    }
555}
556
557/// Real-time Fragmentation Analysis Types
558#[derive(Debug, Clone, Serialize, Deserialize, Default)]
559pub struct RealTimeFragmentationAnalysis {
560    /// Current fragmentation metrics
561    pub current_fragmentation: FragmentationMetrics,
562    /// Trends in fragmentation over time
563    pub fragmentation_trends: FragmentationTrends,
564    /// Adaptive strategies for fragmentation
565    pub adaptive_strategies: Vec<AdaptiveStrategy>,
566    /// Real-time metrics for fragmentation
567    pub real_time_metrics: RealTimeMetrics,
568    /// Fragmentation visualization
569    pub fragmentation_visualization: FragmentationVisualization,
570    /// Mitigation recommendations for fragmentation
571    pub mitigation_recommendations: Vec<FragmentationMitigationStrategy>,
572}
573
574/// Trends in fragmentation over time
575#[derive(Debug, Clone, Serialize, Deserialize)]
576pub struct FragmentationTrends {
577    /// Direction of fragmentation trend over time
578    pub trend_direction: TrendDirection,
579    /// Rate of change of fragmentation
580    pub rate_of_change: f64,
581    /// Predicted future state of fragmentation
582    pub predicted_future_state: FragmentationPrediction,
583}
584
585impl Default for FragmentationTrends {
586    fn default() -> Self {
587        Self {
588            trend_direction: TrendDirection::Stable,
589            rate_of_change: 0.0,
590            predicted_future_state: FragmentationPrediction::default(),
591        }
592    }
593}
594
595/// Direction of fragmentation trend over time
596#[derive(Debug, Clone, Serialize, Deserialize)]
597pub enum TrendDirection {
598    /// Fragmentation is decreasing over time
599    Improving,
600    /// Fragmentation is relatively constant
601    Stable,
602    /// Fragmentation is increasing over time
603    Degrading,
604    /// Fragmentation is changing unpredictably
605    Volatile,
606}
607
608/// Prediction of fragmentation in the future
609#[derive(Debug, Clone, Serialize, Deserialize)]
610pub struct FragmentationPrediction {
611    /// Predicted fragmentation in 1 hour
612    pub predicted_fragmentation_in_1h: f64,
613    /// Predicted fragmentation in 24 hours
614    pub predicted_fragmentation_in_24h: f64,
615    /// Confidence level of the prediction
616    pub confidence_level: f64,
617}
618
619impl Default for FragmentationPrediction {
620    fn default() -> Self {
621        Self {
622            predicted_fragmentation_in_1h: 0.0,
623            predicted_fragmentation_in_24h: 0.0,
624            confidence_level: 0.0,
625        }
626    }
627}
628
629/// Time point of fragmentation analysis
630#[derive(Debug, Clone, Serialize, Deserialize)]
631pub struct FragmentationTimePoint {
632    /// Timestamp of the fragmentation analysis
633    pub timestamp: u64,
634    /// Fragmentation level at the time point
635    pub fragmentation_level: f64,
636    /// Number of allocations at the time point
637    pub allocation_count: usize,
638}
639
640/// Fragmentation heatmap data for visualization
641#[derive(Debug, Clone, Serialize, Deserialize, Default)]
642pub struct FragmentationHeatmapData {
643    /// Memory regions for fragmentation analysis
644    pub memory_regions: Vec<MemoryRegion>,
645    /// Fragmentation scores for each memory region
646    pub fragmentation_scores: Vec<f64>,
647}
648
649/// Memory region information for fragmentation analysis
650#[derive(Debug, Clone, Serialize, Deserialize)]
651pub struct MemoryRegion {
652    /// Start address of the memory region
653    pub start_address: usize,
654    /// End address of the memory region
655    pub end_address: usize,
656    /// Fragmentation score of the memory region
657    pub fragmentation_score: f64,
658}
659
660/// Types of fragmentation mitigation strategies
661#[derive(Debug, Clone, Serialize, Deserialize)]
662pub enum MitigationType {
663    /// Memory pooling strategy
664    MemoryPooling,
665    /// Compaction strategy
666    Compaction,
667    /// Size class segregation strategy
668    SizeClassSegregation,
669    /// Custom allocator strategy
670    CustomAllocator,
671}
672
673/// Adaptive strategy for fragmentation mitigation
674#[derive(Debug, Clone, Serialize, Deserialize)]
675pub struct AdaptiveStrategy {
676    /// Name of the adaptive strategy
677    pub strategy_name: String,
678    /// Trigger conditions for the adaptive strategy
679    pub trigger_conditions: Vec<String>,
680    /// Actions to be taken by the adaptive strategy
681    pub actions: Vec<String>,
682    /// Effectiveness score of the adaptive strategy
683    pub effectiveness_score: f64,
684}
685
686/// Fragmentation visualization
687#[derive(Debug, Clone, Serialize, Deserialize, Default)]
688pub struct FragmentationVisualization {
689    /// Memory map of the fragmentation visualization
690    pub memory_map: Vec<MemoryBlock>,
691    /// Fragmentation heatmap of the fragmentation visualization
692    pub fragmentation_heatmap: Vec<f64>,
693    /// Allocation timeline of the fragmentation visualization
694    pub allocation_timeline: Vec<AllocationEvent>,
695}
696
697/// Memory block information for fragmentation visualization
698#[derive(Debug, Clone, Serialize, Deserialize, Default)]
699pub struct MemoryBlock {
700    /// Start address of the memory block
701    pub start_address: usize,
702    /// Size of the memory block
703    pub size: usize,
704    /// Type of the memory block
705    pub block_type: MemoryBlockType,
706    /// Fragmentation score of the memory block
707    pub fragmentation_score: f64,
708}
709
710/// Types of memory blocks
711#[derive(Debug, Clone, Serialize, Deserialize, Default)]
712pub enum MemoryBlockType {
713    /// Free memory block (default state)
714    #[default]
715    Free,
716    /// Allocated memory block
717    Allocated,
718    /// Reserved memory block
719    Reserved,
720    /// Fragmented memory block
721    Fragmented,
722}
723
724/// Overall optimization recommendation
725#[derive(Debug, Clone, Serialize, Deserialize)]
726pub struct OverallOptimizationRecommendation {
727    /// Category of the optimization recommendation
728    pub category: OptimizationCategory,
729    /// Priority of the optimization recommendation
730    pub priority: Priority,
731    /// Description of the optimization recommendation
732    pub description: String,
733    /// Expected improvement of the optimization recommendation
734    pub expected_improvement: f64,
735    /// Implementation effort of the optimization recommendation
736    pub implementation_effort: ImplementationDifficulty,
737    /// Affected components of the optimization recommendation
738    pub affected_components: Vec<String>,
739}
740
741/// Additional supporting types for comprehensive analysis
742#[derive(Debug, Clone, Default, Serialize, Deserialize)]
743pub struct StackHeapInteractionAnalysis {
744    /// Reference relationships between stack and heap allocations
745    pub reference_relationships: Vec<ReferenceRelationship>,
746    /// Lifetime dependencies between allocations
747    pub lifetime_dependencies: Vec<LifetimeDependency>,
748    /// Performance implications of stack and heap interactions
749    pub performance_implications: Vec<PerformanceImplication>,
750}
751
752/// Reference relationship between stack and heap allocations
753#[derive(Debug, Clone, Serialize, Deserialize)]
754pub struct ReferenceRelationship {
755    /// Stack allocation address
756    pub stack_allocation: usize,
757    /// Heap allocation address
758    pub heap_allocation: usize,
759    /// Type of reference relationship
760    pub relationship_type: ReferenceType,
761}
762
763/// Types of reference relationships
764#[derive(Debug, Clone, Serialize, Deserialize)]
765pub enum ReferenceType {
766    /// Direct reference relationship
767    DirectReference,
768    /// Indirect reference relationship
769    IndirectReference,
770    /// Weak reference relationship
771    WeakReference,
772    /// Ownership transfer relationship
773    OwnershipTransfer,
774}
775
776/// Lifetime dependency between allocations
777#[derive(Debug, Clone, Serialize, Deserialize)]
778pub struct LifetimeDependency {
779    /// Dependent allocation address
780    pub dependent_allocation: usize,
781    /// Dependency allocation address
782    pub dependency_strength: DependencyStrength,
783}
784
785/// Dependency strength between allocations
786#[derive(Debug, Clone, Serialize, Deserialize)]
787pub enum DependencyStrength {
788    /// Strong dependency strength
789    Strong,
790    /// Weak dependency strength
791    Weak,
792    /// Optional dependency strength
793    Optional,
794}
795
796/// Performance implication of stack and heap interactions
797#[derive(Debug, Clone, Serialize, Deserialize)]
798pub struct PerformanceImplication {
799    /// Type of performance implication
800    pub implication_type: PerformanceImplicationType,
801    /// Severity of the performance implication
802    pub severity: Severity,
803    /// Description of the performance implication
804    pub description: String,
805    /// Mitigation suggestion for the performance implication
806    pub mitigation_suggestion: String,
807}
808
809/// Types of performance implications
810#[derive(Debug, Clone, Serialize, Deserialize)]
811pub enum PerformanceImplicationType {
812    /// Cache miss performance implication
813    CacheMiss,
814    /// Memory latency performance implication
815    MemoryLatency,
816    /// Allocation overhead performance implication
817    AllocationOverhead,
818    /// Fragmentation impact performance implication
819    MemoryOptimization,
820    /// Positive performance implication
821    Positive,
822    /// Negative performance implication
823    Negative,
824    /// Neutral performance implication
825    Neutral,
826}
827
828/// Severity of performance implications
829#[derive(Debug, Clone, Serialize, Deserialize)]
830pub enum Severity {
831    /// Low severity
832    Low,
833    /// Medium severity
834    Medium,
835    /// High severity
836    High,
837    /// Critical severity
838    Critical,
839}
840
841/// Memory space coverage
842#[derive(Debug, Clone, Serialize, Deserialize)]
843pub struct MemorySpaceCoverage {
844    /// Total tracked bytes
845    pub total_tracked_bytes: usize,
846    /// Stack coverage percentage
847    pub stack_coverage_percent: f64,
848    /// Heap coverage percentage
849    pub heap_coverage_percent: f64,
850    /// Unknown region percentage
851    pub unknown_region_percent: f64,
852}
853
854/// Boundary detection accuracy
855#[derive(Debug, Clone, Serialize, Deserialize)]
856pub struct BoundaryDetectionAccuracy {
857    /// Stack detection accuracy
858    pub stack_detection_accuracy: f64,
859    /// Heap detection accuracy
860    pub heap_detection_accuracy: f64,
861    /// False positive rate
862    pub false_positive_rate: f64,
863    /// False negative rate
864    pub false_negative_rate: f64,
865}
866
867/// Stack and heap optimization
868#[derive(Debug, Clone, Serialize, Deserialize)]
869pub struct StackHeapOptimization {
870    /// Type of stack and heap optimization
871    pub optimization_type: StackHeapOptimizationType,
872    /// Description of the stack and heap optimization
873    pub description: String,
874    /// Affected allocations
875    pub affected_allocations: Vec<usize>,
876    /// Expected benefit of the stack and heap optimization
877    pub expected_benefit: String,
878}
879
880/// Types of stack and heap optimizations
881#[derive(Debug, Clone, Serialize, Deserialize)]
882pub enum StackHeapOptimizationType {
883    /// Stack to heap promotion
884    StackToHeapPromotion,
885    /// Heap to stack demotion
886    HeapToStackDemotion,
887    /// Allocation elimination
888    AllocationElimination,
889    /// Lifetime optimization
890    LifetimeOptimization,
891}
892
893/// Generic type analysis report
894#[derive(Debug, Clone, Serialize, Deserialize, Default)]
895pub struct GenericTypeAnalysisReport {
896    /// Instantiation analysis of generic types
897    pub instantiation_analysis: Vec<crate::core::types::GenericInstantiationInfo>,
898    /// Code bloat assessment of generic types
899    pub code_bloat_assessment: CodeBloatAssessment,
900    /// Optimization recommendations for generic types
901    pub optimization_recommendations: Vec<crate::core::types::MemoryOptimizationRecommendation>,
902    /// Monomorphization statistics of generic types
903    pub monomorphization_statistics: crate::enhanced_memory_analysis::MonomorphizationStatistics,
904    /// Performance characteristics of generic types
905    pub performance_characteristics: PerformanceCharacteristics,
906}
907
908/// Object lifecycle analysis report
909#[derive(Debug, Clone, Serialize, Deserialize, Default)]
910pub struct ObjectLifecycleAnalysisReport {
911    /// Lifecycle reports of objects
912    pub lifecycle_reports: Vec<ObjectLifecycleInfo>,
913    /// Lifecycle patterns of objects
914    pub lifecycle_patterns: Vec<LifecyclePattern>,
915    /// Resource waste analysis of objects
916    pub resource_waste_analysis: ResourceWasteAnalysis,
917    /// Lifecycle optimizations of objects
918    pub lifecycle_optimizations: Vec<crate::enhanced_memory_analysis::LifecycleOptimization>,
919    /// Efficiency metrics of objects
920    pub efficiency_metrics: crate::enhanced_memory_analysis::EfficiencyMetrics,
921    /// Object relationship graph of objects
922    pub object_relationship_graph: crate::enhanced_memory_analysis::ObjectRelationshipGraph,
923}
924
925/// Memory access analysis report
926#[derive(Debug, Clone, Serialize, Deserialize, Default)]
927pub struct MemoryAccessAnalysisReport {
928    /// Access patterns of memory
929    pub access_patterns: Vec<AccessPattern>,
930    /// Layout recommendations of memory
931    pub layout_recommendations: Vec<crate::enhanced_memory_analysis::LayoutRecommendation>,
932    /// Actual access tracking of memory
933    pub actual_access_tracking: crate::enhanced_memory_analysis::ActualAccessTracking,
934    /// Bandwidth utilization of memory
935    pub bandwidth_utilization: crate::enhanced_memory_analysis::BandwidthUtilization,
936    /// Locality analysis of memory
937    pub locality_analysis: crate::enhanced_memory_analysis::LocalityAnalysis,
938}
939
940/// Cache optimization report
941#[derive(Debug, Clone, Serialize, Deserialize, Default)]
942pub struct CacheOptimizationReport {
943    /// Cache line analysis of memory
944    pub cache_line_analysis: crate::enhanced_memory_analysis::CacheLineAnalysis,
945    /// Data structure optimizations of memory
946    pub data_structure_optimizations:
947        Vec<crate::enhanced_memory_analysis::DataStructureOptimization>,
948    /// Access pattern optimizations of memory
949    pub access_pattern_optimizations:
950        Vec<crate::enhanced_memory_analysis::AccessPatternOptimization>,
951    /// Cache efficiency metrics of memory
952    pub cache_efficiency_metrics: LifecycleEfficiencyMetrics,
953    /// Optimization recommendations of memory
954    pub optimization_recommendations: Vec<OptimizationRecommendation>,
955    /// Performance projections of memory
956    pub performance_projections: PerformanceImplication,
957}
958
959/// Enhanced memory analysis report
960#[derive(Debug, Clone, Serialize, Deserialize)]
961pub struct EnhancedMemoryAnalysisReport {
962    /// Timestamp of the analysis
963    pub timestamp: u64,
964    /// Analysis duration in milliseconds
965    pub analysis_duration_ms: u64,
966    /// Stack and heap boundary analysis
967    pub stack_heap_analysis: StackHeapBoundaryAnalysis,
968    /// Temporary object analysis report
969    pub temp_object_analysis: TemporaryObjectAnalysisReport,
970    /// Fragmentation analysis report
971    pub fragmentation_analysis: RealTimeFragmentationAnalysis,
972    /// Generic type analysis report
973    pub generic_analysis: GenericTypeAnalysisReport,
974    /// Object lifecycle analysis report
975    pub lifecycle_analysis: ObjectLifecycleAnalysisReport,
976    /// Memory access analysis report
977    pub access_pattern_analysis: MemoryAccessAnalysisReport,
978    /// Cache optimization report
979    pub cache_optimization: CacheOptimizationReport,
980    /// Overall optimization recommendations
981    pub overall_recommendations: Vec<OverallOptimizationRecommendation>,
982}
983
984/// Stack heap boundary analysis
985#[derive(Debug, Clone, Default, Serialize, Deserialize)]
986pub struct StackHeapBoundaryAnalysis {
987    /// Stack allocations of memory
988    pub stack_allocations: Vec<StackAllocationDetails>,
989    /// Heap allocations of memory
990    pub heap_allocations: Vec<HeapAllocationDetails>,
991    /// Ambiguous allocations of memory
992    pub ambiguous_allocations: Vec<AmbiguousAllocation>,
993    /// Stack and heap interactions of memory
994    pub stack_heap_interactions: StackHeapInteractionAnalysis,
995    /// Memory space coverage of memory
996    pub memory_space_coverage: MemorySpaceCoverage,
997    /// Boundary detection accuracy of memory
998    pub boundary_detection_accuracy: BoundaryDetectionAccuracy,
999    /// Optimization opportunities of memory
1000    pub optimization_opportunities: Vec<StackHeapOptimization>,
1001}
1002
1003/// Code bloat assessment
1004#[derive(Debug, Clone, Serialize, Deserialize)]
1005pub struct CodeBloatAssessment {
1006    /// Bloat level of the code
1007    pub bloat_level: BloatLevel,
1008    /// Estimated code size increase
1009    pub estimated_code_size_increase: f64,
1010    /// Compilation time impact
1011    pub compilation_time_impact: f64,
1012    /// Binary size impact
1013    pub binary_size_impact: f64,
1014}
1015
1016/// Bloat level of the code
1017#[derive(Debug, Clone, Serialize, Deserialize)]
1018pub enum BloatLevel {
1019    /// Minimal bloat level
1020    Minimal,
1021    /// Low bloat level
1022    Low,
1023    /// Moderate bloat level
1024    Moderate,
1025    /// High bloat level
1026    High,
1027    /// Severe bloat level
1028    Severe,
1029}
1030
1031/// Resource waste analysis of memory
1032#[derive(Debug, Clone, Serialize, Deserialize)]
1033pub struct ResourceWasteAnalysis {
1034    /// Wasted allocations of memory
1035    pub wasted_allocations: usize,
1036    /// Total wasted memory of memory
1037    pub total_wasted_memory: usize,
1038    /// Waste percentage of memory
1039    pub waste_percentage: f64,
1040    /// Waste categories of memory
1041    pub waste_categories: Vec<WasteCategory>,
1042}
1043
1044/// Waste category of memory
1045#[derive(Debug, Clone, Serialize, Deserialize)]
1046pub struct WasteCategory {
1047    /// Waste category type
1048    pub category_type: WasteCategoryType,
1049    /// Wasted bytes of memory
1050    pub wasted_bytes: usize,
1051    /// Frequency of memory
1052    pub frequency: usize,
1053}
1054
1055/// Waste category type of memory
1056#[derive(Debug, Clone, Serialize, Deserialize)]
1057pub enum WasteCategoryType {
1058    /// Unused allocations of memory
1059    UnusedAllocations,
1060    /// Over allocations of memory
1061    OverAllocations,
1062    /// Leaked memory of memory
1063    LeakedMemory,
1064    /// Fragmentation waste of memory
1065    FragmentationWaste,
1066    /// Temporary object waste of memory
1067    TemporaryObjectWaste,
1068}
1069
1070/// Additional supporting types
1071#[derive(Debug, Clone, Serialize, Deserialize)]
1072pub enum MemoryLocation {
1073    /// Stack allocation of memory
1074    Stack(crate::enhanced_memory_analysis::StackFrameInfo),
1075    /// Heap allocation of memory
1076    Heap(HeapRegionInfo),
1077    /// Ambiguous allocation of memory
1078    Ambiguous(AmbiguityReason),
1079}
1080
1081/// Reasons why memory allocation tracking might be ambiguous or uncertain
1082#[derive(Debug, Clone, Serialize, Deserialize)]
1083pub enum AmbiguityReason {
1084    /// Insufficient metadata available to accurately track the allocation
1085    InsufficientMetadata,
1086    /// Address is at the border of tracked memory regions
1087    BorderlineAddress,
1088    /// Memory tracking data has been corrupted
1089    CorruptedTracking,
1090    /// Allocation was made by an external system not fully tracked by this tool
1091    ExternalAllocation,
1092}
1093
1094/// Information about a heap memory region managed by an allocator
1095#[derive(Debug, Clone, Serialize, Deserialize)]
1096pub struct HeapRegionInfo {
1097    /// Starting address of the heap region
1098    pub region_start: usize,
1099    /// Ending address of the heap region
1100    pub region_end: usize,
1101    /// Name of the allocator managing this heap region
1102    pub allocator_name: String,
1103    /// Type of heap region (main heap, large object heap, etc.)
1104    pub region_type: HeapRegionType,
1105}
1106
1107#[derive(Debug, Clone, Serialize, Deserialize)]
1108/// Types of heap regions managed by memory allocators
1109pub enum HeapRegionType {
1110    /// Main heap area for general allocations
1111    MainHeap,
1112    /// Specialized heap area for large object allocations
1113    LargeObjectHeap,
1114    /// Specialized heap area for small object allocations
1115    SmallObjectHeap,
1116    /// Thread-local heap areas
1117    ThreadLocalHeap,
1118}
1119
1120// Fragmentation analysis types
1121#[derive(Debug, Clone, Serialize, Deserialize)]
1122/// Comprehensive analysis of memory fragmentation with metrics, causes, and recommendations
1123pub struct EnhancedFragmentationAnalysis {
1124    /// Metrics quantifying different aspects of memory fragmentation
1125    pub fragmentation_metrics: FragmentationMetrics,
1126    /// Assessment of fragmentation severity level
1127    pub fragmentation_severity: FragmentationSeverity,
1128    /// Identified causes contributing to memory fragmentation
1129    pub fragmentation_causes: Vec<FragmentationCause>,
1130    /// Strategies to mitigate the identified fragmentation issues
1131    pub mitigation_strategies: Vec<FragmentationMitigationStrategy>,
1132    /// Analysis of fragmentation trends over time
1133    pub fragmentation_trends: FragmentationTrends,
1134    /// Real-time monitoring data for ongoing fragmentation analysis
1135    pub real_time_monitoring: crate::enhanced_memory_analysis::RealTimeMonitoringData,
1136    /// Adaptive recommendations based on current fragmentation patterns
1137    pub adaptive_recommendations: Vec<crate::enhanced_memory_analysis::AdaptiveRecommendation>,
1138}
1139
1140#[derive(Debug, Clone, Serialize, Deserialize)]
1141/// Quantitative metrics measuring different aspects of memory fragmentation
1142pub struct FragmentationMetrics {
1143    /// Ratio of external fragmentation (unusable gaps between allocations)
1144    pub external_fragmentation_ratio: f64,
1145    /// Ratio of internal fragmentation (unused space within allocations)
1146    pub internal_fragmentation_ratio: f64,
1147    /// Combined ratio of all fragmentation types
1148    pub total_fragmentation_ratio: f64,
1149    /// Size of the largest contiguous free memory block
1150    pub largest_free_block: usize,
1151    /// Total number of free memory blocks
1152    pub free_block_count: usize,
1153    /// Average size of free memory blocks
1154    pub average_free_block_size: f64,
1155    /// Ratio of memory actually used vs. total allocated
1156    pub memory_utilization_ratio: f64,
1157}
1158
1159impl Default for FragmentationMetrics {
1160    fn default() -> Self {
1161        Self {
1162            external_fragmentation_ratio: 0.0,
1163            internal_fragmentation_ratio: 0.0,
1164            total_fragmentation_ratio: 0.0,
1165            largest_free_block: 0,
1166            free_block_count: 0,
1167            average_free_block_size: 0.0,
1168            memory_utilization_ratio: 1.0,
1169        }
1170    }
1171}
1172
1173/// Severity levels of memory fragmentation
1174#[derive(Debug, Clone, Serialize, Deserialize)]
1175pub enum FragmentationSeverity {
1176    /// Low severity - minimal fragmentation, little impact on performance
1177    Low,
1178    /// Moderate severity - noticeable fragmentation, some impact on performance
1179    Moderate,
1180    /// High severity - significant fragmentation, considerable impact on performance
1181    High,
1182    /// Critical severity - severe fragmentation, major impact on performance
1183    Critical,
1184}
1185
1186// Additional missing types for enhanced memory analysis
1187#[derive(Debug, Clone, Serialize, Deserialize)]
1188/// Represents a potential optimization for temporary memory usage patterns
1189pub struct TemporaryOptimization {
1190    /// Type of optimization strategy to apply
1191    pub optimization_type: OptimizationType,
1192    /// Expected performance or memory benefit as a ratio (higher is better)
1193    pub expected_benefit: f64,
1194    /// Estimated difficulty of implementing this optimization
1195    pub implementation_effort: ImplementationDifficulty,
1196    /// Detailed description of the optimization approach
1197    pub description: String,
1198}
1199
1200#[derive(Debug, Clone, Serialize, Deserialize)]
1201/// Statistical analysis of temporary memory allocation patterns
1202pub struct TemporaryPatternStatistics {
1203    /// Total number of temporary allocation patterns identified
1204    pub total_patterns: usize,
1205    /// Distribution of different pattern classifications and their frequencies
1206    pub pattern_distribution: HashMap<TemporaryPatternClassification, usize>,
1207    /// Memory impact (in bytes) of each pattern classification
1208    pub memory_impact: HashMap<TemporaryPatternClassification, usize>,
1209}
1210
1211#[derive(Debug, Clone, Serialize, Deserialize)]
1212/// Analysis of performance impacts caused by temporary object allocations
1213pub struct TemporaryObjectPerformanceImpact {
1214    /// Computational overhead of allocation operations (normalized ratio)
1215    pub allocation_overhead: f64,
1216    /// Computational overhead of deallocation operations (normalized ratio)
1217    pub deallocation_overhead: f64,
1218    /// Impact on CPU cache efficiency (normalized ratio, lower is better)
1219    pub cache_impact: f64,
1220    /// Combined performance cost metric (normalized ratio, lower is better)
1221    pub overall_cost: f64,
1222}
1223
1224#[derive(Debug, Clone, Serialize, Deserialize)]
1225/// Strategies for optimizing memory usage patterns
1226pub enum OptimizationStrategy {
1227    /// Completely eliminate the temporary allocation
1228    Eliminate,
1229    /// Reuse existing objects instead of creating new ones
1230    Reuse,
1231    /// Use object pooling to reduce allocation/deallocation overhead
1232    Pool,
1233    /// Defer allocation until absolutely necessary
1234    Defer,
1235}
1236
1237#[derive(Debug, Clone, Serialize, Deserialize)]
1238/// Analysis of memory fragmentation trends over time
1239pub struct FragmentationTrendAnalysis {
1240    /// Historical fragmentation analysis data points
1241    pub historical_data: Vec<FragmentationAnalysis>,
1242    /// Direction of the fragmentation trend (increasing, decreasing, stable)
1243    pub trend_direction: TrendDirection,
1244    /// Projected future fragmentation levels
1245    pub projected_levels: Vec<FragmentationProjection>,
1246    /// Historical fragmentation level measurements as raw values
1247    pub fragmentation_levels: Vec<f64>,
1248}
1249
1250#[derive(Debug, Clone, Serialize, Deserialize)]
1251/// Strategy that adapts to changing fragmentation conditions
1252pub struct AdaptiveFragmentationStrategy {
1253    /// Name of the adaptive strategy
1254    pub strategy_name: String,
1255    /// Conditions that trigger this strategy to be applied
1256    pub trigger_conditions: Vec<String>,
1257    /// Actions to take when the strategy is triggered
1258    pub actions: Vec<String>,
1259    /// Estimated effectiveness score of this strategy (0.0-1.0)
1260    pub effectiveness_score: f64,
1261}
1262
1263#[derive(Debug, Clone, Serialize, Deserialize)]
1264/// Real-time metrics for monitoring memory fragmentation
1265pub struct RealTimeFragmentationMetrics {
1266    /// Current fragmentation ratio (0.0-1.0, higher means more fragmented)
1267    pub current_fragmentation: f64,
1268    /// Rate of memory allocations per second
1269    pub allocation_rate: f64,
1270    /// Rate of memory deallocations per second
1271    pub deallocation_rate: f64,
1272    /// Current memory pressure (0.0-1.0, higher means more pressure)
1273    pub memory_pressure: f64,
1274}
1275
1276#[derive(Debug, Clone, Serialize, Deserialize)]
1277/// Data for visualizing memory fragmentation patterns
1278pub struct FragmentationVisualizationData {
1279    /// Map of memory blocks showing allocated and free regions
1280    pub memory_map: Vec<MemoryBlock>,
1281    /// Heatmap data showing fragmentation intensity across memory regions
1282    pub fragmentation_heatmap: Vec<f64>,
1283    /// Timeline of allocation events for temporal visualization
1284    pub allocation_timeline: Vec<AllocationEvent>,
1285}
1286
1287#[derive(Debug, Clone, Serialize, Deserialize)]
1288/// Recommendation for mitigating memory fragmentation issues
1289pub struct FragmentationMitigationRecommendation {
1290    /// Type of mitigation strategy being recommended
1291    pub strategy_type: MitigationStrategyType,
1292    /// Detailed description of the recommendation
1293    pub description: String,
1294    /// Expected improvement in fragmentation metrics (0.0-1.0)
1295    pub expected_improvement: f64,
1296    /// Estimated complexity of implementing this recommendation
1297    pub implementation_complexity: ImplementationComplexity,
1298}
1299
1300#[derive(Debug, Clone, Serialize, Deserialize)]
1301/// Analysis of trends in memory usage or fragmentation metrics
1302pub struct TrendAnalysis {
1303    /// Direction of the trend (increasing, decreasing, stable)
1304    pub direction: TrendDirection,
1305    /// Rate of change per time unit
1306    pub rate_of_change: f64,
1307    /// Confidence level in the trend analysis (0.0-1.0)
1308    pub confidence: f64,
1309}
1310
1311#[derive(Debug, Clone, Serialize, Deserialize)]
1312/// Represents a cyclical pattern in memory usage or fragmentation
1313pub struct CyclicalPattern {
1314    /// Name or identifier for this pattern
1315    pub pattern_name: String,
1316    /// Duration of one complete cycle
1317    pub cycle_duration: Duration,
1318    /// Amplitude of the cycle (magnitude of change)
1319    pub amplitude: f64,
1320}
1321
1322#[derive(Debug, Clone, Serialize, Deserialize)]
1323/// Represents an anomaly detected in memory fragmentation patterns
1324pub struct FragmentationAnomaly {
1325    /// Type or category of the anomaly
1326    pub anomaly_type: String,
1327    /// Severity of the anomaly (0.0-1.0, higher is more severe)
1328    pub severity: f64,
1329    /// Timestamp when the anomaly was detected
1330    pub timestamp: u64,
1331    /// Detailed description of the anomaly
1332    pub description: String,
1333}
1334
1335#[derive(Debug, Clone, Serialize, Deserialize)]
1336/// Projection of future memory fragmentation levels
1337pub struct FragmentationProjection {
1338    /// Time horizon for the projection in hours
1339    pub time_horizon_hours: u32,
1340    /// Projected fragmentation ratio at the specified time horizon
1341    pub projected_fragmentation: f64,
1342    /// Confidence level in the projection (0.0-1.0)
1343    pub confidence: f64,
1344}
1345
1346#[derive(Debug, Clone, Serialize, Deserialize)]
1347/// Impact of memory usage patterns on system scalability
1348pub enum ScalabilityImpact {
1349    /// Positive impact on scalability (improves as scale increases)
1350    Positive,
1351    /// Neutral impact on scalability (neither improves nor worsens with scale)
1352    Neutral,
1353    /// Negative impact on scalability (worsens as scale increases)
1354    Negative,
1355}
1356
1357#[derive(Debug, Clone, Serialize, Deserialize)]
1358/// Strategy that adapts to mitigate memory fragmentation based on thresholds
1359pub struct AdaptiveMitigationStrategy {
1360    /// Name of the adaptive mitigation strategy
1361    pub strategy_name: String,
1362    /// Threshold value that triggers this strategy (typically a fragmentation ratio)
1363    pub trigger_threshold: f64,
1364    /// Actions to take when the strategy is triggered
1365    pub actions: Vec<String>,
1366    /// Expected effectiveness of this strategy (0.0-1.0)
1367    pub expected_effectiveness: f64,
1368}
1369
1370#[derive(Debug, Clone, Serialize, Deserialize)]
1371/// Current state of memory fragmentation
1372pub struct CurrentFragmentationState {
1373    /// Current external fragmentation ratio (0.0-1.0)
1374    pub external_fragmentation: f64,
1375    /// Current internal fragmentation ratio (0.0-1.0)
1376    pub internal_fragmentation: f64,
1377    /// Assessment of the current fragmentation severity
1378    pub severity_level: FragmentationSeverity,
1379    /// Timestamp when this state was captured
1380    pub timestamp: u64,
1381}
1382
1383// Additional Default implementations for missing structures
1384impl Default for CodeBloatAssessment {
1385    fn default() -> Self {
1386        Self {
1387            bloat_level: BloatLevel::Minimal,
1388            estimated_code_size_increase: 0.0,
1389            compilation_time_impact: 0.0,
1390            binary_size_impact: 0.0,
1391        }
1392    }
1393}
1394
1395impl Default for ResourceWasteAnalysis {
1396    fn default() -> Self {
1397        Self {
1398            wasted_allocations: 0,
1399            total_wasted_memory: 0,
1400            waste_percentage: 0.0,
1401            waste_categories: Vec::new(),
1402        }
1403    }
1404}
1405
1406impl Default for MemorySpaceCoverage {
1407    fn default() -> Self {
1408        Self {
1409            total_tracked_bytes: 0,
1410            stack_coverage_percent: 0.0,
1411            heap_coverage_percent: 0.0,
1412            unknown_region_percent: 0.0,
1413        }
1414    }
1415}
1416
1417impl Default for BoundaryDetectionAccuracy {
1418    fn default() -> Self {
1419        Self {
1420            stack_detection_accuracy: 0.0,
1421            heap_detection_accuracy: 0.0,
1422            false_positive_rate: 0.0,
1423            false_negative_rate: 0.0,
1424        }
1425    }
1426}
1427
1428impl Default for PerformanceImplication {
1429    fn default() -> Self {
1430        Self {
1431            implication_type: PerformanceImplicationType::Neutral,
1432            severity: Severity::Low,
1433            description: String::new(),
1434            mitigation_suggestion: String::new(),
1435        }
1436    }
1437}
1438
1439#[cfg(test)]
1440mod tests {
1441    use super::*;
1442    use std::time::Duration;
1443
1444    #[test]
1445    fn test_stack_boundaries_creation() {
1446        let boundaries = StackBoundaries::detect();
1447
1448        assert_eq!(boundaries.stack_base, 0x7fff_0000_0000);
1449        assert_eq!(boundaries.stack_size, 8 * 1024 * 1024);
1450        assert_eq!(
1451            boundaries.stack_top,
1452            boundaries.stack_base + boundaries.stack_size
1453        );
1454    }
1455
1456    #[test]
1457    fn test_stack_boundaries_contains() {
1458        let boundaries = StackBoundaries::detect();
1459
1460        // Test pointer within stack
1461        let stack_ptr = boundaries.stack_base + 1024;
1462        assert!(boundaries.contains(stack_ptr));
1463
1464        // Test pointer outside stack
1465        let heap_ptr = 0x1000_0000;
1466        assert!(!boundaries.contains(heap_ptr));
1467
1468        // Test boundary conditions
1469        assert!(boundaries.contains(boundaries.stack_base));
1470        assert!(!boundaries.contains(boundaries.stack_top));
1471    }
1472
1473    #[test]
1474    fn test_stack_boundaries_get_frame_base() {
1475        let boundaries = StackBoundaries::detect();
1476
1477        let frame_base_0 = boundaries.get_frame_base(0);
1478        let frame_base_1 = boundaries.get_frame_base(1);
1479
1480        assert_eq!(frame_base_0, boundaries.stack_base);
1481        assert_eq!(frame_base_1, boundaries.stack_base + 4096);
1482        assert!(frame_base_1 > frame_base_0);
1483    }
1484
1485    #[test]
1486    fn test_heap_segment_contains() {
1487        let segment = HeapSegment {
1488            start: 0x1000_0000,
1489            end: 0x2000_0000,
1490        };
1491
1492        // Test pointer within segment
1493        assert!(segment.contains(0x1500_0000));
1494
1495        // Test pointer outside segment
1496        assert!(!segment.contains(0x500_0000));
1497        assert!(!segment.contains(0x2500_0000));
1498
1499        // Test boundary conditions
1500        assert!(segment.contains(segment.start));
1501        assert!(!segment.contains(segment.end));
1502    }
1503
1504    #[test]
1505    fn test_allocation_strategy_variants() {
1506        let strategies = vec![
1507            AllocationStrategy::FirstFit,
1508            AllocationStrategy::BestFit,
1509            AllocationStrategy::WorstFit,
1510            AllocationStrategy::NextFit,
1511            AllocationStrategy::SlabAllocation,
1512        ];
1513
1514        for strategy in strategies {
1515            assert!(!format!("{strategy:?}").is_empty());
1516        }
1517    }
1518
1519    #[test]
1520    fn test_temporary_pattern_classification_variants() {
1521        let patterns = vec![
1522            TemporaryPatternClassification::StringConcatenation,
1523            TemporaryPatternClassification::VectorReallocation,
1524            TemporaryPatternClassification::IteratorChaining,
1525            TemporaryPatternClassification::ClosureCapture,
1526            TemporaryPatternClassification::AsyncAwait,
1527            TemporaryPatternClassification::ErrorHandling,
1528            TemporaryPatternClassification::SerializationDeserialization,
1529            TemporaryPatternClassification::GenericInstantiation,
1530            TemporaryPatternClassification::TraitObjectCreation,
1531            TemporaryPatternClassification::Unknown,
1532        ];
1533
1534        for pattern in patterns {
1535            assert!(!format!("{pattern:?}").is_empty());
1536        }
1537    }
1538
1539    #[test]
1540    fn test_elimination_feasibility_variants() {
1541        let feasibilities = vec![
1542            EliminationFeasibility::HighlyFeasible {
1543                suggested_approach: "Use string builder".to_string(),
1544            },
1545            EliminationFeasibility::Feasible {
1546                constraints: vec!["Memory limit".to_string()],
1547            },
1548            EliminationFeasibility::Difficult {
1549                blockers: vec!["API constraints".to_string()],
1550            },
1551            EliminationFeasibility::Infeasible {
1552                reasons: vec!["Required by interface".to_string()],
1553            },
1554        ];
1555
1556        for feasibility in feasibilities {
1557            assert!(!format!("{feasibility:?}").is_empty());
1558        }
1559    }
1560
1561    #[test]
1562    fn test_escape_analysis_variants() {
1563        let analyses = vec![
1564            EscapeAnalysis::DoesNotEscape,
1565            EscapeAnalysis::EscapesToHeap,
1566            EscapeAnalysis::EscapesToCaller,
1567            EscapeAnalysis::EscapesToGlobal,
1568            EscapeAnalysis::Unknown,
1569        ];
1570
1571        for analysis in analyses {
1572            assert!(!format!("{analysis:?}").is_empty());
1573        }
1574    }
1575
1576    #[test]
1577    fn test_real_time_metrics_creation() {
1578        let metrics = RealTimeMetrics::new();
1579
1580        assert_eq!(metrics.current_fragmentation, 0.0);
1581        assert_eq!(metrics.allocation_rate, 0.0);
1582        assert_eq!(metrics.deallocation_rate, 0.0);
1583        assert_eq!(metrics.memory_pressure, 0.0);
1584    }
1585
1586    #[test]
1587    fn test_real_time_metrics_default() {
1588        let metrics = RealTimeMetrics::default();
1589
1590        assert_eq!(metrics.current_fragmentation, 0.0);
1591        assert_eq!(metrics.allocation_rate, 0.0);
1592        assert_eq!(metrics.deallocation_rate, 0.0);
1593        assert_eq!(metrics.memory_pressure, 0.0);
1594    }
1595
1596    #[test]
1597    fn test_real_time_metrics_update_allocation() {
1598        use crate::core::types::AllocationInfo;
1599
1600        let mut metrics = RealTimeMetrics::new();
1601        let allocation = AllocationInfo::new(0x1000, 512);
1602
1603        let initial_rate = metrics.allocation_rate;
1604        metrics.update_allocation(&allocation);
1605
1606        assert!(metrics.allocation_rate > initial_rate);
1607        assert_eq!(metrics.allocation_rate, initial_rate + 1.0);
1608    }
1609
1610    #[test]
1611    fn test_enhanced_allocation_event_type_variants() {
1612        let events = vec![
1613            EnhancedAllocationEventType::Allocate,
1614            EnhancedAllocationEventType::Deallocate,
1615            EnhancedAllocationEventType::Reallocate,
1616        ];
1617
1618        for event in events {
1619            assert!(!format!("{event:?}").is_empty());
1620        }
1621    }
1622
1623    #[test]
1624    fn test_fragmentation_cause_variants() {
1625        let causes = vec![
1626            FragmentationCause::FrequentSmallAllocations,
1627            FragmentationCause::MixedSizeAllocations,
1628            FragmentationCause::LongLivedAllocations,
1629            FragmentationCause::PoorDeallocationPatterns,
1630            FragmentationCause::AllocatorLimitations,
1631        ];
1632
1633        for cause in causes {
1634            assert!(!format!("{cause:?}").is_empty());
1635        }
1636    }
1637
1638    #[test]
1639    fn test_mitigation_strategy_type_variants() {
1640        let strategies = vec![
1641            MitigationStrategyType::PoolAllocation,
1642            MitigationStrategyType::SizeClassSegregation,
1643            MitigationStrategyType::GenerationalGC,
1644            MitigationStrategyType::CompactionGC,
1645            MitigationStrategyType::CustomAllocator,
1646        ];
1647
1648        for strategy in strategies {
1649            assert!(!format!("{strategy:?}").is_empty());
1650        }
1651    }
1652
1653    #[test]
1654    fn test_implementation_complexity_variants() {
1655        let complexities = vec![
1656            ImplementationComplexity::Low,
1657            ImplementationComplexity::Medium,
1658            ImplementationComplexity::High,
1659            ImplementationComplexity::VeryHigh,
1660        ];
1661
1662        for complexity in complexities {
1663            assert!(!format!("{complexity:?}").is_empty());
1664        }
1665    }
1666
1667    #[test]
1668    fn test_impact_level_variants() {
1669        let levels = vec![
1670            ImpactLevel::Low,
1671            ImpactLevel::Medium,
1672            ImpactLevel::High,
1673            ImpactLevel::Critical,
1674        ];
1675
1676        for level in levels {
1677            assert!(!format!("{level:?}").is_empty());
1678        }
1679    }
1680
1681    #[test]
1682    fn test_optimization_type_variants() {
1683        let types = vec![
1684            OptimizationType::EliminateTemporary,
1685            OptimizationType::ReuseAllocation,
1686            OptimizationType::PoolAllocation,
1687            OptimizationType::LazyInitialization,
1688            OptimizationType::CopyElision,
1689        ];
1690
1691        for opt_type in types {
1692            assert!(!format!("{opt_type:?}").is_empty());
1693        }
1694    }
1695
1696    #[test]
1697    fn test_priority_variants() {
1698        let priorities = vec![
1699            Priority::Low,
1700            Priority::Medium,
1701            Priority::High,
1702            Priority::Critical,
1703        ];
1704
1705        for priority in priorities {
1706            assert!(!format!("{priority:?}").is_empty());
1707        }
1708    }
1709
1710    #[test]
1711    fn test_optimization_category_variants() {
1712        let categories = vec![
1713            OptimizationCategory::MemoryLayout,
1714            OptimizationCategory::TemporaryObjectReduction,
1715            OptimizationCategory::CacheOptimization,
1716            OptimizationCategory::AllocationStrategy,
1717            OptimizationCategory::LifecycleManagement,
1718        ];
1719
1720        for category in categories {
1721            assert!(!format!("{category:?}").is_empty());
1722        }
1723    }
1724
1725    #[test]
1726    fn test_pattern_statistics_default() {
1727        let stats = PatternStatistics::default();
1728
1729        assert_eq!(stats.total_patterns_detected, 0);
1730        assert!(stats.pattern_frequency_distribution.is_empty());
1731        assert!(stats.memory_impact_by_pattern.is_empty());
1732    }
1733
1734    #[test]
1735    fn test_performance_impact_assessment_default() {
1736        let assessment = PerformanceImpactAssessment::default();
1737
1738        assert_eq!(assessment.allocation_overhead, 0.0);
1739        assert_eq!(assessment.deallocation_overhead, 0.0);
1740        assert_eq!(assessment.cache_impact, 0.0);
1741        assert_eq!(assessment.overall_performance_cost, 0.0);
1742    }
1743
1744    #[test]
1745    fn test_trend_direction_variants() {
1746        let directions = vec![
1747            TrendDirection::Improving,
1748            TrendDirection::Stable,
1749            TrendDirection::Degrading,
1750            TrendDirection::Volatile,
1751        ];
1752
1753        for direction in directions {
1754            assert!(!format!("{direction:?}").is_empty());
1755        }
1756    }
1757
1758    #[test]
1759    fn test_fragmentation_prediction_default() {
1760        let prediction = FragmentationPrediction::default();
1761
1762        assert_eq!(prediction.predicted_fragmentation_in_1h, 0.0);
1763        assert_eq!(prediction.predicted_fragmentation_in_24h, 0.0);
1764        assert_eq!(prediction.confidence_level, 0.0);
1765    }
1766
1767    #[test]
1768    fn test_fragmentation_trends_default() {
1769        let trends = FragmentationTrends::default();
1770
1771        assert!(matches!(trends.trend_direction, TrendDirection::Stable));
1772        assert_eq!(trends.rate_of_change, 0.0);
1773    }
1774
1775    #[test]
1776    fn test_memory_block_type_variants() {
1777        let types = vec![
1778            MemoryBlockType::Free,
1779            MemoryBlockType::Allocated,
1780            MemoryBlockType::Reserved,
1781            MemoryBlockType::Fragmented,
1782        ];
1783
1784        for block_type in types {
1785            assert!(!format!("{block_type:?}").is_empty());
1786        }
1787    }
1788
1789    #[test]
1790    fn test_memory_block_default() {
1791        let block = MemoryBlock::default();
1792
1793        assert_eq!(block.start_address, 0);
1794        assert_eq!(block.size, 0);
1795        assert!(matches!(block.block_type, MemoryBlockType::Free));
1796        assert_eq!(block.fragmentation_score, 0.0);
1797    }
1798
1799    #[test]
1800    fn test_reference_type_variants() {
1801        let types = vec![
1802            ReferenceType::DirectReference,
1803            ReferenceType::IndirectReference,
1804            ReferenceType::WeakReference,
1805            ReferenceType::OwnershipTransfer,
1806        ];
1807
1808        for ref_type in types {
1809            assert!(!format!("{ref_type:?}").is_empty());
1810        }
1811    }
1812
1813    #[test]
1814    fn test_dependency_strength_variants() {
1815        let strengths = vec![
1816            DependencyStrength::Strong,
1817            DependencyStrength::Weak,
1818            DependencyStrength::Optional,
1819        ];
1820
1821        for strength in strengths {
1822            assert!(!format!("{strength:?}").is_empty());
1823        }
1824    }
1825
1826    #[test]
1827    fn test_performance_implication_type_variants() {
1828        let types = vec![
1829            PerformanceImplicationType::CacheMiss,
1830            PerformanceImplicationType::MemoryLatency,
1831            PerformanceImplicationType::AllocationOverhead,
1832            PerformanceImplicationType::MemoryOptimization,
1833            PerformanceImplicationType::Positive,
1834            PerformanceImplicationType::Negative,
1835            PerformanceImplicationType::Neutral,
1836        ];
1837
1838        for impl_type in types {
1839            assert!(!format!("{impl_type:?}").is_empty());
1840        }
1841    }
1842
1843    #[test]
1844    fn test_severity_variants() {
1845        let severities = vec![
1846            Severity::Low,
1847            Severity::Medium,
1848            Severity::High,
1849            Severity::Critical,
1850        ];
1851
1852        for severity in severities {
1853            assert!(!format!("{severity:?}").is_empty());
1854        }
1855    }
1856
1857    #[test]
1858    fn test_fragmentation_metrics_default() {
1859        let metrics = FragmentationMetrics::default();
1860
1861        assert_eq!(metrics.external_fragmentation_ratio, 0.0);
1862        assert_eq!(metrics.internal_fragmentation_ratio, 0.0);
1863        assert_eq!(metrics.total_fragmentation_ratio, 0.0);
1864        assert_eq!(metrics.largest_free_block, 0);
1865        assert_eq!(metrics.free_block_count, 0);
1866        assert_eq!(metrics.average_free_block_size, 0.0);
1867        assert_eq!(metrics.memory_utilization_ratio, 1.0);
1868    }
1869
1870    #[test]
1871    fn test_fragmentation_severity_variants() {
1872        let severities = vec![
1873            FragmentationSeverity::Low,
1874            FragmentationSeverity::Moderate,
1875            FragmentationSeverity::High,
1876            FragmentationSeverity::Critical,
1877        ];
1878
1879        for severity in severities {
1880            assert!(!format!("{severity:?}").is_empty());
1881        }
1882    }
1883
1884    #[test]
1885    fn test_bloat_level_variants() {
1886        let levels = vec![
1887            BloatLevel::Minimal,
1888            BloatLevel::Low,
1889            BloatLevel::Moderate,
1890            BloatLevel::High,
1891            BloatLevel::Severe,
1892        ];
1893
1894        for level in levels {
1895            assert!(!format!("{level:?}").is_empty());
1896        }
1897    }
1898
1899    #[test]
1900    fn test_code_bloat_assessment_default() {
1901        let assessment = CodeBloatAssessment::default();
1902
1903        assert!(matches!(assessment.bloat_level, BloatLevel::Minimal));
1904        assert_eq!(assessment.estimated_code_size_increase, 0.0);
1905        assert_eq!(assessment.compilation_time_impact, 0.0);
1906        assert_eq!(assessment.binary_size_impact, 0.0);
1907    }
1908
1909    #[test]
1910    fn test_waste_category_type_variants() {
1911        let types = vec![
1912            WasteCategoryType::UnusedAllocations,
1913            WasteCategoryType::OverAllocations,
1914            WasteCategoryType::LeakedMemory,
1915            WasteCategoryType::FragmentationWaste,
1916            WasteCategoryType::TemporaryObjectWaste,
1917        ];
1918
1919        for waste_type in types {
1920            assert!(!format!("{waste_type:?}").is_empty());
1921        }
1922    }
1923
1924    #[test]
1925    fn test_resource_waste_analysis_default() {
1926        let analysis = ResourceWasteAnalysis::default();
1927
1928        assert_eq!(analysis.wasted_allocations, 0);
1929        assert_eq!(analysis.total_wasted_memory, 0);
1930        assert_eq!(analysis.waste_percentage, 0.0);
1931        assert!(analysis.waste_categories.is_empty());
1932    }
1933
1934    #[test]
1935    fn test_ambiguity_reason_variants() {
1936        let reasons = vec![
1937            AmbiguityReason::InsufficientMetadata,
1938            AmbiguityReason::BorderlineAddress,
1939            AmbiguityReason::CorruptedTracking,
1940            AmbiguityReason::ExternalAllocation,
1941        ];
1942
1943        for reason in reasons {
1944            assert!(!format!("{reason:?}").is_empty());
1945        }
1946    }
1947
1948    #[test]
1949    fn test_heap_region_type_variants() {
1950        let types = vec![
1951            HeapRegionType::MainHeap,
1952            HeapRegionType::LargeObjectHeap,
1953            HeapRegionType::SmallObjectHeap,
1954            HeapRegionType::ThreadLocalHeap,
1955        ];
1956
1957        for region_type in types {
1958            assert!(!format!("{region_type:?}").is_empty());
1959        }
1960    }
1961
1962    #[test]
1963    fn test_memory_space_coverage_default() {
1964        let coverage = MemorySpaceCoverage::default();
1965
1966        assert_eq!(coverage.total_tracked_bytes, 0);
1967        assert_eq!(coverage.stack_coverage_percent, 0.0);
1968        assert_eq!(coverage.heap_coverage_percent, 0.0);
1969        assert_eq!(coverage.unknown_region_percent, 0.0);
1970    }
1971
1972    #[test]
1973    fn test_boundary_detection_accuracy_default() {
1974        let accuracy = BoundaryDetectionAccuracy::default();
1975
1976        assert_eq!(accuracy.stack_detection_accuracy, 0.0);
1977        assert_eq!(accuracy.heap_detection_accuracy, 0.0);
1978        assert_eq!(accuracy.false_positive_rate, 0.0);
1979        assert_eq!(accuracy.false_negative_rate, 0.0);
1980    }
1981
1982    #[test]
1983    fn test_performance_implication_default() {
1984        let implication = PerformanceImplication::default();
1985
1986        assert!(matches!(
1987            implication.implication_type,
1988            PerformanceImplicationType::Neutral
1989        ));
1990        assert!(matches!(implication.severity, Severity::Low));
1991        assert!(implication.description.is_empty());
1992        assert!(implication.mitigation_suggestion.is_empty());
1993    }
1994
1995    #[test]
1996    fn test_scalability_impact_variants() {
1997        let impacts = vec![
1998            ScalabilityImpact::Positive,
1999            ScalabilityImpact::Neutral,
2000            ScalabilityImpact::Negative,
2001        ];
2002
2003        for impact in impacts {
2004            assert!(!format!("{impact:?}").is_empty());
2005        }
2006    }
2007
2008    #[test]
2009    fn test_optimization_strategy_variants() {
2010        let strategies = vec![
2011            OptimizationStrategy::Eliminate,
2012            OptimizationStrategy::Reuse,
2013            OptimizationStrategy::Pool,
2014            OptimizationStrategy::Defer,
2015        ];
2016
2017        for strategy in strategies {
2018            assert!(!format!("{strategy:?}").is_empty());
2019        }
2020    }
2021
2022    #[test]
2023    fn test_temporary_object_analysis_report_default() {
2024        let report = TemporaryObjectAnalysisReport::default();
2025
2026        assert!(report.temporary_objects.is_empty());
2027        assert!(report.optimization_candidates.is_empty());
2028        assert!(report.hot_temporary_patterns.is_empty());
2029        assert!(report.optimization_suggestions.is_empty());
2030    }
2031
2032    #[test]
2033    fn test_real_time_fragmentation_analysis_default() {
2034        let analysis = RealTimeFragmentationAnalysis::default();
2035
2036        // Test that default values are reasonable
2037        assert_eq!(
2038            analysis.current_fragmentation.external_fragmentation_ratio,
2039            0.0
2040        );
2041        assert!(matches!(
2042            analysis.fragmentation_trends.trend_direction,
2043            TrendDirection::Stable
2044        ));
2045        assert!(analysis.adaptive_strategies.is_empty());
2046        assert_eq!(analysis.real_time_metrics.current_fragmentation, 0.0);
2047    }
2048
2049    #[test]
2050    fn test_complex_struct_creation() {
2051        let allocation_event = AllocationEvent {
2052            timestamp: 1000,
2053            event_type: EnhancedAllocationEventType::Allocate,
2054            ptr: 0x1000,
2055            size: 512,
2056            type_name: Some("Vec<i32>".to_string()),
2057        };
2058
2059        assert_eq!(allocation_event.timestamp, 1000);
2060        assert!(matches!(
2061            allocation_event.event_type,
2062            EnhancedAllocationEventType::Allocate
2063        ));
2064        assert_eq!(allocation_event.ptr, 0x1000);
2065        assert_eq!(allocation_event.size, 512);
2066        assert_eq!(allocation_event.type_name, Some("Vec<i32>".to_string()));
2067    }
2068
2069    #[test]
2070    fn test_temporary_lifetime_analysis_creation() {
2071        let analysis = TemporaryLifetimeAnalysis {
2072            creation_time: 1000,
2073            destruction_time: Some(2000),
2074            estimated_lifetime: Duration::from_millis(1000),
2075            usage_frequency: 5,
2076            scope_escape_analysis: EscapeAnalysis::DoesNotEscape,
2077        };
2078
2079        assert_eq!(analysis.creation_time, 1000);
2080        assert_eq!(analysis.destruction_time, Some(2000));
2081        assert_eq!(analysis.estimated_lifetime, Duration::from_millis(1000));
2082        assert_eq!(analysis.usage_frequency, 5);
2083        assert!(matches!(
2084            analysis.scope_escape_analysis,
2085            EscapeAnalysis::DoesNotEscape
2086        ));
2087    }
2088
2089    #[test]
2090    fn test_fragmentation_mitigation_strategy_creation() {
2091        let strategy = FragmentationMitigationStrategy {
2092            strategy_type: MitigationStrategyType::PoolAllocation,
2093            description: "Use memory pools for similar-sized allocations".to_string(),
2094            expected_improvement: 0.3,
2095            implementation_complexity: ImplementationComplexity::Medium,
2096        };
2097
2098        assert!(matches!(
2099            strategy.strategy_type,
2100            MitigationStrategyType::PoolAllocation
2101        ));
2102        assert!(strategy.description.contains("memory pools"));
2103        assert_eq!(strategy.expected_improvement, 0.3);
2104        assert!(matches!(
2105            strategy.implementation_complexity,
2106            ImplementationComplexity::Medium
2107        ));
2108    }
2109}
memscope_rs/enhanced_types.rs

memscope_rs/
enhanced_types.rs
