Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

perf(renderer): trace per-frame rendering phases

ldm04117a16f2df9
diff --git a/moli-layout/src/layout_tree/pass_result.rs b/moli-layout/src/layout_tree/pass_result.rs
index 8723ee9a0..dcd091fca 100644
--- a/moli-layout/src/layout_tree/pass_result.rs
+++ b/moli-layout/src/layout_tree/pass_result.rs
@@ -37,6 +37,18 @@ pub enum LayoutFlushReason {
pub struct LayoutPassMetrics {
pub reason: LayoutFlushReason,
pub elapsed: Duration,
+ pub box_tree_elapsed: Duration,
+ pub list_marker_elapsed: Duration,
+ pub form_control_elapsed: Duration,
+ pub inline_preparation_elapsed: Duration,
+ pub numeric_layout_elapsed: Duration,
+ pub numeric_first_pass_elapsed: Duration,
+ pub numeric_followup_passes_elapsed: Duration,
+ pub overflow_detection_elapsed: Duration,
+ pub scrollbar_feedback_elapsed: Duration,
+ pub embedded_frame_elapsed: Duration,
+ pub projection_elapsed: Duration,
+ pub numeric_layout_pass_count: usize,
pub box_count: usize,
pub fragment_count: usize,
pub paint_operation_count: usize,
diff --git a/moli-layout/src/pass.rs b/moli-layout/src/pass.rs
index 8a8ed7803..306fa1975 100644
--- a/moli-layout/src/pass.rs
+++ b/moli-layout/src/pass.rs
@@ -9,7 +9,7 @@ use crate::{
taffy_tree::compute_world_layout,
};
use std::collections::HashMap;
-use std::time::Instant;
+use std::time::{Duration, Instant};
/// Owned products for one embedded browsing context in the same synchronous
/// layout demand as its parent.
@@ -211,7 +211,9 @@ where
F: EmbeddedFrameRenderer<S::NodeId>,
{
let started = Instant::now();
+ let phase_started = Instant::now();
let mut world = build_layout_world(source, styles)?;
+ let box_tree_elapsed = phase_started.elapsed();
debug_assert!(
world
.viewport_scroll_policy
@@ -219,11 +221,20 @@ where
.is_none_or(|body| world.box_by_id(body).is_some()),
"viewport policy must retain only a live pass-local body box identity"
);
+ let phase_started = Instant::now();
prepare_list_markers(&mut world)?;
+ let list_marker_elapsed = phase_started.elapsed();
+ let phase_started = Instant::now();
prepare_form_controls(&mut world)?;
+ let form_control_elapsed = phase_started.elapsed();
+ let phase_started = Instant::now();
prepare_inline_contexts(&mut world, services);
+ let inline_preparation_elapsed = phase_started.elapsed();
world.validate_invariants()?;
- compute_world_layout_with_scrollbars(&mut world, request.viewport);
+ let phase_started = Instant::now();
+ let numeric_metrics = compute_world_layout_with_scrollbars(&mut world, request.viewport);
+ let numeric_layout_elapsed = phase_started.elapsed();
+ let phase_started = Instant::now();
let mut embedded_frames = HashMap::new();
if request.requests_embedded_frames() {
for index in 0..world.boxes.len() {
@@ -262,6 +273,7 @@ where
}
}
}
+ let embedded_frame_elapsed = phase_started.elapsed();
finish_layout_pass(
&world,
source.root(),
@@ -271,6 +283,19 @@ where
request.paint_capture,
embedded_frames,
request.requests_embedded_frames(),
+ crate::projection::LayoutPassPhaseMetrics {
+ box_tree_elapsed,
+ list_marker_elapsed,
+ form_control_elapsed,
+ inline_preparation_elapsed,
+ numeric_layout_elapsed,
+ numeric_first_pass_elapsed: numeric_metrics.first_pass_elapsed,
+ numeric_followup_passes_elapsed: numeric_metrics.followup_passes_elapsed,
+ overflow_detection_elapsed: numeric_metrics.overflow_detection_elapsed,
+ scrollbar_feedback_elapsed: numeric_metrics.scrollbar_feedback_elapsed,
+ embedded_frame_elapsed,
+ numeric_layout_pass_count: numeric_metrics.pass_count,
+ },
)
}
@@ -278,10 +303,20 @@ where
/// classic browser scrollbars: lay out without an automatic gutter, reveal
/// every axis that overflows, then repeat because one gutter can make the
/// perpendicular axis overflow. Each axis changes at most once.
+#[derive(Default)]
+struct NumericLayoutMetrics {
+ pass_count: usize,
+ first_pass_elapsed: Duration,
+ followup_passes_elapsed: Duration,
+ overflow_detection_elapsed: Duration,
+ scrollbar_feedback_elapsed: Duration,
+}
+
fn compute_world_layout_with_scrollbars<N>(
world: &mut crate::LayoutWorld<N>,
viewport: LayoutViewport,
-) where
+) -> NumericLayoutMetrics
+where
N: Copy + std::fmt::Debug + Eq + std::hash::Hash,
{
let root_id = world.root;
@@ -299,9 +334,21 @@ fn compute_world_layout_with_scrollbars<N>(
}
}
+ let mut metrics = NumericLayoutMetrics::default();
loop {
+ metrics.pass_count = metrics.pass_count.saturating_add(1);
+ let phase_started = Instant::now();
compute_world_layout(world, viewport);
+ let elapsed = phase_started.elapsed();
+ if metrics.pass_count == 1 {
+ metrics.first_pass_elapsed = elapsed;
+ } else {
+ metrics.followup_passes_elapsed += elapsed;
+ }
+ let phase_started = Instant::now();
let overflow = overflowing_axes(world, viewport);
+ metrics.overflow_detection_elapsed += phase_started.elapsed();
+ let phase_started = Instant::now();
let (root_overflow_x, root_overflow_y) = overflow[root];
let mut changed = world
.viewport_scroll_policy
@@ -327,10 +374,12 @@ fn compute_world_layout_with_scrollbars<N>(
overflow_y,
);
}
+ metrics.scrollbar_feedback_elapsed += phase_started.elapsed();
if !changed {
break;
}
}
+ metrics
}
fn css_viewport_dimension(value: f32) -> u32 {
diff --git a/moli-layout/src/projection.rs b/moli-layout/src/projection.rs
index a65d24593..2a5644042 100644
--- a/moli-layout/src/projection.rs
+++ b/moli-layout/src/projection.rs
@@ -15,6 +15,20 @@ use crate::{
PaintDiagnosticSeverity,
};
+pub(crate) struct LayoutPassPhaseMetrics {
+ pub(crate) box_tree_elapsed: std::time::Duration,
+ pub(crate) list_marker_elapsed: std::time::Duration,
+ pub(crate) form_control_elapsed: std::time::Duration,
+ pub(crate) inline_preparation_elapsed: std::time::Duration,
+ pub(crate) numeric_layout_elapsed: std::time::Duration,
+ pub(crate) numeric_first_pass_elapsed: std::time::Duration,
+ pub(crate) numeric_followup_passes_elapsed: std::time::Duration,
+ pub(crate) overflow_detection_elapsed: std::time::Duration,
+ pub(crate) scrollbar_feedback_elapsed: std::time::Duration,
+ pub(crate) embedded_frame_elapsed: std::time::Duration,
+ pub(crate) numeric_layout_pass_count: usize,
+}
+
pub(crate) fn finish_layout_pass<N>(
world: &LayoutWorld<N>,
source_root: N,
@@ -24,10 +38,12 @@ pub(crate) fn finish_layout_pass<N>(
paint_capture: Option<PaintCaptureRequest>,
mut embedded_frames: HashMap<LayoutBoxId, (N, crate::EmbeddedFrameSnapshot<N>)>,
embedded_frames_complete: bool,
+ phase_metrics: LayoutPassPhaseMetrics,
) -> Result<LayoutPassResult<N>, LayoutError>
where
N: Copy + Debug + Eq + Hash,
{
+ let projection_started = Instant::now();
let mut projection = OutputProjection::new(world, viewport);
projection.build_local_box_geometry();
projection.resolve_scrollable_overflow();
@@ -73,6 +89,18 @@ where
let metrics = LayoutPassMetrics {
reason,
elapsed: started.elapsed(),
+ box_tree_elapsed: phase_metrics.box_tree_elapsed,
+ list_marker_elapsed: phase_metrics.list_marker_elapsed,
+ form_control_elapsed: phase_metrics.form_control_elapsed,
+ inline_preparation_elapsed: phase_metrics.inline_preparation_elapsed,
+ numeric_layout_elapsed: phase_metrics.numeric_layout_elapsed,
+ numeric_first_pass_elapsed: phase_metrics.numeric_first_pass_elapsed,
+ numeric_followup_passes_elapsed: phase_metrics.numeric_followup_passes_elapsed,
+ overflow_detection_elapsed: phase_metrics.overflow_detection_elapsed,
+ scrollbar_feedback_elapsed: phase_metrics.scrollbar_feedback_elapsed,
+ embedded_frame_elapsed: phase_metrics.embedded_frame_elapsed,
+ projection_elapsed: projection_started.elapsed(),
+ numeric_layout_pass_count: phase_metrics.numeric_layout_pass_count,
box_count: projection.boxes.len(),
fragment_count: projection.fragments.len(),
paint_operation_count: paint_snapshot
diff --git a/moli-renderer-v8/src/native_bridge/context_host/layout.rs b/moli-renderer-v8/src/native_bridge/context_host/layout.rs
index cb12bac1e..4843e541c 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/layout.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/layout.rs
@@ -248,6 +248,31 @@ impl JsContextHost {
.get()
.saturating_add(pass.metrics.elapsed),
);
+ if moli_trace::cpu_profile_enabled() {
+ let metrics = pass.metrics;
+ tracing::info!(
+ target: "moli_cpu_profile",
+ stage = "layout_pass",
+ reason = ?metrics.reason,
+ total_us = metrics.elapsed.as_micros(),
+ box_tree_us = metrics.box_tree_elapsed.as_micros(),
+ list_marker_us = metrics.list_marker_elapsed.as_micros(),
+ form_control_us = metrics.form_control_elapsed.as_micros(),
+ inline_preparation_us = metrics.inline_preparation_elapsed.as_micros(),
+ numeric_layout_us = metrics.numeric_layout_elapsed.as_micros(),
+ numeric_first_pass_us = metrics.numeric_first_pass_elapsed.as_micros(),
+ numeric_followup_passes_us = metrics.numeric_followup_passes_elapsed.as_micros(),
+ overflow_detection_us = metrics.overflow_detection_elapsed.as_micros(),
+ scrollbar_feedback_us = metrics.scrollbar_feedback_elapsed.as_micros(),
+ embedded_frame_us = metrics.embedded_frame_elapsed.as_micros(),
+ projection_us = metrics.projection_elapsed.as_micros(),
+ numeric_layout_pass_count = metrics.numeric_layout_pass_count,
+ box_count = metrics.box_count,
+ fragment_count = metrics.fragment_count,
+ paint_operation_count = metrics.paint_operation_count,
+ fallback_count = metrics.fallback_count,
+ );
+ }
pass.validate_retention_budget()?;
let consumed = consume(&mut pass)?;
let metrics = pass.metrics;
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/mock/queries.rs b/moli-renderer-v8/src/native_bridge/element/geometry/mock/queries.rs
index 578a6bc5a..79adfdae6 100644
--- a/moli-renderer-v8/src/native_bridge/element/geometry/mock/queries.rs
+++ b/moli-renderer-v8/src/native_bridge/element/geometry/mock/queries.rs
@@ -144,6 +144,18 @@ pub(crate) fn answer_queries(
metrics: LayoutPassMetrics {
reason,
elapsed: Duration::ZERO,
+ box_tree_elapsed: Duration::ZERO,
+ list_marker_elapsed: Duration::ZERO,
+ form_control_elapsed: Duration::ZERO,
+ inline_preparation_elapsed: Duration::ZERO,
+ numeric_layout_elapsed: Duration::ZERO,
+ numeric_first_pass_elapsed: Duration::ZERO,
+ numeric_followup_passes_elapsed: Duration::ZERO,
+ overflow_detection_elapsed: Duration::ZERO,
+ scrollbar_feedback_elapsed: Duration::ZERO,
+ embedded_frame_elapsed: Duration::ZERO,
+ projection_elapsed: Duration::ZERO,
+ numeric_layout_pass_count: 1,
box_count: 0,
fragment_count: 0,
paint_operation_count: 0,
diff --git a/moli-renderer-v8/src/runtime/page_screenshot.rs b/moli-renderer-v8/src/runtime/page_screenshot.rs
index 4e89afb8e..3d7efd78d 100644
--- a/moli-renderer-v8/src/runtime/page_screenshot.rs
+++ b/moli-renderer-v8/src/runtime/page_screenshot.rs
@@ -2,12 +2,59 @@ use moli_browser_profile::DEFAULT_WINDOW_SURFACE_PROFILE;
use moli_layout::{LayoutRect, PaintCaptureRequest, PaintViewport};
use moli_page_types::LayoutPolicy;
use std::sync::Arc;
+use std::time::Instant;
use super::{
PageVm, RendererCaptureScreencastFrameReply, RendererCaptureScreenshotReply,
RendererCapturedScreencastFrame, RendererCapturedScreenshot, RendererDocumentLifecycleIdentity,
};
+#[derive(Default)]
+struct PaintFragmentProfile {
+ push_layer: usize,
+ push_clip: usize,
+ pop_layer: usize,
+ fill: usize,
+ stroke: usize,
+ border: usize,
+ box_shadow: usize,
+ text_decoration: usize,
+ text_shadow: usize,
+ glyph_run: usize,
+ glyph: usize,
+ image: usize,
+ svg_image: usize,
+}
+
+impl PaintFragmentProfile {
+ fn from_snapshot(snapshot: &moli_layout::PaintSnapshot) -> Self {
+ let mut profile = Self::default();
+ for fragment in &snapshot.fragments {
+ match fragment {
+ moli_layout::PaintFragment::PushLayer { .. } => profile.push_layer += 1,
+ moli_layout::PaintFragment::PushClip { .. } => profile.push_clip += 1,
+ moli_layout::PaintFragment::PopLayer => profile.pop_layer += 1,
+ moli_layout::PaintFragment::Fill { .. } => profile.fill += 1,
+ moli_layout::PaintFragment::Stroke(_) => profile.stroke += 1,
+ moli_layout::PaintFragment::Border { .. } => profile.border += 1,
+ moli_layout::PaintFragment::BoxShadow(_) => profile.box_shadow += 1,
+ moli_layout::PaintFragment::TextDecoration(_) => profile.text_decoration += 1,
+ moli_layout::PaintFragment::TextShadow(shadow) => {
+ profile.text_shadow += 1;
+ profile.glyph += shadow.run.glyphs.len();
+ }
+ moli_layout::PaintFragment::GlyphRun(run) => {
+ profile.glyph_run += 1;
+ profile.glyph += run.glyphs.len();
+ }
+ moli_layout::PaintFragment::Image(_) => profile.image += 1,
+ moli_layout::PaintFragment::SvgImage(_) => profile.svg_image += 1,
+ }
+ }
+ profile
+ }
+}
+
/// Opaque identity for the renderer state that can affect one viewport frame.
///
/// The token retains generation metadata only. It never owns layout, paint,
@@ -253,6 +300,8 @@ impl PageVm {
paint_capture: PaintCaptureRequest,
reason: moli_layout::LayoutFlushReason,
) -> anyhow::Result<RendererImageCaptureOutcome> {
+ let profile_enabled = moli_trace::cpu_profile_enabled();
+ let total_started = profile_enabled.then(Instant::now);
if self.layout_policy == LayoutPolicy::Mock {
return Ok(RendererImageCaptureOutcome::LayoutDisabled);
}
@@ -264,14 +313,44 @@ impl PageVm {
surface.inner_height,
surface.device_pixel_ratio as f32,
);
+ let layout_started = profile_enabled.then(Instant::now);
let Some(snapshot) =
self.vm_mut()
.paint_layout_snapshot_with_capture(viewport, reason, paint_capture)?
else {
return Ok(RendererImageCaptureOutcome::NoDocument);
};
+ let layout_us = layout_started
+ .map(|started| started.elapsed().as_micros())
+ .unwrap_or_default();
+
+ if profile_enabled {
+ let profile = PaintFragmentProfile::from_snapshot(&snapshot);
+ tracing::info!(
+ target: "moli_cpu_profile",
+ stage = "paint_fragment_profile",
+ push_layer = profile.push_layer,
+ push_clip = profile.push_clip,
+ pop_layer = profile.pop_layer,
+ fill = profile.fill,
+ stroke = profile.stroke,
+ border = profile.border,
+ box_shadow = profile.box_shadow,
+ text_decoration = profile.text_decoration,
+ text_shadow = profile.text_shadow,
+ glyph_run = profile.glyph_run,
+ glyph = profile.glyph,
+ image = profile.image,
+ svg_image = profile.svg_image,
+ );
+ }
+ let raster_started = profile_enabled.then(Instant::now);
let raster = moli_paint::raster_snapshot(&snapshot)?;
+ let raster_us = raster_started
+ .map(|started| started.elapsed().as_micros())
+ .unwrap_or_default();
+ let encode_started = profile_enabled.then(Instant::now);
let (mime_type, width, height, bytes) = match format {
RendererScreenshotFormat::Png => {
let encoded = moli_image::encode_png_with_options(
@@ -285,6 +364,23 @@ impl PageVm {
("image/jpeg", encoded.width, encoded.height, encoded.bytes)
}
};
+ let encode_us = encode_started
+ .map(|started| started.elapsed().as_micros())
+ .unwrap_or_default();
+ if let Some(started) = total_started {
+ tracing::info!(
+ target: "moli_cpu_profile",
+ stage = "image_capture",
+ reason = ?reason,
+ width,
+ height,
+ encoded_bytes = bytes.len(),
+ layout_us,
+ raster_us,
+ encode_us,
+ total_us = started.elapsed().as_micros(),
+ );
+ }
Ok(RendererImageCaptureOutcome::Captured(
RendererCapturedScreenshot {
mime_type: mime_type.to_owned(),