blob: 6c30e84ff38dcd4d2c6ab761abd2d5c827204d62 [file]
#!/usr/bin/env fuchsia-vendored-python
# Copyright 2023 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.
"""Unit tests for trace_utils.py."""
import unittest
import test_utils
from reporting import metrics
from trace_processing import trace_model, trace_time, trace_utils
# Boilerplate-busting constants:
U = metrics.Unit
TCR = metrics.TestCaseResult
class TraceUtilsTest(unittest.TestCase):
"""Trace utils tests"""
def test_compute_stats(self) -> None:
self.assertAlmostEqual(
trace_utils.percentile(
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0], 25
),
3.0,
)
self.assertAlmostEqual(
trace_utils.percentile(
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0], 50
),
5.0,
)
self.assertAlmostEqual(
trace_utils.percentile(
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0], 75
),
7.0,
)
self.assertAlmostEqual(
trace_utils.percentile(
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0], 25
),
3.25,
)
self.assertAlmostEqual(
trace_utils.percentile(
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0], 50
),
5.5,
)
self.assertAlmostEqual(
trace_utils.percentile(
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0], 75
),
7.75,
)
def test_filter_events(self) -> None:
events: list[trace_model.Event] = [
trace_model.DurationEvent(
duration=None,
parent=None,
child_durations=[],
child_flows=[],
base=trace_model.Event(
category="cat_a",
name="name_a",
start=trace_time.TimePoint.from_epoch_delta(
trace_time.TimeDelta.from_microseconds(
697778328.2160872
)
),
pid=7009,
tid=7022,
args={},
),
),
trace_model.DurationEvent(
duration=None,
parent=None,
child_durations=[],
child_flows=[],
base=trace_model.Event(
category="cat_b",
name="name_b",
start=trace_time.TimePoint.from_epoch_delta(
trace_time.TimeDelta.from_microseconds(
697778328.2160872
)
),
pid=7009,
tid=7022,
args={},
),
),
]
filtered = list(
trace_utils.filter_events(
iter(events),
category="cat_a",
name="name_a",
type=trace_model.Event,
)
)
self.assertEqual(filtered, [events[0]])
filtered2 = list(
trace_utils.filter_events(
iter(events),
category="cat_c",
name="name_c",
type=trace_model.Event,
)
)
self.assertEqual(filtered2, [])
def test_filter_events_with_name_collection(self) -> None:
events: list[trace_model.Event] = [
trace_model.DurationEvent(
duration=None,
parent=None,
child_durations=[],
child_flows=[],
base=trace_model.Event(
category="cat_a",
name="name_a",
start=trace_time.TimePoint.from_epoch_delta(
trace_time.TimeDelta.from_microseconds(0)
),
pid=7009,
tid=7022,
args={},
),
),
trace_model.DurationEvent(
duration=None,
parent=None,
child_durations=[],
child_flows=[],
base=trace_model.Event(
category="cat_b",
name="name_b",
start=trace_time.TimePoint.from_epoch_delta(
trace_time.TimeDelta.from_microseconds(0)
),
pid=7009,
tid=7022,
args={},
),
),
trace_model.DurationEvent(
duration=None,
parent=None,
child_durations=[],
child_flows=[],
base=trace_model.Event(
category="cat_c",
name="name_c",
start=trace_time.TimePoint.from_epoch_delta(
trace_time.TimeDelta.from_microseconds(0)
),
pid=7009,
tid=7022,
args={},
),
),
]
filtered = list(
trace_utils.filter_events(
iter(events), name={"name_a", "name_c"}, type=trace_model.Event
)
)
self.assertEqual(filtered, [events[0], events[2]])
filtered2 = list(
trace_utils.filter_events(
iter(events), name=["name_b", "name_c"], type=trace_model.Event
)
)
self.assertEqual(filtered2, [events[1], events[2]])
def test_filter_events_with_type(self) -> None:
events: list[trace_model.Event] = [
trace_model.DurationEvent(
duration=None,
parent=None,
child_durations=[],
child_flows=[],
base=trace_model.Event(
category="cat_a",
name="name_a",
start=trace_time.TimePoint.from_epoch_delta(
trace_time.TimeDelta.from_microseconds(
697778328.2160872
)
),
pid=7009,
tid=7022,
args={},
),
),
trace_model.DurationEvent(
duration=None,
parent=None,
child_durations=[],
child_flows=[],
base=trace_model.Event(
category="cat_b",
name="name_b",
start=trace_time.TimePoint.from_epoch_delta(
trace_time.TimeDelta.from_microseconds(
697778328.2160872
)
),
pid=7009,
tid=7022,
args={},
),
),
]
filtered: list[trace_model.Event] = list(
trace_utils.filter_events(
iter(events),
category="cat_a",
name="name_a",
type=trace_model.DurationEvent,
)
)
self.assertEqual(filtered, [events[0]])
filtered2: list[trace_model.Event] = list(
trace_utils.filter_events(
iter(events),
category="cat_c",
name="name_c",
type=trace_model.DurationEvent,
)
)
self.assertEqual(filtered2, [])
filtered3: list[trace_model.Event] = list(
trace_utils.filter_events(
iter(events),
category="cat_a",
name="name_a",
type=trace_model.InstantEvent,
)
)
self.assertEqual(filtered3, [])
def test_total_event_duration(self) -> None:
model: trace_model.Model = test_utils.get_test_model()
mode_duration: trace_time.TimeDelta = (
trace_time.TimeDelta.from_microseconds(
test_utils.TEST_MODEL_END_TIME_IN_US
)
- trace_time.TimeDelta.from_microseconds(
test_utils.TEST_MODEL_BEGIN_TIME_IN_US
)
)
self.assertEqual(
trace_utils.total_event_duration(model.all_events()), mode_duration
)
def test_standard_metrics_set(self) -> None:
values: list[float] = [0.0, 10.0]
unit = U.milliseconds
results = trace_utils.standard_metrics_set(
values=values, label_prefix="Foo", unit=unit
)
p_format_str = "{}, {}th percentile"
self.maxDiff = None
self.assertEqual(
results,
[
TCR("FooP5", unit, [0.5], p_format_str.format("Foo", 5)),
TCR("FooP25", unit, [2.5], p_format_str.format("Foo", 25)),
TCR("FooP50", unit, [5.0], p_format_str.format("Foo", 50)),
TCR("FooP75", unit, [7.5], p_format_str.format("Foo", 75)),
TCR("FooP95", unit, [9.5], p_format_str.format("Foo", 95)),
TCR("FooMin", unit, [0.0], "Foo, minimum"),
TCR("FooMax", unit, [10.0], "Foo, maximum"),
TCR("FooAverage", unit, [5.0], "Foo, mean"),
],
)
results = trace_utils.standard_metrics_set(
values=values, label_prefix="Foo", unit=unit, doc_prefix="Foo doc"
)
self.assertEqual(
results,
[
TCR("FooP5", unit, [0.5], p_format_str.format("Foo doc", 5)),
TCR("FooP25", unit, [2.5], p_format_str.format("Foo doc", 25)),
TCR("FooP50", unit, [5.0], p_format_str.format("Foo doc", 50)),
TCR("FooP75", unit, [7.5], p_format_str.format("Foo doc", 75)),
TCR("FooP95", unit, [9.5], p_format_str.format("Foo doc", 95)),
TCR("FooMin", unit, [0.0], "Foo doc, minimum"),
TCR("FooMax", unit, [10.0], "Foo doc, maximum"),
TCR("FooAverage", unit, [5.0], "Foo doc, mean"),
],
)
def test_common_process_start_time_and_min_start_flows(self) -> None:
# Process 1 starts tracing at t=10us; Process 2 starts tracing later at t=50us.
# Flow 0 (t=20us -> t=60us) starts before Process 2 began recording;
# Flow 1 (t=70us -> t=90us) occurs after both processes are recording.
p1_early_dur = trace_model.DurationEvent(
duration=trace_time.TimeDelta.from_microseconds(5),
parent=None,
child_durations=[],
child_flows=[],
base=trace_model.Event(
category="gfx",
name="StartFrame",
start=trace_time.TimePoint.from_microseconds(20),
pid=1,
tid=10,
args={},
),
)
p2_first_event = trace_model.DurationEvent(
duration=trace_time.TimeDelta.from_microseconds(5),
parent=None,
child_durations=[],
child_flows=[],
base=trace_model.Event(
category="gfx",
name="Init",
start=trace_time.TimePoint.from_microseconds(50),
pid=2,
tid=20,
args={},
),
)
p2_early_vsync = trace_model.DurationEvent(
duration=trace_time.TimeDelta.from_microseconds(5),
parent=None,
child_durations=[],
child_flows=[],
base=trace_model.Event(
category="gfx",
name="Vsync",
start=trace_time.TimePoint.from_microseconds(60),
pid=2,
tid=20,
args={},
),
)
f0_end = trace_model.FlowEvent(
id="0",
phase=trace_model.FlowEventPhase.END,
enclosing_duration=p2_early_vsync,
previous_flow=None,
next_flow=None,
base=trace_model.Event(
category="gfx",
name="frame_flow",
start=trace_time.TimePoint.from_microseconds(60),
pid=2,
tid=20,
args={},
),
)
f0_start = trace_model.FlowEvent(
id="0",
phase=trace_model.FlowEventPhase.START,
enclosing_duration=p1_early_dur,
previous_flow=None,
next_flow=f0_end,
base=trace_model.Event(
category="gfx",
name="frame_flow",
start=trace_time.TimePoint.from_microseconds(20),
pid=1,
tid=10,
args={},
),
)
f0_end.previous_flow = f0_start
p1_early_dur.child_flows = (f0_start,)
p2_early_vsync.child_flows = (f0_end,)
p1_valid_dur = trace_model.DurationEvent(
duration=trace_time.TimeDelta.from_microseconds(5),
parent=None,
child_durations=(),
child_flows=(),
base=trace_model.Event(
category="gfx",
name="StartFrame",
start=trace_time.TimePoint.from_microseconds(70),
pid=1,
tid=10,
args={},
),
)
p2_valid_vsync = trace_model.DurationEvent(
duration=trace_time.TimeDelta.from_microseconds(5),
parent=None,
child_durations=(),
child_flows=(),
base=trace_model.Event(
category="gfx",
name="Vsync",
start=trace_time.TimePoint.from_microseconds(90),
pid=2,
tid=20,
args={},
),
)
f1_end = trace_model.FlowEvent(
id="1",
phase=trace_model.FlowEventPhase.END,
enclosing_duration=p2_valid_vsync,
previous_flow=None,
next_flow=None,
base=trace_model.Event(
category="gfx",
name="frame_flow",
start=trace_time.TimePoint.from_microseconds(90),
pid=2,
tid=20,
args={},
),
)
f1_start = trace_model.FlowEvent(
id="1",
phase=trace_model.FlowEventPhase.START,
enclosing_duration=p1_valid_dur,
previous_flow=None,
next_flow=f1_end,
base=trace_model.Event(
category="gfx",
name="frame_flow",
start=trace_time.TimePoint.from_microseconds(70),
pid=1,
tid=10,
args={},
),
)
f1_end.previous_flow = f1_start
p1_valid_dur.child_flows = (f1_start,)
p2_valid_vsync.child_flows = (f1_end,)
model = trace_model.Model(
processes=[
trace_model.Process(
1,
"scenic",
[
trace_model.Thread(
10,
"main",
[p1_early_dur, f0_start, p1_valid_dur, f1_start],
)
],
),
trace_model.Process(
2,
"display",
[
trace_model.Thread(
20,
"vsync",
[
p2_first_event,
p2_early_vsync,
f0_end,
p2_valid_vsync,
f1_end,
],
)
],
),
],
scheduling_records={},
)
common_start = trace_utils.get_common_process_start_time(
model,
"StartFrame",
category="gfx",
type=trace_model.DurationEvent,
)
self.assertEqual(
common_start, trace_time.TimePoint.from_microseconds(50)
)
# Early flow starting before common_start is ignored when min_start is set.
self.assertEqual(
list(
trace_utils.get_following_flow_events(
p1_early_dur, min_start=common_start
)
),
[],
)
self.assertIsNone(
trace_utils.get_nearest_following_flow_event(
p1_early_dur, "gfx", "Vsync", min_start=common_start
)
)
# Valid flow starting after common_start resolves identically to adjust_to_common_process_start.
nearest = trace_utils.get_nearest_following_flow_event(
p1_valid_dur, "gfx", "Vsync", min_start=common_start
)
self.assertIs(nearest, p2_valid_vsync)
sliced_model = trace_utils.adjust_to_common_process_start(
model,
"StartFrame",
category="gfx",
type=trace_model.DurationEvent,
)
sliced_starts = list(
trace_utils.filter_events(
sliced_model.all_events(),
category="gfx",
name="StartFrame",
type=trace_model.DurationEvent,
)
)
self.assertEqual(len(sliced_starts), 1)
self.assertEqual(sliced_starts[0].start, p1_valid_dur.start)