1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
# Copyright 2013 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import unittest
from telemetry.testing import test_page_test_results
from telemetry.timeline import model as model_module
from telemetry.web_perf import timeline_interaction_record as tir_module
from metrics import timeline
def _GetInteractionRecord(start, end):
return tir_module.TimelineInteractionRecord('test-record', start, end)
class LoadTimesTimelineMetric(unittest.TestCase):
def GetResults(self, metric, model, renderer_thread, interaction_records):
results = test_page_test_results.TestPageTestResults(self)
metric.AddResults(model, renderer_thread, interaction_records, results)
return results
def testSanitizing(self):
model = model_module.TimelineModel()
renderer_main = model.GetOrCreateProcess(1).GetOrCreateThread(2)
renderer_main.name = 'CrRendererMain'
# [ X ]
# [ Y ]
renderer_main.BeginSlice('cat1', 'x.y', 10, 0)
renderer_main.EndSlice(20, 20)
model.FinalizeImport()
metric = timeline.LoadTimesTimelineMetric()
results = self.GetResults(
metric, model=model, renderer_thread=renderer_main,
interaction_records=[_GetInteractionRecord(0, float('inf'))])
results.AssertHasPageSpecificScalarValue(
'CrRendererMain|x_y', 'ms', 10)
results.AssertHasPageSpecificScalarValue(
'CrRendererMain|x_y_max', 'ms', 10)
results.AssertHasPageSpecificScalarValue(
'CrRendererMain|x_y_avg', 'ms', 10)
def testTimelineBetweenRange(self):
model = model_module.TimelineModel()
renderer_main = model.GetOrCreateProcess(1).GetOrCreateThread(2)
renderer_main.name = 'CrRendererMain'
# [ X ] [ Z ]
# [ Y ] [ T ]
# [ interaction record ]
renderer_main.BeginSlice('cat1', 'x.y', 10, 0)
renderer_main.EndSlice(20, 20)
renderer_main.BeginSlice('cat1', 'z.t', 30, 0)
renderer_main.EndSlice(35, 35)
model.FinalizeImport()
metric = timeline.LoadTimesTimelineMetric()
results = self.GetResults(
metric, model=model, renderer_thread=renderer_main,
interaction_records=[_GetInteractionRecord(10, 20)])
results.AssertHasPageSpecificScalarValue(
'CrRendererMain|x_y', 'ms', 10)
results.AssertHasPageSpecificScalarValue(
'CrRendererMain|x_y_max', 'ms', 10)
results.AssertHasPageSpecificScalarValue(
'CrRendererMain|x_y_avg', 'ms', 10)
def testCounterSanitizing(self):
model = model_module.TimelineModel()
renderer_main = model.GetOrCreateProcess(1).GetOrCreateThread(2)
renderer_main.name = 'CrRendererMain'
x_counter = renderer_main.parent.GetOrCreateCounter('cat', 'x.y')
x_counter.samples += [1, 2]
x_counter.series_names += ['a']
x_counter.timestamps += [0, 1]
model.FinalizeImport()
metric = timeline.LoadTimesTimelineMetric()
results = self.GetResults(
metric, model=model, renderer_thread=renderer_main,
interaction_records=[_GetInteractionRecord(0, float('inf'))])
results.AssertHasPageSpecificScalarValue(
'cat_x_y', 'count', 3)
results.AssertHasPageSpecificScalarValue(
'cat_x_y_avg', 'count', 1.5)
class ThreadTimesTimelineMetricUnittest(unittest.TestCase):
def GetResults(self, metric, model, renderer_thread, interaction_record):
results = test_page_test_results.TestPageTestResults(self)
metric.AddResults(model, renderer_thread, interaction_record,
results)
return results
def testResults(self):
model = model_module.TimelineModel()
renderer_main = model.GetOrCreateProcess(1).GetOrCreateThread(2)
renderer_main.name = 'CrRendererMain'
metric = timeline.ThreadTimesTimelineMetric()
metric.details_to_report = timeline.ReportMainThreadOnly
results = self.GetResults(metric, model, renderer_main.parent,
[_GetInteractionRecord(1, 2)])
# Test that all result thread categories exist
for name in timeline.TimelineThreadCategories.values():
results.GetPageSpecificValueNamed(
timeline.ThreadCpuTimeResultName(name, 'frame'))
def testBasic(self):
model = model_module.TimelineModel()
renderer_main = model.GetOrCreateProcess(1).GetOrCreateThread(2)
renderer_main.name = 'CrRendererMain'
# Create two frame swaps (Results times should be divided by two) for
# an interaction that lasts 20 milliseconds.
cc_main = model.GetOrCreateProcess(1).GetOrCreateThread(3)
cc_main.name = 'Compositor'
cc_main.BeginSlice('cc_cat', timeline.FrameTraceName, 10, 10)
cc_main.EndSlice(11, 11)
cc_main.BeginSlice('cc_cat', timeline.FrameTraceName, 12, 12)
cc_main.EndSlice(13, 13)
# [ X ] [ Z ]
# [ Y ]
renderer_main.BeginSlice('cat1', 'X', 10, 0)
renderer_main.BeginSlice('cat2', 'Y', 15, 5)
renderer_main.EndSlice(16, 5.5)
renderer_main.EndSlice(30, 19.5)
renderer_main.BeginSlice('cat1', 'Z', 31, 20)
renderer_main.BeginSlice('cat1', 'Z', 33, 21)
model.FinalizeImport()
# Exclude 'Z' using an action-range.
metric = timeline.ThreadTimesTimelineMetric()
metric.details_to_report = timeline.ReportMainThreadOnly
results = self.GetResults(metric, model, renderer_main.parent,
[_GetInteractionRecord(10, 30)])
# Test for the results we expect.
main_thread = 'renderer_main'
cc_thread = 'renderer_compositor'
assert_results = [
(timeline.ThreadMeanFrameTimeResultName(cc_thread), 'ms', 10.0),
(timeline.ThreadTasksResultName(main_thread, 'frame'), 'tasks', 0.5),
(timeline.ThreadTasksResultName(main_thread, 'second'), 'tasks', 50.0),
(timeline.ThreadTasksResultName(cc_thread, 'frame'), 'tasks', 1.0),
(timeline.ThreadTasksResultName(cc_thread, 'second'), 'tasks', 100.0),
(timeline.ThreadCpuTimeResultName(main_thread, 'frame'), 'ms', 9.75),
(timeline.ThreadCpuTimeResultName(main_thread, 'second'), '%', 97.5),
(timeline.ThreadCpuTimeResultName(cc_thread, 'frame'), 'ms', 1.0),
(timeline.ThreadCpuTimeResultName(cc_thread, 'second'), '%', 10.0),
(timeline.ThreadDetailResultName(main_thread, 'frame', 'cat1'),
'ms', 9.5),
(timeline.ThreadDetailResultName(main_thread, 'second', 'cat1'),
'%', 95.0),
(timeline.ThreadDetailResultName(main_thread, 'frame', 'cat2'),
'ms', 0.5),
(timeline.ThreadDetailResultName(main_thread, 'second', 'cat2'),
'%', 5.0),
(timeline.ThreadDetailResultName(
main_thread, 'frame', 'idle'), 'ms', 0),
(timeline.ThreadDetailResultName(
main_thread, 'second', 'idle'), '%', 0)
]
for name, unit, value in assert_results:
results.AssertHasPageSpecificScalarValue(name, unit, value)
def testOverheadIsRemoved(self):
model = model_module.TimelineModel()
renderer_main = model.GetOrCreateProcess(1).GetOrCreateThread(2)
renderer_main.name = 'CrRendererMain'
# Create one frame swap.
cc_main = model.GetOrCreateProcess(1).GetOrCreateThread(3)
cc_main.name = 'Compositor'
cc_main.BeginSlice('cc_cat', timeline.FrameTraceName, 10, 10)
cc_main.EndSlice(11, 11)
# [ X ]
# [Overhead]
overhead_category = timeline.OverheadTraceCategory
overhead_name = timeline.OverheadTraceName
renderer_main.BeginSlice('cat1', 'X', 10, 0)
renderer_main.BeginSlice(overhead_category, overhead_name, 15, 5)
renderer_main.EndSlice(16, 6)
renderer_main.EndSlice(30, 10)
model.FinalizeImport()
# Include everything in an action-range.
metric = timeline.ThreadTimesTimelineMetric()
metric.details_to_report = timeline.ReportMainThreadOnly
results = self.GetResults(metric, model, renderer_main.parent,
[_GetInteractionRecord(10, 30)])
# Test a couple specific results.
assert_results = [
(timeline.ThreadCpuTimeResultName(
'renderer_main', 'frame'), 'ms', 9.0),
(timeline.ThreadCpuTimeResultName(
'renderer_main', 'second'), '%', 45.0),
]
for name, unit, value in assert_results:
results.AssertHasPageSpecificScalarValue(name, unit, value)
|
