mirror of
https://github.com/servo/servo.git
synced 2025-08-03 12:40:06 +01:00
Cargoify servo
This commit is contained in:
parent
db2f642c32
commit
c6ab60dbfc
1761 changed files with 8423 additions and 2294 deletions
561
components/layout/parallel.rs
Normal file
561
components/layout/parallel.rs
Normal file
|
@ -0,0 +1,561 @@
|
|||
/* 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/. */
|
||||
|
||||
//! Implements parallel traversals over the DOM and flow trees.
|
||||
//!
|
||||
//! This code is highly unsafe. Keep this file small and easy to audit.
|
||||
|
||||
use css::matching::{ApplicableDeclarations, CannotShare, MatchMethods, StyleWasShared};
|
||||
use construct::FlowConstructor;
|
||||
use context::{LayoutContext, SharedLayoutContext};
|
||||
use extra::LayoutAuxMethods;
|
||||
use flow::{Flow, MutableFlowUtils, PreorderFlowTraversal, PostorderFlowTraversal};
|
||||
use flow;
|
||||
use flow_ref::FlowRef;
|
||||
use layout_task::{AssignBSizesAndStoreOverflowTraversal, AssignISizesTraversal};
|
||||
use layout_task::{BubbleISizesTraversal};
|
||||
use util::{LayoutDataAccess, LayoutDataWrapper, OpaqueNodeMethods};
|
||||
use wrapper::{layout_node_to_unsafe_layout_node, layout_node_from_unsafe_layout_node, LayoutNode, PostorderNodeMutTraversal};
|
||||
use wrapper::{ThreadSafeLayoutNode, UnsafeLayoutNode};
|
||||
|
||||
use gfx::display_list::OpaqueNode;
|
||||
use servo_util::time::{TimeProfilerChan, profile};
|
||||
use servo_util::time;
|
||||
use servo_util::workqueue::{WorkQueue, WorkUnit, WorkerProxy};
|
||||
use std::mem;
|
||||
use std::ptr;
|
||||
use std::sync::atomics::{AtomicInt, Relaxed, SeqCst};
|
||||
use style::TNode;
|
||||
|
||||
#[allow(dead_code)]
|
||||
fn static_assertion(node: UnsafeLayoutNode) {
|
||||
unsafe {
|
||||
let _: UnsafeFlow = ::std::intrinsics::transmute(node);
|
||||
}
|
||||
}
|
||||
|
||||
/// Vtable + pointer representation of a Flow trait object.
|
||||
pub type UnsafeFlow = (uint, uint);
|
||||
|
||||
fn null_unsafe_flow() -> UnsafeFlow {
|
||||
(0, 0)
|
||||
}
|
||||
|
||||
pub fn owned_flow_to_unsafe_flow(flow: *const FlowRef) -> UnsafeFlow {
|
||||
unsafe {
|
||||
mem::transmute_copy(&*flow)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn mut_owned_flow_to_unsafe_flow(flow: *mut FlowRef) -> UnsafeFlow {
|
||||
unsafe {
|
||||
mem::transmute_copy(&*flow)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn borrowed_flow_to_unsafe_flow(flow: &Flow) -> UnsafeFlow {
|
||||
unsafe {
|
||||
mem::transmute_copy(&flow)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn mut_borrowed_flow_to_unsafe_flow(flow: &mut Flow) -> UnsafeFlow {
|
||||
unsafe {
|
||||
mem::transmute_copy(&flow)
|
||||
}
|
||||
}
|
||||
|
||||
/// Information that we need stored in each DOM node.
|
||||
pub struct DomParallelInfo {
|
||||
/// The number of children that still need work done.
|
||||
pub children_count: AtomicInt,
|
||||
}
|
||||
|
||||
impl DomParallelInfo {
|
||||
pub fn new() -> DomParallelInfo {
|
||||
DomParallelInfo {
|
||||
children_count: AtomicInt::new(0),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Information that we need stored in each flow.
|
||||
pub struct FlowParallelInfo {
|
||||
/// The number of children that still need work done.
|
||||
pub children_count: AtomicInt,
|
||||
/// The number of children and absolute descendants that still need work done.
|
||||
pub children_and_absolute_descendant_count: AtomicInt,
|
||||
/// The address of the parent flow.
|
||||
pub parent: UnsafeFlow,
|
||||
}
|
||||
|
||||
impl FlowParallelInfo {
|
||||
pub fn new() -> FlowParallelInfo {
|
||||
FlowParallelInfo {
|
||||
children_count: AtomicInt::new(0),
|
||||
children_and_absolute_descendant_count: AtomicInt::new(0),
|
||||
parent: null_unsafe_flow(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A parallel bottom-up flow traversal.
|
||||
trait ParallelPostorderFlowTraversal : PostorderFlowTraversal {
|
||||
/// Process current flow and potentially traverse its ancestors.
|
||||
///
|
||||
/// If we are the last child that finished processing, recursively process
|
||||
/// our parent. Else, stop.
|
||||
/// Also, stop at the root (obviously :P).
|
||||
///
|
||||
/// Thus, if we start with all the leaves of a tree, we end up traversing
|
||||
/// the whole tree bottom-up because each parent will be processed exactly
|
||||
/// once (by the last child that finishes processing).
|
||||
///
|
||||
/// The only communication between siblings is that they both
|
||||
/// fetch-and-subtract the parent's children count.
|
||||
fn run_parallel(&mut self,
|
||||
mut unsafe_flow: UnsafeFlow,
|
||||
_: &mut WorkerProxy<*const SharedLayoutContext,UnsafeFlow>) {
|
||||
loop {
|
||||
unsafe {
|
||||
// Get a real flow.
|
||||
let flow: &mut FlowRef = mem::transmute(&unsafe_flow);
|
||||
|
||||
// Perform the appropriate traversal.
|
||||
if self.should_process(flow.get_mut()) {
|
||||
self.process(flow.get_mut());
|
||||
}
|
||||
|
||||
let base = flow::mut_base(flow.get_mut());
|
||||
|
||||
// Reset the count of children for the next layout traversal.
|
||||
base.parallel.children_count.store(base.children.len() as int, Relaxed);
|
||||
|
||||
// Possibly enqueue the parent.
|
||||
let unsafe_parent = base.parallel.parent;
|
||||
if unsafe_parent == null_unsafe_flow() {
|
||||
// We're done!
|
||||
break
|
||||
}
|
||||
|
||||
// No, we're not at the root yet. Then are we the last child
|
||||
// of our parent to finish processing? If so, we can continue
|
||||
// on with our parent; otherwise, we've gotta wait.
|
||||
let parent: &mut FlowRef = mem::transmute(&unsafe_parent);
|
||||
let parent_base = flow::mut_base(parent.get_mut());
|
||||
if parent_base.parallel.children_count.fetch_sub(1, SeqCst) == 1 {
|
||||
// We were the last child of our parent. Reflow our parent.
|
||||
unsafe_flow = unsafe_parent
|
||||
} else {
|
||||
// Stop.
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A parallel top-down flow traversal.
|
||||
trait ParallelPreorderFlowTraversal : PreorderFlowTraversal {
|
||||
fn run_parallel(&mut self,
|
||||
unsafe_flow: UnsafeFlow,
|
||||
proxy: &mut WorkerProxy<*const SharedLayoutContext,UnsafeFlow>);
|
||||
|
||||
#[inline(always)]
|
||||
fn run_parallel_helper(&mut self,
|
||||
unsafe_flow: UnsafeFlow,
|
||||
proxy: &mut WorkerProxy<*const SharedLayoutContext,UnsafeFlow>,
|
||||
top_down_func: extern "Rust" fn(UnsafeFlow,
|
||||
&mut WorkerProxy<*const SharedLayoutContext,
|
||||
UnsafeFlow>),
|
||||
bottom_up_func: extern "Rust" fn(UnsafeFlow,
|
||||
&mut WorkerProxy<*const SharedLayoutContext,
|
||||
UnsafeFlow>)) {
|
||||
let mut had_children = false;
|
||||
unsafe {
|
||||
// Get a real flow.
|
||||
let flow: &mut FlowRef = mem::transmute(&unsafe_flow);
|
||||
|
||||
// Perform the appropriate traversal.
|
||||
self.process(flow.get_mut());
|
||||
|
||||
// Possibly enqueue the children.
|
||||
for kid in flow::child_iter(flow.get_mut()) {
|
||||
had_children = true;
|
||||
proxy.push(WorkUnit {
|
||||
fun: top_down_func,
|
||||
data: borrowed_flow_to_unsafe_flow(kid),
|
||||
});
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// If there were no more children, start assigning block-sizes.
|
||||
if !had_children {
|
||||
bottom_up_func(unsafe_flow, proxy)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ParallelPostorderFlowTraversal for BubbleISizesTraversal<'a> {}
|
||||
|
||||
impl<'a> ParallelPreorderFlowTraversal for AssignISizesTraversal<'a> {
|
||||
fn run_parallel(&mut self,
|
||||
unsafe_flow: UnsafeFlow,
|
||||
proxy: &mut WorkerProxy<*const SharedLayoutContext,UnsafeFlow>) {
|
||||
self.run_parallel_helper(unsafe_flow,
|
||||
proxy,
|
||||
assign_inline_sizes,
|
||||
assign_block_sizes_and_store_overflow)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ParallelPostorderFlowTraversal for AssignBSizesAndStoreOverflowTraversal<'a> {}
|
||||
|
||||
fn recalc_style_for_node(unsafe_layout_node: UnsafeLayoutNode,
|
||||
proxy: &mut WorkerProxy<*const SharedLayoutContext,UnsafeLayoutNode>) {
|
||||
let shared_layout_context = unsafe { &**proxy.user_data() };
|
||||
let layout_context = LayoutContext::new(shared_layout_context);
|
||||
|
||||
// Get a real layout node.
|
||||
let node: LayoutNode = unsafe {
|
||||
layout_node_from_unsafe_layout_node(&unsafe_layout_node)
|
||||
};
|
||||
|
||||
// Initialize layout data.
|
||||
//
|
||||
// FIXME(pcwalton): Stop allocating here. Ideally this should just be done by the HTML
|
||||
// parser.
|
||||
node.initialize_layout_data(layout_context.shared.layout_chan.clone());
|
||||
|
||||
// Get the parent node.
|
||||
let opaque_node: OpaqueNode = OpaqueNodeMethods::from_layout_node(&node);
|
||||
let parent_opt = if opaque_node == layout_context.shared.reflow_root {
|
||||
None
|
||||
} else {
|
||||
node.parent_node()
|
||||
};
|
||||
|
||||
// First, check to see whether we can share a style with someone.
|
||||
let style_sharing_candidate_cache = layout_context.style_sharing_candidate_cache();
|
||||
let sharing_result = unsafe {
|
||||
node.share_style_if_possible(style_sharing_candidate_cache,
|
||||
parent_opt.clone())
|
||||
};
|
||||
|
||||
// Otherwise, match and cascade selectors.
|
||||
match sharing_result {
|
||||
CannotShare(mut shareable) => {
|
||||
let mut applicable_declarations = ApplicableDeclarations::new();
|
||||
|
||||
if node.is_element() {
|
||||
// Perform the CSS selector matching.
|
||||
let stylist = unsafe { &*layout_context.shared.stylist };
|
||||
node.match_node(stylist, &mut applicable_declarations, &mut shareable);
|
||||
}
|
||||
|
||||
// Perform the CSS cascade.
|
||||
unsafe {
|
||||
node.cascade_node(parent_opt,
|
||||
&applicable_declarations,
|
||||
layout_context.applicable_declarations_cache());
|
||||
}
|
||||
|
||||
// Add ourselves to the LRU cache.
|
||||
if shareable {
|
||||
style_sharing_candidate_cache.insert_if_possible(&node);
|
||||
}
|
||||
}
|
||||
StyleWasShared(index) => style_sharing_candidate_cache.touch(index),
|
||||
}
|
||||
|
||||
// Prepare for flow construction by counting the node's children and storing that count.
|
||||
let mut child_count = 0u;
|
||||
for _ in node.children() {
|
||||
child_count += 1;
|
||||
}
|
||||
if child_count != 0 {
|
||||
let mut layout_data_ref = node.mutate_layout_data();
|
||||
match &mut *layout_data_ref {
|
||||
&Some(ref mut layout_data) => {
|
||||
layout_data.data.parallel.children_count.store(child_count as int, Relaxed)
|
||||
}
|
||||
&None => fail!("no layout data"),
|
||||
}
|
||||
}
|
||||
|
||||
// It's *very* important that this block is in a separate scope to the block above,
|
||||
// to avoid a data race that can occur (github issue #2308). The block above issues
|
||||
// a borrow on the node layout data. That borrow must be dropped before the child
|
||||
// nodes are actually pushed into the work queue. Otherwise, it's possible for a child
|
||||
// node to get into construct_flows() and move up it's parent hierarchy, which can call
|
||||
// borrow on the layout data before it is dropped from the block above.
|
||||
if child_count != 0 {
|
||||
// Enqueue kids.
|
||||
for kid in node.children() {
|
||||
proxy.push(WorkUnit {
|
||||
fun: recalc_style_for_node,
|
||||
data: layout_node_to_unsafe_layout_node(&kid),
|
||||
});
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// If we got here, we're a leaf. Start construction of flows for this node.
|
||||
construct_flows(unsafe_layout_node, &layout_context)
|
||||
}
|
||||
|
||||
fn construct_flows(mut unsafe_layout_node: UnsafeLayoutNode,
|
||||
layout_context: &LayoutContext) {
|
||||
loop {
|
||||
// Get a real layout node.
|
||||
let node: LayoutNode = unsafe {
|
||||
layout_node_from_unsafe_layout_node(&unsafe_layout_node)
|
||||
};
|
||||
|
||||
// Construct flows for this node.
|
||||
{
|
||||
let mut flow_constructor = FlowConstructor::new(layout_context);
|
||||
flow_constructor.process(&ThreadSafeLayoutNode::new(&node));
|
||||
}
|
||||
|
||||
// Reset the count of children for the next traversal.
|
||||
//
|
||||
// FIXME(pcwalton): Use children().len() when the implementation of that is efficient.
|
||||
let mut child_count = 0u;
|
||||
for _ in node.children() {
|
||||
child_count += 1
|
||||
}
|
||||
{
|
||||
let mut layout_data_ref = node.mutate_layout_data();
|
||||
match &mut *layout_data_ref {
|
||||
&Some(ref mut layout_data) => {
|
||||
layout_data.data.parallel.children_count.store(child_count as int, Relaxed)
|
||||
}
|
||||
&None => fail!("no layout data"),
|
||||
}
|
||||
}
|
||||
|
||||
// If this is the reflow root, we're done.
|
||||
let opaque_node: OpaqueNode = OpaqueNodeMethods::from_layout_node(&node);
|
||||
if layout_context.shared.reflow_root == opaque_node {
|
||||
break
|
||||
}
|
||||
|
||||
// Otherwise, enqueue the parent.
|
||||
match node.parent_node() {
|
||||
Some(parent) => {
|
||||
|
||||
// No, we're not at the root yet. Then are we the last sibling of our parent?
|
||||
// If so, we can continue on with our parent; otherwise, we've gotta wait.
|
||||
unsafe {
|
||||
match *parent.borrow_layout_data_unchecked() {
|
||||
Some(ref parent_layout_data) => {
|
||||
let parent_layout_data: &mut LayoutDataWrapper = mem::transmute(parent_layout_data);
|
||||
if parent_layout_data.data
|
||||
.parallel
|
||||
.children_count
|
||||
.fetch_sub(1, SeqCst) == 1 {
|
||||
// We were the last child of our parent. Construct flows for our
|
||||
// parent.
|
||||
unsafe_layout_node = layout_node_to_unsafe_layout_node(&parent)
|
||||
} else {
|
||||
// Get out of here and find another node to work on.
|
||||
break
|
||||
}
|
||||
}
|
||||
None => fail!("no layout data for parent?!"),
|
||||
}
|
||||
}
|
||||
}
|
||||
None => fail!("no parent and weren't at reflow root?!"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn assign_inline_sizes(unsafe_flow: UnsafeFlow,
|
||||
proxy: &mut WorkerProxy<*const SharedLayoutContext,UnsafeFlow>) {
|
||||
let shared_layout_context = unsafe { &**proxy.user_data() };
|
||||
let layout_context = LayoutContext::new(shared_layout_context);
|
||||
let mut assign_inline_sizes_traversal = AssignISizesTraversal {
|
||||
layout_context: &layout_context,
|
||||
};
|
||||
assign_inline_sizes_traversal.run_parallel(unsafe_flow, proxy)
|
||||
}
|
||||
|
||||
fn assign_block_sizes_and_store_overflow(unsafe_flow: UnsafeFlow,
|
||||
proxy: &mut WorkerProxy<*const SharedLayoutContext,UnsafeFlow>) {
|
||||
let shared_layout_context = unsafe { &**proxy.user_data() };
|
||||
let layout_context = LayoutContext::new(shared_layout_context);
|
||||
let mut assign_block_sizes_traversal = AssignBSizesAndStoreOverflowTraversal {
|
||||
layout_context: &layout_context,
|
||||
};
|
||||
assign_block_sizes_traversal.run_parallel(unsafe_flow, proxy)
|
||||
}
|
||||
|
||||
fn compute_absolute_position(unsafe_flow: UnsafeFlow,
|
||||
proxy: &mut WorkerProxy<*const SharedLayoutContext,UnsafeFlow>) {
|
||||
let mut had_descendants = false;
|
||||
unsafe {
|
||||
// Get a real flow.
|
||||
let flow: &mut FlowRef = mem::transmute(&unsafe_flow);
|
||||
|
||||
// Compute the absolute position for the flow.
|
||||
flow.get_mut().compute_absolute_position();
|
||||
|
||||
// Count the number of absolutely-positioned children, so that we can subtract it from
|
||||
// from `children_and_absolute_descendant_count` to get the number of real children.
|
||||
let mut absolutely_positioned_child_count = 0u;
|
||||
for kid in flow::child_iter(flow.get_mut()) {
|
||||
if kid.is_absolutely_positioned() {
|
||||
absolutely_positioned_child_count += 1;
|
||||
}
|
||||
}
|
||||
|
||||
// Don't enqueue absolutely positioned children.
|
||||
drop(flow::mut_base(flow.get_mut()).parallel
|
||||
.children_and_absolute_descendant_count
|
||||
.fetch_sub(absolutely_positioned_child_count as int,
|
||||
SeqCst));
|
||||
|
||||
// Possibly enqueue the children.
|
||||
for kid in flow::child_iter(flow.get_mut()) {
|
||||
if !kid.is_absolutely_positioned() {
|
||||
had_descendants = true;
|
||||
proxy.push(WorkUnit {
|
||||
fun: compute_absolute_position,
|
||||
data: borrowed_flow_to_unsafe_flow(kid),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Possibly enqueue absolute descendants.
|
||||
for absolute_descendant_link in flow::mut_base(flow.get_mut()).abs_descendants.iter() {
|
||||
had_descendants = true;
|
||||
let descendant = absolute_descendant_link;
|
||||
proxy.push(WorkUnit {
|
||||
fun: compute_absolute_position,
|
||||
data: borrowed_flow_to_unsafe_flow(descendant),
|
||||
});
|
||||
}
|
||||
|
||||
// If there were no more descendants, start building the display list.
|
||||
if !had_descendants {
|
||||
build_display_list(mut_owned_flow_to_unsafe_flow(flow),
|
||||
proxy)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn build_display_list(mut unsafe_flow: UnsafeFlow,
|
||||
proxy: &mut WorkerProxy<*const SharedLayoutContext,UnsafeFlow>) {
|
||||
let shared_layout_context = unsafe { &**proxy.user_data() };
|
||||
let layout_context = LayoutContext::new(shared_layout_context);
|
||||
|
||||
loop {
|
||||
unsafe {
|
||||
// Get a real flow.
|
||||
let flow: &mut FlowRef = mem::transmute(&unsafe_flow);
|
||||
|
||||
// Build display lists.
|
||||
flow.get_mut().build_display_list(&layout_context);
|
||||
|
||||
{
|
||||
let base = flow::mut_base(flow.get_mut());
|
||||
|
||||
// Reset the count of children and absolute descendants for the next layout
|
||||
// traversal.
|
||||
let children_and_absolute_descendant_count = base.children.len() +
|
||||
base.abs_descendants.len();
|
||||
base.parallel
|
||||
.children_and_absolute_descendant_count
|
||||
.store(children_and_absolute_descendant_count as int, Relaxed);
|
||||
}
|
||||
|
||||
// Possibly enqueue the parent.
|
||||
let unsafe_parent = if flow.get().is_absolutely_positioned() {
|
||||
match *flow::mut_base(flow.get_mut()).absolute_cb.get() {
|
||||
None => fail!("no absolute containing block for absolutely positioned?!"),
|
||||
Some(ref mut absolute_cb) => {
|
||||
mut_borrowed_flow_to_unsafe_flow(absolute_cb.get_mut())
|
||||
}
|
||||
}
|
||||
} else {
|
||||
flow::mut_base(flow.get_mut()).parallel.parent
|
||||
};
|
||||
if unsafe_parent == null_unsafe_flow() {
|
||||
// We're done!
|
||||
break
|
||||
}
|
||||
|
||||
// No, we're not at the root yet. Then are we the last child
|
||||
// of our parent to finish processing? If so, we can continue
|
||||
// on with our parent; otherwise, we've gotta wait.
|
||||
let parent: &mut FlowRef = mem::transmute(&unsafe_parent);
|
||||
let parent_base = flow::mut_base(parent.get_mut());
|
||||
if parent_base.parallel
|
||||
.children_and_absolute_descendant_count
|
||||
.fetch_sub(1, SeqCst) == 1 {
|
||||
// We were the last child of our parent. Build display lists for our parent.
|
||||
unsafe_flow = unsafe_parent
|
||||
} else {
|
||||
// Stop.
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn recalc_style_for_subtree(root_node: &LayoutNode,
|
||||
shared_layout_context: &SharedLayoutContext,
|
||||
queue: &mut WorkQueue<*const SharedLayoutContext,UnsafeLayoutNode>) {
|
||||
queue.data = shared_layout_context as *const _;
|
||||
|
||||
// Enqueue the root node.
|
||||
queue.push(WorkUnit {
|
||||
fun: recalc_style_for_node,
|
||||
data: layout_node_to_unsafe_layout_node(root_node),
|
||||
});
|
||||
|
||||
queue.run();
|
||||
|
||||
queue.data = ptr::null()
|
||||
}
|
||||
|
||||
pub fn traverse_flow_tree_preorder(root: &mut FlowRef,
|
||||
time_profiler_chan: TimeProfilerChan,
|
||||
shared_layout_context: &SharedLayoutContext,
|
||||
queue: &mut WorkQueue<*const SharedLayoutContext,UnsafeFlow>) {
|
||||
queue.data = shared_layout_context as *const _;
|
||||
|
||||
profile(time::LayoutParallelWarmupCategory, time_profiler_chan, || {
|
||||
queue.push(WorkUnit {
|
||||
fun: assign_inline_sizes,
|
||||
data: mut_owned_flow_to_unsafe_flow(root),
|
||||
})
|
||||
});
|
||||
|
||||
queue.run();
|
||||
|
||||
queue.data = ptr::null()
|
||||
}
|
||||
|
||||
pub fn build_display_list_for_subtree(root: &mut FlowRef,
|
||||
time_profiler_chan: TimeProfilerChan,
|
||||
shared_layout_context: &SharedLayoutContext,
|
||||
queue: &mut WorkQueue<*const SharedLayoutContext,UnsafeFlow>) {
|
||||
queue.data = shared_layout_context as *const _;
|
||||
|
||||
profile(time::LayoutParallelWarmupCategory, time_profiler_chan, || {
|
||||
queue.push(WorkUnit {
|
||||
fun: compute_absolute_position,
|
||||
data: mut_owned_flow_to_unsafe_flow(root),
|
||||
})
|
||||
});
|
||||
|
||||
queue.run();
|
||||
|
||||
queue.data = ptr::null()
|
||||
}
|
||||
|
Loading…
Add table
Add a link
Reference in a new issue