Trait mm0_deepsize::DeepSizeOf [−][src]
pub trait DeepSizeOf {
fn deep_size_of_children(&self, context: &mut Context) -> usize;
fn deep_size_of(&self) -> usize { ... }
fn deep_size_of_with(&self, context: &mut Context) -> usize { ... }
}A trait for measuring the size of an object and its children
In many cases this is just std::mem::size_of::<T>(), but if
the struct contains a Vec, String, Box, or other allocated object or
reference, then it is the size of the struct, plus the size of the contents
of the object.
Required methods
fn deep_size_of_children(&self, context: &mut Context) -> usize[src]
Returns an estimation of the heap-managed storage of this object. This does not include the size of the object itself.
This is an estimation and not a precise result, because it doesn’t account for allocator’s overhead.
This is an internal function (this shouldn’t be called directly),
and requires a Context to track visited references.
Implementations of this function should only call deep_size_of_children,
and not deep_size_of so that they reference tracking is not reset.
In all other cases, deep_size_of should be called instead of this function.
If a struct and all of its children do not allocate or have references,
this method should return 0, as it cannot have any heap allocated
children. There is a shortcut macro for this implementation, known_size_of,
used like known_deep_size!(0, (), u32, u64); which generates the impls.
The most common way to use this method, and how the derive works,
is to call this method on each of the structs members and sum the
results, which works as long as all members of the struct implmeent
DeepSizeOf.
To implement this for a collection type, you should sum the deep sizes of the items of the collection and then add the size of the allocation of the collection itself. This can become much more complicated if the collection has multiple seperate allocations.
Here is an example from the implementation of DeepSizeOf for Vec<T>
ⓘ
impl<T> DeepSizeOf for std::vec::Vec<T> where T: DeepSizeOf { fn deep_size_of_children(&self, context: &mut Context) -> usize { // Size of heap allocations for each child self.iter().map(|child| child.deep_size_of_children(context)).sum() + self.capacity() * std::mem::size_of::<T>() // Size of Vec's heap allocation } }
Provided methods
fn deep_size_of(&self) -> usize[src]
Returns an estimation of a total size of memory owned by the object, including heap-managed storage.
This is an estimation and not a precise result, because it doesn’t account for allocator’s overhead.
fn deep_size_of_with(&self, context: &mut Context) -> usize[src]
Returns an estimation of a total size of memory owned by the object, including heap-managed storage.