Trait deepsize::DeepSizeOf

pub trait DeepSizeOf {
    fn deep_size_of_children(&self, context: &mut Context) -> usize;

    fn deep_size_of(&self) -> usize { ... }
    fn recurse_deep_size_of(&self, context: &mut Context) -> usize { ... }
    fn stack_size(&self) -> 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

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.

This is an internal function, and requires a Context to track visited references.

Loading content...

Provided methods

fn deep_size_of(&self) -> usize

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.

use deepsize::DeepSizeOf;
use std::collections::HashMap;

let mut map: HashMap<Box<u32>, Vec<String>> = HashMap::new();

map.insert(Box::new(42u32), vec![String::from("Hello World")]);
map.insert(Box::new(20u32), vec![String::from("Something")]);
map.insert(Box::new(0u32),  vec![String::from("A string")]);
map.insert(Box::new(255u32), vec![String::from("Dynamically Allocated!")]);

assert_eq!(map.deep_size_of(), 1312);

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

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.

This is an internal function, and requires a Context to track visited references.

fn stack_size(&self) -> usize

Returns the size of the memory the object uses itself

This method is generally equivalent to size_of_val

Loading content...

Implementations on Foreign Types

impl DeepSizeOf for bool

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for char

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for str

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for u8

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for u16

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for u32

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for u64

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for usize

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for i8

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for i16

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for i32

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for i64

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for isize

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for f32

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for f64

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for ()

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for AtomicBool

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for AtomicIsize

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for AtomicUsize

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl<T: ?Sized> DeepSizeOf for PhantomData<T>

fn deep_size_of_children(&self, _: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl DeepSizeOf for String

fn deep_size_of_children(&self, context: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl<T> DeepSizeOf for Vec<T> where     T: DeepSizeOf,

fn deep_size_of_children(&self, context: &mut Context) -> usize

Sums the size of each child object, and then adds the size of the unused capacity.

use deepsize::DeepSizeOf;

let mut vec: Vec<u8> = vec![];
for i in 0..13 {
    vec.push(i);
}

// The capacity (16) plus three usizes (len, cap, pointer)
assert_eq!(vec.deep_size_of(), 16 + 24);

With allocated objects:

use deepsize::DeepSizeOf;

let mut vec: Vec<Box<u64>> = vec![];
for i in 0..13 {
    vec.push(Box::new(i));
}

// The capacity (16?) * size (8) plus three usizes (len, cap, pointer)
// and length (13) * the allocated size of each object
assert_eq!(vec.deep_size_of(), 24 + vec.capacity() * 8 + 13 * 8);

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl<T> DeepSizeOf for VecDeque<T> where     T: DeepSizeOf,

fn deep_size_of_children(&self, context: &mut Context) -> usize

Sums the size of each child object, and then adds the size of the unused capacity.

use deepsize::DeepSizeOf;
use std::collections::VecDeque;

let mut vec: VecDeque<u8> = VecDeque::new();
for i in 0..12 {
    vec.push_back(i);
}
vec.push_front(13);

// The capacity (15?) plus four usizes (start, end, cap, pointer)
assert_eq!(vec.deep_size_of(), vec.capacity() * 1 + 32);

With allocated objects:

use deepsize::DeepSizeOf;
use std::collections::VecDeque;

let mut vec: VecDeque<Box<u64>> = VecDeque::new();
for i in 0..12 {
    vec.push_back(Box::new(i));
}
vec.push_front(Box::new(13));

// The capacity (15?) * size (8) plus four usizes (start, end, cap, pointer)
// and length (13) * the allocated size of each object
assert_eq!(vec.deep_size_of(), 32 + vec.capacity() * 8 + 13 * 8);

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl<T> DeepSizeOf for LinkedList<T> where     T: DeepSizeOf,

fn deep_size_of_children(&self, context: &mut Context) -> usize

Sums the size of each child object, assuming the overhead of each node is 2 usize (next, prev)

use deepsize::DeepSizeOf;
use std::collections::LinkedList;

let mut list: LinkedList<u8> = LinkedList::new();
for i in 0..12 {
    list.push_back(i);
}
list.push_front(13);

assert_eq!(list.deep_size_of(), std::mem::size_of::<LinkedList<u8>>()
                               + 13 * 1 + 13 * 2 * 8);

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl<K, V, S> DeepSizeOf for HashMap<K, V, S> where     K: DeepSizeOf + Eq + Hash,     V: DeepSizeOf,     S: BuildHasher,

fn deep_size_of_children(&self, context: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl<T, S> DeepSizeOf for HashSet<T, S> where     T: DeepSizeOf + Eq + Hash,     S: BuildHasher,

fn deep_size_of_children(&self, context: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl<T> DeepSizeOf for Box<T> where     T: DeepSizeOf,

fn deep_size_of_children(&self, context: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

impl<T> DeepSizeOf for Arc<T> where     T: DeepSizeOf,

fn deep_size_of_children(&self, context: &mut Context) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn stack_size(&self) -> usize

impl<T> DeepSizeOf for Rc<T> where     T: DeepSizeOf,

fn deep_size_of_children(&self, context: &mut Context) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn stack_size(&self) -> usize

impl<T: ?Sized, '_> DeepSizeOf for &'_ T where     T: DeepSizeOf,

fn deep_size_of_children(&self, context: &mut Context) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

fn deep_size_of(&self) -> usize

fn stack_size(&self) -> usize

impl<T> DeepSizeOf for [T] where     T: DeepSizeOf,

fn deep_size_of_children(&self, context: &mut Context) -> usize

fn stack_size(&self) -> usize

fn deep_size_of(&self) -> usize

fn recurse_deep_size_of(&self, context: &mut Context) -> usize

Loading content...

Implementors

Loading content...