Skip to content
Permalink
Browse files

style: Introduce StyleBloom

The idea is this will fix the bad behavior of the bloom filter in parallel
traversal.
  • Loading branch information
emilio committed Nov 27, 2016
1 parent 7d69f53 commit 84a50ed5cb1f136baf47d34d06b0577d939337a6
@@ -18,9 +18,7 @@ use style::data::ElementData;
use style::dom::{StylingMode, TElement, TNode};
use style::selector_parser::RestyleDamage;
use style::servo::restyle_damage::{BUBBLE_ISIZES, REFLOW, REFLOW_OUT_OF_FLOW, REPAINT};
use style::traversal::{DomTraversalContext, put_thread_local_bloom_filter};
use style::traversal::{recalc_style_at, remove_from_bloom_filter};
use style::traversal::take_thread_local_bloom_filter;
use style::traversal::{DomTraversalContext, recalc_style_at, remove_from_bloom_filter};
use util::opts;
use wrapper::{GetRawData, LayoutNodeHelpers, LayoutNodeLayoutData};

@@ -79,32 +77,12 @@ impl<'lc, N> DomTraversalContext<N> for RecalcStyleAndConstructFlows<'lc>
// done by the HTML parser.
node.initialize_data();

if node.is_text_node() {
// FIXME(bholley): Stop doing this silly work to maintain broken bloom filter
// invariants.
//
// Longer version: The bloom filter is entirely busted for parallel traversal. Because
// parallel traversal is breadth-first, each sibling rejects the bloom filter set up
// by the previous sibling (which is valid for children, not siblings) and recreates
// it. Similarly, the fixup performed in the bottom-up traversal is useless, because
// threads perform flow construction up the parent chain until they find a parent with
// other unprocessed children, at which point they bail to the work queue and find a
// different node.
//
// Nevertheless, the remove_from_bloom_filter call at the end of flow construction
// asserts that the bloom filter is valid for the current node. This breaks when we
// stop calling recalc_style_at for text nodes, because the recursive chain of
// construct_flows_at calls is no longer necessarily rooted in a call that sets up the
// thread-local bloom filter for the leaf node.
//
// The bloom filter stuff is all going to be rewritten, so we just hackily duplicate
// the bloom filter manipulation from recalc_style_at to maintain invariants.
let parent = node.parent_node().unwrap().as_element();
let bf = take_thread_local_bloom_filter(parent, self.root, self.context.shared_context());
put_thread_local_bloom_filter(bf, &node.to_unsafe(), self.context.shared_context());
} else {
// FIXME(emilio): Get it!
let traversal_depth = None;

if !node.is_text_node() {
let el = node.as_element().unwrap();
recalc_style_at::<_, _, Self>(&self.context, self.root, el);
recalc_style_at::<_, _, Self>(&self.context, traversal_depth, el);
}
}

@@ -174,9 +152,9 @@ fn construct_flows_at<'a, N: LayoutNode>(context: &'a LayoutContext<'a>, root: O
if let Some(el) = node.as_element() {
el.mutate_data().unwrap().persist();
unsafe { el.unset_dirty_descendants(); }
}

remove_from_bloom_filter(context, root, node);
remove_from_bloom_filter(context, root, el);
}
}

/// The bubble-inline-sizes traversal, the first part of layout computation. This computes
@@ -175,14 +175,6 @@ impl<'ln> TNode for ServoLayoutNode<'ln> {
unsafe { self.get_jsmanaged().opaque() }
}

fn layout_parent_element(self, reflow_root: OpaqueNode) -> Option<ServoLayoutElement<'ln>> {
if self.opaque() == reflow_root {
None
} else {
self.parent_node().and_then(|x| x.as_element())
}
}

fn debug_id(self) -> usize {
self.opaque().0
}
@@ -0,0 +1,235 @@
/* 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/. */

//! The style bloom filter is used as an optimization when matching deep
//! descendant selectors.

use dom::{TNode, TElement, UnsafeNode};
use matching::MatchMethods;
use selectors::bloom::BloomFilter;

pub struct StyleBloom {
/// The bloom filter per se.
filter: Box<BloomFilter>,

/// The stack of elements that this bloom filter contains. These unsafe
/// nodes are guaranteed to be elements.
///
/// Note that the use we do for them is safe, since the data we access from
/// them is completely read-only during restyling.
elements: Vec<UnsafeNode>,

/// A monotonic counter incremented which each reflow in order to invalidate
/// the bloom filter if appropriate.
generation: u32,
}

impl StyleBloom {
pub fn new(generation: u32) -> Self {
StyleBloom {
filter: Box::new(BloomFilter::new()),
elements: vec![],
generation: generation,
}
}

pub fn filter(&self) -> &BloomFilter {
&*self.filter
}

pub fn generation(&self) -> u32 {
self.generation
}

pub fn maybe_pop<E>(&mut self, element: E)
where E: TElement + MatchMethods
{
if self.elements.last() == Some(&element.as_node().to_unsafe()) {
self.pop::<E>().unwrap();
}
}

/// Push an element to the bloom filter, knowing that it's a child of the
/// last element parent.
pub fn push<E>(&mut self, element: E)
where E: TElement + MatchMethods,
{
if cfg!(debug_assertions) {
if self.elements.is_empty() {
assert!(element.parent_element().is_none());
}
}
element.insert_into_bloom_filter(&mut *self.filter);
self.elements.push(element.as_node().to_unsafe());
}

/// Pop the last element in the bloom filter and return it.
fn pop<E>(&mut self) -> Option<E>
where E: TElement + MatchMethods,
{
let popped =
self.elements.pop().map(|unsafe_node| {
let parent = unsafe {
E::ConcreteNode::from_unsafe(&unsafe_node)
};
parent.as_element().unwrap()
});
if let Some(popped) = popped {
popped.remove_from_bloom_filter(&mut self.filter);
}

popped
}

fn clear(&mut self) {
self.filter.clear();
self.elements.clear();
}

fn rebuild<E>(&mut self, mut element: E) -> usize
where E: TElement + MatchMethods,
{
self.clear();

while let Some(parent) = element.parent_element() {
parent.insert_into_bloom_filter(&mut *self.filter);
self.elements.push(parent.as_node().to_unsafe());
element = parent;
}

// Put them in the order we expect, from root to `element`'s parent.
self.elements.reverse();
return self.elements.len();
}

/// In debug builds, asserts that all the parents of `element` are in the
/// bloom filter.
pub fn assert_complete<E>(&self, mut element: E)
where E: TElement,
{
if cfg!(debug_assertions) {
let mut checked = 0;
while let Some(parent) = element.parent_element() {
assert_eq!(parent.as_node().to_unsafe(),
self.elements[self.elements.len() - 1 - checked]);
element = parent;
checked += 1;
}
assert_eq!(checked, self.elements.len());
}
}

/// Insert the parents of an element in the bloom filter, trying to recover
/// the filter if the last element inserted doesn't match.
///
/// Gets the element depth in the dom, to make it efficient, or if not
/// provided always rebuilds the filter from scratch.
///
/// Returns the new bloom filter depth.
pub fn insert_parents_recovering<E>(&mut self,
element: E,
element_depth: Option<usize>,
generation: u32)
-> usize
where E: TElement,
{
// Easy case, we're in a different restyle, or we're empty.
if self.generation != generation || self.elements.is_empty() {
self.generation = generation;
return self.rebuild(element);
}

let parent_element = match element.parent_element() {
Some(parent) => parent,
None => {
// Yay, another easy case.
self.clear();
return 0;
}
};

let unsafe_parent = parent_element.as_node().to_unsafe();
if self.elements.last() == Some(&unsafe_parent) {
// Ta da, cache hit, we're all done.
return self.elements.len();
}

let element_depth = match element_depth {
Some(depth) => depth,
// If we don't know the depth of `element`, we'd rather don't try
// fixing up the bloom filter, since it's quadratic.
None => {
return self.rebuild(element);
}
};

// We should've early exited above.
debug_assert!(element_depth != 0,
"We should have already cleared the bloom filter");
debug_assert!(!self.elements.is_empty(),
"How! We should've just rebuilt!");

// Now the fun begins: We have the depth of the dom and the depth of the
// last element inserted in the filter, let's try to find a common
// parent.
//
// The current depth, that is, the depth of the last element inserted in
// the bloom filter, is the number of elements _minus one_, that is: if
// there's one element, it must be the root -> depth zero.
let mut current_depth = self.elements.len() - 1;

// If the filter represents an element too deep in the dom, we need to
// pop ancestors.
while current_depth >= element_depth - 1 {
self.pop::<E>().expect("Emilio is bad at math");
current_depth -= 1;
}

// Now let's try to find a common parent in the bloom filter chain,
// starting with parent_element.
let mut common_parent = parent_element;
let mut common_parent_depth = element_depth - 1;

// Let's collect the parents we are going to need to insert once we've
// found the common one.
let mut parents_to_insert = vec![];

// If the bloom filter still doesn't have enough elements, the common
// parent is up in the dom.
while common_parent_depth > current_depth {
// TODO(emilio): Seems like we could insert parents here, then
// reverse the slice.
parents_to_insert.push(common_parent);
common_parent =
common_parent.parent_element().expect("We were lied");
common_parent_depth -= 1;
}

// Now the two depths are the same.
debug_assert_eq!(common_parent_depth, current_depth);

// Happy case: The parents match, we only need to push the ancestors
// we've collected and we'll never enter in this loop.
//
// Not-so-happy case: Parent's don't match, so we need to keep going up
// until we find a common ancestor.
while *self.elements.last().unwrap() != common_parent.as_node().to_unsafe() {
parents_to_insert.push(common_parent);
common_parent =
common_parent.parent_element().expect("We were lied again?");
self.pop::<E>().unwrap();
}

// Now the parents match, so insert the stack of elements we have been
// collecting so far.
for parent in parents_to_insert.into_iter().rev() {
self.push(parent);
}

debug_assert_eq!(self.elements.len(), element_depth);

// We're done! Easy.
return self.elements.len();
}
}
@@ -122,12 +122,8 @@ pub trait TNode : Sized + Copy + Clone + NodeInfo {
/// Converts self into an `OpaqueNode`.
fn opaque(&self) -> OpaqueNode;

fn layout_parent_element(self, reflow_root: OpaqueNode) -> Option<Self::ConcreteElement> {
if self.opaque() == reflow_root {
None
} else {
self.parent_node().and_then(|n| n.as_element())
}
fn parent_element(&self) -> Option<Self::ConcreteElement> {
self.parent_node().and_then(|n| n.as_element())
}

fn debug_id(self) -> usize;
@@ -92,6 +92,7 @@ pub mod animation;
pub mod atomic_refcell;
pub mod attr;
pub mod bezier;
pub mod bloom;
pub mod cache;
pub mod cascade_info;
pub mod context;
@@ -125,8 +125,12 @@ fn bottom_up_dom<N, C>(root: OpaqueNode,
// Perform the appropriate operation.
context.process_postorder(node);

let parent = match node.layout_parent_element(root) {
None => break,
if node.opaque() == root {
break;
}

let parent = match node.parent_element() {
None => unreachable!("How can this happen after the break above?"),
Some(parent) => parent,
};

0 comments on commit 84a50ed

Please sign in to comment.
You can’t perform that action at this time.