Moved CPU Usage helper functions from Youtube class to BasePerfTest class in perf.py.

chrome/test/functional/perf.py

 #!/usr/bin/python
 # Copyright (c) 2011 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 181 matching lines @@
         self.GetBrowserWindow(0).GetTab(1).Close(True)
 
     self._PrintSummaryResults(description, timings, 'milliseconds')
 
   def _LoginToGoogleAccount(self):
     """Logs in to a testing Google account."""
     creds = self.GetPrivateInfo()['test_google_account']
     test_utils.GoogleAccountsLogin(self, creds['username'], creds['password'])
     self.NavigateToURL('about:blank')  # Clear the existing tab.
 
+  def _GetCPUUsage(self):
+    """Returns machine's CPU usage.
+
+    This function uses /proc/stat to identify CPU usage, and therefore works
+    only on Linux/ChromeOS.
+
+    Returns:
+      A dictionary with 'user', 'nice', 'system' and 'idle' values.
+      Sample dictionary:
+      {
+        'user': 254544,
+        'nice': 9,
+        'system': 254768,
+        'idle': 2859878,
+      }
+    """
+    try:
+      f = open('/proc/stat', 'r')
+      cpu_usage_str = f.readline().split()
+      f.close()
+    except IOError, e:
+      self.fail('Could not retrieve CPU usage: ' + str(e))
+    return {
+      'user': int(cpu_usage_str[1]),
+      'nice': int(cpu_usage_str[2]),
+      'system': int(cpu_usage_str[3]),
+      'idle': int(cpu_usage_str[4])
+    }
+
+  def _GetFractionNonIdleCPUTime(self, cpu_usage_start, cpu_usage_end):
+    """Computes the fraction of CPU time spent non-idling.
+
+    This function should be invoked using before/after values from calls to
+    _GetCPUUsage().
+    """
+    time_non_idling_end = (cpu_usage_end['user'] + cpu_usage_end['nice'] +
+                           cpu_usage_end['system'])
+    time_non_idling_start = (cpu_usage_start['user'] + cpu_usage_start['nice'] +
+                             cpu_usage_start['system'])
+    total_time_end = (cpu_usage_end['user'] + cpu_usage_end['nice'] +
+                      cpu_usage_end['system'] + cpu_usage_end['idle'])
+    total_time_start = (cpu_usage_start['user'] + cpu_usage_start['nice'] +
+                        cpu_usage_start['system'] + cpu_usage_start['idle'])
+    return ((float(time_non_idling_end) - time_non_idling_start) /
+            (total_time_end - total_time_start))
+
 
 class TabPerfTest(BasePerfTest):
   """Tests that involve opening tabs."""
 
   def testNewTab(self):
     """Measures time to open a new tab."""
     self._RunNewTabTest('NewTabPage',
                         lambda: self._AppendTab('chrome://newtab'))
 
   def testNewTabPdf(self):
@@ skipping 279 matching lines @@
     self._RunNewTabTest('NewTabDocs', _RunSingleDocsTabOpen)
 
 
 class YoutubePerfTest(BasePerfTest, YoutubeTestHelper):
   """Test Youtube video performance."""
 
   def __init__(self, methodName='runTest', **kwargs):
     pyauto.PyUITest.__init__(self, methodName, **kwargs)
     YoutubeTestHelper.__init__(self, self)
 
-  def GetCPUUsage(self):
-    """Returns machine's CPU usage
-       
-    It uses /proc/stat to count CPU usage.
-    Returns:
-      A dictionary with user, nice, system and idle values.
-      Sample dictionary :
-      {
-        'user': 254544,
-        'nice': 9,
-        'system': 254768,
-        'idle': 2859878,
-      }
-    """
-    cpu = open('/proc/stat').readline().split()
-    return {
-        'user': int(cpu[1]),
-        'nice': int(cpu[2]),
-        'system': int(cpu[3]),
-        'idle': int(cpu[4])
-        }
-
-  def VerifyVideoTotalBytes(self):
-    """Returns true if video total bytes information is available"""
+  def _VerifyVideoTotalBytes(self):
+    """Returns true if video total bytes information is available."""
     return self.GetVideoTotalBytes() > 0
 
-  def VerifyVideoLoadedBytes(self):
-    """Returns true if video loaded bytes information is available"""
+  def _VerifyVideoLoadedBytes(self):
+    """Returns true if video loaded bytes information is available."""
     return self.GetVideoLoadedBytes() > 0
 
   def StartVideoForPerformance(self):
-    """Start the test video with all required buffering"""
+    """Start the test video with all required buffering."""
     self.PlayVideoAndAssert()
     self.ExecuteJavascript("""
         ytplayer.setPlaybackQuality('hd720');
         window.domAutomationController.send('');
     """)
     self.AssertPlayingState()
     self.assertTrue(
-        self.WaitUntil(self.VerifyVideoTotalBytes, expect_retval=True),
+        self.WaitUntil(self._VerifyVideoTotalBytes, expect_retval=True),
         msg='Failed to get video total bytes information.')
     self.assertTrue(
-        self.WaitUntil(self.VerifyVideoLoadedBytes, expect_retval=True), 
+        self.WaitUntil(self._VerifyVideoLoadedBytes, expect_retval=True),
         msg='Failed to get video loaded bytes information')
     loaded_video_bytes = self.GetVideoLoadedBytes()
     total_video_bytes = self.GetVideoTotalBytes()
     self.PauseVideo()
-    count = 0
+    # Wait for the video to finish loading.
     while total_video_bytes > loaded_video_bytes:
       loaded_video_bytes = self.GetVideoLoadedBytes()
       time.sleep(1)
-      count = count + 1
     self.PlayVideo()
-    # Ignoring first 10 seconds of video playing so we get smooth
-    # videoplayback.
+    # Ignore first 10 seconds of video playing so we get smooth videoplayback.
     time.sleep(10)
 
   def testYoutubeDroppedFrames(self):
     """Measures the Youtube video dropped frames. Runs for 60 secs."""
     self.StartVideoForPerformance()
     init_dropped_frames = self.GetVideoDroppedFrames()
     total_dropped_frames = 0
     dropped_fps = []
     for _ in xrange(60):
       frames = self.GetVideoDroppedFrames() - init_dropped_frames
       current_dropped_frames = frames - total_dropped_frames 
       dropped_fps.append(current_dropped_frames)
       total_dropped_frames = frames
       # Play the video for some time
       time.sleep(1)
     self._PrintSummaryResults('YoutubeDroppedFrames', dropped_fps, 'frames')
 
   def testYoutubeCPU(self):
-    """Measure the Youtube video CPU usage. Runs for 60 seconds.
+    """Measures the Youtube video CPU usage. Runs for 60 seconds.
 
-    Measures the Youtube video CPU usage (between 0 and 1) extrapolated to
+    Measures the Youtube video CPU usage (between 0 and 1), extrapolated to
     totalframes in the video by taking dropped frames into account. For smooth
     videoplayback this number should be < 0.5..1.0 on a hyperthreaded CPU.
     """
     self.StartVideoForPerformance()
     init_dropped_frames = self.GetVideoDroppedFrames()
-    cpu_usage1 = self.GetCPUUsage() 
+    cpu_usage_start = self._GetCPUUsage()
     total_shown_frames = 0
-    for _ in xrange(60):
-      total_shown_frames = total_shown_frames + self.GetVideoFrames() 
-      # Play the video for some time
-      time.sleep(1)
+    num_seconds = 60
+    for sec_num in xrange(num_seconds):
+      total_shown_frames = total_shown_frames + self.GetVideoFrames()
+      if sec_num < num_seconds - 1:  # Do not sleep on the last iteration.

[rohitbm, 2011/11/18 00:24:53]

Should we use xrange(num_seconds-1) above instead of checking sec_num <
num_seconds-1 in each iteration?

[dennis_jeffrey, 2011/11/18 00:51:29]

That's a good question.  I actually do want the loop to iterate 60 times like it
did before (that's why I'm using xrange(num_seconds).  However, on the very last
loop iteration, after we update total_shown_frames for the final time, I want to
avoid sleeping in that case.  The reason is because the length of time that we
sleep affects the overall results, since we're computing the difference in CPU
usage between |cpu_usage_start| and |cpu_usage_end|.  If we let the video play
for 1 more second in the last loop iteration, then exit the loop, then the CPU
has been utilized for 1 more second, which we have not accounted for in the
|total_shown_frames| variable.  Does that make sense?

But you do have a point that it's undesirable to have an extra check on each
loop iteration.  I think that if we reverse the order of the statements inside
the loop (i.e., sleep first, then update |total_shown_frames|, I think that
would be better.  I went ahead and made that change ;-)

+        # Play the video for some time.
+        time.sleep(1)
     total_dropped_frames = self.GetVideoDroppedFrames() - init_dropped_frames
-    cpu_usage2 = self.GetCPUUsage() 
+    cpu_usage_end = self._GetCPUUsage()
     
-    x2 = cpu_usage2['user'] + cpu_usage2['nice'] + cpu_usage2['system']
-    x1 = cpu_usage1['user'] + cpu_usage1['nice'] + cpu_usage1['system']
-    y2 = cpu_usage2['user'] + cpu_usage2['nice'] + \
-         cpu_usage2['system'] + cpu_usage2['idle']
-    y1 = cpu_usage1['user'] + cpu_usage1['nice'] + \
-         cpu_usage1['system'] + cpu_usage1['idle']
+    fraction_non_idle_time = self._GetFractionNonIdleCPUTime(
+        cpu_usage_start, cpu_usage_end)
     total_frames = total_shown_frames + total_dropped_frames
-    # Counting extrapolation for utilization to play the video
-    self._PrintSummaryResults('YoutubeCPUExtrapolation',
-        [((float(x2) - x1) / (y2 - y1)) * total_frames/total_shown_frames],
-        'extrapolation')
+    # Counting extrapolation for utilization to play the video.
+    extrapolation_value = (fraction_non_idle_time *
+                           (total_frames / total_shown_frames))
+    logging.info('Youtube CPU extrapolation: %.2f' % extrapolation_value)
+    self._OutputPerfGraphValue('extrapolation_YoutubeCPUExtrapolation',
+                               extrapolation_value)
 
 
 class WebGLTest(BasePerfTest):
   """Tests for WebGL performance."""
 
   def _RunWebGLTest(self, url, description):
     """Measures FPS using a specified WebGL demo.
 
     Args:
       url: The string URL that, once loaded, will run the WebGL demo (default
@@ skipping 705 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()