cc serialization perf: Add a couple more tests

cc/ipc/cc_serialization_perftest.cc

 // Copyright 2013 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 <utility>
 
 #include "base/test/launcher/unit_test_launcher.h"
 #include "base/test/test_suite.h"
 #include "cc/ipc/cc_param_traits.h"
 #include "cc/ipc/compositor_frame.mojom.h"
@@ skipping 17 matching lines @@
 #include "ui/gfx/geometry/mojo/geometry_struct_traits.h"
 #include "ui/gfx/mojo/selection_bound_struct_traits.h"
 
 namespace cc {
 namespace {
 
 static const int kTimeLimitMillis = 2000;
 static const int kNumWarmupRuns = 20;
 static const int kTimeCheckInterval = 10;
 
+enum class UseSingleSharedQuadState { YES, NO };
+
 class CCSerializationPerfTest : public testing::Test {
  protected:
   static bool ReadMessage(const IPC::Message* msg, CompositorFrame* frame) {
     base::PickleIterator iter(*msg);
     return IPC::ParamTraits<CompositorFrame>::Read(msg, &iter, frame);
   }
 
   static void RunDeserializationTestParamTraits(const std::string& test_name,
                                                 const CompositorFrame& frame) {
     IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
@@ skipping 124 matching lines @@
     }
 
     perf_test::PrintResult(
         "StructTraits serialization min_frame_serialization_time", "",
         test_name, min_time.InMillisecondsF() / kTimeCheckInterval * 1000, "us",
         true);
     perf_test::PrintResult("StructTraits serialization: num runs in 2 seconds",
                            "", test_name, count, "", true);
   }
 
+  static void RunCompositorFrameTest(const std::string& test_name,
+                                     uint32_t num_quads,
+                                     uint32_t num_passes,
+                                     UseSingleSharedQuadState single_sqs) {
+    CompositorFrame frame;
+    frame.delegated_frame_data.reset(new DelegatedFrameData);
+
+    for (uint32_t i = 0; i < num_passes; ++i) {
+      std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+      render_pass->SetNew(RenderPassId(1, 1), gfx::Rect(), gfx::Rect(),
+                          gfx::Transform());
+      for (uint32_t j = 0; j < num_quads; ++j) {
+        if (j == 0 || single_sqs == UseSingleSharedQuadState::NO)
+          render_pass->CreateAndAppendSharedQuadState();
+        const gfx::Rect bounds(100, 100, 100, 100);
+        const bool kForceAntiAliasingOff = true;
+        SolidColorDrawQuad* quad =
+            render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
+        quad->SetNew(render_pass->shared_quad_state_list.back(), bounds, bounds,
+                     SK_ColorRED, kForceAntiAliasingOff);
+      }
+      frame.delegated_frame_data->render_pass_list.push_back(
+          std::move(render_pass));
+    }
+    RunTest(test_name, std::move(frame));
+  }
+
   static void RunTest(const std::string& test_name, CompositorFrame frame) {
     RunSerializationTestStructTraits(test_name, frame);
     RunDeserializationTestStructTraits(test_name, frame);
     RunSerializationTestParamTraits(test_name, frame);
     RunDeserializationTestParamTraits(test_name, frame);
   }
 };
 
 TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_1_4000) {
-  CompositorFrame frame;
-
-  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
-  render_pass->SetNew(RenderPassId(1, 1), gfx::Rect(), gfx::Rect(),
-                      gfx::Transform());
-  render_pass->CreateAndAppendSharedQuadState();
-  for (int i = 0; i < 4000; ++i) {
-    const gfx::Rect bounds(100, 100, 100, 100);
-    const bool kForceAntiAliasingOff = true;
-    SolidColorDrawQuad* quad =
-        render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-    quad->SetNew(render_pass->shared_quad_state_list.back(), bounds, bounds,
-                 SK_ColorRED, kForceAntiAliasingOff);
-  }
-
-  frame.delegated_frame_data.reset(new DelegatedFrameData);
-  frame.delegated_frame_data->render_pass_list.push_back(
-      std::move(render_pass));
-
-  RunTest("DelegatedFrame_ManyQuads_1_4000", std::move(frame));
+  RunCompositorFrameTest("DelegatedFrame_ManyQuads_1_4000", 4000, 1,
+                         UseSingleSharedQuadState::YES);
 }
 
 TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_1_100000) {
-  CompositorFrame frame;
-
-  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
-  render_pass->SetNew(RenderPassId(1, 1), gfx::Rect(), gfx::Rect(),
-                      gfx::Transform());
-  render_pass->CreateAndAppendSharedQuadState();
-  for (int i = 0; i < 100000; ++i) {
-    const gfx::Rect bounds(100, 100, 100, 100);
-    const bool kForceAntiAliasingOff = true;
-    SolidColorDrawQuad* quad =
-        render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-    quad->SetNew(render_pass->shared_quad_state_list.back(), bounds, bounds,
-                 SK_ColorRED, kForceAntiAliasingOff);
-  }
-
-  frame.delegated_frame_data.reset(new DelegatedFrameData);
-  frame.delegated_frame_data->render_pass_list.push_back(
-      std::move(render_pass));
-
-  RunTest("DelegatedFrame_ManyQuads_1_100000", std::move(frame));
+  RunCompositorFrameTest("DelegatedFrame_ManyQuads_1_100000", 100000, 1,
+                         UseSingleSharedQuadState::YES);
 }
 
 TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_4000_4000) {
-  CompositorFrame frame;
-
-  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
-  render_pass->SetNew(RenderPassId(1, 1), gfx::Rect(), gfx::Rect(),
-                      gfx::Transform());
-  for (int i = 0; i < 4000; ++i) {
-    const gfx::Rect bounds(100, 100, 100, 100);
-    const bool kForceAntiAliasingOff = true;
-    render_pass->CreateAndAppendSharedQuadState();
-    SolidColorDrawQuad* quad =
-        render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-    quad->SetNew(render_pass->shared_quad_state_list.back(), bounds, bounds,
-                 SK_ColorRED, kForceAntiAliasingOff);
-  }
-
-  frame.delegated_frame_data.reset(new DelegatedFrameData);
-  frame.delegated_frame_data->render_pass_list.push_back(
-      std::move(render_pass));
-
-  RunTest("DelegatedFrame_ManyQuads_4000_4000", std::move(frame));
+  RunCompositorFrameTest("DelegatedFrame_ManyQuads_4000_4000", 4000, 1,
+                         UseSingleSharedQuadState::NO);
 }
 
 TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_100000_100000) {
-  CompositorFrame frame;
+  RunCompositorFrameTest("DelegatedFrame_ManyQuads_100000_100000", 100000, 1,
+                         UseSingleSharedQuadState::NO);
+}
 
-  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
-  render_pass->SetNew(RenderPassId(1, 1), gfx::Rect(), gfx::Rect(),
-                      gfx::Transform());
-  for (int i = 0; i < 100000; ++i) {
-    render_pass->CreateAndAppendSharedQuadState();
-    const gfx::Rect bounds(100, 100, 100, 100);
-    const bool kForceAntiAliasingOff = true;
-    SolidColorDrawQuad* quad =
-        render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-    quad->SetNew(render_pass->shared_quad_state_list.back(), bounds, bounds,
-                 SK_ColorRED, kForceAntiAliasingOff);
-  }
+TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyRenderPasses_5_100) {
+  RunCompositorFrameTest("DelegatedFrame_ManyRenderPasses_5_100", 100, 5,
+                         UseSingleSharedQuadState::NO);
+}
 
-  frame.delegated_frame_data.reset(new DelegatedFrameData);
-  frame.delegated_frame_data->render_pass_list.push_back(
-      std::move(render_pass));
-
-  RunTest("DelegatedFrame_ManyQuads_100000_100000", std::move(frame));
+TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyRenderPasses_10_500) {
+  RunCompositorFrameTest("DelegatedFrame_ManyRenderPasses_10_500", 500, 10,
+                         UseSingleSharedQuadState::NO);
 }
 
 TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyRenderPasses_10000_100) {
-  CompositorFrame frame;
-  frame.delegated_frame_data.reset(new DelegatedFrameData);
-
-  for (int i = 0; i < 1000; ++i) {
-    std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
-    render_pass->SetNew(RenderPassId(1, 1), gfx::Rect(), gfx::Rect(),
-                        gfx::Transform());
-    for (int j = 0; j < 100; ++j) {
-      render_pass->CreateAndAppendSharedQuadState();
-      const gfx::Rect bounds(100, 100, 100, 100);
-      const bool kForceAntiAliasingOff = true;
-      SolidColorDrawQuad* quad =
-          render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-      quad->SetNew(render_pass->shared_quad_state_list.back(), bounds, bounds,
-                   SK_ColorRED, kForceAntiAliasingOff);
-    }
-    frame.delegated_frame_data->render_pass_list.push_back(
-        std::move(render_pass));
-  }
-
-  RunTest("DelegatedFrame_ManyRenderPasses_10000_100", std::move(frame));
+  RunCompositorFrameTest("DelegatedFrame_ManyRenderPasses_10000_100", 100, 1000,

[ajuma, 2016/07/28 20:06:29]

Should the constant here be 10000 rather than 1000 to match the name of the
test? (1000 does match the existing logic, but seems unexpected.)

[Fady Samuel, 2016/07/28 20:16:14]

Changed the name because I don't want to lose the test.

+                         UseSingleSharedQuadState::NO);
 }
 
 }  // namespace
 }  // namespace cc