ZacharyZhang-NY/ELY-Browser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

perf(sidecar): use payloadless hardware frames after warmup

Browse Source
This commit is contained in:
ZacharyZhang-NY
2026-05-16 02:50:11 -04:00
parent bd59e74ad2
commit dbfcbdb377
8 changed files with 346 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/ely_servo_host/src/bin/ely_servo_sidecar/live.rs
+92 -18
View File
@@ -7,7 +7,7 @@ use std::{
use ely_domain::{ProfileId, TabId, UrlText};
#[cfg(all(feature = "hardware-render", target_os = "macos"))]
use ely_servo_host::WebViewState;
use ely_servo_host::ServoHostError;
use ely_servo_host::{
IOSurfaceIdentity, NavigationRequest, RenderingContextKind, ServoHost, ServoSurfaceSize,
SoftwareServoHost,
@@ -26,6 +26,7 @@ use super::perf::{FramePerfAggregator, FramePerfSummary, elapsed_ns};
pub(super) fn run_live(args: LiveArgs) -> Result<(), LiveSidecarError> {
let LiveArgs { profile_data_dir, iosurface_mach_service, rendering_context_kind } = args;
let publish_readback_surface_fields = iosurface_mach_service.is_none();
fs::create_dir_all(&profile_data_dir)?;
let context_label = rendering_context_label(rendering_context_kind);
let mut host = SoftwareServoHost::new_with_config_dir_and_kind(
@@ -64,6 +65,7 @@ pub(super) fn run_live(args: LiveArgs) -> Result<(), LiveSidecarError> {
&mut sessions,
&mut published_surface_ids,
rendering_context_kind,
publish_readback_surface_fields,
request,
),
Err(error) => Err(LiveSidecarError::Json(error)),
@@ -92,6 +94,7 @@ fn handle_request(
sessions: &mut HashMap<String, LiveSession>,
published_surface_ids: &mut HashMap<String, HashSet<IOSurfaceIdentity>>,
rendering_context_kind: RenderingContextKind,
publish_readback_surface_fields: bool,
request: LiveRequest,
) -> Result<LiveOutcome, LiveSidecarError> {
match request {
@@ -159,12 +162,14 @@ fn handle_request(
session.awaiting_visible_frame = true;
}
let webview_id = session.webview_id.clone();
let mut outcome = poll_frame(host, session, rendering_context_kind)?;
let mut outcome =
poll_frame(host, session, rendering_context_kind, &tab_id, published_surface_ids)?;
populate_surface_fields(
host,
&webview_id,
&tab_id,
published_surface_ids,
publish_readback_surface_fields,
&mut outcome,
);
Ok(outcome)
@@ -174,12 +179,14 @@ fn handle_request(
return Ok(LiveOutcome::empty());
};
let webview_id = session.webview_id.clone();
let mut outcome = poll_frame(host, session, rendering_context_kind)?;
let mut outcome =
poll_frame(host, session, rendering_context_kind, &tab_id, published_surface_ids)?;
populate_surface_fields(
host,
&webview_id,
&tab_id,
published_surface_ids,
publish_readback_surface_fields,
&mut outcome,
);
Ok(outcome)
@@ -198,6 +205,8 @@ fn poll_frame(
host: &mut SoftwareServoHost,
session: &mut LiveSession,
rendering_context_kind: RenderingContextKind,
tab_id: &str,
published_surface_ids: &HashMap<String, HashSet<IOSurfaceIdentity>>,
) -> Result<LiveOutcome, LiveSidecarError> {
host.tick();
let snapshot = host.snapshot(&session.webview_id)?;
@@ -206,8 +215,14 @@ fn poll_frame(
return Ok(LiveOutcome::empty());
}
let (outcome, has_visible_content) =
paint_pending_frame(host, session, rendering_context_kind, has_pending_frame)?;
let (outcome, has_visible_content) = paint_pending_frame(
host,
session,
rendering_context_kind,
tab_id,
published_surface_ids,
has_pending_frame,
)?;
if has_visible_content {
session.awaiting_visible_frame = false;
session.ever_visible_frame = true;
@@ -228,14 +243,23 @@ fn paint_pending_frame(
host: &mut SoftwareServoHost,
session: &mut LiveSession,
rendering_context_kind: RenderingContextKind,
tab_id: &str,
published_surface_ids: &HashMap<String, HashSet<IOSurfaceIdentity>>,
has_pending_frame: bool,
) -> Result<(LiveOutcome, bool), LiveSidecarError> {
#[cfg(not(all(feature = "hardware-render", target_os = "macos")))]
let _ = (tab_id, published_surface_ids);
match rendering_context_kind {
RenderingContextKind::Software => paint_readback_frame(host, session, !has_pending_frame),
#[cfg(all(feature = "hardware-render", target_os = "macos"))]
RenderingContextKind::Hardware => {
paint_hardware_surface_frame(host, session, has_pending_frame)
}
RenderingContextKind::Hardware => paint_hardware_surface_frame(
host,
session,
tab_id,
published_surface_ids,
has_pending_frame,
),
#[cfg(not(all(feature = "hardware-render", target_os = "macos")))]
RenderingContextKind::Hardware => paint_readback_frame(host, session, !has_pending_frame),
}
@@ -264,16 +288,22 @@ fn paint_readback_frame(
fn paint_hardware_surface_frame(
host: &mut SoftwareServoHost,
session: &LiveSession,
tab_id: &str,
published_surface_ids: &HashMap<String, HashSet<IOSurfaceIdentity>>,
has_pending_frame: bool,
) -> Result<(LiveOutcome, bool), LiveSidecarError> {
if !session.ever_visible_frame {
return paint_initial_hardware_surface_frame(host, session, !has_pending_frame);
}
// Cross-process IOSurface lookup can block the app-side worker for
// seconds on macOS. Live app frames use readback so scroll/click
// input stays bounded by the paint barrier instead of the surface
// import path.
paint_readback_frame(host, session, !has_pending_frame)
if !payloadless_surface_pool_ready(published_surface_ids, tab_id, session.width, session.height)
{
return paint_readback_frame(host, session, !has_pending_frame);
}
let (outcome, identity) = paint_hardware_surface_report(host, session, !has_pending_frame)?;
if !surface_has_been_published(published_surface_ids, tab_id, identity) {
return paint_readback_frame(host, session, true);
}
Ok((outcome, true))
}
#[cfg(all(feature = "hardware-render", target_os = "macos"))]
@@ -289,17 +319,61 @@ fn paint_initial_hardware_surface_frame(
let paint_ns = elapsed_ns(paint_started_at);
let encode_started_at = Instant::now();
let report = LiveFrameReport::new(&snapshot, &frame, session.device_pixel_ratio());
let has_visible_content = frame.non_white_pixel_count() > 0
&& frame.content_pixel_count() > 0
&& hardware_snapshot_has_visible_document(&snapshot);
let has_visible_content = frame.non_white_pixel_count() > 0 && frame.content_pixel_count() > 0;
let encode_ns = elapsed_ns(encode_started_at);
let timings = PartialFrameTimings { paint_ns, encode_ns };
Ok((LiveOutcome::from_frame(report, frame, timings), has_visible_content))
}
#[cfg(all(feature = "hardware-render", target_os = "macos"))]
fn hardware_snapshot_has_visible_document(snapshot: &ely_servo_host::WebViewSnapshot) -> bool {
snapshot.title().is_some() || matches!(snapshot.state(), WebViewState::Complete)
fn paint_hardware_surface_report(
host: &mut SoftwareServoHost,
session: &LiveSession,
wait_for_completion: bool,
) -> Result<(LiveOutcome, IOSurfaceIdentity), LiveSidecarError> {
let paint_started_at = Instant::now();
host.paint_without_readback_with_completion(&session.webview_id, wait_for_completion)?;
let snapshot = host.snapshot(&session.webview_id)?;
let identity = host.peek_iosurface_identity(&session.webview_id)?.ok_or_else(|| {
ServoHostError::HardwareSurfaceUnavailable { id: session.webview_id.clone() }
})?;
let paint_ns = elapsed_ns(paint_started_at);
let encode_started_at = Instant::now();
let report = LiveFrameReport::from_surface(
&snapshot,
identity.width,
identity.height,
session.device_pixel_ratio(),
);
let encode_ns = elapsed_ns(encode_started_at);
let timings = PartialFrameTimings { paint_ns, encode_ns };
Ok((LiveOutcome::from_report(report, timings), identity))
}
#[cfg(all(feature = "hardware-render", target_os = "macos"))]
fn payloadless_surface_pool_ready(
published_surface_ids: &HashMap<String, HashSet<IOSurfaceIdentity>>,
tab_id: &str,
width: u32,
height: u32,
) -> bool {
published_surface_ids.get(tab_id).is_some_and(|published| {
published
.iter()
.filter(|identity| identity.width == width && identity.height == height)
.take(2)
.count()
>= 2
})
}
#[cfg(all(feature = "hardware-render", target_os = "macos"))]
fn surface_has_been_published(
published_surface_ids: &HashMap<String, HashSet<IOSurfaceIdentity>>,
tab_id: &str,
identity: IOSurfaceIdentity,
) -> bool {
published_surface_ids.get(tab_id).is_some_and(|published| published.contains(&identity))
}
#[cfg(test)]
crates/ely_servo_host/src/bin/ely_servo_sidecar/live_output.rs
+12 -10
View File
@@ -11,8 +11,12 @@ use ely_servo_host::{IOSurfaceIdentity, SoftwareServoHost};
use super::live_protocol::{LiveOutcome, LiveSidecarError, PartialFrameTimings};
use super::perf::{FramePerfAggregator, FramePerfSummary, FrameStageTimings, elapsed_ns};
/// Populate the hardware surface protocol fields on `outcome`. Two
/// pieces of state ride out together:
/// Populate the hardware surface protocol fields on `outcome`. Mach
/// app clients keep readback frames free of surface fields because
/// synchronous IOSurface import can block the live worker; the no-Mach
/// bench path publishes readback warm-up handles so it can validate
/// payloadless steady-state frames. Two pieces of state ride out
/// together:
///
/// * `current_surface_id` — set on every payload-bearing hardware
/// frame so the receiver knows which previously-imported
@@ -30,12 +34,13 @@ pub(super) fn populate_surface_fields(
webview_id: &ely_domain::WebViewId,
tab_id: &str,
published_surface_ids: &mut HashMap<String, HashSet<IOSurfaceIdentity>>,
publish_readback_surface_fields: bool,
outcome: &mut LiveOutcome,
) {
if outcome.response.frame.is_none() {
return;
}
if outcome.frame.is_some() {
if outcome.frame.is_some() && !publish_readback_surface_fields {
return;
}
#[cfg(all(feature = "hardware-render", target_os = "macos"))]
@@ -58,7 +63,7 @@ pub(super) fn populate_surface_fields(
}
#[cfg(not(all(feature = "hardware-render", target_os = "macos")))]
{
let _ = (host, webview_id, tab_id, published_surface_ids);
let _ = (host, webview_id, tab_id, published_surface_ids, publish_readback_surface_fields);
}
}
@@ -154,12 +159,9 @@ pub(super) fn write_outcome(
if let Some(summary) = pending_summary.take() {
outcome.response.perf = Some(summary);
}
// Hardware path: receiver samples the IOSurface directly through
// its CVPixelBuffer cache, so the raw RGBA payload is dead
// weight. Drop it from the wire (and zero the byte count in the
// header so the client knows nothing follows). At 1080p × 60 fps
// that's 8 MB × 60 = ~480 MB/s of pipe traffic eliminated.
let drop_rgba_payload = outcome.response.current_surface_id.is_some();
// Payloadless hardware frames carry only the IOSurface selector.
let drop_rgba_payload =
outcome.response.current_surface_id.is_some() && outcome.frame.is_none();
if drop_rgba_payload && let Some(report) = outcome.response.frame.as_mut() {
report.rgba_byte_count = 0;
}
crates/ely_servo_host/src/bin/ely_servo_sidecar/live_protocol.rs
+26 -1
View File
@@ -103,7 +103,7 @@ impl LiveOutcome {
}
}
#[cfg(test)]
#[cfg(any(test, all(feature = "hardware-render", target_os = "macos")))]
pub fn from_report(report: LiveFrameReport, partial_timings: PartialFrameTimings) -> Self {
Self {
response: LiveResponse::frame(report),
@@ -204,6 +204,31 @@ impl LiveFrameReport {
sample_hash: frame.sample_hash(),
}
}
#[cfg(all(feature = "hardware-render", target_os = "macos"))]
pub fn from_surface(
snapshot: &WebViewSnapshot,
width: u32,
height: u32,
device_pixel_ratio: f32,
) -> Self {
let (css_viewport_width, css_viewport_height) =
css_viewport_size(width, height, device_pixel_ratio);
Self {
loaded_url: snapshot.url().map(str::to_string),
title: snapshot.title().map(str::to_string),
state: state_label(snapshot.state()),
width,
height,
device_pixel_ratio,
css_viewport_width,
css_viewport_height,
rgba_byte_count: 0,
non_white_pixel_count: 0,
content_pixel_count: 0,
sample_hash: 0,
}
}
}
fn css_viewport_size(width: u32, height: u32, device_pixel_ratio: f32) -> (u32, u32) {