[telemetry] Timeline model cleanups

tools/telemetry/telemetry/core/timeline/thread.py

 # 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 telemetry.core.timeline.event as timeline_event
-import telemetry.core.timeline.tracing.sample as tracing_sample
-import telemetry.core.timeline.tracing.slice as tracing_slice
+import telemetry.core.timeline.event_container as event_container
+import telemetry.core.timeline.sample as tracing_sample
+import telemetry.core.timeline.slice as tracing_slice
 
-class Thread(timeline_event.TimelineEvent):
+class Thread(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.
   '''
   def __init__(self, process, tid):
-    super(Thread, self).__init__('thread %s' % tid, 0, 0, parent=process)
+    super(Thread, self).__init__('thread %s' % tid, parent=process)
     self.tid = tid
-    self._open_slices = []
     self._async_slices = []
     self._samples = []
-    self._slices = []
+    self._toplevel_slices = []
+
+    # State only valid during import.
+    self._open_slices = []
+    self._newly_added_slices = []
 
   @property
-  def slices(self):
-    return self._slices
+  def toplevel_slices(self):
+    return self._toplevel_slices
+
+  @property
+  def all_slices(self):
+    return list(self.IterAllSlices())
 
   @property
   def samples(self):
     return self._samples
 
   @property
+  def async_slices(self):
+    return self._async_slices
+
+  @property
   def open_slice_count(self):
     return len(self._open_slices)
 
-  @property
-  def async_slices(self):
-    return self._async_slices
+  def IterChildContainers(self):
+    return iter([])
+
+  def IterAllSlices(self):
+    for s in self._toplevel_slices:
+      yield s
+      for sub_slice in s.IterEventsInThisContainerRecrusively():
+        yield sub_slice
+  def IterAllAsyncSlices(self):
+    for async_slice in self._async_slices:
+      yield async_slice
+      for sub_slice in async_slice.IterEventsInThisContainerRecrusively():
+        yield sub_slice
+
+  def IterEventsInThisContainer(self):
+    for s in self._open_slices:

[Tim Song, 2013/07/18 23:13:55]

There is a convenience function itertools.chain that might make this a bit
cleaner.

+      yield s
+    for s in self._newly_added_slices:
+      yield s
+    for s in self.IterAllAsyncSlices():
+      yield s
+    for s in self.IterAllSlices():
+      yield s
+    for sample in self._samples:
+      yield sample
 
   def AddSample(self, category, name, timestamp, args=None):
     if len(self._samples) and timestamp < self._samples[-1].start:
       raise ValueError(
           'Samples must be added in increasing timestamp order')
-    sample = tracing_sample.Sample(
-        category, name, timestamp, args=args, parent=self)
+    sample = tracing_sample.Sample(self,
+        category, name, timestamp, args=args)
     self._samples.append(sample)
-    self.children.append(sample)
 
   def AddAsyncSlice(self, async_slice):
     self._async_slices.append(async_slice)
-    async_slice.parent = self
-    self.children.append(async_slice)
 
   def BeginSlice(self, category, name, timestamp, 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.
     * 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')
     self._open_slices.append(
-        tracing_slice.Slice(category, name, timestamp, args=args, parent=self))
+        tracing_slice.Slice(self, category, name, timestamp, args=args))
 
   def EndSlice(self, end_timestamp):
     """ Ends the last begun slice in this group and pushes it onto the slice
     array.
 
     * end_timestamp: Timestamp when the slice ended in milliseconds
 
     returns completed slice.
     """
     if not len(self._open_slices):
       raise ValueError(
           'EndSlice called without an open slice')
     curr_slice = self._open_slices.pop()
     if end_timestamp < curr_slice.start:
       raise ValueError(
           'Slice %s end time is before its start.' % curr_slice.name)
     curr_slice.duration = end_timestamp - curr_slice.start
     return self.PushSlice(curr_slice)
 
   def PushSlice(self, new_slice):
-    self._slices.append(new_slice)
-    self.children.append(new_slice)
+    self._newly_added_slices.append(new_slice)
     return new_slice
 
-  def AutoCloseOpenSlices(self, max_timestamp=None):
-    if max_timestamp is None:
-      self.UpdateBounds()
-      max_timestamp = self.end
+  def AutoCloseOpenSlices(self, max_timestamp):
     while len(self._open_slices) > 0:
       curr_slice = self.EndSlice(max_timestamp)
       curr_slice.did_not_finish = True
 
   def IsTimestampValidForBeginOrEnd(self, timestamp):
     if not len(self._open_slices):
       return True
     return timestamp >= self._open_slices[-1].start
 
-  def UpdateBounds(self):
-    super(Thread, self).UpdateBounds()
-
-    # Take open slices into account for the start and duration of thread event
-    if len(self._open_slices) > 0:
-      if not len(self.slices) or self.start > self._open_slices[0].start:
-        self.start = self._open_slices[0].start
-      if not len(self.slices) or self.end < self._open_slices[-1].start:
-        self.duration = self._open_slices[-1].start - self.start
-
   def FinalizeImport(self):
     self._BuildSliceSubRows()
 
   def _BuildSliceSubRows(self):
     '''This function works by walking through slices by start time.
 
      The basic idea here is to insert each slice as deep into the subrow
      list as it can go such that every subslice is fully contained by its
      parent slice.
 
@@ skipping 21 matching lines @@
       0:  [    a       ]  [f]
       1:    [  b  ][e]
     '''
     def CompareSlices(s1, s2):
       if s1.start == s2.start:
         # Break ties by having the slice with the greatest
         # end timestamp come first.
         return cmp(s2.end, s1.end)
       return cmp(s1.start, s2.start)
 
-    if not len(self._slices):
+    assert len(self._toplevel_slices) == 0
+    if not len(self._newly_added_slices):
       return
 
-    sorted_slices = sorted(self._slices, cmp=CompareSlices)
+    sorted_slices = sorted(self._newly_added_slices, cmp=CompareSlices)
     root_slice = sorted_slices[0]
+    self._toplevel_slices.append(root_slice)
     for s in sorted_slices[1:]:
       if not self._AddSliceIfBounds(root_slice, s):
         root_slice = s
+        self._toplevel_slices.append(root_slice)
+    self._newly_added_slices = []
 
   def _AddSliceIfBounds(self, root, child):
     ''' Adds a child slice to a root slice its proper row.
     Return False if the child slice is not in the bounds
     of the root slice.
 
     Because we know that the start time of child is >= the start time
     of all other slices seen so far, we can just check the last slice
     of each row for bounding.
     '''
     if child.start >= root.start and child.end <= root.end:
       if len(root.sub_slices) > 0:
         if self._AddSliceIfBounds(root.sub_slices[-1], child):
           return True
+      child.parent_slice = root
       root.AddSubSlice(child)
       return True
     return False