Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-22 23:03:42 +01:00
Code Issues Projects Releases Packages Wiki Activity

Remove the dependency of parallel DOM traversal and style calculation on LayoutContext.

Browse source
This commit is contained in:
Bobby Holley 2016-01-03 19:18:34 -08:00
parent ebc5eb1b98
commit bf1a7d243f
4 changed files with 145 additions and 99 deletions
Download patch file Download diff file Expand all files Collapse all files

10
components/layout/context.rs
View file

@ -128,16 +128,6 @@ impl<'a> LayoutContext<'a> {
self.cached_local_layout_context.font_context.borrow_mut()
}
#[inline(always)]
pub fn applicable_declarations_cache(&self) -> RefMut<ApplicableDeclarationsCache> {
self.local_context().applicable_declarations_cache.borrow_mut()
}
#[inline(always)]
pub fn style_sharing_candidate_cache(&self) -> RefMut<StyleSharingCandidateCache> {
self.local_context().style_sharing_candidate_cache.borrow_mut()
}
pub fn get_or_request_image(&self, url: Url, use_placeholder: UsePlaceholder)
-> Option<Arc<Image>> {
// See if the image is already available

62
components/layout/parallel.rs
View file

@ -19,7 +19,7 @@ use style::dom::{TNode, UnsafeNode};
use traversal::PostorderNodeMutTraversal;
use traversal::{AssignBSizesAndStoreOverflow, AssignISizes, BubbleISizes};
use traversal::{BuildDisplayList, ComputeAbsolutePositions};
use traversal::{DomTraversal, DomTraversalContext};
use traversal::DomTraversalContext;
use util::opts;
use util::workqueue::{WorkQueue, WorkUnit, WorkerProxy};
@ -233,15 +233,10 @@ impl<'a> ParallelPostorderFlowTraversal for BuildDisplayList<'a> {}
/// A parallel top-down DOM traversal.
#[inline(always)]
fn top_down_dom<'ln, N, T>(unsafe_nodes: UnsafeNodeList,
proxy: &mut WorkerProxy<SharedLayoutContext, UnsafeNodeList>)
where N: TNode<'ln>, T: DomTraversal<'ln, N> {
let shared_layout_context = proxy.user_data();
let layout_context = LayoutContext::new(shared_layout_context);
let traversal_context = DomTraversalContext {
layout_context: &layout_context,
root: unsafe_nodes.1,
};
fn top_down_dom<'ln, N, C>(unsafe_nodes: UnsafeNodeList,
proxy: &mut WorkerProxy<C::SharedContext, UnsafeNodeList>)
where N: TNode<'ln>, C: DomTraversalContext<'ln, N> {
let context = C::new(proxy.user_data(), unsafe_nodes.1);
let mut discovered_child_nodes = Vec::new();
for unsafe_node in *unsafe_nodes.0 {
@ -249,7 +244,7 @@ fn top_down_dom<'ln, N, T>(unsafe_nodes: UnsafeNodeList,
let node = unsafe { N::from_unsafe(&unsafe_node) };
// Perform the appropriate traversal.
T::process_preorder(&traversal_context, node);
context.process_preorder(node);
let child_count = node.children_count();
@ -267,13 +262,13 @@ fn top_down_dom<'ln, N, T>(unsafe_nodes: UnsafeNodeList,
}
} else {
// If there were no more children, start walking back up.
bottom_up_dom::<N, T>(unsafe_nodes.1, unsafe_node, proxy)
bottom_up_dom::<N, C>(unsafe_nodes.1, unsafe_node, proxy)
}
}
for chunk in discovered_child_nodes.chunks(CHUNK_SIZE) {
proxy.push(WorkUnit {
fun: top_down_dom::<N, T>,
fun: top_down_dom::<N, C>,
data: (box chunk.iter().cloned().collect(), unsafe_nodes.1),
});
}
@ -290,24 +285,19 @@ fn top_down_dom<'ln, N, T>(unsafe_nodes: UnsafeNodeList,
///
/// The only communication between siblings is that they both
/// fetch-and-subtract the parent's children count.
fn bottom_up_dom<'ln, N, T>(root: OpaqueNode,
fn bottom_up_dom<'ln, N, C>(root: OpaqueNode,
unsafe_node: UnsafeNode,
proxy: &mut WorkerProxy<SharedLayoutContext, UnsafeNodeList>)
where N: TNode<'ln>, T: DomTraversal<'ln, N> {
let shared_layout_context = proxy.user_data();
let layout_context = LayoutContext::new(shared_layout_context);
let traversal_context = DomTraversalContext {
layout_context: &layout_context,
root: root,
};
proxy: &mut WorkerProxy<C::SharedContext, UnsafeNodeList>)
where N: TNode<'ln>, C: DomTraversalContext<'ln, N> {
let context = C::new(proxy.user_data(), root);
// Get a real layout node.
let mut node = unsafe { N::from_unsafe(&unsafe_node) };
loop {
// Perform the appropriate operation.
T::process_postorder(&traversal_context, node);
context.process_postorder(node);
let parent = match node.layout_parent_node(traversal_context.root) {
let parent = match node.layout_parent_node(root) {
None => break,
Some(parent) => parent,
};
@ -371,29 +361,29 @@ fn build_display_list(unsafe_flow: UnsafeFlow,
build_display_list_traversal.run_parallel(unsafe_flow);
}
fn run_queue_with_custom_work_data_type<To, F>(
queue: &mut WorkQueue<SharedLayoutContext, WorkQueueData>,
fn run_queue_with_custom_work_data_type<To, F, SharedContext: Sync>(
queue: &mut WorkQueue<SharedContext, WorkQueueData>,
callback: F,
shared_layout_context: &SharedLayoutContext)
where To: 'static + Send, F: FnOnce(&mut WorkQueue<SharedLayoutContext, To>) {
let queue: &mut WorkQueue<SharedLayoutContext, To> = unsafe {
shared: &SharedContext)
where To: 'static + Send, F: FnOnce(&mut WorkQueue<SharedContext, To>) {
let queue: &mut WorkQueue<SharedContext, To> = unsafe {
mem::transmute(queue)
};
callback(queue);
queue.run(shared_layout_context);
queue.run(shared);
}
pub fn traverse_dom_preorder<'ln, N, T>(
pub fn traverse_dom_preorder<'ln, N, C>(
root: N,
shared_layout_context: &SharedLayoutContext,
queue: &mut WorkQueue<SharedLayoutContext, WorkQueueData>)
where N: TNode<'ln>, T: DomTraversal<'ln, N> {
queue_data: &C::SharedContext,
queue: &mut WorkQueue<C::SharedContext, WorkQueueData>)
where N: TNode<'ln>, C: DomTraversalContext<'ln, N> {
run_queue_with_custom_work_data_type(queue, |queue| {
queue.push(WorkUnit {
fun: top_down_dom::<N, T>,
fun: top_down_dom::<N, C>,
data: (box vec![root.to_unsafe()], root.opaque()),
});
}, shared_layout_context);
}, queue_data);
}
pub fn traverse_flow_tree_preorder(

27
components/layout/sequential.rs
View file

@ -15,32 +15,27 @@ use generated_content::ResolveGeneratedContent;
use traversal::PostorderNodeMutTraversal;
use traversal::{AssignBSizesAndStoreOverflow, AssignISizes};
use traversal::{BubbleISizes, BuildDisplayList, ComputeAbsolutePositions};
use traversal::{DomTraversal, DomTraversalContext};
use traversal::DomTraversalContext;
use util::opts;
use wrapper::LayoutNode;
pub fn traverse_dom_preorder<'ln, N, T>(root: N,
shared_layout_context: &SharedLayoutContext)
pub fn traverse_dom_preorder<'ln, N, C>(root: N,
shared: &C::SharedContext)
where N: LayoutNode<'ln>,
T: DomTraversal<'ln, N> {
fn doit<'a, 'ln, N, T>(context: &'a DomTraversalContext<'a>, node: N)
where N: LayoutNode<'ln>, T: DomTraversal<'ln, N> {
T::process_preorder(context, node);
C: DomTraversalContext<'ln, N> {
fn doit<'a, 'ln, N, C>(context: &'a C, node: N)
where N: LayoutNode<'ln>, C: DomTraversalContext<'ln, N> {
context.process_preorder(node);
for kid in node.children() {
doit::<N, T>(context, kid);
doit::<N, C>(context, kid);
}
T::process_postorder(context, node);
context.process_postorder(node);
}
let layout_context = LayoutContext::new(shared_layout_context);
let traversal_context = DomTraversalContext {
layout_context: &layout_context,
root: root.opaque(),
};
doit::<N, T>(&traversal_context, root);
let context = C::new(shared, root.opaque());
doit::<N, C>(&context, root);
}
pub fn resolve_generated_content(root: &mut FlowRef, shared_layout_context: &SharedLayoutContext) {

145
components/layout/traversal.rs
View file

@ -4,8 +4,10 @@
//! Traversals over the DOM and flow trees, running the layout computations.
#![allow(unsafe_code)]
use construct::FlowConstructor;
use context::LayoutContext;
use context::{LayoutContext, SharedLayoutContext};
use flow::{PostorderFlowTraversal, PreorderFlowTraversal};
use flow::{self, Flow};
use gfx::display_list::OpaqueNode;
@ -14,7 +16,8 @@ use script::layout_interface::ReflowGoal;
use selectors::bloom::BloomFilter;
use std::cell::RefCell;
use std::mem;
use style::context::StyleContext;
use std::rc::Rc;
use style::context::{LocalStyleContext, SharedStyleContext, StyleContext};
use style::dom::{TNode, TRestyleDamage, UnsafeNode};
use style::matching::{ApplicableDeclarations, ElementMatchMethods, MatchMethods, StyleSharingResult};
use util::opts;
@ -54,7 +57,7 @@ thread_local!(
/// it will be cleared and reused.
fn take_task_local_bloom_filter<'ln, N>(parent_node: Option<N>,
root: OpaqueNode,
layout_context: &LayoutContext)
context: &SharedStyleContext)
-> Box<BloomFilter>
where N: TNode<'ln> {
STYLE_BLOOM.with(|style_bloom| {
@ -73,7 +76,7 @@ fn take_task_local_bloom_filter<'ln, N>(parent_node: Option<N>,
// Found cached bloom filter.
(Some(parent), Some((mut bloom_filter, old_node, old_generation))) => {
if old_node == parent.to_unsafe() &&
old_generation == layout_context.shared_context().generation {
old_generation == context.generation {
// Hey, the cached parent is our parent! We can reuse the bloom filter.
debug!("[{}] Parent matches (={}). Reusing bloom filter.", tid(), old_node.0);
} else {
@ -90,11 +93,11 @@ fn take_task_local_bloom_filter<'ln, N>(parent_node: Option<N>,
fn put_task_local_bloom_filter(bf: Box<BloomFilter>,
unsafe_node: &UnsafeNode,
layout_context: &LayoutContext) {
context: &SharedStyleContext) {
STYLE_BLOOM.with(move |style_bloom| {
assert!(style_bloom.borrow().is_none(),
"Putting into a never-taken task-local bloom filter");
*style_bloom.borrow_mut() = Some((bf, *unsafe_node, layout_context.shared_context().generation));
*style_bloom.borrow_mut() = Some((bf, *unsafe_node, context.generation));
})
}
@ -117,30 +120,98 @@ fn insert_ancestors_into_bloom_filter<'ln, N>(bf: &mut Box<BloomFilter>,
debug!("[{}] Inserted {} ancestors.", tid(), ancestors);
}
#[derive(Copy, Clone)]
pub struct DomTraversalContext<'a> {
pub layout_context: &'a LayoutContext<'a>,
pub root: OpaqueNode,
}
pub trait DomTraversal<'ln, N: TNode<'ln>> {
fn process_preorder<'a>(context: &'a DomTraversalContext<'a>, node: N);
fn process_postorder<'a>(context: &'a DomTraversalContext<'a>, node: N);
pub trait DomTraversalContext<'ln, N: TNode<'ln>> {
type SharedContext: Sync + 'static;
fn new<'a>(&'a Self::SharedContext, OpaqueNode) -> Self;
fn process_preorder(&self, node: N);
fn process_postorder(&self, node: N);
}
/// FIXME(bholley): I added this now to demonstrate the usefulness of the new design.
/// This is currently unused, but will be used shortly.
#[allow(dead_code)]
pub struct RecalcStyleOnly;
impl<'ln, N: TNode<'ln>> DomTraversal<'ln, N> for RecalcStyleOnly {
fn process_preorder<'a>(context: &'a DomTraversalContext<'a>, node: N) { recalc_style_at(context, node); }
fn process_postorder<'a>(_: &'a DomTraversalContext<'a>, _: N) {}
pub struct StandaloneStyleContext<'a> {
pub shared: &'a SharedStyleContext,
cached_local_style_context: Rc<LocalStyleContext>,
}
pub struct RecalcStyleAndConstructFlows;
impl<'ln, N: LayoutNode<'ln>> DomTraversal<'ln, N> for RecalcStyleAndConstructFlows {
fn process_preorder<'a>(context: &'a DomTraversalContext<'a>, node: N) { recalc_style_at(context, node); }
fn process_postorder<'a>(context: &'a DomTraversalContext<'a>, node: N) { construct_flows_at(context, node); }
impl<'a> StandaloneStyleContext<'a> {
pub fn new(_: &'a SharedStyleContext) -> Self { panic!("Not implemented") }
}
impl<'a> StyleContext<'a> for StandaloneStyleContext<'a> {
fn shared_context(&self) -> &'a SharedStyleContext {
&self.shared
}
fn local_context(&self) -> &LocalStyleContext {
&self.cached_local_style_context
}
}
#[allow(dead_code)]
pub struct RecalcStyleOnly<'lc> {
context: StandaloneStyleContext<'lc>,
root: OpaqueNode,
}
impl<'lc, 'ln, N: TNode<'ln>> DomTraversalContext<'ln, N> for RecalcStyleOnly<'lc> {
type SharedContext = SharedStyleContext;
fn new<'a>(shared: &'a Self::SharedContext, root: OpaqueNode) -> Self {
// See the comment in RecalcStyleAndConstructFlows::new for an explanation of why this is
// necessary.
let shared_lc: &'lc SharedStyleContext = unsafe { mem::transmute(shared) };
RecalcStyleOnly {
context: StandaloneStyleContext::new(shared_lc),
root: root,
}
}
fn process_preorder(&self, node: N) { recalc_style_at(&self.context, self.root, node); }
fn process_postorder(&self, _: N) {}
}
pub struct RecalcStyleAndConstructFlows<'lc> {
context: LayoutContext<'lc>,
root: OpaqueNode,
}
impl<'lc, 'ln, N: LayoutNode<'ln>> DomTraversalContext<'ln, N> for RecalcStyleAndConstructFlows<'lc> {
type SharedContext = SharedLayoutContext;
fn new<'a>(shared: &'a Self::SharedContext, root: OpaqueNode) -> Self {
// FIXME(bholley): This transmutation from &'a to &'lc is very unfortunate, but I haven't
// found a way to avoid it despite spending several days on it (and consulting Manishearth,
// brson, and nmatsakis).
//
// The crux of the problem is that parameterizing DomTraversalContext on the lifetime of
// the SharedContext doesn't work for a variety of reasons [1]. However, the code in
// parallel.rs needs to be able to use the DomTraversalContext trait (or something similar)
// to stack-allocate a struct (a generalized LayoutContext<'a>) that holds a borrowed
// SharedContext, which means that the struct needs to be parameterized on a lifetime.
// Given the aforementioned constraint, the only way to accomplish this is to avoid
// propagating the borrow lifetime from the struct to the trait, but that means that the
// new() method on the trait cannot require the lifetime of its argument to match the
// lifetime of the Self object it creates.
//
// This could be solved with an associated type with an unbound lifetime parameter, but
// that would require higher-kinded types, which don't exist yet and probably aren't coming
// for a while.
//
// So we transmute. :-(
//
// [1] For example, the WorkQueue type needs to be parameterized on the concrete type of
// DomTraversalContext::SharedContext, and the WorkQueue lifetime is similar to that of the
// LayoutTask, generally much longer than that of a given SharedLayoutContext borrow.
let shared_lc: &'lc SharedLayoutContext = unsafe { mem::transmute(shared) };
RecalcStyleAndConstructFlows {
context: LayoutContext::new(shared_lc),
root: root,
}
}
fn process_preorder(&self, node: N) { recalc_style_at(&self.context, self.root, node); }
fn process_postorder(&self, node: N) { construct_flows_at(&self.context, self.root, node); }
}
/// A bottom-up, parallelizable traversal.
@ -153,7 +224,7 @@ pub trait PostorderNodeMutTraversal<'ln, ConcreteThreadSafeLayoutNode: ThreadSaf
/// layout computation. This computes the styles applied to each node.
#[inline]
#[allow(unsafe_code)]
fn recalc_style_at<'a, 'ln, N: TNode<'ln>> (context: &'a DomTraversalContext<'a>, node: N) {
fn recalc_style_at<'a, 'ln, N: TNode<'ln>, C: StyleContext<'a>> (context: &'a C, root: OpaqueNode, node: N) {
// Initialize layout data.
//
// FIXME(pcwalton): Stop allocating here. Ideally this should just be done by the HTML
@ -161,10 +232,10 @@ fn recalc_style_at<'a, 'ln, N: TNode<'ln>> (context: &'a DomTraversalContext<'a>
node.initialize_data();
// Get the parent node.
let parent_opt = node.layout_parent_node(context.root);
let parent_opt = node.layout_parent_node(root);
// Get the style bloom filter.
let mut bf = take_task_local_bloom_filter(parent_opt, context.root, context.layout_context);
let mut bf = take_task_local_bloom_filter(parent_opt, root, context.shared_context());
let nonincremental_layout = opts::get().nonincremental_layout;
if nonincremental_layout || node.is_dirty() {
@ -176,7 +247,7 @@ fn recalc_style_at<'a, 'ln, N: TNode<'ln>> (context: &'a DomTraversalContext<'a>
// Check to see whether we can share a style with someone.
let style_sharing_candidate_cache =
&mut context.layout_context.style_sharing_candidate_cache();
&mut context.local_context().style_sharing_candidate_cache.borrow_mut();
let sharing_result = match node.as_element() {
Some(element) => {
@ -196,7 +267,7 @@ fn recalc_style_at<'a, 'ln, N: TNode<'ln>> (context: &'a DomTraversalContext<'a>
let shareable_element = match node.as_element() {
Some(element) => {
// Perform the CSS selector matching.
let stylist = unsafe { &*context.layout_context.shared_context().stylist.0 };
let stylist = unsafe { &*context.shared_context().stylist.0 };
if element.match_element(stylist,
Some(&*bf),
&mut applicable_declarations) {
@ -215,11 +286,11 @@ fn recalc_style_at<'a, 'ln, N: TNode<'ln>> (context: &'a DomTraversalContext<'a>
// Perform the CSS cascade.
unsafe {
node.cascade_node(&context.layout_context.shared.style_context,
node.cascade_node(&context.shared_context(),
parent_opt,
&applicable_declarations,
&mut context.layout_context.applicable_declarations_cache(),
&context.layout_context.shared_context().new_animations_sender);
&mut context.local_context().applicable_declarations_cache.borrow_mut(),
&context.shared_context().new_animations_sender);
}
// Add ourselves to the LRU cache.
@ -242,13 +313,13 @@ fn recalc_style_at<'a, 'ln, N: TNode<'ln>> (context: &'a DomTraversalContext<'a>
node.insert_into_bloom_filter(&mut *bf);
// NB: flow construction updates the bloom filter on the way up.
put_task_local_bloom_filter(bf, &unsafe_layout_node, context.layout_context);
put_task_local_bloom_filter(bf, &unsafe_layout_node, context.shared_context());
}
/// The flow construction traversal, which builds flows for styled nodes.
#[inline]
#[allow(unsafe_code)]
fn construct_flows_at<'a, 'ln, N: LayoutNode<'ln>>(context: &'a DomTraversalContext<'a>, node: N) {
fn construct_flows_at<'a, 'ln, N: LayoutNode<'ln>>(context: &'a LayoutContext<'a>, root: OpaqueNode, node: N) {
// Construct flows for this node.
{
let tnode = node.to_threadsafe();
@ -256,7 +327,7 @@ fn construct_flows_at<'a, 'ln, N: LayoutNode<'ln>>(context: &'a DomTraversalCont
// Always reconstruct if incremental layout is turned off.
let nonincremental_layout = opts::get().nonincremental_layout;
if nonincremental_layout || node.has_dirty_descendants() {
let mut flow_constructor = FlowConstructor::new(context.layout_context);
let mut flow_constructor = FlowConstructor::new(context);
if nonincremental_layout || !flow_constructor.repair_if_possible(&tnode) {
flow_constructor.process(&tnode);
debug!("Constructed flow for {:x}: {:x}",
@ -285,9 +356,9 @@ fn construct_flows_at<'a, 'ln, N: LayoutNode<'ln>>(context: &'a DomTraversalCont
});
assert_eq!(old_node, unsafe_layout_node);
assert_eq!(old_generation, context.layout_context.shared_context().generation);
assert_eq!(old_generation, context.shared_context().generation);
match node.layout_parent_node(context.root) {
match node.layout_parent_node(root) {
None => {
debug!("[{}] - {:X}, and deleting BF.", tid(), unsafe_layout_node.0);
// If this is the reflow root, eat the task-local bloom filter.
@ -296,7 +367,7 @@ fn construct_flows_at<'a, 'ln, N: LayoutNode<'ln>>(context: &'a DomTraversalCont
// Otherwise, put it back, but remove this node.
node.remove_from_bloom_filter(&mut *bf);
let unsafe_parent = parent.to_unsafe();
put_task_local_bloom_filter(bf, &unsafe_parent, context.layout_context);
put_task_local_bloom_filter(bf, &unsafe_parent, &context.shared_context());
},
};
}