cc::CompositorFrame: Implement ParamTraits vs. StructTraits perf test

cc/ipc/cc_serialization_perftest.cc

Index: cc/ipc/cc_serialization_perftest.cc
diff --git a/cc/ipc/cc_serialization_perftest.cc b/cc/ipc/cc_serialization_perftest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..cad089477775a5c42317a6cecc98105f60261ee9
--- /dev/null
+++ b/cc/ipc/cc_serialization_perftest.cc
@@ -0,0 +1,217 @@
+// 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"
+#include "cc/ipc/compositor_frame_metadata_struct_traits.h"
+#include "cc/ipc/compositor_frame_struct_traits.h"
+#include "cc/ipc/render_pass_struct_traits.h"
+#include "cc/ipc/selection_struct_traits.h"
+#include "cc/ipc/shared_quad_state_struct_traits.h"
+#include "cc/ipc/surface_id_struct_traits.h"
+#include "cc/ipc/transferable_resource_struct_traits.h"
+#include "cc/output/compositor_frame.h"
+#include "cc/quads/picture_draw_quad.h"
+#include "gpu/ipc/common/mailbox_holder_struct_traits.h"
+#include "gpu/ipc/common/mailbox_struct_traits.h"
+#include "gpu/ipc/common/sync_token_struct_traits.h"
+#include "ipc/ipc_message.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/perf/perf_test.h"
+#include "ui/events/mojo/latency_info_struct_traits.h"
+#include "ui/gfx/geometry/mojo/geometry.mojom.h"
+#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;
+
+class CCSerializationPerfTest : public testing::Test {
+ protected:
+  static void RunTestParamTraits(const std::string& test_name,
+                                 const CompositorFrame& frame) {
+    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::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);
+        ++count;
+      }
+
+      base::TimeTicks now = base::TimeTicks::Now();
+      if (now - start < min_time || min_time.is_zero())
+        min_time = now - start;
+      start = base::TimeTicks::Now();
+    }
+
+    perf_test::PrintResult(
+        "ParamTraits: min_frame_serialization_time", "", test_name,
+        min_time.InMillisecondsF() / kTimeCheckInterval * 1000, "us", true);
+    perf_test::PrintResult("ParamTraits: num runs in 2 seconds", "", test_name,
+                           count, "", true);
+  }
+
+  static void RunTestStructTraits(const std::string& test_name,
+                                  const CompositorFrame& frame) {
+    for (int i = 0; i < kNumWarmupRuns; ++i) {
+      mojo::Array<uint8_t> 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::TimeDelta min_time;
+    size_t count = 0;
+    while (start < end) {
+      for (int i = 0; i < kTimeCheckInterval; ++i) {
+        mojo::Array<uint8_t> data = mojom::CompositorFrame::Serialize(&frame);
+        DCHECK_GT(data.size(), 0u);
+        ++count;
+      }
+
+      base::TimeTicks now = base::TimeTicks::Now();
+      if (now - start < min_time || min_time.is_zero())
+        min_time = now - start;
+      start = base::TimeTicks::Now();
+    }
+
+    perf_test::PrintResult(
+        "StructTraits min_frame_serialization_time", "", test_name,
+        min_time.InMillisecondsF() / kTimeCheckInterval * 1000, "us", true);
+    perf_test::PrintResult("StructTraits: num runs in 2 seconds", "", test_name,
+                           count, "", true);
+  }
+
+  static void RunTest(const std::string& test_name, CompositorFrame frame) {
+    RunTestStructTraits(test_name, frame);
+    RunTestParamTraits(test_name, frame);
+  }
+};
+
+TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_1_4000) {
+  CompositorFrame frame;
+
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+  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));
+}
+
+TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_1_100000) {
+  CompositorFrame frame;
+
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+  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));
+}
+
+TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_4000_4000) {
+  CompositorFrame frame;
+
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+  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));
+}
+
+TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_100000_100000) {
+  CompositorFrame frame;
+
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+  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);
+  }
+
+  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_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();
+    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));
+}
+
+}  // namespace
+}  // namespace cc