Adding pyauto-based memory usage tests for ChromeOS.

chrome/test/functional/perf.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.
 
 """Basic pyauto performance tests.
 
 For tests that need to be run for multiple iterations (e.g., so that average
 and standard deviation values can be reported), the default number of iterations
 run for each of these tests is specified by |_DEFAULT_NUM_ITERATIONS|.
@@ skipping 72 matching lines @@
     self._seen_graph_lines = {}
 
     pyauto.PyUITest.setUp(self)
 
     # Flush all buffers to disk and wait until system calms down.  Must be done
     # *after* calling pyauto.PyUITest.setUp, since that is where Chrome is
     # killed and re-initialized for a new test.
     # TODO(dennisjeffrey): Implement wait for idle CPU on Windows/Mac.
     if self.IsLinux():  # IsLinux() also implies IsChromeOS().
       os.system('sync')
-      self._WaitForIdleCPU(60.0, 0.03)
+      self._WaitForIdleCPU(60.0, 0.05)
 
   def _WaitForIdleCPU(self, timeout, utilization):
     """Waits for the CPU to become idle (< utilization).
 
     Args:
       timeout: The longest time in seconds to wait before throwing an error.
       utilization: The CPU usage below which the system should be considered
           idle (between 0 and 1.0 independent of cores/hyperthreads).
     """
     time_passed = 0.0
@@ skipping 1654 matching lines @@
   def testIntl2File(self):
     self._RunPageCyclerTest('intl2', self._num_iterations, 'Intl2File')
 
   def testMozFile(self):
     self._RunPageCyclerTest('moz', self._num_iterations, 'MozFile')
 
   def testMoz2File(self):
     self._RunPageCyclerTest('moz2', self._num_iterations, 'Moz2File')
 
 
+class MemoryTest(BasePerfTest):
+  """Tests to measure memory consumption under different usage scenarios."""
+
+  def setUp(self):
+    pyauto.PyUITest.setUp(self)
+

[ilja, 2012/04/25 23:37:37]

I assume you are logging out to use a fresh copy of Chrome and clean memory
state. Please leave a note to this intent.

[dennis_jeffrey, 2012/04/26 01:46:25]

Done.

+    if self.GetLoginInfo()['is_logged_in']:
+      self.Logout()
+      self.assertFalse(self.GetLoginInfo()['is_logged_in'],
+                      msg='Failed to log out.')
+
+    # Log in.
+    credentials = self.GetPrivateInfo()['test_google_account']
+    self.Login(credentials['username'], credentials['password'])
+    self.assertTrue(self.GetLoginInfo()['is_logged_in'],
+                    msg='Failed to log in.')
+
+  def _GetMemoryStats(self, duration=10):

[ilja, 2012/04/25 23:37:37]

I spoke with James and he thinks duration should be 15..20 seconds while
Stephane wanted 10..20. But see my comments below on loading pages. I think
better have no default.

[dennis_jeffrey, 2012/04/26 01:46:25]

I removed the default value to force the caller to choose an appropriate value.

+    """Identifies and returns different kinds of current memory usage stats.
+
+    This function samples values each second for |duration| seconds, then
+    outputs the min, max, and ending values for each measurement type.
+
+    Args:
+      duration: The number of seconds to sample data before outputting the
+          minimum, maximum, and ending values for each measurement type.
+
+    Returns:
+      A dictionary containing memory usage information.  Each measurement type
+      is associated with the min, max, and ending values from among all
+      sampled values.  Values are specified in KB.
+      {
+        'gtt': {  # GPU memory usage (graphics translation table)
+          'min': ...,
+          'max': ...,
+          'end': ...,
+        },
+        'mem_available': { ... },  # CPU available memory
+        'mem_shared': { ... },  # CPU shared memory
+      }
+    """
+    logging.debug('Sampling memory information for %d seconds...' % duration)
+    stats = {
+      'gtt': [],
+      'mem_available': [],
+      'mem_shared': [],
+    }
+
+    for _ in xrange(duration):
+      p = subprocess.Popen('grep bytes /sys/kernel/debug/dri/0/i915_gem_gtt',
+                           stdout=subprocess.PIPE,
+                           shell=True)
+      stdout = p.communicate()[0]
+
+      # GPU memory.
+      gtt_used = re.search(
+          'Total [\d]+ objects, ([\d]+) bytes', stdout).group(1)
+      stats['gtt'].append(int(gtt_used) / 1024.0)
+
+      # CPU memory.
+      stdout = ''
+      with open('/proc/meminfo') as f:
+        stdout = f.read()
+      mem_free = re.search('MemFree:\s*([\d]+) kB', stdout).group(1)
+      mem_dirty = re.search('Dirty:\s*([\d]+) kB', stdout).group(1)
+      mem_active_file = re.search(
+          'Active\(file\):\s*([\d]+) kB', stdout).group(1)
+      mem_inactive_file = re.search(
+          'Inactive\(file\):\s*([\d]+) kB', stdout).group(1)
+      stats['mem_available'].append(
+          (int(mem_active_file) + int(mem_inactive_file)) - int(mem_dirty) +
+          int(mem_free))
+
+      mem_shared = re.search('Shmem:\s*([\d]+) kB', stdout).group(1)
+      stats['mem_shared'].append(int(mem_shared))
+
+      time.sleep(1)
+
+    # Compute min, max, and ending values to return.
+    result = {}
+    for measurement_type in stats:
+      values = stats[measurement_type]
+      result[measurement_type] = {
+        'min': min(values),
+        'max': max(values),
+        'end': values[-1],
+      }
+
+    return result
+
+  def _RecordMemoryStats(self, description, when):
+    mem = self._GetMemoryStats()

[ilja, 2012/04/25 23:37:37]

Lets not use the default duration here. If we are loading 10 empty tabs 15
seconds might be appropriate. But if we are loading heavy websites maybe we want
to wait much longer (I think our test that opens gmail, G+ etc. measures 5
seconds or more per tab to load).

[dennis_jeffrey, 2012/04/26 01:46:25]

Now using 15 seconds as the duration for the empty tabs.

+    measurement_types = [
+      ('gtt', 'GTT'),
+      ('mem_available', 'MemAvail'),
+      ('mem_shared', 'MemShared'),
+    ]
+    for type_key, type_string in measurement_types:
+      self._OutputPerfGraphValue(
+          '%s-%sMin-%s' % (description, type_string, when),

[ilja, 2012/04/25 23:37:37]

'%s-Min%s-%s' etc. is easier to read and does not fuse with GTT.

[dennis_jeffrey, 2012/04/26 01:46:25]

Done.

+          mem[type_key]['min'], 'KB', '%s-%s' % (description, type_string))
+      self._OutputPerfGraphValue(
+          '%s-%sMax-%s' % (description, type_string, when),

[ilja, 2012/04/25 23:37:37]

dito

[dennis_jeffrey, 2012/04/26 01:46:25]

Done.

+          mem[type_key]['max'], 'KB', '%s-%s' % (description, type_string))
+      self._OutputPerfGraphValue(
+          '%s-%sEnd-%s' % (description, type_string, when),

[ilja, 2012/04/25 23:37:37]

dito

[dennis_jeffrey, 2012/04/26 01:46:25]

Done.

+          mem[type_key]['end'], 'KB', '%s-%s' % (description, type_string))
+
+  def _RunTest(self, tabs, description):

[ilja, 2012/04/25 23:37:37]

_RunTest needs duration as parameter when we run with real websites.

[dennis_jeffrey, 2012/04/26 01:46:25]

Done.

+    self._RecordMemoryStats(description, 'Start')

[ilja, 2012/04/25 23:37:37]

Can we call this Close0 to be consistent with the rest? Or maybe 0Tabs0 which I
think is easiest to understand?

[dennis_jeffrey, 2012/04/26 01:46:25]

I changed it to "0Tabs0" to follow the same format as what's recommended in your
comment at line 1883 below.

+
+    for iteration_num in xrange(2):
+      for site in tabs:
+        self.AppendTab(pyauto.GURL(site))
+
+      self._RecordMemoryStats(description, 'Open%d' % (iteration_num + 1))

[ilja, 2012/04/25 23:37:37]

'%dTabs%d' % (len(tabs), iteration_num + 1)

[dennis_jeffrey, 2012/04/26 01:46:25]

Done.

+
+      for _ in xrange(len(tabs)):
+        self.GetBrowserWindow(0).GetTab(1).Close(True)
+
+      self._RecordMemoryStats(description, 'Close%d' % (iteration_num + 1))

[ilja, 2012/04/25 23:37:37]

'0Tabs%d'

[dennis_jeffrey, 2012/04/26 01:46:25]

Done.

+
+  def testOpenCloseTabsControl(self):
+    tabs = ['about:blank'] * 10
+    self._RunTest(tabs, 'MemCtrl')
+
+
 class PerfTestServerRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
   """Request handler for the local performance test server."""
 
   def _IgnoreHandler(self, unused_args):
     """A GET request handler that simply replies with status code 200.
 
     Args:
       unused_args: A dictionary of arguments for the current GET request.
           The arguments are ignored.
     """
@@ skipping 212 matching lines @@
     """Identifies the port number to which the server is currently bound.
 
     Returns:
       The numeric port number to which the server is currently bound.
     """
     return self._server.server_address[1]
 
 
 if __name__ == '__main__':
   pyauto_functional.Main()