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

tools/telemetry/telemetry/timeline/trace_event_importer_unittest.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.
 
 import unittest
 
 import telemetry.timeline.counter as tracing_counter
 import telemetry.timeline.model as timeline_model
 from telemetry.timeline import trace_data as trace_data_module
 
@@ skipping 1041 matching lines @@
     trace_data = trace_data_module.TraceData(events)
     m = timeline_model.TimelineModel(trace_data)
     self.assertEqual(0, len(m.flow_events))
 
   def testImportMemoryDumpEvents(self):
     events = [
       {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 52, 'ts': 123,
        'id': '1234ABCD'},
       {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 54, 'ts': 134,
        'id': '1234ABCD'},
+      {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 52, 'ts': 134,
+       'id': '1234ABCD'},
       {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 52, 'ts': 245,
        'id': '1234ABDF'},
       {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 54, 'ts': 256,
        'id': '1234ABDF'},
+      {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 52, 'ts': 256,
+       'id': '1234ABDF'},
     ]
 
-    expected = [['1234ABCD', 0, 11], ['1234ABDF', 122, 11]]
+    expected_processes = set([52, 54])
+    expected_results = [['1234ABCD', 0, 11], ['1234ABDF', 122, 11]]
     trace_data = trace_data_module.TraceData(events)
     m = timeline_model.TimelineModel(trace_data)
+    assert set(p.pid for p in m.GetAllProcesses()) == expected_processes
+
     memory_dumps = list(m.IterGlobalMemoryDumps())
-    self.assertEqual(len(expected), len(memory_dumps))
-    for memory_dump, test_values in zip(memory_dumps, expected):
+    self.assertEqual(len(expected_results), len(memory_dumps))
+    for memory_dump, test_values in zip(memory_dumps, expected_results):
+      assert len(list(memory_dump.IterProcessMemoryDumps())) == len(
+          expected_processes)
       dump_id, start, duration = test_values
       self.assertEquals(dump_id, memory_dump.dump_id)
       self.assertAlmostEqual(start / 1000.0, memory_dump.start)
       self.assertAlmostEqual(duration / 1000.0, memory_dump.duration)
 
+  def testImportComposableMemoryDumpEvents(self):

[perezju, 2016/01/12 15:53:38]

I still feel this is more complicated than it has too. Composability should be
tested in memory_dump_event_unittest.py. Here you only want to test that raw
events are sorted in the correct dump/process id bucket.

I would add no allocators/mmaps to these events, instead add *more* events with
some matching an non-matching dump/process ids; and then check that you get the
expected number of global dumps with correct timestamps/durations.

[ssid, 2016/01/12 17:13:18]

True. I have added to the previous test and removed this one.

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

sgtm

+    events = [
+      {
+        'name': 'a',
+        'cat': 'b',
+        'ph': 'v',
+        'pid': 52,
+        'ts': 123,
+        'id': '123',
+        'args': {
+          'dumps': {
+            'allocators': {
+              'v8': {'attrs': {'size': {'units': 'bytes', 'value': '0xa'}}}
+            }
+          }
+        }
+      },
+      {
+        'name': 'a',
+        'cat': 'b',
+        'ph': 'v',
+        'pid': 54,
+        'ts': 134,
+        'id': '123',
+        'args': {
+          'dumps': {
+            'allocators': {
+              'v8': {'attrs': {'size': {'units': 'bytes', 'value': '0xc'}}}
+            },
+            'process_mmaps': {'vm_regions': [{'mf': '', 'bs': {'pss': '0xd'}}]}
+          }
+        }
+      },
+      {
+        'name': 'a',
+        'cat': 'b',
+        'ph': 'v',
+        'pid': 52,
+        'ts': 134,
+        'id': '123',
+        'args': {
+          'dumps': {
+            'process_mmaps': {'vm_regions': [{'mf': '', 'bs': {'pss': '0xb'}}]}
+          }
+        }
+      }
+    ]
+
+    expected = [[10, 11], [12, 13]]
+    trace_data = trace_data_module.TraceData(events)
+    m = timeline_model.TimelineModel(trace_data)
+    memory_dumps_iter = m.IterGlobalMemoryDumps()
+    process_dumps = list(next(memory_dumps_iter).IterProcessMemoryDumps())
+    assert len(process_dumps) == len(expected)
+    for process_dump, test_values in zip(process_dumps, expected):
+      v8_size, heap_size = test_values
+      assert process_dump.has_mmaps
+      assert process_dump.GetMemoryBucket('/Native heap').GetValue(
+          'proportional_resident') == heap_size
+      assert process_dump.GetMemoryUsage()['allocator_v8'] == v8_size
+    assert not next(memory_dumps_iter, None)
+
   def testImportOutOfOrderMemoryDumpEvents(self):
     events = [
       {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 52, 'ts': 245,
        'id': '1234ABDF'},
       {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 54, 'ts': 134,
        'id': '1234ABCD'},
       {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 54, 'ts': 256,
        'id': '1234ABDF'},
       {'name': 'a', 'cat': 'b', 'ph': 'v', 'pid': 52, 'ts': 123,
        'id': '1234ABCD'},
@@ skipping 25 matching lines @@
     ]
     trace_data = trace_data_module.TraceData(events)
     m = timeline_model.TimelineModel(trace_data)
     processes = m.GetAllProcesses()
 
     self.assertEqual(len(processes), len(expected))
     for process, test_values in zip(processes, expected):
       process_labels, process_name = test_values
       self.assertEquals(process_labels, process.labels)
       self.assertEquals(process_name, process.name)