Enable Deep Memory Profiler in perf_endure.py.

chrome/test/functional/perf_endure.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """Performance tests for Chrome Endure (long-running perf tests on Chrome).
 
 This module accepts the following environment variable inputs:
   TEST_LENGTH: The number of seconds in which to run each test.
   PERF_STATS_INTERVAL: The number of seconds to wait in-between each sampling
       of performance/memory statistics.
 """
 
 import logging
 import os
 import re
+import shutil
+import tempfile
 import time
 
 import perf
 import pyauto_functional  # Must be imported before pyauto.
 import pyauto
 import remote_inspector_client
 import selenium.common.exceptions
 from selenium.webdriver.support.ui import WebDriverWait
 
+DMPROF_DIR_PATH = os.path.join(os.path.dirname(__file__),

[Nirnimesh, 2012/04/09 18:46:44]

Unless you want these vars to be accessible from outside this file, prefix _ to
them. Better stil, move them inside the class below.

[Dai Mikurube (NOT FULLTIME), 2012/04/13 11:16:49]

Done.

+                               os.pardir,
+                               os.pardir,
+                               os.pardir,
+                               'tools',
+                               'deep_memory_profiler')
+
+DMPROF_PATH = os.path.join(DMPROF_DIR_PATH,
+                           'dmprof.py')
+
+# TODO(dmikurube): Need to find an actual running chrome.
+CHROME_BIN_PATH = os.path.join(os.path.dirname(__file__),
+                               os.pardir,
+                               os.pardir,
+                               os.pardir,
+                               'out',
+                               'Debug',
+                               'chrome')

[Nirnimesh, 2012/04/09 18:46:44]

What about non-linux?

[Dai Mikurube (NOT FULLTIME), 2012/04/13 11:16:49]

Done.

 
 class ChromeEndureBaseTest(perf.BasePerfTest):
   """Implements common functionality for all Chrome Endure tests.
 
   All Chrome Endure test classes should inherit from this class.
   """
 
   _DEFAULT_TEST_LENGTH_SEC = 60 * 60 * 6  # Tests run for 6 hours.
   _GET_PERF_STATS_INTERVAL = 60 * 10  # Measure perf stats every 10 minutes.
   _ERROR_COUNT_THRESHOLD = 300  # Number of ChromeDriver errors to tolerate.
@@ skipping 79 matching lines @@
         last_perf_stats_time = time.time()
         self._GetPerformanceStats(
             webapp_name, test_description, tab_title_substring)
 
       if self._iteration_num % 10 == 0:
         remaining_time = self._test_length_sec - (time.time() -
                                                   self._test_start_time)
         logging.info('Chrome interaction #%d. Time remaining in test: %d sec.' %
                      (self._iteration_num, remaining_time))
 
+      if self._iteration_num % 20 == 5:

[Dai Mikurube (NOT FULLTIME), 2012/04/09 09:10:40]

Temporary trigger.

[Nirnimesh, 2012/04/09 18:46:44]

Add comments / TODO notes.

[dennis_jeffrey, 2012/04/09 19:12:38]

We'll likely want to be able to turn profiling on/off and specify the interval
in which we dump profile data (or analyze the dumped data)

[Dai Mikurube (NOT FULLTIME), 2012/04/11 08:44:02]

Ah, exactly.  Such an option is required.  How can I give an option to Endure
from external?

[dennis_jeffrey, 2012/04/12 00:51:52]

Right now it's done through environment variables.  See lines 60-63 above.

[Dai Mikurube (NOT FULLTIME), 2012/04/13 11:16:49]

Using an environment variable DEEP_MEMORY_PROFILE_INTERVAL.  Thanks.

+        self.HeapProfilerDump('In ChromeEndureControlTest')
+
       do_scenario()
 
     self._GetPerformanceStats(
         webapp_name, test_description, tab_title_substring)
 
   def _GetProcessInfo(self, tab_title_substring):
     """Gets process info associated with an open browser/tab.
 
     Args:
       tab_title_substring: A unique substring contained within the title of
@@ skipping 36 matching lines @@
                      msg='Expected to find 1 %s tab process, but found %d '
                          'instead.\nCurrent process info:\n%s.' % (
                          tab_title_substring, len(tab_proc_info),
                          self.pformat(info)))
 
     browser_proc_info = browser_proc_info[0]
     tab_proc_info = tab_proc_info[0]
     return {
       'browser_private_mem': browser_proc_info['working_set_mem']['priv'],
       'tab_private_mem': tab_proc_info['working_set_mem']['priv'],
+      'browser_pid': browser_proc_info['pid'],

[dennis_jeffrey, 2012/04/09 19:12:38]

is this value used anywhere?

[Dai Mikurube (NOT FULLTIME), 2012/04/13 11:16:49]

No for now.  Removed it.

+      'tab_pid': tab_proc_info['pid'],
     }
 
   def _GetPerformanceStats(self, webapp_name, test_description,
                            tab_title_substring):
     """Gets performance statistics and outputs the results.
 
     Args:
       webapp_name: A string name for the webapp being tested.  Should not
           include spaces.  For example, 'Gmail', 'Docs', or 'Plus'.
       test_description: A string description of what the test does, used for
@@ skipping 25 matching lines @@
     logging.info('  Tab process private memory: %d KB' %
                  proc_info['tab_private_mem'])
     self._tab_process_private_mem_results.append(
         (elapsed_time, proc_info['tab_private_mem']))
 
     v8_info = self.GetV8HeapStats()  # First window, first tab.
     v8_mem_used = v8_info['v8_memory_used'] / 1024.0  # Convert to KB.
     logging.info('  V8 memory used: %f KB' % v8_mem_used)
     self._v8_mem_used_results.append((elapsed_time, v8_mem_used))
 
+    # TODO(dmikurube): Add --single in dmprof.py?

[dennis_jeffrey, 2012/04/09 19:12:38]

So in general, a test will periodically call HeapProfilerDump(), and also
periodically, we'll analyze the dumped data.  What are the requirements for how
often each of these things should occur?  What are the tradeoffs involved in
dumping more frequently, or analyzing the dumped data more frequently?

[Dai Mikurube (NOT FULLTIME), 2012/04/11 08:44:02]

I'm in tries-and-errors about that.  Dumping may take a little long
stop-the-world (2-3 sec), and dumped data are large (3-4 MB or more for one
dump).

Frequent analysis has less negative impact.  But, of course, more frequent
analysis than dumping is just waste.  (Yes, the current version does it.)

+    first_dump = ''
+    print '^%s/endure.%05d.\d+.heap$' % (

[Nirnimesh, 2012/04/09 18:46:44]

Use the right logging call instead of print.

[Dai Mikurube (NOT FULLTIME), 2012/04/16 09:43:20]

Done.

+          self._deep_tempdir, proc_info['tab_pid'])
+    for filename in sorted(os.listdir(self._deep_tempdir)):
+      if re.match('^%s/endure.%05d.\d+.heap$' % (

[Nirnimesh, 2012/04/09 18:46:44]

use os.path.join() instead of hardcoding /

[Dai Mikurube (NOT FULLTIME), 2012/04/16 09:43:20]

Done.

+          self._deep_tempdir, proc_info['tab_pid']), filename):
+        first_dump = filename
+        break
+
+    # Test printing.
+    if first_dump:

[dennis_jeffrey, 2012/04/09 19:12:38]

What does it mean for a file to be the "first dump", and why do we only need to
use the first dump file?

[Dai Mikurube (NOT FULLTIME), 2012/04/11 08:44:02]

This is just a test printing, and will be removed eventually.

The current deep memory profiler receives the first dump file, and finds next
dump files by itself.  Analyzing the same data many times is wasteful, but it's
the easiest way to store the result in one file.  (Re-analyzing doesn't cost so
much.)

I'm trying analyzing a single file, and storing its result into one file in
dmprof.py.

+      print 'First Dump: %s' % first_dump

[Nirnimesh, 2012/04/09 18:46:44]

logging.info()?

[Dai Mikurube (NOT FULLTIME), 2012/04/16 09:43:20]

Done.

+    else:
+      print 'No Dump!'
+    """
+      with open('%s/endure.%05d.json' % (self._deep_tempdir,

[Nirnimesh, 2012/04/09 18:46:44]

use os.path.join

[Dai Mikurube (NOT FULLTIME), 2012/04/13 11:16:49]

Done.

+                                         proc_info['tab_pid']), 'w+') as json_f:
+        p = subprocess.Popen(

[Nirnimesh, 2012/04/09 18:46:44]

use better varname instead of |p|

[Dai Mikurube (NOT FULLTIME), 2012/04/11 08:44:02]

Good catch.  Thanks.

+            '%s --json %s %s %s' % (DMPROF_PATH,
+                                    CHROME_BIN_PATH,
+                                    os.path.join(DMPROF_DIR_PATH, 'dmpolicy'),
+                                    @@@SNAPSHOT@@@),
+            shell=True, stdout=json_f)
+        p.wait()

[Nirnimesh, 2012/04/09 18:46:44]

you won't need this if you use subprocess.call() in the previous line.

[Dai Mikurube (NOT FULLTIME), 2012/04/16 09:43:20]

Finally, this script is required to run on background.  (dmprof may take long
time.)

The latest version supports background execution with Popen.  Please look at
that.

+        """
+
+    # 2) Parse .json (including only the latest snapshot) file here.
+
     # Output the results seen so far, to be graphed.
     self._OutputPerfGraphValue(
         'TotalDOMNodeCount', self._dom_node_count_results, 'nodes',
         graph_name='%s%s-Nodes-DOM' % (webapp_name, test_description),
         units_x='seconds')
     self._OutputPerfGraphValue(
         'EventListenerCount', self._event_listener_count_results, 'listeners',
         graph_name='%s%s-EventListeners' % (webapp_name, test_description),
         units_x='seconds')
     self._OutputPerfGraphValue(
         'BrowserPrivateMemory', self._browser_process_private_mem_results, 'KB',
         graph_name='%s%s-BrowserMem-Private' % (webapp_name, test_description),
         units_x='seconds')
     self._OutputPerfGraphValue(
         'TabPrivateMemory', self._tab_process_private_mem_results, 'KB',
         graph_name='%s%s-TabMem-Private' % (webapp_name, test_description),
         units_x='seconds')
     self._OutputPerfGraphValue(
         'V8MemoryUsed', self._v8_mem_used_results, 'KB',
         graph_name='%s%s-V8MemUsed' % (webapp_name, test_description),
         units_x='seconds')
+    # 3) Do self._OutputPerfGraphValue for multiple lines, here.
 
   def _GetElement(self, find_by, value):
     """Gets a WebDriver element object from the webpage DOM.
 
     Args:
       find_by: A callable that queries WebDriver for an element from the DOM.
       value: A string value that can be passed to the |find_by| callable.
 
     Returns:
       The identified WebDriver element object, if found in the DOM, or
@@ skipping 46 matching lines @@
       return False
     return True
 
 
 class ChromeEndureControlTest(ChromeEndureBaseTest):
   """Control tests for Chrome Endure."""
 
   _webapp_name = 'Control'
   _tab_title_substring = 'Chrome Endure Control Test'
 
+  def setUp(self):

[dennis_jeffrey, 2012/04/09 19:12:38]

This only enables profiling in the two control tests, since it's inside of class
ChromeEndureControlTest.  Did you mean to enable profiling in all Chrome Endure
tests?

[Dai Mikurube (NOT FULLTIME), 2012/04/11 08:44:02]

Finally, yes.  Is there an efficient way to enable it for all Endure tests?

[dennis_jeffrey, 2012/04/12 00:51:52]

Yes - if you enable profiling above in class ChromeEndureBaseTest (see setUp
function in line 57), then it will be enabled for all Chrome Endure tests, since
all Chrome Endure tests execute that setUp function.

[Dai Mikurube (NOT FULLTIME), 2012/04/13 11:16:49]

I see.  Thank you.
I did it in the uploaded code.

+    # TODO(dmikurube): Have to specify "--no-sandbox" for Chrome.

[Dai Mikurube (NOT FULLTIME), 2012/04/09 09:20:27]

Note: ExtraChromeFlags would work.

+    self._deep_tempdir = tempfile.mkdtemp()
+    os.environ['HEAPPROFILE'] = '%s/endure' % self._deep_tempdir

[Nirnimesh, 2012/04/09 18:46:44]

os.path.join

[Dai Mikurube (NOT FULLTIME), 2012/04/13 11:16:49]

Done.

+    os.environ['DEEP_HEAP_PROFILE'] = 'True'
+    ChromeEndureBaseTest.setUp(self)
+
+  def tearDown(self):
+    del os.environ['DEEP_HEAP_PROFILE']
+    del os.environ['HEAPPROFILE']
+    ChromeEndureBaseTest.tearDown(self)
+    # shutil.rmtree(self._deep_tempdir)
+
   def testControlAttachDetachDOMTree(self):
     """Continually attach and detach a DOM tree from a basic document."""
     test_description = 'AttachDetachDOMTree'
     url = self.GetHttpURLForDataPath('chrome_endure', 'endurance_control.html')
     self.NavigateToURL(url)
     loaded_tab_title = self.GetActiveTabTitle()
     self.assertTrue(self._tab_title_substring in loaded_tab_title,
                     msg='Loaded tab title does not contain "%s": "%s"' %
                         (self._tab_title_substring, loaded_tab_title))
 
@@ skipping 515 matching lines @@
           self._driver, self._wait, 'id("state")[text()="offline"]'):
         self._num_errors += 1
       time.sleep(1)
 
     self._RunEndureTest(self._webapp_name, self._tab_title_substring,
                         test_description, scenario)
 
 
 if __name__ == '__main__':
   pyauto_functional.Main()