Purge unpinned ashmem before parsing /proc/$pid/smaps.

build/android/pylib/android_commands.py

 # 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.
 
 """Provides an interface to communicate with the device via the adb command.
 
 Assumes adb binary is currently on system path.
 """
 
 import collections
 import datetime
 import logging
 import os
 import re
 import shlex
 import signal
 import subprocess
 import sys
 import tempfile
 import time
 
 import cmd_helper
 import constants
+
+from utils import host_path_finder
+
 try:
   from pylib import pexpect
 except:
   pexpect = None
 
 sys.path.append(os.path.join(
     constants.DIR_SOURCE_ROOT, 'third_party', 'android_testrunner'))
 import adb_interface
 import am_instrument_parser
 import errors
@@ skipping 1368 matching lines @@
       if stats.device == 'mmcblk0':
         return {
             'num_reads': stats.num_reads_issued,
             'num_writes': stats.num_writes_completed,
             'read_ms': stats.ms_spent_reading,
             'write_ms': stats.ms_spent_writing,
         }
     logging.warning('Could not find disk IO stats.')
     return None
 
+  def _PurgeUnpinnedAshmem(self):

[bulach, 2013/11/05 16:25:14]

probably best to make this public and let callers decide whether or not they
want to purge, wdyt?
(and it can also be done just once rather than per pid)

[Philippe, 2013/11/05 16:37:42]

Yeah, good idea. I don't think many clients will need to have ashmem purged so
it's probably ok if we let the client deal with this detail (which he will
certainly miss but again clients other than Telemetry should not have to worry
too much about this).
I did not find an easy/not too hackish way for doing it only once though.

+    """Purges the unpinned ashmem memory for the whole system.
+
+    This can be used to make memory measurements more stable in particular.
+    """
+    host_path = host_path_finder.GetMostRecentHostPath('purge_ashmem')
+    if host_path:
+      device_path = os.path.join(constants.TEST_EXECUTABLE_DIR, 'purge_ashmem')
+      self.PushIfNeeded(host_path, device_path)
+      if self.RunShellCommand(device_path, log_result=True):
+        return
+    logging.error('Could not purge ashmem. Measurement might be unstable.')
+
   def GetMemoryUsageForPid(self, pid):
     """Returns the memory usage for given pid.
 
     Args:
       pid: The pid number of the specific process running on device.
 
     Returns:
       A tuple containg:
       [0]: Dict of {metric:usage_kb}, for the process which has specified pid.
       The metric keys which may be included are: Size, Rss, Pss, Shared_Clean,
       Shared_Dirty, Private_Clean, Private_Dirty, Referenced, Swap,
       KernelPageSize, MMUPageSize, Nvidia (tablet only).
       [1]: Detailed /proc/[PID]/smaps information.
     """
     usage_dict = collections.defaultdict(int)
     smaps = collections.defaultdict(dict)
+    self._PurgeUnpinnedAshmem()
     current_smap = ''
     for line in self.GetProtectedFileContents('/proc/%s/smaps' % pid,
                                               log_result=False):
       items = line.split()
       # See man 5 proc for more details. The format is:
       # address perms offset dev inode pathname
       if len(items) > 5:
         current_smap = ' '.join(items[5:])
       elif len(items) > 3:
         current_smap = ' '.join(items[3:])
@@ skipping 216 matching lines @@
   """
   def __init__(self, output):
     self._output = output
 
   def write(self, data):
     data = data.replace('\r\r\n', '\n')
     self._output.write(data)
 
   def flush(self):
     self._output.flush()