[telemetry] Add support for composable process dumps in memory-infra

tools/telemetry/telemetry/timeline/memory_dump_event.py

 # Copyright 2015 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 posixpath
 import re
 
 from telemetry.timeline import event as timeline_event
 
 
@@ skipping 122 matching lines @@
     return self._bucket[name]
 
 
 class ProcessMemoryDumpEvent(timeline_event.TimelineEvent):
   """A memory dump event belonging to a single timeline.Process object.
 
   It's a subclass of telemetry's TimelineEvent so it can be included in
   the stream of events contained in timeline.model objects, and have its
   timing correlated with that of other events in the model.
 
+  Args:
+    process: The Process object associated with the memory dump.
+    dump_events: A list of dump events of the process with the same dump id.
+
   Properties:
     dump_id: A string to identify events belonging to the same global dump.
     process: The timeline.Process object that owns this memory dump event.
     has_mmaps: True if the memory dump has mmaps information. If False then
         GetMemoryUsage will report all zeros.
   """
-  def __init__(self, process, event):
-    assert event['ph'] == 'v' and process.pid == event['pid']
+  def __init__(self, process, dump_events):
+    assert dump_events
 
-    super(ProcessMemoryDumpEvent, self).__init__(
-        'memory', 'memory_dump', event['ts'] / 1000.0, 0.0)
+    start_time = min(event['ts'] for event in dump_events) / 1000.0
+    duration = max(event['ts'] for event in dump_events) / 1000.0 - start_time
+    super(ProcessMemoryDumpEvent, self).__init__('memory', 'memory_dump',
+                                                 start_time, duration)
 
     self.process = process
-    self.dump_id = event['id']
+    self.dump_id = dump_events[0]['id']
 
-    try:
-      allocators_dict = event['args']['dumps']['allocators']
-    except KeyError:
-      allocators_dict = {}
+    allocator_dumps = {}
+    vm_regions = []
+    for event in dump_events:
+      assert (event['ph'] == 'v' and self.process.pid == event['pid'] and
+              self.dump_id == event['id'])
+      try:
+        allocator_dumps.update(event['args']['dumps']['allocators'])
+      except KeyError:
+        pass  # It's ok if any of those keys are not present.
+      try:
+        value = event['args']['dumps']['process_mmaps']['vm_regions']
+        assert not vm_regions
+        vm_regions = value
+      except KeyError:
+        pass  # It's ok if any of those keys are not present.
+
     self._allocators = {}
     parent_path = ''
     parent_has_size = False
-    for allocator_name, size_values in sorted(allocators_dict.iteritems()):
-      if ((allocator_name.startswith(parent_path) and parent_has_size)
-          or allocator_name.startswith('global/')):
+    for allocator_name, size_values in sorted(allocator_dumps.iteritems()):
+      if ((allocator_name.startswith(parent_path) and parent_has_size) or
+          allocator_name.startswith('global/')):
         continue
       parent_path = allocator_name + '/'
       parent_has_size = 'size' in size_values['attrs']
       name_parts = allocator_name.split('/')
       allocator_name = name_parts[0]
       # For 'gpu/android_memtrack/*' we want to keep track of individual
       # components. E.g. 'gpu/android_memtrack/gl' will be stored as
       # 'android_memtrack_gl' in the allocators dict.
-      if (len(name_parts) == 3 and allocator_name == 'gpu'
-          and name_parts[1] == 'android_memtrack'):
+      if (len(name_parts) == 3 and allocator_name == 'gpu' and
+          name_parts[1] == 'android_memtrack'):
         allocator_name = '_'.join(name_parts[1:3])
       allocator = self._allocators.setdefault(allocator_name, {})
       for size_key, size_value in size_values['attrs'].iteritems():
         if size_value['units'] == 'bytes':
           allocator[size_key] = (allocator.get(size_key, 0)
                                  + int(size_value['value'], 16))
     # we need to discount tracing from malloc size.
     try:
       self._allocators['malloc']['size'] -= self._allocators['tracing']['size']
     except KeyError:
-      pass # it's ok if any of those keys are not present
+      pass  # It's ok if any of those keys are not present.
 
+    self.has_mmaps = bool(vm_regions)
     self._buckets = {}
-    try:
-      vm_regions = event['args']['dumps']['process_mmaps']['vm_regions']
-    except KeyError:
-      vm_regions = []
-    self.has_mmaps = bool(vm_regions)
     for vm_region in vm_regions:
       self._AddRegion(vm_region)
 
   @property
   def process_name(self):
     return self.process.name
 
   def _AddRegion(self, vm_region):
     path = ''
     category = ROOT_CATEGORY
@@ skipping 84 matching lines @@
     have_mmaps = set(dump.has_mmaps for dump in self._process_dumps)
     assert len(have_mmaps) == 1
     self.has_mmaps = have_mmaps.pop()
 
   @property
   def start(self):
     return self._process_dumps[0].start
 
   @property
   def end(self):
-    return self._process_dumps[-1].start
+    return max(dump.end for dump in self._process_dumps)
 
   @property
   def duration(self):
     return self.end - self.start
 
   def IterProcessMemoryDumps(self):
     return iter(self._process_dumps)
 
   def __repr__(self):
     values = ['id=%s' % self.dump_id]
     for key, value in sorted(self.GetMemoryUsage().iteritems()):
       values.append('%s=%d' % (key, value))
     values = ', '.join(values)
     return '%s[%s]' % (type(self).__name__, values)
 
   def GetMemoryUsage(self):
     """Get the aggregated memory usage over all processes in this dump."""
     result = {}
     for dump in self._process_dumps:
       for key, value in dump.GetMemoryUsage().iteritems():
         result[key] = result.get(key, 0) + value
     return result