blob: 7cb8d8e25ab3a106452229f4f2622b686bc3a74c [file]
#!/usr/bin/env fuchsia-vendored-python
# Copyright 2024 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Per App Present trace metrics."""
import logging
import statistics
import typing
from collections.abc import MutableSequence
from reporting import metrics
from trace_processing import trace_metrics, trace_model, trace_time, trace_utils
_LOGGER: logging.Logger = logging.getLogger("AppRenderLatencyMetricsProcessor")
_EVENT_CATEGORY: str = "gfx"
_PRESENT_EVENT_NAME: str = "Flatland::PerAppPresent[{}]"
_DISPLAY_VSYNC_EVENT_NAME: str = "Flatland::DisplayCompositor::OnVsync"
class AppRenderLatencyMetricsProcessor(trace_metrics.MetricsProcessor):
"""Computes present-latency metrics for a given app.
App render latency is measured from the moment that the chosen app begins presenting through
the Flatland API until the first vsync that corresponds with app content being displayed on
screen. Flow events in the trace enable this class to reliably correlate the correct events to
calculate this duration.
By default, this module reports aggregate latency measurements -- such as min, max, average, and
percentiles -- calculated across all presentations of the chosen app during the test. It can be
configured to instead report a time series of latency measurements, one for each event.
"""
def __init__(self, debug_name: str, aggregates_only: bool = True):
"""Constructor.
Args:
debug_name: the flatland client debug name.
aggregates_only: When True, generates AppRenderVsyncLatencyMin,
AppRenderVsyncLatencyMax, AppRenderVsyncLatencyAverage and
AppRenderVsyncLatencyP* (percentiles).
Otherwise generates AppRenderVsyncLatency metric with all
AppRenderVsyncLatency values.
"""
self._debug_name: str = debug_name
self._aggregates_only: bool = aggregates_only
@property
@typing.override
def event_patterns(self) -> set[str]:
return {
_PRESENT_EVENT_NAME.format(self._debug_name),
_DISPLAY_VSYNC_EVENT_NAME,
}
@property
@typing.override
def category_names(self) -> set[str]:
"""This processor follows a flow with many parts across `gfx`."""
return {_EVENT_CATEGORY}
@typing.override
def process_metrics(
self, model: trace_model.Model
) -> MutableSequence[metrics.TestCaseResult]:
# This method looks for a possible race between trace event start in Scenic and magma.
# We can safely skip these events. See https://fxbug.dev/322849857 for more details.
start_time = trace_utils.get_common_process_start_time(
model,
_PRESENT_EVENT_NAME.format(self._debug_name),
category=_EVENT_CATEGORY,
type=trace_model.DurationEvent,
)
present_flow_events = trace_utils.filter_events(
model.all_events(),
category=_EVENT_CATEGORY,
name=_PRESENT_EVENT_NAME.format(self._debug_name),
type=trace_model.Event,
)
present_latencies: list[float] = []
vsync_events: list[trace_model.Event] = []
for present_flow_event in present_flow_events:
if present_flow_event.start < start_time:
continue
if not isinstance(present_flow_event, trace_model.FlowEvent):
continue
if present_flow_event.phase not in (
trace_model.FlowEventPhase.START,
trace_model.FlowEventPhase.STEP,
):
continue
# Follow the flow event graph.
vsync = trace_utils.get_nearest_following_flow_event(
present_flow_event,
_EVENT_CATEGORY,
_DISPLAY_VSYNC_EVENT_NAME,
min_start=start_time,
)
# If vsync is None, it could be that a frame was dropped or not rendered, find the next vsync in chronological order.
if vsync is None:
following_vsyncs = trace_utils.filter_events(
model.all_events(),
category=_EVENT_CATEGORY,
name=_DISPLAY_VSYNC_EVENT_NAME,
type=trace_model.Event,
)
vsync = next(
(
v
for v in following_vsyncs
if v.start >= present_flow_event.start
),
None,
)
# If there isn't a vsync, loop through and find the next event.
if vsync is None:
continue
latency = vsync.start - present_flow_event.start
present_latencies.append(round(latency.to_milliseconds_f(), 3))
vsync_events.append(vsync)
if len(vsync_events) == 0:
_LOGGER.fatal("Not enough valid vsyncs")
present_latency_mean: float = statistics.mean(present_latencies)
_LOGGER.info(f"Average Present Latency: {present_latency_mean}")
if len(vsync_events) < 2:
_LOGGER.fatal(
f"Fewer than two vsync events are present. Perhaps the trace "
f"duration is too short to provide fps information"
)
fps_values: list[float] = []
for i in range(len(vsync_events) - 1):
# Two renders may be squashed into one.
if vsync_events[i + 1].start == vsync_events[i].start:
continue
fps_values.append(
trace_time.TimeDelta.from_seconds(1)
/ (vsync_events[i + 1].start - vsync_events[i].start)
)
if len(fps_values) == 0:
_LOGGER.fatal("Not enough valid vsyncs")
fps_mean: float = statistics.mean(fps_values)
_LOGGER.info(f"Average FPS: {fps_mean}")
if self._aggregates_only:
return trace_utils.standard_metrics_set(
values=present_latencies,
label_prefix="AppRenderVsyncLatency",
unit=metrics.Unit.milliseconds,
) + trace_utils.standard_metrics_set(
values=fps_values,
label_prefix="AppFps",
unit=metrics.Unit.framesPerSecond,
)
else:
return [
metrics.TestCaseResult(
"AppRenderVsyncLatency",
metrics.Unit.milliseconds,
present_latencies,
),
metrics.TestCaseResult(
"AppFps", metrics.Unit.framesPerSecond, fps_values
),
]