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

tools/telemetry/telemetry/timeline/trace_event_importer.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.
 """TraceEventImporter imports TraceEvent-formatted data
 into the provided model.
 This is a port of the trace event importer from
 https://code.google.com/p/trace-viewer/
 """
 
 import collections
@@ skipping 176 matching lines @@
                      event['ts'] / 1000.0,
                      event.get('args'))
 
   def _ProcessFlowEvent(self, event):
     thread = (self._GetOrCreateProcess(event['pid'])
         .GetOrCreateThread(event['tid']))
     self._all_flow_events.append({
         'event': event,
         'thread': thread})
 
-  def _ProcessMemoryDumpEvent(self, event):
-    process = self._GetOrCreateProcess(event['pid'])
-    memory_dump = memory_dump_event.ProcessMemoryDumpEvent(process, event)
-    process.AddMemoryDumpEvent(memory_dump)
-    self._all_memory_dumps_by_dump_id[memory_dump.dump_id].append(memory_dump)
+  def _ProcessMemoryDumpEvents(self, events):
+    # Dictionary to order dumps by id and process.
+    global_dumps = collections.defaultdict(dict)
+    for event in events:
+      process = self._GetOrCreateProcess(event['pid'])
+      if process not in global_dumps[event['id']]:
+        global_dumps[event['id']][

[petrcermak, 2016/01/07 18:59:29]

this might look a bit better as follows:

global_dumps[event['id']][process] = (
    memory_dump_event...

+            process] = memory_dump_event.ProcessMemoryDumpEvent(
+                process, event['id'], event['ts'])
+      global_dumps[event['id']][process].AddRawEvent(event)
+    for dump_id, global_dump in global_dumps.iteritems():
+      for process, process_dump in global_dump.iteritems():
+        process_dump.ProcessAllocatorDumps()
+        process.AddMemoryDumpEvent(process_dump)
+        self._all_memory_dumps_by_dump_id[dump_id].append(process_dump)
 
   def ImportEvents(self):
     """Walks through the events_ list and outputs the structures discovered to
     model_.
     """
+    memory_dump_events = []
     for event in self._events:
       phase = event.get('ph', None)
       if phase == 'B' or phase == 'E':
         self._ProcessDurationEvent(event)
       elif phase == 'X':
         self._ProcessCompleteEvent(event)
       # Note, S, F, T are deprecated and replaced by 'b' and 'e'. For
       # backwards compatibility continue to support them here.
       elif phase == 'S' or phase == 'F' or phase == 'T':
         self._ProcessAsyncEvent(event)
       elif phase == 'b' or phase == 'e':
         self._ProcessAsyncEvent(event)
       # Note, I is historic. The instant event marker got changed, but we
       # want to support loading old trace files so we have both I and i.
       elif phase == 'I' or phase == 'i':
         self._ProcessInstantEvent(event)
       elif phase == 'P':
         self._ProcessSampleEvent(event)
       elif phase == 'C':
         self._ProcessCounterEvent(event)
       elif phase == 'M':
         self._ProcessMetadataEvent(event)
       elif phase == 'N' or phase == 'D' or phase == 'O':
         self._ProcessObjectEvent(event)
       elif phase == 's' or phase == 't' or phase == 'f':
         self._ProcessFlowEvent(event)
       elif phase == 'v':
-        self._ProcessMemoryDumpEvent(event)
+        memory_dump_events.append(event)
       elif phase == 'R':
         self._ProcessMarkEvent(event)
       else:
         self._model.import_errors.append('Unrecognized event phase: ' +
             phase + '(' + event['name'] + ')')
 
+    # Memory dumps of a process with the same dump id need to be merged before
+    # processing. So, memory dump events are processed all at once.
+    self._ProcessMemoryDumpEvents(memory_dump_events)
     return self._model
 
   def FinalizeImport(self):
     """Called by the Model after all other importers have imported their
     events."""
     self._model.UpdateBounds()
 
     # We need to reupdate the bounds in case the minimum start time changes
     self._model.UpdateBounds()
     self._CreateAsyncSlices()
@@ skipping 175 matching lines @@
 
   def _SetBrowserProcess(self):
     for thread in self._model.GetAllThreads():
       if thread.name == 'CrBrowserMain':
         self._model.browser_process = thread.parent
 
   def _SetGpuProcess(self):
     for thread in self._model.GetAllThreads():
       if thread.name == 'CrGpuMain':
         self._model.gpu_process = thread.parent