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

tools/telemetry/telemetry/timeline/trace_event_importer.py

Index: tools/telemetry/telemetry/timeline/trace_event_importer.py
diff --git a/tools/telemetry/telemetry/timeline/trace_event_importer.py b/tools/telemetry/telemetry/timeline/trace_event_importer.py
index 111e241fd1539a6027ed4daa835f69fd244c609f..8513f1cc30b16f0fe01974e9042cd2b876b10010 100644
--- a/tools/telemetry/telemetry/timeline/trace_event_importer.py
+++ b/tools/telemetry/telemetry/timeline/trace_event_importer.py
@@ -194,16 +194,26 @@ class TraceEventTimelineImporter(importer.TimelineImporter):
         '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 = {}
+    for event in events:
+      process = self._GetOrCreateProcess(event['pid'])

[perezju, 2016/01/13 16:30:34]

just being slightly paranoid here, but maybe use the event['pid'] itself as key
to group into buckets; and then, in the following for-loop, create the Process
object required to build the memory dump (that should also be slightly more
efficient).

[ssid, 2016/01/14 14:26:21]

Done.

+      global_dump = global_dumps.setdefault(event['id'], {})
+      dump_events = global_dump.setdefault(process, [])
+      dump_events.append(event)
+    for dump_id, global_dump in global_dumps.iteritems():
+      for process, dump_events in global_dump.iteritems():
+        memory_dump = memory_dump_event.ProcessMemoryDumpEvent(process,
+                                                               dump_events)
+        process.AddMemoryDumpEvent(memory_dump)
+        self._all_memory_dumps_by_dump_id[dump_id].append(memory_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':
@@ -231,13 +241,16 @@ class TraceEventTimelineImporter(importer.TimelineImporter):
       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):