Add compositor thread mode to latency tests

chrome/test/perf/rendering/latency_tests.cc

 // 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.
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
@@ skipping 62 matching lines @@
 using trace_analyzer::FindClosest;
 using trace_analyzer::FindLastOf;
 using trace_analyzer::RateStats;
 using trace_analyzer::Query;
 using trace_analyzer::TraceAnalyzer;
 using trace_analyzer::TraceEvent;
 using trace_analyzer::TraceEventVector;
 
 enum LatencyTestMode {
   kWebGL,
+  kWebGLThread,
   kSoftware
 };
 
 enum LatencyTestFlags {
   kInputHeavy   = 1 << 0,
   kInputDirty   = 1 << 1,
   kRafHeavy     = 1 << 2,
   kPaintHeavy   = 1 << 3
 };
 
 const int kWebGLCanvasWidth = 10;
 const int kNumFrames = 80;
 const int kInputsPerFrame = 16;
 // Magic number to identify certain glClear events.
 const int kClearColorGreen = 137;
 const int kMouseY = 5;
 
 // Don't analyze begin frames that may be inaccurate. Latencies can be as high
 // as 5 frames or so, so skip the first 6 frames to get more accurate results.
 const int kIgnoreBeginFrames = 6;
 // Don't analyze end frames that may be inaccurate.
 const int kIgnoreEndFrames = 4;
 // Minimum frames to produce an answer.
 const int kMinimumFramesForAnalysis = 5;
 
 class LatencyTest
     : public BrowserPerfTest,
       public ::testing::WithParamInterface<int> {
  public:
-  LatencyTest() :
+  explicit LatencyTest(LatencyTestMode mode) :
       query_instant_(Query::EventPhase() ==
                      Query::Phase(TRACE_EVENT_PHASE_INSTANT)),
       // These queries are initialized in RunTest.
       query_begin_swaps_(Query::Bool(false)),
       query_end_swaps_(Query::Bool(false)),
       query_inputs_(Query::Bool(false)),
       query_blits_(Query::Bool(false)),
       query_clears_(Query::Bool(false)),
       mouse_x_(0),
       tab_width_(0),
-      mode_(kWebGL),
+      mode_(mode),
       delay_time_us_(0),
       num_frames_(0),
       verbose_(false),
-      test_flags_(0) {}
+      test_flags_(0),
+      use_gpu_(mode == kWebGL || mode == kWebGLThread) {}
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE;
 
   std::vector<int> GetAllBehaviors();
 
-  // Run test with specified |mode| and |behaviors|.
-  // |mode| can be webgl or software.
+  // Run test with specified |behaviors|.
   // |behaviors| is a list of combinations of LatencyTestFlags.
-  void RunTest(LatencyTestMode mode, const std::vector<int>& behaviors);
+  void RunTest(const std::vector<int>& behaviors);
 
  private:
   void RunTestInternal(const std::string& test_url,
                        bool send_inputs,
                        int input_delay_us);
 
   double CalculateLatency();
 
   std::string GetModeString() {
     switch (mode_) {
       case kWebGL:
         return "webgl";
+      case kWebGLThread:
+        return "webgl_thread";
       case kSoftware:
         return "software";
       default:
         NOTREACHED() << "invalid mode";
         return "";
     }
   }
 
   std::string GetTraceName(int flags);
 
@@ skipping 54 matching lines @@
   int num_frames_;
 
   // Map from test flags combination to the calculated mean latency.
   std::map<int, double> latencies_;
 
   // Whether to print more verbose output.
   bool verbose_;
 
   // Current test flags combination, determining the behavior of the test.
   int test_flags_;
+
+  bool use_gpu_;
 };
 
 void LatencyTest::SetUpCommandLine(CommandLine* command_line) {
   BrowserPerfTest::SetUpCommandLine(command_line);
-  if (CommandLine::ForCurrentProcess()->
-      HasSwitch(switches::kEnableThreadedCompositing)) {
+  if (mode_ == kWebGLThread) {
+    ASSERT_TRUE(use_gpu_);
     command_line->AppendSwitch(switches::kEnableThreadedCompositing);
+  } else {
+    command_line->AppendSwitch(switches::kDisableThreadedCompositing);
   }
+  if (!use_gpu_)
+    command_line->AppendSwitch(switches::kDisableAcceleratedCompositing);
   command_line->AppendSwitch(switches::kDisableBackgroundNetworking);
 }
 
 std::vector<int> LatencyTest::GetAllBehaviors() {
   std::vector<int> behaviors;
   int max_behaviors = kInputHeavy | kInputDirty | kRafHeavy | kPaintHeavy;
   for (int i = 0; i <= max_behaviors; ++i)
     behaviors.push_back(i);
   return behaviors;
 }
 
-void LatencyTest::RunTest(LatencyTestMode mode,
-                          const std::vector<int>& behaviors) {
-  mode_ = mode;
+void LatencyTest::RunTest(const std::vector<int>& behaviors) {
   verbose_ = (logging::GetVlogLevel("latency_tests") > 0);
 
   // Linux Intel uses mesa driver, where multisampling is not supported.
   // Multisampling is also not supported on virtualized mac os.
   // The latency test uses the multisampling blit trace event to determine when
   // the compositor is consuming the webgl context, so it currently doesn't work
   // without multisampling. Since the Latency test does not depend much on the
   // GPU, let's just skip testing on Intel since the data is redundant with
   // other non-Intel bots.
   GPUTestBotConfig test_bot;
   test_bot.LoadCurrentConfig(NULL);
   const std::vector<uint32>& gpu_vendor = test_bot.gpu_vendor();
 #if defined(OS_LINUX)
   if (gpu_vendor.size() == 1 && gpu_vendor[0] == 0x8086)
     return;
 #endif  // defined(OS_LINUX)
 #if defined(OS_MACOSX)
   if (gpu_vendor.size() == 1 && gpu_vendor[0] == 0x15AD)
     return;
 #endif  // defined(OS_MACOSX)
 
 #if defined(OS_WIN)
   // Latency test doesn't work on WinXP. crbug.com/128066
   if (base::win::OSInfo::GetInstance()->version() == base::win::VERSION_XP)
     return;
 #endif
 
   // Construct queries for searching trace events via TraceAnalyzer.
-  if (mode_ == kWebGL) {
+  if (use_gpu_) {
     query_begin_swaps_ = query_instant_ &&
         Query::EventName() == Query::String("SwapBuffersLatency") &&
         Query::EventArg("width") != Query::Int(kWebGLCanvasWidth);
     query_end_swaps_ = query_instant_ &&
         Query::EventName() == Query::String("CompositorSwapBuffersComplete");
   } else if (mode_ == kSoftware) {
     // Software updates need to have x=0 and y=0 to contain the input color.
     query_begin_swaps_ = query_instant_ &&
         Query::EventName() == Query::String("UpdateRect") &&
         Query::EventArg("x+y") == Query::Int(0);
     query_end_swaps_ = query_instant_ &&
         Query::EventName() == Query::String("UpdateRectComplete") &&
         Query::EventArg("x+y") == Query::Int(0);
   }
   query_inputs_ = query_instant_ &&
       Query::EventName() == Query::String("MouseEventBegin");
   query_blits_ = query_instant_ &&
       Query::EventName() == Query::String("DoBlit") &&
       Query::EventArg("width") == Query::Int(kWebGLCanvasWidth);
   query_clears_ = query_instant_ &&
       Query::EventName() == Query::String("DoClear") &&
       Query::EventArg("green") == Query::Int(kClearColorGreen);
-  Query query_width_swaps = query_begin_swaps_;
-  if (mode_ == kSoftware) {
+  Query query_width_swaps = Query::Bool(false);
+  if (use_gpu_) {
+    query_width_swaps = query_begin_swaps_;
+  } else if (mode_ == kSoftware) {
     query_width_swaps = query_instant_ &&
         Query::EventName() == Query::String("UpdateRectWidth") &&
         Query::EventArg("width") > Query::Int(kWebGLCanvasWidth);
   }
 
   // Set path to test html.
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_path_));
   test_path_ = test_path_.Append(FILE_PATH_LITERAL("perf"));
   test_path_ = test_path_.Append(FILE_PATH_LITERAL("latency_suite.html"));
   ASSERT_TRUE(file_util::PathExists(test_path_))
@@ skipping 107 matching lines @@
   std::string json_events;
   ASSERT_TRUE(tracing::EndTracing(&json_events));
 
   analyzer_.reset(TraceAnalyzer::Create(json_events));
   analyzer_->AssociateBeginEndEvents();
   analyzer_->MergeAssociatedEventArgs();
 }
 
 double LatencyTest::CalculateLatency() {
   TraceEventVector events;
-  if (mode_ == kWebGL) {
+  if (use_gpu_) {
     // Search for three types of events in WebGL mode:
     //  - onscreen swaps.
     //  - DoClear calls that contain the mouse x coordinate.
     //  - mouse events.
     analyzer_->FindEvents(query_begin_swaps_ || query_end_swaps_ ||
                           query_inputs_ || query_blits_ || query_clears_,
                           &events);
   } else if (mode_ == kSoftware) {
     analyzer_->FindEvents(query_begin_swaps_ || query_end_swaps_ ||
                           query_inputs_, &events);
@@ skipping 17 matching lines @@
       ++swap_count;
       // Don't analyze first few swaps, because they are filling the rendering
       // pipeline and may be unstable.
       if (swap_count > kIgnoreBeginFrames) {
         // First, find the beginning of this swap.
         size_t begin_swap_pos = 0;
         EXPECT_TRUE(FindLastOf(events, query_begin_swaps_, end_swap_pos,
                                &begin_swap_pos));
 
         int mouse_x = 0;
-        if (mode_ == kWebGL) {
+        if (use_gpu_) {
           // Trace backwards through the events to find the input event that
           // matches the glClear that was presented by this SwapBuffers.
 
           // Step 1: Find the last blit (which will be the WebGL blit).
           size_t blit_pos = 0;
           EXPECT_TRUE(FindLastOf(events, query_blits_, begin_swap_pos,
                                  &blit_pos));
           // Skip this SwapBuffers if the blit has already been consumed by a
           // previous SwapBuffers. This means the current frame did not receive
           // an update from WebGL.
@@ skipping 158 matching lines @@
       printf("|\nframe %03d: ", swap_count + 1);
     } else if (is_software && events[i]->name == "UpdateRect") {
       ++swap_count;
       printf("(%d)|\nframe %03d: ",
               events[i]->GetKnownArgAsInt("color"), swap_count + 1);
     }
   }
   printf("\n");
 }
 
+// For running tests on GPU:
+class LatencyTestWebGL : public LatencyTest {
+ public:
+  LatencyTestWebGL() : LatencyTest(kWebGL) {}
+};
+
+// For running tests on GPU with the compositor thread:
+class LatencyTestWebGLThread : public LatencyTest {
+ public:
+  LatencyTestWebGLThread() : LatencyTest(kWebGLThread) {}
+};
+
+// For running tests on Software:
+class LatencyTestSW : public LatencyTest {
+ public:
+  LatencyTestSW() : LatencyTest(kSoftware) {}
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 /// Tests
 
 using ::testing::Values;
 
 // For manual testing only, run all input latency tests and print summary.
-IN_PROC_BROWSER_TEST_F(LatencyTest, DISABLED_LatencyWebGLAll) {
-  RunTest(kWebGL, GetAllBehaviors());
+IN_PROC_BROWSER_TEST_F(LatencyTestWebGL, DISABLED_LatencyWebGLAll) {
+  RunTest(GetAllBehaviors());
 }
 
 // For manual testing only, run all input latency tests and print summary.
-IN_PROC_BROWSER_TEST_F(LatencyTest, DISABLED_LatencySoftwareAll) {
-  RunTest(kSoftware, GetAllBehaviors());
+IN_PROC_BROWSER_TEST_F(LatencyTestWebGLThread, DISABLED_LatencyWebGLThreadAll) {
+  RunTest(GetAllBehaviors());
 }
 
-IN_PROC_BROWSER_TEST_P(LatencyTest, LatencySoftware) {
-  RunTest(kSoftware, std::vector<int>(1, GetParam()));
+// For manual testing only, run all input latency tests and print summary.
+IN_PROC_BROWSER_TEST_F(LatencyTestSW, DISABLED_LatencySoftwareAll) {
+  RunTest(GetAllBehaviors());
 }
 
-IN_PROC_BROWSER_TEST_P(LatencyTest, LatencyWebGL) {
-  RunTest(kWebGL, std::vector<int>(1, GetParam()));
+IN_PROC_BROWSER_TEST_P(LatencyTestWebGL, LatencyWebGL) {
+  RunTest(std::vector<int>(1, GetParam()));
 }
 
-INSTANTIATE_TEST_CASE_P(, LatencyTest, ::testing::Values(
-    0,
-    kInputHeavy,
-    kInputHeavy | kInputDirty | kRafHeavy,
-    kInputHeavy | kInputDirty | kRafHeavy | kPaintHeavy,
-    kInputDirty | kPaintHeavy,
-    kInputDirty | kRafHeavy | kPaintHeavy
-    ));
+IN_PROC_BROWSER_TEST_P(LatencyTestWebGLThread, LatencyWebGLThread) {
+  RunTest(std::vector<int>(1, GetParam()));
+}
+
+IN_PROC_BROWSER_TEST_P(LatencyTestSW, LatencySoftware) {
+  RunTest(std::vector<int>(1, GetParam()));
+}
+
+#define LATENCY_SUITE_MODES() ::testing::Values( \
+    0, \
+    kInputHeavy, \
+    kInputHeavy | kInputDirty | kRafHeavy, \
+    kInputHeavy | kInputDirty | kRafHeavy | kPaintHeavy, \
+    kInputDirty | kPaintHeavy, \
+    kInputDirty | kRafHeavy | kPaintHeavy)
+
+INSTANTIATE_TEST_CASE_P(, LatencyTestWebGL, LATENCY_SUITE_MODES());
+INSTANTIATE_TEST_CASE_P(, LatencyTestWebGLThread, LATENCY_SUITE_MODES());
+INSTANTIATE_TEST_CASE_P(, LatencyTestSW, LATENCY_SUITE_MODES());
 
 }  // namespace