[DoNotCommit] telemetry: Retrieve per-allocator memory usage

tools/perf/measurements/memory_infra.py

Index: tools/perf/measurements/memory_infra.py
diff --git a/tools/perf/measurements/memory_infra.py b/tools/perf/measurements/memory_infra.py
new file mode 100644
index 0000000000000000000000000000000000000000..9dc2b4cc38e23494f01c18816a53ed24aa8173bc
--- /dev/null
+++ b/tools/perf/measurements/memory_infra.py
@@ -0,0 +1,88 @@
+# 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.
+
+# TODO(bashi): DO-NOT-FOR-COMMIT. Just for local measurements.
+
+import logging
+
+from telemetry.page import action_runner
+from telemetry.page import page_test
+from telemetry.timeline import tracing_category_filter
+from telemetry.timeline import tracing_options
+from telemetry.timeline.model import TimelineModel
+from telemetry.value import scalar
+
+
+class MemoryInfra(page_test.PageTest):
+  def __init__(self):
+    super(MemoryInfra, self).__init__()
+
+  def WillNavigateToPage(self, page, tab):
+    category_filter = tracing_category_filter.TracingCategoryFilter(
+      '-*,blink.console,disabled-by-default-memory-infra')
+    options = tracing_options.TracingOptions()
+    options.enable_chrome_trace = True
+    tab.browser.platform.tracing_controller.Start(options, category_filter,
+                                                  10)
+  def CustomizeBrowserOptions(self, options):
+    options.AppendExtraBrowserArgs(['--no-sandbox'])
+
+  def DidNavigateToPage(self, page, tab):
+    runner = action_runner.ActionRunner(tab)
+    runner.Wait(10)
+
+  def ValidateAndMeasurePage(self, page, tab, results):
+    timeline_data = tab.browser.platform.tracing_controller.Stop()
+    timeline_model = TimelineModel(timeline_data)
+    renderer_process = timeline_model.GetRendererProcessFromTabId(tab.id)
+    latest = self._FindLatestRendererDump(timeline_model, renderer_process.pid)
+    self._AddAllocatorResults(latest, results)
+    self._AddMMapResults(latest, results)
+
+  def CleanUpAfterPage(self, page, tab):
+    if tab.browser.platform.tracing_controller.is_tracing_running:
+      tab.browser.platform.tracing_controller.Stop()
+
+  def _FindLatestRendererDump(self, timeline_model, pid):
+    """Returns the latest ProcessMemoryDumpEvent which is associated with
+    the renderer process and its |has_mmaps| is true.
+    """
+    latest = None
+    for memory_event in timeline_model.IterGlobalMemoryDumps():
+      renderer_events = filter(lambda event: event.process.pid == pid,
+                               memory_event._process_dumps)
+      if len(renderer_events) == 0:
+        continue
+      assert(len(renderer_events) == 1)
+      current = renderer_events[0]
+      if current.has_mmaps and (not latest or latest.start < current.start):
+        latest = current
+    assert(latest != None)
+    return latest
+      
+  def _AddAllocatorResults(self, latest, results):
+    usage = latest.GetMemoryUsage()
+    def _AddAllocatorStat(category):
+      results.AddValue(scalar.ScalarValue(
+        results.current_page, category, 'MiB',
+        float(usage.get('allocator_' + category, 0.0)) / 1024**2,
+        description='Total memoy allocated by %s' % category))
+    _AddAllocatorStat('malloc')
+    _AddAllocatorStat('v8')
+    _AddAllocatorStat('blink_gc')
+    _AddAllocatorStat('partition_alloc')
+    _AddAllocatorStat('discardable')
+    #_AddAllocatorStat('tracing')
+
+  def _AddMMapResults(self, latest, results):
+    usage = latest.GetMemoryUsage()
+    def _AddMMapStat(category):
+      results.AddValue(scalar.ScalarValue(
+        results.current_page, category, 'MiB',
+        float(usage.get('mmaps_' + category, 0.0)) / 1024**2,
+        description=category))
+    _AddMMapStat('private_dirty')
+    #_AddMMapStat('overall_pss')
+    #_AddMMapStat('native_heap')
+    #_AddMMapStat('java_heap')