Make latency tests measure until the end of swap buffers.

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 89 matching lines @@
 const int kMinimumFramesForAnalysis = 5;
 
 class LatencyTest
     : public BrowserPerfTest,
       public ::testing::WithParamInterface<int> {
  public:
   LatencyTest() :
       query_instant_(Query::EventPhase() ==
                      Query::Phase(TRACE_EVENT_PHASE_INSTANT)),
       // These queries are initialized in RunTest.
-      query_swaps_(Query::Bool(false)),
+      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),
       delay_time_us_(0),
       num_frames_(0),
       verbose_(false),
       test_flags_(0) {}
@@ skipping 37 matching lines @@
   void SendInput();
 
   void PrintEvents(const TraceEventVector& events);
 
   // Path to html file.
   FilePath test_path_;
 
   // Query INSTANT events.
   Query query_instant_;
 
-  // Query "swaps" which is SwapBuffers for GL and UpdateRect for software.
-  Query query_swaps_;
+  // Query begin of "swaps" which is SwapBuffers for GL and UpdateRect for
+  // software.
+  Query query_begin_swaps_;
+
+  // Query end of "swaps" which is SwapBuffers for GL and UpdateRect for
+  // software.
+  Query query_end_swaps_;
 
   // Query mouse input entry events in browser process (ForwardMouseEvent).
   Query query_inputs_;
 
   // Query GL blits for the WebGL canvas -- represents the compositor consuming
   // the WebGL contents for display.
   Query query_blits_;
 
   // Query glClear calls with mouse coordinate as clear color.
   Query query_clears_;
@@ skipping 52 matching lines @@
   return behaviors;
 }
 
 void LatencyTest::RunTest(LatencyTestMode mode,
                           const std::vector<int>& behaviors) {
   mode_ = mode;
   verbose_ = (logging::GetVlogLevel("latency_tests") > 0);
 
   // Construct queries for searching trace events via TraceAnalyzer.
   if (mode_ == kWebGL) {
-    query_swaps_ = query_instant_ &&
+    query_begin_swaps_ = query_instant_ &&
         Query::EventName() == Query::String("SwapBuffers") &&
         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_swaps_ = query_instant_ &&
+    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_swaps_;
+  Query query_width_swaps = query_begin_swaps_;
   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"));
@@ skipping 113 matching lines @@
   analyzer_->MergeAssociatedEventArgs();
 }
 
 double LatencyTest::CalculateLatency() {
   TraceEventVector events;
   if (mode_ == kWebGL) {
     // Search for three types of events in WebGL mode:
     //  - onscreen swaps.
     //  - DoClear calls that contain the mouse x coordinate.
     //  - mouse events.
-    analyzer_->FindEvents(query_swaps_ || query_inputs_ ||
-                          query_blits_ || query_clears_, &events);
+    analyzer_->FindEvents(query_begin_swaps_ || query_end_swaps_ ||
+                          query_inputs_ || query_blits_ || query_clears_,
+                          &events);
   } else if (mode_ == kSoftware) {
-    analyzer_->FindEvents(query_swaps_ || query_inputs_, &events);
+    analyzer_->FindEvents(query_begin_swaps_ || query_end_swaps_ ||
+                          query_inputs_, &events);
   } else {
     NOTREACHED() << "invalid mode";
   }
 
   if (verbose_)
     PrintEvents(events);
 
   int swap_count = 0;
   size_t previous_blit_pos = 0;
   swap_count = 0;
   std::vector<int> latencies;
   printf("Measured latency (in number of frames) for each frame:\n");
   for (size_t i = 0; i < events.size(); ++i) {
-    if (query_swaps_.Evaluate(*events[i])) {
+    if (query_end_swaps_.Evaluate(*events[i])) {
+      size_t end_swap_pos = i;
+
       // Compositor context swap buffers.
       ++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) {
           // 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_, i, &blit_pos));
+          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.
           EXPECT_GT(blit_pos, previous_blit_pos);
           if (blit_pos == previous_blit_pos) {
             if (verbose_)
               printf(" %03d: ERROR\n", swap_count);
             else
               printf(" ERROR");
             continue;
           }
           previous_blit_pos = blit_pos;
 
           // Step 2: find the last clear from the WebGL blit. This will be the
           // value of the latest mouse input that has affected this swap.
           size_t clear_pos = 0;
           EXPECT_TRUE(FindLastOf(events, query_clears_, blit_pos, &clear_pos));
           mouse_x = events[clear_pos]->GetKnownArgAsInt("red");
         } else if (mode_ == kSoftware) {
           // The software path gets the mouse_x directly from the DIB colors.
-          mouse_x = events[i]->GetKnownArgAsInt("color");
+          mouse_x = events[begin_swap_pos]->GetKnownArgAsInt("color");
         }
 
         // Find the corresponding mouse input.
         size_t input_pos = 0;
         Query query_mouse_event = query_inputs_ &&
             Query::EventArg("x") == Query::Int(mouse_x);
-        EXPECT_TRUE(FindLastOf(events, query_mouse_event, i, &input_pos));
+        EXPECT_TRUE(FindLastOf(events, query_mouse_event, begin_swap_pos,
+                               &input_pos));
 
         // Step 4: Find the nearest onscreen SwapBuffers to this input event.
-        size_t closest_swap = 0;
+        size_t closest_swap_to_input = 0;
         size_t second_closest_swap = 0;
-        EXPECT_TRUE(FindClosest(events, query_swaps_, input_pos,
-                                       &closest_swap, &second_closest_swap));
-        int latency = CountMatches(events, query_swaps_, closest_swap, i);
+        EXPECT_TRUE(FindClosest(events, query_end_swaps_, input_pos,
+                                &closest_swap_to_input, &second_closest_swap));
+
+        // Calculate latency by counting the number of swaps between the input
+        // event and the corresponding on-screen end-of-swap.
+        int latency = CountMatches(events, query_end_swaps_,
+                                   closest_swap_to_input, end_swap_pos);
         latencies.push_back(latency);
         if (verbose_)
           printf(" %03d: %d\n", swap_count, latency);
         else
           printf(" %d", latency);
       }
     }
   }
   printf("\n");
 
@@ skipping 61 matching lines @@
   test_url += "&canvasWidth=" + base::IntToString(kWebGLCanvasWidth);
   test_url += "&clearColorGreen=" + base::IntToString(kClearColorGreen);
   test_url += "&delayTimeMS=" + base::IntToString(delay_time_us_ / 1000);
   test_url += "&y=" + base::IntToString(kMouseY);
   return test_url + GetUrlModeString(flags);
 }
 
 void LatencyTest::GetMeanFrameTimeMicros(int* frame_time) const {
   TraceEventVector events;
   // Search for compositor swaps (or UpdateRects in the software path).
-  analyzer_->FindEvents(query_swaps_, &events);
+  analyzer_->FindEvents(query_end_swaps_, &events);
   RateStats stats;
   ASSERT_TRUE(GetRateStats(events, &stats, NULL));
 
   // Check that the number of swaps is close to kNumFrames.
   EXPECT_LT(num_frames_ - num_frames_ / 4, static_cast<int>(events.size()));
   *frame_time = static_cast<int>(stats.mean_us);
 }
 
 void LatencyTest::SendInput() {
   content::RenderViewHost* rvh = browser()->GetSelectedTabContentsWrapper()->
@@ skipping 63 matching lines @@
 INSTANTIATE_TEST_CASE_P(, LatencyTest, ::testing::Values(
     0,
     kInputHeavy,
     kInputHeavy | kInputDirty | kRafHeavy,
     kInputHeavy | kInputDirty | kRafHeavy | kPaintHeavy,
     kInputDirty | kPaintHeavy,
     kInputDirty | kRafHeavy | kPaintHeavy
     ));
 
 }  // namespace