Adding CPU performance test for Youtube video

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|.
 That value can optionally be tweaked by setting an environment variable
 'NUM_ITERATIONS' to a positive integer, representing the number of iterations
 to run.
 
 Some tests rely on repeatedly appending tabs to Chrome.  Occasionally, these
 automation calls time out, thereby affecting the timing measurements (see issue
 crosbug.com/20503).  To work around this, the tests discard timing measurements
 that involve automation timeouts.  The value |_DEFAULT_MAX_TIMEOUT_COUNT|
 specifies the threshold number of timeouts that can be tolerated before the test
 fails.  To tweak this value, set environment variable 'MAX_TIMEOUT_COUNT' to the
 desired threshold value.
 """
 
 import BaseHTTPServer
+import commands
 import logging
 import math
 import os
 import posixpath
 import re
 import SimpleHTTPServer
 import SocketServer
 import tempfile
 import threading
 import time
@@ skipping 455 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 testYoutubeDroppedFrames(self):
-    """Measures the Youtube video dropped frames. Runs for 60 secs."""
+  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,
+      }
+    """
+    file = open('/proc/stat')
+    cpu = file.readline().split()

[Nirnimesh, 2011/11/15 08:11:29]

merge with previous line. you don't need the |file| variable
(BTW |file| is a keyword in python anyway)

+    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"""
+    return self.GetVideoTotalBytes() > 0
+
+  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"""
     self.PlayVideoAndAssert()
     self.ExecuteJavascript("""
         ytplayer.setPlaybackQuality('hd720');
         window.domAutomationController.send('');
     """)
+    self.AssertPlayingState()
+    self.assertTrue(
+        self.WaitUntil(self.VerifyVideoTotalBytes, expect_retval=True),
+        msg='Failed to get video total bytes information.')
+    self.assertTrue(
+        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
+    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.
+    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 = []
-    youtube_apis = self.GetPrivateInfo()['youtube_api']
-    youtube_debug_text = youtube_apis['GetDebugText']
     for _ in xrange(60):
-      video_data = self.ExecuteJavascript(
-          'window.domAutomationController.send(%s);' % youtube_debug_text)
-      # Video data returns total dropped frames so far, so calculating
-      # the dropped frames for the last second.
-      matched = re.search('droppedFrames=([\d\.]+)', video_data)
-      if matched:
-        frames = int(matched.group(1))
+      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 (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() 
+    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)
+    total_dropped_frames = self.GetVideoDroppedFrames() - init_dropped_frames
+    cpu_usage2 = 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']
+    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')
+
 
 class FileUploadDownloadTest(BasePerfTest):
   """Tests that involve measuring performance of upload and download."""
 
   def setUp(self):
     """Performs necessary setup work before running each test in this class."""
     self._temp_dir = tempfile.mkdtemp()
     self._test_server = PerfTestServer(self._temp_dir)
     self._test_server_port = self._test_server.GetPort()
     self._test_server.Run()
@@ skipping 645 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()