cc: Add more seriliazation perf test cases

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 26 matching lines @@
 
 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) {
+  static void RunDeserializationTestParamTraits(
+      const std::string& test_name,
+      const CompositorFrame& frame,
+      UseSingleSharedQuadState single_sqs) {
     IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
     IPC::ParamTraits<CompositorFrame>::Write(&msg, frame);
     for (int i = 0; i < kNumWarmupRuns; ++i) {
       CompositorFrame compositor_frame;
       ReadMessage(&msg, &compositor_frame);
     }
 
     base::TimeTicks start = base::TimeTicks::Now();
     base::TimeTicks end =
         start + base::TimeDelta::FromMilliseconds(kTimeLimitMillis);
     base::TimeTicks now = start;
     base::TimeDelta min_time;
     size_t count = 0;
     while (start < end) {
       for (int i = 0; i < kTimeCheckInterval; ++i) {
         CompositorFrame compositor_frame;
         ReadMessage(&msg, &compositor_frame);
         now = base::TimeTicks::Now();
         // We don't count iterations after the end time.
         if (now < end)
           ++count;
       }
 
       if (now - start < min_time || min_time.is_zero())
         min_time = now - start;
       start = now;
     }
 
     perf_test::PrintResult(
-        "ParamTraits deserialization: min_frame_deserialization_time", "",
+        "ParamTraits deserialization: min_frame_deserialization_time",
+        single_sqs == UseSingleSharedQuadState::YES
+            ? "_per_render_pass_shared_quad_state"
+            : "_per_quad_shared_quad_state",
         test_name, min_time.InMillisecondsF() / kTimeCheckInterval * 1000, "us",
         true);
     perf_test::PrintResult("ParamTraits deserialization: num runs in 2 seconds",
-                           "", test_name, count, "", true);
+                           single_sqs == UseSingleSharedQuadState::YES
+                               ? "_per_render_pass_shared_quad_state"
+                               : "_per_quad_shared_quad_state",
+                           test_name, count, "", true);
   }
 
-  static void RunSerializationTestParamTraits(const std::string& test_name,
-                                              const CompositorFrame& frame) {
+  static void RunSerializationTestParamTraits(
+      const std::string& test_name,
+      const CompositorFrame& frame,
+      UseSingleSharedQuadState single_sqs) {
     for (int i = 0; i < kNumWarmupRuns; ++i) {
       IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
       IPC::ParamTraits<CompositorFrame>::Write(&msg, frame);
     }
 
     base::TimeTicks start = base::TimeTicks::Now();
     base::TimeTicks end =
         start + base::TimeDelta::FromMilliseconds(kTimeLimitMillis);
     base::TimeTicks now = start;
     base::TimeDelta min_time;
     size_t count = 0;
     while (start < end) {
       for (int i = 0; i < kTimeCheckInterval; ++i) {
         IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
         IPC::ParamTraits<CompositorFrame>::Write(&msg, frame);
         now = base::TimeTicks::Now();
         // We don't count iterations after the end time.
         if (now < end)
           ++count;
       }
 
       if (now - start < min_time || min_time.is_zero())
         min_time = now - start;
       start = now;
     }
 
     perf_test::PrintResult(
-        "ParamTraits serialization: min_frame_serialization_time", "",
+        "ParamTraits serialization: min_frame_serialization_time",
+        single_sqs == UseSingleSharedQuadState::YES
+            ? "_per_render_pass_shared_quad_state"
+            : "_per_quad_shared_quad_state",
         test_name, min_time.InMillisecondsF() / kTimeCheckInterval * 1000, "us",
         true);
     perf_test::PrintResult("ParamTraits serialization: num runs in 2 seconds",
-                           "", test_name, count, "", true);
+                           single_sqs == UseSingleSharedQuadState::YES
+                               ? "_per_render_pass_shared_quad_state"
+                               : "_per_quad_shared_quad_state",
+                           test_name, count, "", true);
   }
 
-  static void RunDeserializationTestStructTraits(const std::string& test_name,
-                                                 const CompositorFrame& frame) {
+  static void RunDeserializationTestStructTraits(
+      const std::string& test_name,
+      const CompositorFrame& frame,
+      UseSingleSharedQuadState single_sqs) {
     auto data = mojom::CompositorFrame::Serialize(&frame);
     DCHECK_GT(data.size(), 0u);
     for (int i = 0; i < kNumWarmupRuns; ++i) {
       CompositorFrame compositor_frame;
       mojom::CompositorFrame::Deserialize(data, &compositor_frame);
     }
 
     base::TimeTicks start = base::TimeTicks::Now();
     base::TimeTicks end =
         start + base::TimeDelta::FromMilliseconds(kTimeLimitMillis);
     base::TimeTicks now = start;
     base::TimeDelta min_time;
     size_t count = 0;
     while (start < end) {
       for (int i = 0; i < kTimeCheckInterval; ++i) {
         CompositorFrame compositor_frame;
         mojom::CompositorFrame::Deserialize(data, &compositor_frame);
         now = base::TimeTicks::Now();
         // We don't count iterations after the end time.
         if (now < end)
           ++count;
       }
 
       if (now - start < min_time || min_time.is_zero())
         min_time = now - start;
       start = now;
     }
 
     perf_test::PrintResult(
-        "StructTraits deserialization min_frame_deserialization_time", "",
+        "StructTraits deserialization min_frame_deserialization_time",
+        single_sqs == UseSingleSharedQuadState::YES
+            ? "_per_render_pass_shared_quad_state"
+            : "_per_quad_shared_quad_state",
         test_name, min_time.InMillisecondsF() / kTimeCheckInterval * 1000, "us",
         true);
     perf_test::PrintResult(
-        "StructTraits deserialization: num runs in 2 seconds", "", test_name,
-        count, "", true);
+        "StructTraits deserialization: num runs in 2 seconds",
+        single_sqs == UseSingleSharedQuadState::YES
+            ? "_per_render_pass_shared_quad_state"
+            : "_per_quad_shared_quad_state",
+        test_name, count, "", true);
   }
 
-  static void RunSerializationTestStructTraits(const std::string& test_name,
-                                               const CompositorFrame& frame) {
+  static void RunSerializationTestStructTraits(
+      const std::string& test_name,
+      const CompositorFrame& frame,
+      UseSingleSharedQuadState single_sqs) {
     for (int i = 0; i < kNumWarmupRuns; ++i) {
       auto data = mojom::CompositorFrame::Serialize(&frame);
       DCHECK_GT(data.size(), 0u);
     }
 
     base::TimeTicks start = base::TimeTicks::Now();
     base::TimeTicks end =
         start + base::TimeDelta::FromMilliseconds(kTimeLimitMillis);
     base::TimeTicks now = start;
     base::TimeDelta min_time;
     size_t count = 0;
     while (start < end) {
       for (int i = 0; i < kTimeCheckInterval; ++i) {
         auto data = mojom::CompositorFrame::Serialize(&frame);
         DCHECK_GT(data.size(), 0u);
         now = base::TimeTicks::Now();
         // We don't count iterations after the end time.
         if (now < end)
           ++count;
       }
 
       if (now - start < min_time || min_time.is_zero())
         min_time = now - start;
       start = now;
     }
 
     perf_test::PrintResult(
-        "StructTraits serialization min_frame_serialization_time", "",
+        "StructTraits serialization min_frame_serialization_time",
+        single_sqs == UseSingleSharedQuadState::YES
+            ? "_per_render_pass_shared_quad_state"
+            : "_per_quad_shared_quad_state",
         test_name, min_time.InMillisecondsF() / kTimeCheckInterval * 1000, "us",
         true);
     perf_test::PrintResult("StructTraits serialization: num runs in 2 seconds",
-                           "", test_name, count, "", true);
+                           single_sqs == UseSingleSharedQuadState::YES
+                               ? "_per_render_pass_shared_quad_state"
+                               : "_per_quad_shared_quad_state",
+                           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;
 
     for (uint32_t i = 0; i < num_passes; ++i) {
       std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
       render_pass->SetNew(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.render_pass_list.push_back(std::move(render_pass));
     }
-    RunTest(test_name, std::move(frame));
+    RunTest(test_name, std::move(frame), single_sqs);
   }
 
-  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);
+  static void RunTest(const std::string& test_name,
+                      CompositorFrame frame,
+                      UseSingleSharedQuadState single_sqs) {
+    RunSerializationTestStructTraits(test_name, frame, single_sqs);
+    RunDeserializationTestStructTraits(test_name, frame, single_sqs);
+    RunSerializationTestParamTraits(test_name, frame, single_sqs);
+    RunDeserializationTestParamTraits(test_name, frame, single_sqs);
   }
 };
 
+// Test for compositor frames with one render pass and 4000 quads.
 TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_1_4000) {
+  // Case 1: One shared quad state for all quads in one render pass.
   RunCompositorFrameTest("DelegatedFrame_ManyQuads_1_4000", 4000, 1,
                          UseSingleSharedQuadState::YES);
+  // Case 2: One shared quad state for each quad.
+  RunCompositorFrameTest("DelegatedFrame_ManyQuads_1_4000", 4000, 1,
+                         UseSingleSharedQuadState::NO);
+}
+
+// Test for compositor frames with one render pass and 100000 quads.
+TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_1_100000) {
+  // Case 1: One shared quad state for all quads in one render pass.
+  RunCompositorFrameTest("DelegatedFrame_ManyQuads_1_100000", 100000, 1,
+                         UseSingleSharedQuadState::YES);
+  // Case 2: One shared quad state for each quad.
+  RunCompositorFrameTest("DelegatedFrame_ManyQuads_1_100000", 100000, 1,
+                         UseSingleSharedQuadState::NO);
+}
+
+// Test for compositor frames with 100 render pass and each with 4000 quads.
+TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_100_4000) {
+  // One shared quad state for all quads in one render pass.
+  RunCompositorFrameTest("DelegatedFrame_ManyQuads_100_4000", 4000, 100,
+                         UseSingleSharedQuadState::YES);
 }
 
-TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_1_100000) {
-  RunCompositorFrameTest("DelegatedFrame_ManyQuads_1_100000", 100000, 1,
+// Test for compositor frames with 10 render pass and each with 100000 quads.
+TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_10_100000) {
+  // One shared quad state for all quads in one render pass.
+  RunCompositorFrameTest("DelegatedFrame_ManyQuads_10_100000", 100000, 10,
                          UseSingleSharedQuadState::YES);
 }
 
-TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_4000_4000) {
-  RunCompositorFrameTest("DelegatedFrame_ManyQuads_4000_4000", 4000, 1,
-                         UseSingleSharedQuadState::NO);
-}
-
-TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_100000_100000) {
-  RunCompositorFrameTest("DelegatedFrame_ManyQuads_100000_100000", 100000, 1,
-                         UseSingleSharedQuadState::NO);
-}
-
+// Test for compositor frames with 5 render pass and each with 100 quads.
 TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyRenderPasses_5_100) {
+  // Case 1: One shared quad state for all quads in one render pass.
+  RunCompositorFrameTest("DelegatedFrame_ManyRenderPasses_5_100", 100, 5,
+                         UseSingleSharedQuadState::YES);
+  // Case 2: One shared quad state for each quad.
   RunCompositorFrameTest("DelegatedFrame_ManyRenderPasses_5_100", 100, 5,
                          UseSingleSharedQuadState::NO);
 }
 
+// Test for compositor frames with 10 render pass and each with 500 quads.
 TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyRenderPasses_10_500) {
+  // Case 1: One shared quad state for all quads in one render pass.
+  RunCompositorFrameTest("DelegatedFrame_ManyRenderPasses_10_500", 500, 10,
+                         UseSingleSharedQuadState::YES);
+  // Case 2: One shared quad state for each quad.
   RunCompositorFrameTest("DelegatedFrame_ManyRenderPasses_10_500", 500, 10,
                          UseSingleSharedQuadState::NO);
 }
 
+// Test for compositor frames with 1000 render pass and each with 100 quads.
 TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyRenderPasses_1000_100) {
-  RunCompositorFrameTest("DelegatedFrame_ManyRenderPasses_10000_100", 100, 1000,
+  // Case 1: One shared quad state for all quads in one render pass.
+  RunCompositorFrameTest("DelegatedFrame_ManyRenderPasses_1000_100", 100, 1000,
+                         UseSingleSharedQuadState::YES);
+  // Case 2: One shared quad state for each quad.
+  RunCompositorFrameTest("DelegatedFrame_ManyRenderPasses_1000_100", 100, 1000,
                          UseSingleSharedQuadState::NO);
 }
 
 }  // namespace
 }  // namespace cc