Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-05 21:50:18 +01:00
Code Issues Projects Releases Packages Wiki Activity

Say farewell to in-tree HeapSizeOf

Browse source
This commit is contained in:
Anthony Ramine 2016-01-30 15:06:31 +01:00
parent 9932a5cf82
commit cb5cd8d881
80 changed files with 245 additions and 733 deletions
Download patch file Download diff file Expand all files Collapse all files

12
components/util/Cargo.toml
View file

@ -47,10 +47,12 @@ git = "https://github.com/servo/ipc-channel"
[dependencies]
app_units = {version = "0.2", features = ["plugins"]}
bitflags = "0.3"
cssparser = {version = "0.5.2", features = ["serde-serialization"]}
cssparser = {version = "0.5.2", features = ["heap_size", "serde-serialization"]}
euclid = {version = "0.6.1", features = ["unstable", "plugins"]}
getopts = "0.2.11"
html5ever = {version = "0.4.2", features = ["unstable"], optional = true}
html5ever = {version = "0.4.2", features = ["heap_size", "unstable"], optional = true}
heapsize = "0.2.5"
heapsize_plugin = "0.1.2"
hyper = { version = "0.7", optional = true }
lazy_static = "0.1"
libc = "0.2"
@ -59,12 +61,12 @@ num = "0.1.24"
num_cpus = "0.2.2"
rand = "0.3"
rustc-serialize = "0.3"
selectors = "0.4.1"
selectors = {version = "0.4.1", features = ["heap_size"]}
serde = "0.6"
serde_macros = "0.6"
smallvec = "0.1"
string_cache = "0.2.7"
url = {version = "0.5.4", features = ["serde_serialization"]}
string_cache = {version = "0.2.7", features = ["heap_size"]}
url = {version = "0.5.4", features = ["heap_size", "serde_serialization"]}
uuid = "0.1.17"
[target.x86_64-pc-windows-gnu.dependencies]

2
components/util/cursor.rs
View file

@ -9,7 +9,7 @@ use std::ascii::AsciiExt;
macro_rules! define_cursor {
($( $css: expr => $variant: ident = $value: expr, )+) => {
#[derive(Clone, Copy, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[derive(Clone, Copy, Debug, Deserialize, Eq, HeapSizeOf, PartialEq, Serialize)]
#[repr(u8)]
pub enum Cursor {
$( $variant = $value ),+

6
components/util/geometry.rs
View file

@ -23,7 +23,7 @@ use std::i32;
///
/// The ratio between ScreenPx and DevicePixel for a given display be found by calling
/// `servo::windowing::WindowMethods::hidpi_factor`.
#[derive(Debug, Copy, Clone)]
#[derive(Clone, Copy, Debug, HeapSizeOf)]
pub enum ScreenPx {}
/// One CSS "px" in the coordinate system of the "initial viewport":
@ -35,7 +35,7 @@ pub enum ScreenPx {}
///
/// At the default zoom level of 100%, one PagePx is equal to one ScreenPx. However, if the
/// document is zoomed in or out then this scale may be larger or smaller.
#[derive(RustcEncodable, Debug, Copy, Clone)]
#[derive(Clone, Copy, Debug, HeapSizeOf)]
pub enum ViewportPx {}
/// One CSS "px" in the root coordinate system for the content document.
@ -44,7 +44,7 @@ pub enum ViewportPx {}
/// This is the mobile-style "pinch zoom" that enlarges content without reflowing it. When the
/// viewport zoom is not equal to 1.0, then the layout viewport is no longer the same physical size
/// as the viewable area.
#[derive(RustcEncodable, Debug, Copy, Clone)]
#[derive(Clone, Copy, Debug, HeapSizeOf)]
pub enum PagePx {}
// In summary, the hierarchy of pixel units and the factors to convert from one to the next:

4
components/util/lib.rs
View file

@ -18,7 +18,7 @@
#![feature(step_trait)]
#![feature(zero_one)]
#![plugin(plugins, serde_macros)]
#![plugin(heapsize_plugin, plugins, serde_macros)]
extern crate alloc;
extern crate app_units;
@ -30,6 +30,7 @@ extern crate bitflags;
extern crate cssparser;
extern crate euclid;
extern crate getopts;
extern crate heapsize;
#[cfg(feature = "non-geckolib")]
extern crate html5ever;
#[cfg(feature = "non-geckolib")]
@ -66,7 +67,6 @@ pub mod geometry;
pub mod ipc;
pub mod linked_list;
pub mod logical_geometry;
#[macro_use] pub mod mem;
#[cfg(feature = "non-geckolib")]
pub mod non_geckolib;
pub mod opts;

2
components/util/logical_geometry.rs
View file

@ -11,7 +11,7 @@ use std::fmt::{self, Debug, Error, Formatter};
use std::ops::{Add, Sub};
bitflags!(
#[derive(RustcEncodable)]
#[derive(HeapSizeOf, RustcEncodable)]
flags WritingMode: u8 {
const FLAG_RTL = 1 << 0,
const FLAG_VERTICAL = 1 << 1,

360
components/util/mem.rs
View file

@ -1,360 +0,0 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
//! Data structure measurement.
use app_units::Au;
use cssparser::Color as CSSParserColor;
use cssparser::{RGBA, TokenSerializationType};
use cursor::Cursor;
use euclid::length::Length;
use euclid::scale_factor::ScaleFactor;
use euclid::{Matrix2D, Matrix4, Point2D, Rect, SideOffsets2D, Size2D};
use geometry::{PagePx, ViewportPx};
use libc::{c_void, size_t};
use logical_geometry::WritingMode;
use rand::OsRng;
use range::Range;
use selectors::parser::{Combinator, CompoundSelector, Selector, SimpleSelector, SelectorImpl};
use std::cell::{Cell, RefCell};
use std::collections::{HashMap, LinkedList};
use std::hash::{BuildHasher, Hash};
use std::mem::{size_of, transmute};
use std::rc::Rc;
use std::result::Result;
use std::sync::Arc;
use std::sync::atomic::{AtomicIsize, AtomicUsize};
use str::{DOMString, LengthOrPercentageOrAuto};
use string_cache::atom::Atom;
use string_cache::namespace::{QualName, Namespace};
use url;
use uuid::Uuid;
extern {
// Get the size of a heap block.
//
// Ideally Rust would expose a function like this in std::rt::heap, which would avoid the
// jemalloc dependence.
//
// The C prototype is `je_malloc_usable_size(JEMALLOC_USABLE_SIZE_CONST void *ptr)`. On some
// platforms `JEMALLOC_USABLE_SIZE_CONST` is `const` and on some it is empty. But in practice
// this function doesn't modify the contents of the block that `ptr` points to, so we use
// `*const c_void` here.
fn je_malloc_usable_size(ptr: *const c_void) -> size_t;
}
// A wrapper for je_malloc_usable_size that handles `EMPTY` and returns `usize`.
pub fn heap_size_of(ptr: *const c_void) -> usize {
if ptr == ::alloc::heap::EMPTY as *const c_void {
0
} else {
unsafe { je_malloc_usable_size(ptr) as usize }
}
}
// The simplest trait for measuring the size of heap data structures. More complex traits that
// return multiple measurements -- e.g. measure text separately from images -- are also possible,
// and should be used when appropriate.
//
pub trait HeapSizeOf {
/// Measure the size of any heap-allocated structures that hang off this value, but not the
/// space taken up by the value itself (i.e. what size_of::<T> measures, more or less); that
/// space is handled by the implementation of HeapSizeOf for Box<T> below.
fn heap_size_of_children(&self) -> usize;
}
// There are two possible ways to measure the size of `self` when it's on the heap: compute it
// (with `::std::rt::heap::usable_size(::std::mem::size_of::<T>(), 0)`) or measure it directly
// using the heap allocator (with `heap_size_of`). We do the latter, for the following reasons.
//
// * The heap allocator is the true authority for the sizes of heap blocks; its measurement is
// guaranteed to be correct. In comparison, size computations are error-prone. (For example, the
// `rt::heap::usable_size` function used in some of Rust's non-default allocator implementations
// underestimate the true usable size of heap blocks, which is safe in general but would cause
// under-measurement here.)
//
// * If we measure something that isn't a heap block, we'll get a crash. This keeps us honest,
// which is important because unsafe code is involved and this can be gotten wrong.
//
// However, in the best case, the two approaches should give the same results.
//
impl<T: HeapSizeOf> HeapSizeOf for Box<T> {
fn heap_size_of_children(&self) -> usize {
// Measure size of `self`.
heap_size_of(&**self as *const T as *const c_void) + (**self).heap_size_of_children()
}
}
impl HeapSizeOf for String {
fn heap_size_of_children(&self) -> usize {
heap_size_of(self.as_ptr() as *const c_void)
}
}
impl HeapSizeOf for DOMString {
fn heap_size_of_children(&self) -> usize {
heap_size_of(self.as_ptr() as *const c_void)
}
}
impl<T: HeapSizeOf> HeapSizeOf for Option<T> {
fn heap_size_of_children(&self) -> usize {
match *self {
None => 0,
Some(ref x) => x.heap_size_of_children()
}
}
}
impl HeapSizeOf for url::Url {
fn heap_size_of_children(&self) -> usize {
// Using a struct pattern without `..` rather than `foo.bar` field access
// makes sure this will be updated if a field is added.
let &url::Url { ref scheme, ref scheme_data, ref query, ref fragment } = self;
scheme.heap_size_of_children() +
scheme_data.heap_size_of_children() +
query.heap_size_of_children() +
fragment.heap_size_of_children()
}
}
impl HeapSizeOf for url::SchemeData {
fn heap_size_of_children(&self) -> usize {
match *self {
url::SchemeData::Relative(ref data) => data.heap_size_of_children(),
url::SchemeData::NonRelative(ref str) => str.heap_size_of_children()
}
}
}
impl HeapSizeOf for url::RelativeSchemeData {
fn heap_size_of_children(&self) -> usize {
// Using a struct pattern without `..` rather than `foo.bar` field access
// makes sure this will be updated if a field is added.
let &url::RelativeSchemeData { ref username, ref password, ref host,
ref port, ref default_port, ref path } = self;
username.heap_size_of_children() +
password.heap_size_of_children() +
host.heap_size_of_children() +
port.heap_size_of_children() +
default_port.heap_size_of_children() +
path.heap_size_of_children()
}
}
impl HeapSizeOf for url::Host {
fn heap_size_of_children(&self) -> usize {
match *self {
url::Host::Domain(ref str) => str.heap_size_of_children(),
url::Host::Ipv6(_) => 0,
url::Host::Ipv4(_) => 0,
}
}
}
impl<T: HeapSizeOf, U: HeapSizeOf> HeapSizeOf for (T, U) {
fn heap_size_of_children(&self) -> usize {
self.0.heap_size_of_children() + self.1.heap_size_of_children()
}
}
impl<T: HeapSizeOf> HeapSizeOf for Arc<T> {
fn heap_size_of_children(&self) -> usize {
(**self).heap_size_of_children()
}
}
impl<T: HeapSizeOf> HeapSizeOf for RefCell<T> {
fn heap_size_of_children(&self) -> usize {
self.borrow().heap_size_of_children()
}
}
impl<T: HeapSizeOf + Copy> HeapSizeOf for Cell<T> {
fn heap_size_of_children(&self) -> usize {
self.get().heap_size_of_children()
}
}
impl<T: HeapSizeOf> HeapSizeOf for Vec<T> {
fn heap_size_of_children(&self) -> usize {
heap_size_of(self.as_ptr() as *const c_void) +
self.iter().fold(0, |n, elem| n + elem.heap_size_of_children())
}
}
impl<T> HeapSizeOf for Vec<Rc<T>> {
fn heap_size_of_children(&self) -> usize {
// The fate of measuring Rc<T> is still undecided, but we still want to measure
// the space used for storing them.
heap_size_of(self.as_ptr() as *const c_void)
}
}
impl<K: HeapSizeOf, V: HeapSizeOf, S> HeapSizeOf for HashMap<K, V, S>
where K: Eq + Hash, S: BuildHasher {
fn heap_size_of_children(&self) -> usize {
//TODO(#6908) measure actual bucket memory usage instead of approximating
let size = self.capacity() * (size_of::<V>() + size_of::<K>());
self.iter().fold(size, |n, (key, value)| {
n + key.heap_size_of_children() + value.heap_size_of_children()
})
}
}
// FIXME(njn): We can't implement HeapSizeOf accurately for LinkedList because it requires access
// to the private Node type. Eventually we'll want to add HeapSizeOf (or equivalent) to Rust
// itself. In the meantime, we use the dirty hack of transmuting LinkedList into an identical type
// (LinkedList2) and measuring that.
impl<T: HeapSizeOf> HeapSizeOf for LinkedList<T> {
fn heap_size_of_children(&self) -> usize {
let list2: &LinkedList2<T> = unsafe { transmute(self) };
list2.heap_size_of_children()
}
}
struct LinkedList2<T> {
_length: usize,
list_head: Link<T>,
_list_tail: Rawlink<Node<T>>,
}
type Link<T> = Option<Box<Node<T>>>;
struct Rawlink<T> {
_p: *mut T,
}
struct Node<T> {
next: Link<T>,
_prev: Rawlink<Node<T>>,
value: T,
}
impl<T: HeapSizeOf> HeapSizeOf for Node<T> {
// Unlike most heap_size_of_children() functions, this one does *not* measure descendents.
// Instead, LinkedList2<T>::heap_size_of_children() handles that, so that it can use iteration
// instead of recursion, which avoids potentially blowing the stack.
fn heap_size_of_children(&self) -> usize {
self.value.heap_size_of_children()
}
}
impl<T: HeapSizeOf> HeapSizeOf for LinkedList2<T> {
fn heap_size_of_children(&self) -> usize {
let mut size = 0;
let mut curr: &Link<T> = &self.list_head;
while curr.is_some() {
size += (*curr).heap_size_of_children();
curr = &curr.as_ref().unwrap().next;
}
size
}
}
// This is a basic sanity check. If the representation of LinkedList changes such that it becomes a
// different size to LinkedList2, this will fail at compile-time.
#[allow(dead_code)]
unsafe fn linked_list2_check() {
transmute::<LinkedList<i32>, LinkedList2<i32>>(panic!());
}
// Currently, types that implement the Drop type are larger than those that don't. Because
// LinkedList implements Drop, LinkedList2 must also so that linked_list2_check() doesn't fail.
impl<T> Drop for LinkedList2<T> {
fn drop(&mut self) {}
}
/// For use on types defined in external crates
/// with known heap sizes.
#[macro_export]
macro_rules! known_heap_size(
($size:expr, $($ty:ident),+) => (
$(
impl $crate::mem::HeapSizeOf for $ty {
#[inline(always)]
fn heap_size_of_children(&self) -> usize {
$size
}
}
)+
);
($size: expr, $($ty:ident<$($gen:ident),+>),+) => (
$(
impl<$($gen: $crate::mem::HeapSizeOf),+> $crate::mem::HeapSizeOf for $ty<$($gen),+> {
#[inline(always)]
fn heap_size_of_children(&self) -> usize {
$size
}
}
)+
);
);
impl<T: HeapSizeOf, U: HeapSizeOf> HeapSizeOf for Result<T, U> {
fn heap_size_of_children(&self) -> usize {
match *self {
Result::Ok(ref ok) => ok.heap_size_of_children(),
Result::Err(ref err) => err.heap_size_of_children()
}
}
}
impl HeapSizeOf for () {
fn heap_size_of_children(&self) -> usize {
0
}
}
impl<T: SelectorImpl> HeapSizeOf for Selector<T>
where T::NonTSPseudoClass: HeapSizeOf,
T::PseudoElement: HeapSizeOf {
fn heap_size_of_children(&self) -> usize {
let &Selector { ref compound_selectors, ref pseudo_element, ref specificity } = self;
compound_selectors.heap_size_of_children() + pseudo_element.heap_size_of_children() +
specificity.heap_size_of_children()
}
}
impl<T: SelectorImpl> HeapSizeOf for CompoundSelector<T>
where T::NonTSPseudoClass: HeapSizeOf {
fn heap_size_of_children(&self) -> usize {
let &CompoundSelector { ref simple_selectors, ref next } = self;
simple_selectors.heap_size_of_children() + next.heap_size_of_children()
}
}
impl<T: SelectorImpl> HeapSizeOf for SimpleSelector<T>
where T::NonTSPseudoClass: HeapSizeOf {
fn heap_size_of_children(&self) -> usize {
match *self {
SimpleSelector::Negation(ref vec) => vec.heap_size_of_children(),
SimpleSelector::AttrIncludes(_, ref str) | SimpleSelector::AttrPrefixMatch(_, ref str) |
SimpleSelector::AttrSubstringMatch(_, ref str) | SimpleSelector::AttrSuffixMatch(_, ref str)
=> str.heap_size_of_children(),
SimpleSelector::AttrEqual(_, ref str, _) => str.heap_size_of_children(),
SimpleSelector::AttrDashMatch(_, ref first, ref second)
=> first.heap_size_of_children() + second.heap_size_of_children(),
SimpleSelector::NonTSPseudoClass(ref pseudo_class)
=> pseudo_class.heap_size_of_children(),
// All other types come down to Atom, enum or i32, all 0
_ => 0
}
}
}
known_heap_size!(0, u8, u16, u32, u64, usize);
known_heap_size!(0, i8, i16, i32, i64, isize);
known_heap_size!(0, bool, f32, f64);
known_heap_size!(0, AtomicIsize, AtomicUsize);
known_heap_size!(0, Rect<T>, Point2D<T>, Size2D<T>, Matrix2D<T>, SideOffsets2D<T>, Range<T>);
known_heap_size!(0, Length<T, U>, ScaleFactor<T, U, V>);
known_heap_size!(0, Au, WritingMode, CSSParserColor, RGBA, Cursor, Matrix4, QualName, Atom, Namespace);
known_heap_size!(0, PagePx, ViewportPx, OsRng);
known_heap_size!(0, TokenSerializationType, LengthOrPercentageOrAuto);
known_heap_size!(0, Combinator, str);
known_heap_size!(0, Uuid);

84
components/util/non_geckolib.rs
View file

@ -4,20 +4,10 @@
///! Miscellaneous Code which depends on large libraries that we don't
/// depend on in GeckoLib builds.
use azure::azure_hl::Color;
use html5ever::tree_builder::QuirksMode;
use hyper::header::ContentType;
use hyper::http::RawStatus;
use hyper::method::Method;
use hyper::mime::{Attr, Mime, SubLevel, TopLevel, Value};
use js::conversions::{FromJSValConvertible, ToJSValConvertible, latin1_to_string};
use js::jsapi::{JSContext, JSString, HandleValue, Heap, MutableHandleValue};
use js::jsapi::{JSContext, JSString, HandleValue, MutableHandleValue};
use js::jsapi::{JS_GetTwoByteStringCharsAndLength, JS_StringHasLatin1Chars};
use js::jsval::JSVal;
use js::rust::{GCMethods, ToString};
use layers::geometry::DevicePixel;
use mem::HeapSizeOf;
use js::rust::ToString;
use opts;
use std::char;
use std::ptr;
@ -99,73 +89,3 @@ pub unsafe fn jsstring_to_str(cx: *mut JSContext, s: *mut JSString) -> DOMString
s
})
}
// This is measured properly by the heap measurement implemented in SpiderMonkey.
impl<T: Copy + GCMethods<T>> HeapSizeOf for Heap<T> {
fn heap_size_of_children(&self) -> usize {
0
}
}
impl HeapSizeOf for ContentType {
fn heap_size_of_children(&self) -> usize {
let &ContentType(ref mime) = self;
mime.heap_size_of_children()
}
}
impl HeapSizeOf for Method {
fn heap_size_of_children(&self) -> usize {
match *self {
Method::Extension(ref str) => str.heap_size_of_children(),
_ => 0
}
}
}
impl HeapSizeOf for Mime {
fn heap_size_of_children(&self) -> usize {
let &Mime(ref top_level, ref sub_level, ref vec) = self;
top_level.heap_size_of_children() + sub_level.heap_size_of_children() +
vec.heap_size_of_children()
}
}
impl HeapSizeOf for TopLevel {
fn heap_size_of_children(&self) -> usize {
match *self {
TopLevel::Ext(ref str) => str.heap_size_of_children(),
_ => 0
}
}
}
impl HeapSizeOf for SubLevel {
fn heap_size_of_children(&self) -> usize {
match *self {
SubLevel::Ext(ref str) => str.heap_size_of_children(),
_ => 0
}
}
}
impl HeapSizeOf for Attr {
fn heap_size_of_children(&self) -> usize {
match *self {
Attr::Ext(ref str) => str.heap_size_of_children(),
_ => 0
}
}
}
impl HeapSizeOf for Value {
fn heap_size_of_children(&self) -> usize {
match *self {
Value::Ext(ref str) => str.heap_size_of_children(),
_ => 0
}
}
}
known_heap_size!(0, Color, DevicePixel, JSVal, QuirksMode, RawStatus);

2
components/util/range.rs
View file

@ -136,7 +136,7 @@ macro_rules! int_range_index {
}
/// A range of indices
#[derive(Clone, RustcEncodable, Copy, Deserialize, Serialize)]
#[derive(Clone, Copy, Deserialize, HeapSizeOf, RustcEncodable, Serialize)]
pub struct Range<I> {
begin: I,
length: I,

4
components/util/str.rs
View file

@ -16,7 +16,7 @@ use std::iter::{Filter, Peekable};
use std::ops::{Deref, DerefMut};
use std::str::{Bytes, CharIndices, FromStr, Split, from_utf8};
#[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Deserialize, Serialize, Hash, Debug)]
#[derive(Clone, Debug, Deserialize, Eq, Hash, HeapSizeOf, Ord, PartialEq, PartialOrd, Serialize)]
pub struct DOMString(String);
impl !Send for DOMString {}
@ -220,7 +220,7 @@ pub fn parse_unsigned_integer<T: Iterator<Item=char>>(input: T) -> Option<u32> {
})
}
#[derive(Copy, Clone, Debug, PartialEq)]
#[derive(Clone, Copy, Debug, HeapSizeOf, PartialEq)]
pub enum LengthOrPercentageOrAuto {
Auto,
Percentage(f32),