Struct MemoryAnalysis 

pub struct MemoryAnalysis {
    pub total_memory_usage: u64,
    pub peak_memory_usage: u64,
    pub memory_by_operation: HashMap<OperationType, u64>,
    pub memory_hotspots: Vec<(String, u64)>,
    pub fragmentation_ratio: Option<f64>,
    pub optimization_suggestions: Vec<String>,
}

Memory usage analysis

Fields

total_memory_usage: u64

Total memory usage in bytes

peak_memory_usage: u64

Peak simultaneously-live memory usage in bytes, computed by a real liveness walk over the graph’s topological order (see ComputationGraphAnalyzer::compute_peak_memory_usage): a node’s output is “live” from the step it is produced until the step of its last consumer, and this is the maximum total live bytes at any one step. Never equal to total_memory_usage by construction (as the old placeholder was) unless every tensor really is live simultaneously.

memory_by_operation: HashMap<OperationType, u64>

Memory usage by operation type

memory_hotspots: Vec<(String, u64)>

Nodes with highest memory usage

fragmentation_ratio: Option<f64>

Memory fragmentation ratio, when measurable. This analyzer tracks only logical per-node byte counts, not a real memory allocator/placement model (address ranges, allocation order, free-list state) – fragmentation is a property of how an allocator places live tensors in physical memory, which is a different question from liveness overlap (already captured by Self::peak_memory_usage) and depends on a placement policy this crate does not implement. Honestly None rather than a fabricated number.

optimization_suggestions: Vec<String>

Suggested memory optimizations

Trait Implementations

impl Clone for MemoryAnalysis

fn clone(&self) -> MemoryAnalysis

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MemoryAnalysis

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MemoryAnalysis

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for MemoryAnalysis

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.