telemetry.timeline.thread | index telemetry/timeline/thread.py

`# Copyright 2014 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.`

Modules
`` |  |

telemetry.timeline.async_slice telemetry.timeline.event_container | telemetry.timeline.flow_event telemetry.timeline.sample | telemetry.timeline.slice |

Classes
`` |  |

telemetry.timeline.event_container.TimelineEventContainer(__builtin__.object)
  Thread

class Thread(telemetry.timeline.event_container.TimelineEventContainer)
`` | `A Thread stores all the trace events collected for a particular thread. We organize the synchronous slices on a thread by "subrows," where subrow 0 has all the root slices, subrow 1 those nested 1 deep, and so on. The asynchronous slices are stored in an AsyncSliceGroup object.
`

Method resolution order:
  Thread
  telemetry.timeline.event_container.TimelineEventContainer
  __builtin__.object

Methods defined here:

AddAsyncSlice(self, async_slice)

AddFlowEvent(self, flow_event)

AddSample(self, category, name, timestamp, args=None)

AutoCloseOpenSlices(self, max_timestamp, max_thread_timestamp)

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`

EndSlice(self, end_timestamp, end_thread_timestamp=None)
  `Ends the last begun slice in this group and pushes it onto the slice
  array.
  * end_timestamp: Timestamp when the slice ended in milliseconds
  * end_thread_timestamp: Timestamp when the scheduled time of the slice ended
  in milliseconds
  returns completed slice.`

FinalizeImport(self)

IsTimestampValidForBeginOrEnd(self, timestamp)

IterChildContainers(self)

IterEventsInThisContainer(self, event_type_predicate, event_predicate)

PushCompleteSlice(self, category, name, timestamp, duration, thread_timestamp, thread_duration, args=None)

PushSlice(self, new_slice)

__init__(self, process, tid)

Data descriptors defined here:

all_slices

async_slices

open_slice_count

samples

toplevel_slices

Methods inherited from telemetry.timeline.event_container.TimelineEventContainer:

GetAllEvents(self, recursive=True)
  `# List versions. These should always be simple expressions that list() on
  # an underlying iter method.`

GetAllEventsOfName(self, name, recursive=True)

GetAllToplevelSlicesOfName(self, name, recursive=True)

IterAllAsyncSlicesOfName(self, name, recursive=True)

IterAllAsyncSlicesStartsWithName(self, name, recursive=True)

IterAllEvents(self, recursive=True, event_type_predicate=<function <lambda>>, event_predicate=<function <lambda>>)
  `Iterates all events in this container, pre-filtered by two predicates.
  Only events with a type matching event_type_predicate AND matching event
  event_predicate will be yielded.
  event_type_predicate is given an actual type object, e.g.:
  event_type_predicate(slice_module.Slice)
  event_predicate is given actual events:
  event_predicate(thread.slices[7])`

IterAllEventsOfName(self, name, recursive=True)
  `# Helper functions for finding common kinds of events. Must always take an
  # optinal recurisve parameter and be implemented in terms fo IterAllEvents.`

IterAllFlowEvents(self, recursive=True)

IterAllSlices(self, recursive=True)

IterAllSlicesInRange(self, start, end, recursive=True)

IterAllSlicesOfName(self, name, recursive=True)

IterAllToplevelSlicesOfName(self, name, recursive=True)

Static methods inherited from telemetry.timeline.event_container.TimelineEventContainer:

IsAsyncSlice(t)

Data descriptors inherited from telemetry.timeline.event_container.TimelineEventContainer:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`