def AddRawEventToThreadRecursive(thread, raw_inspector_event):
pending_slice = None
if ('startTime' in raw_inspector_event and
'type' in raw_inspector_event):
args = {}
for x in raw_inspector_event:
if x in ('startTime', 'endTime', 'children'):
continue
args[x] = raw_inspector_event[x]
if len(args) == 0:
args = None
start_time = raw_inspector_event['startTime']
end_time = raw_inspector_event.get('endTime', start_time)
pending_slice = tracing_slice.Slice(
thread, 'inspector',
raw_inspector_event['type'],
start_time,
thread_timestamp=None,
args=args)
for child in raw_inspector_event.get('children', []):
InspectorTimelineImporter.AddRawEventToThreadRecursive(
thread, child)
if pending_slice:
pending_slice.duration = end_time - pending_slice.start
thread.PushSlice(pending_slice)
def _GenerateResultsFromMockedIdleData(self):
data = self._GenerateDataForEmptyPageSet()
# Make a slice that looks like an idle task parent.
slice_start_time = 0
slow_slice_duration = 1000
fast_slice_duration = 250
parent_slice = data.AddSlice(
task_execution_time.TaskExecutionTime.IDLE_SECTION_TRIGGER,
slice_start_time,
slow_slice_duration)
# Add a sub-slice, this should be reported back as occuring in idle time.
sub_slice = slice_data.Slice(
None,
'category',
'slow_sub_slice',
slice_start_time,
slow_slice_duration,
slice_start_time,
slow_slice_duration,
[])
parent_slice.sub_slices.append(sub_slice)
# Add a non-idle task.
data.AddSlice('not_idle', slice_start_time, fast_slice_duration)
# Run the code we are testing.
self._measurement._AddResults(data.results)
return data
def BeginSlice(self,
category,
name,
timestamp,
thread_timestamp=None,
args=None):
"""Opens a new slice for the thread.
Calls to beginSlice and endSlice must be made with
non-monotonically-decreasing timestamps.
* category: Category to which the slice belongs.
* name: Name of the slice to add.
* timestamp: The timetsamp of the slice, in milliseconds.
* thread_timestamp: Thread specific clock (scheduled) timestamp of the
slice, in milliseconds.
* args: Arguments associated with
Returns newly opened slice
"""
if len(self._open_slices
) > 0 and timestamp < self._open_slices[-1].start:
raise ValueError(
'Slices must be added in increasing timestamp order')
new_slice = tracing_slice.Slice(self,
category,
name,
timestamp,
thread_timestamp=thread_timestamp,
args=args)
self._open_slices.append(new_slice)
new_slice.did_not_finish = True
self.PushSlice(new_slice)
return new_slice
def AddEvent(self, process_name, event_category, event_name,
start, duration, thread_start, thread_duration):
thread = self.GetThreadForProcessName(process_name)
record = slice_module.Slice(thread,
event_category,
event_name,
start, duration, thread_start, thread_duration)
thread.PushSlice(record)
def _CreateEvent(self, event_name, ts, duration):
event = tracing_slice.Slice(
None,
'cc,benchmark',
event_name,
ts,
duration=duration,
args={'begin_frame_id': self._begin_frame_id})
self._events.append(event)
return event
def AddAsyncSlice(self, name, timestamp, duration, args):
new_slice = slice_data.Slice(
None,
'category',
name,
timestamp,
duration,
timestamp,
duration,
args)
self._renderer_thread.async_slices.append(new_slice)
return new_slice
def _CreateGPUSlices(parent_thread, name, start_time, duration, offset=0):
args = {'gl_category': gpu_timeline.TOPLEVEL_GL_CATEGORY}
return (slice_module.Slice(parent_thread,
gpu_timeline.TOPLEVEL_SERVICE_CATEGORY,
name, start_time,
args=args,
duration=duration,
thread_duration=duration),
async_slice_module.AsyncSlice(gpu_timeline.TOPLEVEL_DEVICE_CATEGORY,
name, start_time + offset,
args=args,
duration=duration))
def AddSlice(self, name, timestamp, duration):
new_slice = slice_data.Slice(
None,
'category',
name,
timestamp,
duration,
timestamp,
duration,
[])
self._renderer_thread.all_slices.append(new_slice)
return new_slice
def PushCompleteSlice(self, category, name, timestamp, duration,
thread_timestamp, thread_duration, args=None):
new_slice = slice_module.Slice(self, category, name, timestamp,
thread_timestamp=thread_timestamp,
args=args)
if duration == None:
new_slice.did_not_finish = True
else:
new_slice.duration = duration
new_slice.thread_duration = thread_duration
self.PushSlice(new_slice)
return new_slice
def testFrameEventMissingBeginFrameId(self):
timeline = model.TimelineModel()
process = timeline.GetOrCreateProcess(pid=1)
main_thread = process.GetOrCreateThread(tid=11)
timeline_range = timeline_bounds.Bounds()
# Create an event without the begin_frame_id argument
event = tracing_slice.Slice(None, 'cc,benchmark',
RenderingFrame.begin_main_frame_event, 0)
main_thread.PushSlice(event)
process.FinalizeImport()
self.assertRaises(Exception, GetFrameEventsInsideRange, process,
timeline_range)
def _CreateFrameEndSlices(parent_thread, start_time, duration, offset=0):
args = {'gl_category': gpu_timeline.TOPLEVEL_GL_CATEGORY}
return (slice_module.Slice(parent_thread,
SERVICE_FRAME_END_CATEGORY,
SERVICE_FRAME_END_NAME,
start_time,
args=args,
duration=duration,
thread_duration=duration),
async_slice_module.AsyncSlice(DEVICE_FRAME_END_CATEGORY,
DEVICE_FRAME_END_NAME,
start_time + offset,
args=args,
duration=duration))
def PushMarkSlice(self,
category,
name,
timestamp,
thread_timestamp,
args=None):
new_slice = slice_module.Slice(self,
category,
name,
timestamp,
thread_timestamp=thread_timestamp,
args=args)
self.PushSlice(new_slice)
return new_slice
def testIdleTasksAreReported(self):
task_execution_time_metric = task_execution_time.TaskExecutionTime()
ps = self.CreateEmptyPageSet()
page = TestTaskExecutionTimePage(ps, ps.base_dir)
ps.AddUserStory(page)
# Get the name of a thread used by task_execution_time metric and set up
# some dummy execution data pretending to be from that thread & process.
first_thread_name = task_execution_time_metric._RENDERER_THREADS[0]
data = TaskExecutionTestData(first_thread_name)
task_execution_time_metric._renderer_process = data._renderer_process
# Pretend we're about to run the tests to silence lower level asserts.
data.results.WillRunPage(page)
# Make a slice that looks like an idle task parent.
slice_start_time = 0
slice_duration = 1000
parent_slice = data.AddSlice(
task_execution_time_metric.IDLE_SECTION_TRIGGER, slice_start_time,
slice_duration)
# Add a sub-slice, this should be reported back as occuring in idle time.
sub_slice = slice_data.Slice(None, 'category', 'slow_sub_slice',
slice_start_time, slice_duration)
parent_slice.sub_slices.append(sub_slice)
# Add a non-idle task.
data.AddSlice('not_idle', slice_start_time, slice_duration)
# Run the code we are testing.
task_execution_time_metric.ValidateAndMeasurePage(
None, None, data.results)
# The 'slow_sub_slice' should be inside the Idle section and therefore
# removed from the results.
for result in data.results.all_page_specific_values:
if 'slow_sub_slice' in result.name:
self.fail('Tasks within idle section should not be reported')
# The 'not_idle' slice should not have the IDLE_SECTION added to its name
# and should exist.
for result in data.results.all_page_specific_values:
if 'not_idle' in result.name:
self.assertTrue(
task_execution_time_metric.IDLE_SECTION not in result.name)
break
else:
self.fail('Task was incorrectly marked as Idle')
def AddEvent(self,
process_name,
event_category,
event_name,
start,
duration,
thread_start=None,
thread_duration=None):
thread = self.GetThreadForProcessName(process_name)
record = slice_module.Slice(
thread, event_category, event_name, start, duration,
start if thread_start is None else thread_start,
duration if thread_duration is None else thread_duration)
thread.PushSlice(record)
if self.parent_slice is not None:
record.parent_slice = self.parent_slice
self.parent_slice.AddSubSlice(record)
return SliceContext(self, record)
def CreateTestSliceFromTimeRanges(
self, parent_thread, time_start, time_end, thread_start, thread_end):
duration = time_end - time_start
thread_duration = thread_end - thread_start
return slice_module.Slice(parent_thread, 'Test', 'foo', time_start,
duration, thread_start, thread_duration)
