servo_malloc_size_of/
lib.rs

1// Copyright 2016-2017 The Servo Project Developers. See the COPYRIGHT
2// file at the top-level directory of this distribution and at
3// http://rust-lang.org/COPYRIGHT.
4//
5// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8// option. This file may not be copied, modified, or distributed
9// except according to those terms.
10
11//! A crate for measuring the heap usage of data structures in a way that
12//! integrates with Firefox's memory reporting, particularly the use of
13//! mozjemalloc and DMD. In particular, it has the following features.
14//! - It isn't bound to a particular heap allocator.
15//! - It provides traits for both "shallow" and "deep" measurement, which gives
16//!   flexibility in the cases where the traits can't be used.
17//! - It allows for measuring blocks even when only an interior pointer can be
18//!   obtained for heap allocations, e.g. `HashSet` and `HashMap`. (This relies
19//!   on the heap allocator having suitable support, which mozjemalloc has.)
20//! - It allows handling of types like `Rc` and `Arc` by providing traits that
21//!   are different to the ones for non-graph structures.
22//!
23//! Suggested uses are as follows.
24//! - When possible, use the `MallocSizeOf` trait. (Deriving support is
25//!   provided by the `malloc_size_of_derive` crate.)
26//! - If you need an additional synchronization argument, provide a function
27//!   that is like the standard trait method, but with the extra argument.
28//! - If you need multiple measurements for a type, provide a function named
29//!   `add_size_of` that takes a mutable reference to a struct that contains
30//!   the multiple measurement fields.
31//! - When deep measurement (via `MallocSizeOf`) cannot be implemented for a
32//!   type, shallow measurement (via `MallocShallowSizeOf`) in combination with
33//!   iteration can be a useful substitute.
34//! - `Rc` and `Arc` are always tricky, which is why `MallocSizeOf` is not (and
35//!   should not be) implemented for them.
36//! - If an `Rc` or `Arc` is known to be a "primary" reference and can always
37//!   be measured, it should be measured via the `MallocUnconditionalSizeOf`
38//!   trait.
39//! - If an `Rc` or `Arc` should be measured only if it hasn't been seen
40//!   before, it should be measured via the `MallocConditionalSizeOf` trait.
41//! - Using universal function call syntax is a good idea when measuring boxed
42//!   fields in structs, because it makes it clear that the Box is being
43//!   measured as well as the thing it points to. E.g.
44//!   `<Box<_> as MallocSizeOf>::size_of(field, ops)`.
45//!
46//!   Note: WebRender has a reduced fork of this crate, so that we can avoid
47//!   publishing this crate on crates.io.
48
49use std::cell::OnceCell;
50use std::collections::BinaryHeap;
51use std::hash::{BuildHasher, Hash};
52use std::ops::Range;
53use std::rc::Rc;
54use std::sync::Arc;
55
56use style::properties::ComputedValues;
57use style::values::generics::length::GenericLengthPercentageOrAuto;
58pub use stylo_malloc_size_of::MallocSizeOfOps;
59use uuid::Uuid;
60
61/// Trait for measuring the "deep" heap usage of a data structure. This is the
62/// most commonly-used of the traits.
63pub trait MallocSizeOf {
64    /// Measure the heap usage of all descendant heap-allocated structures, but
65    /// not the space taken up by the value itself.
66    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize;
67}
68
69/// Trait for measuring the "shallow" heap usage of a container.
70pub trait MallocShallowSizeOf {
71    /// Measure the heap usage of immediate heap-allocated descendant
72    /// structures, but not the space taken up by the value itself. Anything
73    /// beyond the immediate descendants must be measured separately, using
74    /// iteration.
75    fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize;
76}
77
78/// Like `MallocSizeOf`, but with a different name so it cannot be used
79/// accidentally with derive(MallocSizeOf). For use with types like `Rc` and
80/// `Arc` when appropriate (e.g. when measuring a "primary" reference).
81pub trait MallocUnconditionalSizeOf {
82    /// Measure the heap usage of all heap-allocated descendant structures, but
83    /// not the space taken up by the value itself.
84    fn unconditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize;
85}
86
87/// `MallocUnconditionalSizeOf` combined with `MallocShallowSizeOf`.
88pub trait MallocUnconditionalShallowSizeOf {
89    /// `unconditional_size_of` combined with `shallow_size_of`.
90    fn unconditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize;
91}
92
93/// Like `MallocSizeOf`, but only measures if the value hasn't already been
94/// measured. For use with types like `Rc` and `Arc` when appropriate (e.g.
95/// when there is no "primary" reference).
96pub trait MallocConditionalSizeOf {
97    /// Measure the heap usage of all heap-allocated descendant structures, but
98    /// not the space taken up by the value itself, and only if that heap usage
99    /// hasn't already been measured.
100    fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize;
101}
102
103/// `MallocConditionalSizeOf` combined with `MallocShallowSizeOf`.
104pub trait MallocConditionalShallowSizeOf {
105    /// `conditional_size_of` combined with `shallow_size_of`.
106    fn conditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize;
107}
108
109impl<T: MallocSizeOf> MallocSizeOf for [T] {
110    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
111        let mut n = 0;
112        for elem in self.iter() {
113            n += elem.size_of(ops);
114        }
115        n
116    }
117}
118
119impl<T: MallocConditionalSizeOf> MallocConditionalSizeOf for [T] {
120    fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
121        self.iter()
122            .map(|element| element.conditional_size_of(ops))
123            .sum()
124    }
125}
126
127/// For use on types where size_of() returns 0.
128#[macro_export]
129macro_rules! malloc_size_of_is_0(
130    ($($ty:ty),+) => (
131        $(
132            impl $crate::MallocSizeOf for $ty {
133                #[inline(always)]
134                fn size_of(&self, _: &mut $crate::MallocSizeOfOps) -> usize {
135                    0
136                }
137            }
138        )+
139    );
140    ($($ty:ident<$($gen:ident),+>),+) => (
141        $(
142            impl<$($gen: $crate::MallocSizeOf),+> $crate::MallocSizeOf for $ty<$($gen),+> {
143                #[inline(always)]
144                fn size_of(&self, _: &mut $crate::MallocSizeOfOps) -> usize {
145                    0
146                }
147            }
148        )+
149    );
150);
151
152impl MallocSizeOf for keyboard_types::Key {
153    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
154        match &self {
155            keyboard_types::Key::Character(string) => {
156                <String as MallocSizeOf>::size_of(string, ops)
157            },
158            _ => 0,
159        }
160    }
161}
162
163impl MallocSizeOf for markup5ever::QualName {
164    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
165        self.prefix.size_of(ops) + self.ns.size_of(ops) + self.local.size_of(ops)
166    }
167}
168
169impl MallocSizeOf for String {
170    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
171        unsafe { ops.malloc_size_of(self.as_ptr()) }
172    }
173}
174
175impl<T: ?Sized> MallocSizeOf for &'_ T {
176    fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
177        // Zero makes sense for a non-owning reference.
178        0
179    }
180}
181
182impl<T: ?Sized> MallocShallowSizeOf for Box<T> {
183    fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
184        unsafe { ops.malloc_size_of(&**self) }
185    }
186}
187
188impl<T: MallocSizeOf + ?Sized> MallocSizeOf for Box<T> {
189    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
190        self.shallow_size_of(ops) + (**self).size_of(ops)
191    }
192}
193
194impl MallocSizeOf for () {
195    fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
196        0
197    }
198}
199
200impl<T1, T2> MallocSizeOf for (T1, T2)
201where
202    T1: MallocSizeOf,
203    T2: MallocSizeOf,
204{
205    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
206        self.0.size_of(ops) + self.1.size_of(ops)
207    }
208}
209
210impl<T1, T2, T3> MallocSizeOf for (T1, T2, T3)
211where
212    T1: MallocSizeOf,
213    T2: MallocSizeOf,
214    T3: MallocSizeOf,
215{
216    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
217        self.0.size_of(ops) + self.1.size_of(ops) + self.2.size_of(ops)
218    }
219}
220
221impl<T1, T2, T3, T4> MallocSizeOf for (T1, T2, T3, T4)
222where
223    T1: MallocSizeOf,
224    T2: MallocSizeOf,
225    T3: MallocSizeOf,
226    T4: MallocSizeOf,
227{
228    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
229        self.0.size_of(ops) + self.1.size_of(ops) + self.2.size_of(ops) + self.3.size_of(ops)
230    }
231}
232
233impl<T: MallocConditionalSizeOf> MallocConditionalSizeOf for Option<T> {
234    fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
235        if let Some(val) = self.as_ref() {
236            val.conditional_size_of(ops)
237        } else {
238            0
239        }
240    }
241}
242
243impl<T: MallocConditionalSizeOf> MallocConditionalSizeOf for Vec<T> {
244    fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
245        let mut n = self.shallow_size_of(ops);
246        for elem in self.iter() {
247            n += elem.conditional_size_of(ops);
248        }
249        n
250    }
251}
252
253impl<T: MallocConditionalSizeOf> MallocConditionalSizeOf for std::collections::VecDeque<T> {
254    fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
255        let mut n = self.shallow_size_of(ops);
256        for elem in self.iter() {
257            n += elem.conditional_size_of(ops);
258        }
259        n
260    }
261}
262
263impl<T: MallocConditionalSizeOf> MallocConditionalSizeOf for std::cell::RefCell<T> {
264    fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
265        self.borrow().conditional_size_of(ops)
266    }
267}
268
269impl<T1, T2> MallocConditionalSizeOf for (T1, T2)
270where
271    T1: MallocConditionalSizeOf,
272    T2: MallocConditionalSizeOf,
273{
274    fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
275        self.0.conditional_size_of(ops) + self.1.conditional_size_of(ops)
276    }
277}
278
279impl<T: MallocConditionalSizeOf + ?Sized> MallocConditionalSizeOf for Box<T> {
280    fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
281        self.shallow_size_of(ops) + (**self).conditional_size_of(ops)
282    }
283}
284
285impl<T: MallocConditionalSizeOf, E: MallocSizeOf> MallocConditionalSizeOf for Result<T, E> {
286    fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
287        match *self {
288            Ok(ref x) => x.conditional_size_of(ops),
289            Err(ref e) => e.size_of(ops),
290        }
291    }
292}
293
294impl MallocConditionalSizeOf for () {
295    fn conditional_size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
296        0
297    }
298}
299
300impl<T: MallocSizeOf> MallocSizeOf for Option<T> {
301    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
302        if let Some(val) = self.as_ref() {
303            val.size_of(ops)
304        } else {
305            0
306        }
307    }
308}
309
310impl<T: MallocSizeOf, E: MallocSizeOf> MallocSizeOf for Result<T, E> {
311    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
312        match *self {
313            Ok(ref x) => x.size_of(ops),
314            Err(ref e) => e.size_of(ops),
315        }
316    }
317}
318
319impl<T: MallocSizeOf + Copy> MallocSizeOf for std::cell::Cell<T> {
320    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
321        self.get().size_of(ops)
322    }
323}
324
325impl<T: MallocSizeOf> MallocSizeOf for std::cell::RefCell<T> {
326    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
327        self.borrow().size_of(ops)
328    }
329}
330
331impl<B: ?Sized + ToOwned> MallocSizeOf for std::borrow::Cow<'_, B>
332where
333    B::Owned: MallocSizeOf,
334{
335    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
336        match *self {
337            std::borrow::Cow::Borrowed(_) => 0,
338            std::borrow::Cow::Owned(ref b) => b.size_of(ops),
339        }
340    }
341}
342
343impl<T> MallocShallowSizeOf for Vec<T> {
344    fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
345        unsafe { ops.malloc_size_of(self.as_ptr()) }
346    }
347}
348
349impl<T: MallocSizeOf> MallocSizeOf for Vec<T> {
350    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
351        let mut n = self.shallow_size_of(ops);
352        for elem in self.iter() {
353            n += elem.size_of(ops);
354        }
355        n
356    }
357}
358
359impl<T> MallocShallowSizeOf for std::collections::VecDeque<T> {
360    fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
361        if ops.has_malloc_enclosing_size_of() {
362            if let Some(front) = self.front() {
363                // The front element is an interior pointer.
364                unsafe { ops.malloc_enclosing_size_of(front) }
365            } else {
366                // This assumes that no memory is allocated when the VecDeque is empty.
367                0
368            }
369        } else {
370            // An estimate.
371            self.capacity() * size_of::<T>()
372        }
373    }
374}
375
376impl<T: MallocSizeOf> MallocSizeOf for std::collections::VecDeque<T> {
377    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
378        let mut n = self.shallow_size_of(ops);
379        for elem in self.iter() {
380            n += elem.size_of(ops);
381        }
382        n
383    }
384}
385
386impl<A: smallvec::Array> MallocShallowSizeOf for smallvec::SmallVec<A> {
387    fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
388        if self.spilled() {
389            unsafe { ops.malloc_size_of(self.as_ptr()) }
390        } else {
391            0
392        }
393    }
394}
395
396impl<A> MallocSizeOf for smallvec::SmallVec<A>
397where
398    A: smallvec::Array,
399    A::Item: MallocSizeOf,
400{
401    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
402        let mut n = self.shallow_size_of(ops);
403        for elem in self.iter() {
404            n += elem.size_of(ops);
405        }
406        n
407    }
408}
409
410impl<A: MallocConditionalSizeOf> MallocConditionalSizeOf for smallvec::SmallVec<A>
411where
412    A: smallvec::Array,
413    A::Item: MallocConditionalSizeOf,
414{
415    fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
416        if !self.spilled() {
417            return 0;
418        }
419
420        self.shallow_size_of(ops) +
421            self.iter()
422                .map(|element| element.conditional_size_of(ops))
423                .sum::<usize>()
424    }
425}
426
427impl<T: MallocSizeOf> MallocSizeOf for BinaryHeap<T> {
428    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
429        self.iter().map(|element| element.size_of(ops)).sum()
430    }
431}
432
433macro_rules! malloc_size_of_hash_set {
434    ($ty:ty) => {
435        impl<T, S> MallocShallowSizeOf for $ty
436        where
437            T: Eq + Hash,
438            S: BuildHasher,
439        {
440            fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
441                if ops.has_malloc_enclosing_size_of() {
442                    // The first value from the iterator gives us an interior pointer.
443                    // `ops.malloc_enclosing_size_of()` then gives us the storage size.
444                    // This assumes that the `HashSet`'s contents (values and hashes)
445                    // are all stored in a single contiguous heap allocation.
446                    self.iter()
447                        .next()
448                        .map_or(0, |t| unsafe { ops.malloc_enclosing_size_of(t) })
449                } else {
450                    // An estimate.
451                    self.capacity() * (size_of::<T>() + size_of::<usize>())
452                }
453            }
454        }
455
456        impl<T, S> MallocSizeOf for $ty
457        where
458            T: Eq + Hash + MallocSizeOf,
459            S: BuildHasher,
460        {
461            fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
462                let mut n = self.shallow_size_of(ops);
463                for t in self.iter() {
464                    n += t.size_of(ops);
465                }
466                n
467            }
468        }
469    };
470}
471
472malloc_size_of_hash_set!(std::collections::HashSet<T, S>);
473
474macro_rules! malloc_size_of_hash_map {
475    ($ty:ty) => {
476        impl<K, V, S> MallocShallowSizeOf for $ty
477        where
478            K: Eq + Hash,
479            S: BuildHasher,
480        {
481            fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
482                // See the implementation for std::collections::HashSet for details.
483                if ops.has_malloc_enclosing_size_of() {
484                    self.values()
485                        .next()
486                        .map_or(0, |v| unsafe { ops.malloc_enclosing_size_of(v) })
487                } else {
488                    self.capacity() * (size_of::<V>() + size_of::<K>() + size_of::<usize>())
489                }
490            }
491        }
492
493        impl<K, V, S> MallocSizeOf for $ty
494        where
495            K: Eq + Hash + MallocSizeOf,
496            V: MallocSizeOf,
497            S: BuildHasher,
498        {
499            fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
500                let mut n = self.shallow_size_of(ops);
501                for (k, v) in self.iter() {
502                    n += k.size_of(ops);
503                    n += v.size_of(ops);
504                }
505                n
506            }
507        }
508
509        impl<K, V, S> MallocConditionalSizeOf for $ty
510        where
511            K: Eq + Hash + MallocSizeOf,
512            V: MallocConditionalSizeOf,
513            S: BuildHasher,
514        {
515            fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
516                let mut n = self.shallow_size_of(ops);
517                for (k, v) in self.iter() {
518                    n += k.size_of(ops);
519                    n += v.conditional_size_of(ops);
520                }
521                n
522            }
523        }
524    };
525}
526
527malloc_size_of_hash_map!(std::collections::HashMap<K, V, S>);
528
529impl<K, V> MallocShallowSizeOf for std::collections::BTreeMap<K, V>
530where
531    K: Eq + Hash,
532{
533    fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
534        if ops.has_malloc_enclosing_size_of() {
535            self.values()
536                .next()
537                .map_or(0, |v| unsafe { ops.malloc_enclosing_size_of(v) })
538        } else {
539            self.len() * (size_of::<V>() + size_of::<K>() + size_of::<usize>())
540        }
541    }
542}
543
544impl<K, V> MallocSizeOf for std::collections::BTreeMap<K, V>
545where
546    K: Eq + Hash + MallocSizeOf,
547    V: MallocSizeOf,
548{
549    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
550        let mut n = self.shallow_size_of(ops);
551        for (k, v) in self.iter() {
552            n += k.size_of(ops);
553            n += v.size_of(ops);
554        }
555        n
556    }
557}
558
559// PhantomData is always 0.
560impl<T> MallocSizeOf for std::marker::PhantomData<T> {
561    fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
562        0
563    }
564}
565
566impl<T: MallocSizeOf> MallocSizeOf for OnceCell<T> {
567    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
568        self.get()
569            .map(|interior| interior.size_of(ops))
570            .unwrap_or_default()
571    }
572}
573
574impl<T: MallocConditionalSizeOf> MallocConditionalSizeOf for OnceCell<T> {
575    fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
576        self.get()
577            .map(|interior| interior.conditional_size_of(ops))
578            .unwrap_or_default()
579    }
580}
581
582// See https://github.com/rust-lang/rust/issues/68318:
583// We don't want MallocSizeOf to be defined for Rc and Arc. If negative trait bounds are
584// ever allowed, this code should be uncommented.  Instead, there is a compile-fail test for
585// this.
586// impl<T> !MallocSizeOf for Arc<T> { }
587// impl<T> !MallocShallowSizeOf for Arc<T> { }
588
589impl<T> MallocUnconditionalShallowSizeOf for servo_arc::Arc<T> {
590    fn unconditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
591        unsafe { ops.malloc_size_of(self.heap_ptr()) }
592    }
593}
594
595impl<T: MallocSizeOf> MallocUnconditionalSizeOf for servo_arc::Arc<T> {
596    fn unconditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
597        self.unconditional_shallow_size_of(ops) + (**self).size_of(ops)
598    }
599}
600
601impl<T> MallocConditionalShallowSizeOf for servo_arc::Arc<T> {
602    fn conditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
603        if ops.have_seen_ptr(self.heap_ptr()) {
604            0
605        } else {
606            self.unconditional_shallow_size_of(ops)
607        }
608    }
609}
610
611impl<T: MallocSizeOf> MallocConditionalSizeOf for servo_arc::Arc<T> {
612    fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
613        if ops.have_seen_ptr(self.heap_ptr()) {
614            0
615        } else {
616            self.unconditional_size_of(ops)
617        }
618    }
619}
620
621impl<T> MallocUnconditionalShallowSizeOf for Arc<T> {
622    fn unconditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
623        unsafe { ops.malloc_size_of(Arc::as_ptr(self)) }
624    }
625}
626
627impl<T: MallocSizeOf> MallocUnconditionalSizeOf for Arc<T> {
628    fn unconditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
629        self.unconditional_shallow_size_of(ops) + (**self).size_of(ops)
630    }
631}
632
633impl<T> MallocConditionalShallowSizeOf for Arc<T> {
634    fn conditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
635        if ops.have_seen_ptr(Arc::as_ptr(self)) {
636            0
637        } else {
638            self.unconditional_shallow_size_of(ops)
639        }
640    }
641}
642
643impl<T: MallocSizeOf> MallocConditionalSizeOf for Arc<T> {
644    fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
645        if ops.have_seen_ptr(Arc::as_ptr(self)) {
646            0
647        } else {
648            self.unconditional_size_of(ops)
649        }
650    }
651}
652
653impl<T> MallocUnconditionalShallowSizeOf for Rc<T> {
654    fn unconditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
655        unsafe { ops.malloc_size_of(Rc::as_ptr(self)) }
656    }
657}
658
659impl<T: MallocSizeOf> MallocUnconditionalSizeOf for Rc<T> {
660    fn unconditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
661        self.unconditional_shallow_size_of(ops) + (**self).size_of(ops)
662    }
663}
664
665impl<T: MallocSizeOf> MallocConditionalSizeOf for Rc<T> {
666    fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
667        if ops.have_seen_ptr(Rc::as_ptr(self)) {
668            0
669        } else {
670            self.unconditional_size_of(ops)
671        }
672    }
673}
674
675/// If a mutex is stored directly as a member of a data type that is being measured,
676/// it is the unique owner of its contents and deserves to be measured.
677///
678/// If a mutex is stored inside of an Arc value as a member of a data type that is being measured,
679/// the Arc will not be automatically measured so there is no risk of overcounting the mutex's
680/// contents.
681impl<T: MallocSizeOf> MallocSizeOf for std::sync::Mutex<T> {
682    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
683        (*self.lock().unwrap()).size_of(ops)
684    }
685}
686
687impl<T: MallocSizeOf> MallocSizeOf for parking_lot::Mutex<T> {
688    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
689        (*self.lock()).size_of(ops)
690    }
691}
692
693impl<T: MallocSizeOf> MallocSizeOf for parking_lot::RwLock<T> {
694    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
695        (*self.read()).size_of(ops)
696    }
697}
698
699impl<T: MallocSizeOf, Unit> MallocSizeOf for euclid::Length<T, Unit> {
700    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
701        self.0.size_of(ops)
702    }
703}
704
705impl<T: MallocSizeOf, Src, Dst> MallocSizeOf for euclid::Scale<T, Src, Dst> {
706    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
707        self.0.size_of(ops)
708    }
709}
710
711impl<T: MallocSizeOf, U> MallocSizeOf for euclid::Point2D<T, U> {
712    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
713        self.x.size_of(ops) + self.y.size_of(ops)
714    }
715}
716
717impl<T: MallocSizeOf, U> MallocSizeOf for euclid::Box2D<T, U> {
718    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
719        self.min.size_of(ops) + self.max.size_of(ops)
720    }
721}
722
723impl<T: MallocSizeOf, U> MallocSizeOf for euclid::Rect<T, U> {
724    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
725        self.origin.size_of(ops) + self.size.size_of(ops)
726    }
727}
728
729impl<T: MallocSizeOf, U> MallocSizeOf for euclid::SideOffsets2D<T, U> {
730    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
731        self.top.size_of(ops) +
732            self.right.size_of(ops) +
733            self.bottom.size_of(ops) +
734            self.left.size_of(ops)
735    }
736}
737
738impl<T: MallocSizeOf, U> MallocSizeOf for euclid::Size2D<T, U> {
739    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
740        self.width.size_of(ops) + self.height.size_of(ops)
741    }
742}
743
744impl<T: MallocSizeOf, Src, Dst> MallocSizeOf for euclid::Transform2D<T, Src, Dst> {
745    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
746        self.m11.size_of(ops) +
747            self.m12.size_of(ops) +
748            self.m21.size_of(ops) +
749            self.m22.size_of(ops) +
750            self.m31.size_of(ops) +
751            self.m32.size_of(ops)
752    }
753}
754
755impl<T: MallocSizeOf, Src, Dst> MallocSizeOf for euclid::Transform3D<T, Src, Dst> {
756    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
757        self.m11.size_of(ops) +
758            self.m12.size_of(ops) +
759            self.m13.size_of(ops) +
760            self.m14.size_of(ops) +
761            self.m21.size_of(ops) +
762            self.m22.size_of(ops) +
763            self.m23.size_of(ops) +
764            self.m24.size_of(ops) +
765            self.m31.size_of(ops) +
766            self.m32.size_of(ops) +
767            self.m33.size_of(ops) +
768            self.m34.size_of(ops) +
769            self.m41.size_of(ops) +
770            self.m42.size_of(ops) +
771            self.m43.size_of(ops) +
772            self.m44.size_of(ops)
773    }
774}
775
776impl MallocSizeOf for url::Host {
777    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
778        match *self {
779            url::Host::Domain(ref s) => s.size_of(ops),
780            _ => 0,
781        }
782    }
783}
784
785impl MallocSizeOf for url::Url {
786    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
787        // TODO: This is an estimate, but a real size should be calculated in `rust-url` once
788        // it has support for `malloc_size_of`.
789        self.to_string().size_of(ops)
790    }
791}
792
793impl<T: MallocSizeOf, U> MallocSizeOf for euclid::Vector2D<T, U> {
794    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
795        self.x.size_of(ops) + self.y.size_of(ops)
796    }
797}
798
799impl<Static: string_cache::StaticAtomSet> MallocSizeOf for string_cache::Atom<Static> {
800    fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
801        0
802    }
803}
804
805// Placeholder for unique case where internals of Sender cannot be measured.
806// malloc size of is 0 macro complains about type supplied!
807impl<T> MallocSizeOf for crossbeam_channel::Sender<T> {
808    fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
809        0
810    }
811}
812
813impl<T> MallocSizeOf for tokio::sync::mpsc::UnboundedSender<T> {
814    fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
815        0
816    }
817}
818
819impl<T> MallocSizeOf for ipc_channel::ipc::IpcSender<T> {
820    fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
821        0
822    }
823}
824
825impl<T> MallocSizeOf for ipc_channel::ipc::IpcReceiver<T> {
826    fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
827        0
828    }
829}
830
831impl MallocSizeOf for ipc_channel::ipc::IpcSharedMemory {
832    fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
833        self.len()
834    }
835}
836
837impl<T: MallocSizeOf> MallocSizeOf for accountable_refcell::RefCell<T> {
838    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
839        self.borrow().size_of(ops)
840    }
841}
842
843impl MallocSizeOf for servo_arc::Arc<ComputedValues> {
844    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
845        self.conditional_size_of(ops)
846    }
847}
848
849malloc_size_of_hash_map!(indexmap::IndexMap<K, V, S>);
850malloc_size_of_hash_set!(indexmap::IndexSet<T, S>);
851
852malloc_size_of_is_0!(bool, char, str);
853malloc_size_of_is_0!(f32, f64);
854malloc_size_of_is_0!(i8, i16, i32, i64, i128, isize);
855malloc_size_of_is_0!(u8, u16, u32, u64, u128, usize);
856
857malloc_size_of_is_0!(Range<f32>, Range<f64>);
858malloc_size_of_is_0!(Range<i8>, Range<i16>, Range<i32>, Range<i64>, Range<isize>);
859malloc_size_of_is_0!(Range<u8>, Range<u16>, Range<u32>, Range<u64>, Range<usize>);
860malloc_size_of_is_0!(Uuid);
861malloc_size_of_is_0!(app_units::Au);
862malloc_size_of_is_0!(content_security_policy::Destination);
863malloc_size_of_is_0!(content_security_policy::sandboxing_directive::SandboxingFlagSet);
864malloc_size_of_is_0!(http::StatusCode);
865malloc_size_of_is_0!(keyboard_types::Modifiers);
866malloc_size_of_is_0!(mime::Mime);
867malloc_size_of_is_0!(resvg::usvg::Tree);
868malloc_size_of_is_0!(std::num::NonZeroU16);
869malloc_size_of_is_0!(std::num::NonZeroU64);
870malloc_size_of_is_0!(std::num::NonZeroUsize);
871malloc_size_of_is_0!(std::sync::atomic::AtomicBool);
872malloc_size_of_is_0!(std::sync::atomic::AtomicIsize);
873malloc_size_of_is_0!(std::sync::atomic::AtomicUsize);
874malloc_size_of_is_0!(std::time::Duration);
875malloc_size_of_is_0!(std::time::Instant);
876malloc_size_of_is_0!(std::time::SystemTime);
877malloc_size_of_is_0!(style::data::ElementData);
878malloc_size_of_is_0!(style::font_face::SourceList);
879malloc_size_of_is_0!(style::properties::ComputedValues);
880malloc_size_of_is_0!(style::properties::declaration_block::PropertyDeclarationBlock);
881malloc_size_of_is_0!(style::queries::values::PrefersColorScheme);
882malloc_size_of_is_0!(style::stylesheets::Stylesheet);
883malloc_size_of_is_0!(style::values::specified::source_size_list::SourceSizeList);
884malloc_size_of_is_0!(taffy::Layout);
885malloc_size_of_is_0!(unicode_bidi::Level);
886malloc_size_of_is_0!(unicode_script::Script);
887malloc_size_of_is_0!(urlpattern::UrlPattern);
888malloc_size_of_is_0!(utf8::Incomplete);
889
890macro_rules! malloc_size_of_is_webrender_malloc_size_of(
891    ($($ty:ty),+) => (
892        $(
893            impl MallocSizeOf for $ty {
894                fn size_of(&self, _: &mut MallocSizeOfOps) -> usize {
895                    let mut ops = wr_malloc_size_of::MallocSizeOfOps::new(servo_allocator::usable_size, None);
896                    <$ty as wr_malloc_size_of::MallocSizeOf>::size_of(self, &mut ops)
897                }
898            }
899        )+
900    );
901);
902
903malloc_size_of_is_webrender_malloc_size_of!(webrender_api::BorderRadius);
904malloc_size_of_is_webrender_malloc_size_of!(webrender_api::BorderStyle);
905malloc_size_of_is_webrender_malloc_size_of!(webrender_api::BoxShadowClipMode);
906malloc_size_of_is_webrender_malloc_size_of!(webrender_api::ColorF);
907malloc_size_of_is_webrender_malloc_size_of!(webrender_api::Epoch);
908malloc_size_of_is_webrender_malloc_size_of!(webrender_api::ExtendMode);
909malloc_size_of_is_webrender_malloc_size_of!(webrender_api::ExternalScrollId);
910malloc_size_of_is_webrender_malloc_size_of!(webrender_api::FontKey);
911malloc_size_of_is_webrender_malloc_size_of!(webrender_api::FontInstanceFlags);
912malloc_size_of_is_webrender_malloc_size_of!(webrender_api::FontInstanceKey);
913malloc_size_of_is_webrender_malloc_size_of!(webrender_api::GlyphInstance);
914malloc_size_of_is_webrender_malloc_size_of!(webrender_api::GradientStop);
915malloc_size_of_is_webrender_malloc_size_of!(webrender_api::ImageKey);
916malloc_size_of_is_webrender_malloc_size_of!(webrender_api::ImageRendering);
917malloc_size_of_is_webrender_malloc_size_of!(webrender_api::LineStyle);
918malloc_size_of_is_webrender_malloc_size_of!(webrender_api::MixBlendMode);
919malloc_size_of_is_webrender_malloc_size_of!(webrender_api::NormalBorder);
920malloc_size_of_is_webrender_malloc_size_of!(webrender_api::PipelineId);
921malloc_size_of_is_webrender_malloc_size_of!(webrender_api::ReferenceFrameKind);
922malloc_size_of_is_webrender_malloc_size_of!(webrender_api::RepeatMode);
923malloc_size_of_is_webrender_malloc_size_of!(webrender_api::FontVariation);
924malloc_size_of_is_webrender_malloc_size_of!(webrender_api::SpatialId);
925malloc_size_of_is_webrender_malloc_size_of!(webrender_api::StickyOffsetBounds);
926malloc_size_of_is_webrender_malloc_size_of!(webrender_api::TransformStyle);
927malloc_size_of_is_webrender_malloc_size_of!(webrender::FastTransform<webrender_api::units::LayoutPixel,webrender_api::units::LayoutPixel>);
928
929macro_rules! malloc_size_of_is_stylo_malloc_size_of(
930    ($($ty:ty),+) => (
931        $(
932            impl MallocSizeOf for $ty {
933                fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
934                    <$ty as stylo_malloc_size_of::MallocSizeOf>::size_of(self, ops)
935                }
936            }
937        )+
938    );
939);
940
941impl<S> MallocSizeOf for style::author_styles::GenericAuthorStyles<S>
942where
943    S: style::stylesheets::StylesheetInDocument
944        + std::cmp::PartialEq
945        + stylo_malloc_size_of::MallocSizeOf,
946{
947    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
948        <style::author_styles::GenericAuthorStyles<S> as stylo_malloc_size_of::MallocSizeOf>::size_of(self, ops)
949    }
950}
951
952impl<S> MallocSizeOf for style::stylesheet_set::DocumentStylesheetSet<S>
953where
954    S: style::stylesheets::StylesheetInDocument
955        + std::cmp::PartialEq
956        + stylo_malloc_size_of::MallocSizeOf,
957{
958    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
959        <style::stylesheet_set::DocumentStylesheetSet<S> as stylo_malloc_size_of::MallocSizeOf>::size_of(self, ops)
960    }
961}
962
963impl<T> MallocSizeOf for style::shared_lock::Locked<T> {
964    fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
965        // TODO: fix this implementation when Locked derives MallocSizeOf.
966        0
967        // <style::shared_lock::Locked<T> as stylo_malloc_size_of::MallocSizeOf>::size_of(self, ops)
968    }
969}
970
971impl<T: MallocSizeOf> MallocSizeOf for atomic_refcell::AtomicRefCell<T> {
972    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
973        self.borrow().size_of(ops)
974    }
975}
976
977malloc_size_of_is_stylo_malloc_size_of!(style::animation::DocumentAnimationSet);
978malloc_size_of_is_stylo_malloc_size_of!(style::attr::AttrIdentifier);
979malloc_size_of_is_stylo_malloc_size_of!(style::attr::AttrValue);
980malloc_size_of_is_stylo_malloc_size_of!(style::color::AbsoluteColor);
981malloc_size_of_is_stylo_malloc_size_of!(style::computed_values::font_variant_caps::T);
982malloc_size_of_is_stylo_malloc_size_of!(style::computed_values::text_decoration_style::T);
983malloc_size_of_is_stylo_malloc_size_of!(style::dom::OpaqueNode);
984malloc_size_of_is_stylo_malloc_size_of!(style::invalidation::element::restyle_hints::RestyleHint);
985malloc_size_of_is_stylo_malloc_size_of!(style::logical_geometry::WritingMode);
986malloc_size_of_is_stylo_malloc_size_of!(style::media_queries::MediaList);
987malloc_size_of_is_stylo_malloc_size_of!(
988    style::properties::longhands::align_items::computed_value::T
989);
990malloc_size_of_is_stylo_malloc_size_of!(
991    style::properties::longhands::flex_direction::computed_value::T
992);
993malloc_size_of_is_stylo_malloc_size_of!(style::properties::longhands::flex_wrap::computed_value::T);
994malloc_size_of_is_stylo_malloc_size_of!(style::properties::style_structs::Font);
995malloc_size_of_is_stylo_malloc_size_of!(style::selector_parser::PseudoElement);
996malloc_size_of_is_stylo_malloc_size_of!(style::selector_parser::RestyleDamage);
997malloc_size_of_is_stylo_malloc_size_of!(style::selector_parser::Snapshot);
998malloc_size_of_is_stylo_malloc_size_of!(style::shared_lock::SharedRwLock);
999malloc_size_of_is_stylo_malloc_size_of!(style::stylesheets::DocumentStyleSheet);
1000malloc_size_of_is_stylo_malloc_size_of!(style::stylist::Stylist);
1001malloc_size_of_is_stylo_malloc_size_of!(style::values::computed::BorderStyle);
1002malloc_size_of_is_stylo_malloc_size_of!(style::values::computed::ContentDistribution);
1003malloc_size_of_is_stylo_malloc_size_of!(style::values::computed::FontStretch);
1004malloc_size_of_is_stylo_malloc_size_of!(style::values::computed::FontStyle);
1005malloc_size_of_is_stylo_malloc_size_of!(style::values::computed::FontWeight);
1006malloc_size_of_is_stylo_malloc_size_of!(style::values::computed::font::SingleFontFamily);
1007malloc_size_of_is_stylo_malloc_size_of!(style::values::specified::align::AlignFlags);
1008malloc_size_of_is_stylo_malloc_size_of!(style::values::specified::box_::Overflow);
1009malloc_size_of_is_stylo_malloc_size_of!(style::values::specified::font::FontSynthesis);
1010malloc_size_of_is_stylo_malloc_size_of!(style::values::specified::TextDecorationLine);
1011malloc_size_of_is_stylo_malloc_size_of!(stylo_dom::ElementState);
1012
1013impl<T> MallocSizeOf for GenericLengthPercentageOrAuto<T>
1014where
1015    T: stylo_malloc_size_of::MallocSizeOf,
1016{
1017    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
1018        <GenericLengthPercentageOrAuto<T> as stylo_malloc_size_of::MallocSizeOf>::size_of(self, ops)
1019    }
1020}
servo_malloc_size_of/lib.rs

servo_malloc_size_of/
lib.rs
