telemetry: Add a page set for blink's memory usage measurement

tools/perf/measurements/renderer_memory.py

Index: tools/perf/measurements/renderer_memory.py
diff --git a/tools/perf/measurements/renderer_memory.py b/tools/perf/measurements/renderer_memory.py
new file mode 100644
index 0000000000000000000000000000000000000000..b52b6dd07b2dc05e8fa6b91f1856a81390913530
--- /dev/null
+++ b/tools/perf/measurements/renderer_memory.py
@@ -0,0 +1,66 @@
+# 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.
+
+from telemetry.page import page_test
+#from telemetry.page import action_runner
+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 RendererMemory(page_test.PageTest):
+    def __init__(self):
+        super(RendererMemory, 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'])

[petrcermak, 2015/08/04 13:05:03]

You need to add '--enable-memory-benchmarking' here to disable periodic memory
dumps.

[bashi, 2015/08/05 09:46:30]

Done.

+
+    def ValidateAndMeasurePage(self, page, tab, results):
+        assert tab.browser.supports_memory_dumping
+        guid = tab.browser.DumpMemory()

[petrcermak, 2015/08/04 13:05:03]

I suggest you add an assert below this statement:

assert guid is not None

[bashi, 2015/08/05 09:46:30]

Done.

+        #runner = action_runner.ActionRunner(tab)
+        #runner.Wait(4)
+        timeline_data = tab.browser.platform.tracing_controller.Stop()
+        timeline_model = TimelineModel(timeline_data)
+        dump = self._FindRendererDump(timeline_model, guid)
+        self._AddAllocatorResults(dump, results)
+
+    def _FindRendererDump(self, timeline_model, guid):
+        memory_dumps = [dump for dump in timeline_model.IterGlobalMemoryDumps()
+                        if dump.dump_id == guid]

[petrcermak, 2015/08/04 13:05:03]

You won't need to do any filtering once you disable the periodic dumps via the
extra command-line flag:

memory_dumps = list(timeline_model.IterGlobalMemoryDumps())
assert len(memory_dumps) == 1
assert memory_dumps[0].dump_id == guid

[bashi, 2015/08/05 09:46:30]

Done.

+        assert len(memory_dumps) == 1

[bashi, 2015/08/04 06:44:23]

I hit this assert. How can I make sure that the requested dump is actually in
IterGlobalMemoryDumps()?

[petrcermak, 2015/08/04 13:05:03]

You should not need to do this (the dump should always be there when you disable
the periodic dumps), but it could be done as follows (again, you should not need
to do this):

for _ in xrange(MAX_RETRIES):
  guid = tab.browser.DumpMemory()
  if guid is not None:
    break
else:
  raise Exception('Failed to dump memory')

[bashi, 2015/08/05 09:46:30]

Removed filtering:)

+        renderer_dumps = [
+            dump for dump in memory_dumps[0].IterProcessMemoryDumps()
+            if dump.process_name == 'Renderer']
+        assert len(renderer_dumps) == 1
+        return renderer_dumps[0]
+
+    def _AddAllocatorResults(self, dump, results):
+        usage = dump.GetMemoryUsage()
+        def _AddAllocatorStats(category):
+            results.AddValue(scalar.ScalarValue(
+                results.current_page, category, 'MiB',
+                float(usage.get('allocator_' + category, 0.0)) / 1024**2,
+                description='Total memory allocated by ' + category))
+        _AddAllocatorStats('malloc')
+        _AddAllocatorStats('v8')
+        _AddAllocatorStats('blink_gc')
+        _AddAllocatorStats('partition_alloc')
+        _AddAllocatorStats('discardable')
+
+        def _AddMMapStats(category):
+            results.AddValue(scalar.ScalarValue(
+                results.current_page, category, 'MiB',
+                float(usage.get('mmaps_' + category, 0.0)) / 1024**2,
+                description=category))
+        _AddMMapStats('private_dirty')