IPC pickling optimization for render passes.

Call Pickle::Reserve() for the size of the data in the shared quad
state and quad lists. This prevents the WriteFoo() invocations for
all of the quad/shared quad states from causing memory re-allocations
and moves.

This is based on https://codereview.chromium.org/34413002/ from piman@.

This is also based after https://codereview.chromium.org/30593005/ and
perf numbers (both before and after) include that CL also.

content_perftest results on linux chromeos release official build:

BEFORE
*RESULT mean_frame_serialization_time: DelegatedFrame_ManyQuads_1_4000= 50 us
*RESULT mean_frame_serialization_time: DelegatedFrame_ManyQuads_1_100000= 1888 us
*RESULT mean_frame_serialization_time: DelegatedFrame_ManyQuads_4000_4000= 728 us
*RESULT mean_frame_serialization_time: DelegatedFrame_ManyQuads_100000_100000= 23771 us
*RESULT mean_frame_serialization_time: DelegatedFrame_ManyRenderPasses_10000_100= 24118 us

AFTER
*RESULT mean_frame_serialization_time: DelegatedFrame_ManyQuads_1_4000= 48 us
*RESULT mean_frame_serialization_time: DelegatedFrame_ManyQuads_1_100000= 1626 us
*RESULT mean_frame_serialization_time: DelegatedFrame_ManyQuads_4000_4000= 460 us
*RESULT mean_frame_serialization_time: DelegatedFrame_ManyQuads_100000_100000= 14771 us
*RESULT mean_frame_serialization_time: DelegatedFrame_ManyRenderPasses_10000_100= 15626 us

This gives a further ~1.5x improvement in serialization time for shared quad
states and render passes.

R=jar@chromium.org, piman@chromium.org, tsepez@chromium.org, piman
BUG=307480

Review URL: https://codereview.chromium.org/35893002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@231656 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 72 insertions, 0 deletions

diff --git a/content/common/cc_messages.cc b/content/common/cc_messages.cc
index d27446a..8b54af2 100644
--- a/content/common/cc_messages.cc
+++ b/content/common/cc_messages.cc
@@ -369,6 +369,19 @@ void ParamTraits<cc::RenderPass>::Write(
   }
 }
 
+static size_t ReserveSizeForRenderPassWrite(const cc::RenderPass& p) {
+  size_t to_reserve = sizeof(cc::RenderPass);
+
+  to_reserve += p.shared_quad_state_list.size() * sizeof(cc::SharedQuadState);
+
+  // The shared_quad_state_index for each quad.
+  to_reserve += p.quad_list.size() * sizeof(size_t);
+
+  // The largest quad type, verified by a unit test.
+  to_reserve += p.quad_list.size() * sizeof(cc::RenderPassDrawQuad);
+  return to_reserve;
+}
+
 template<typename QuadType>
 static scoped_ptr<cc::DrawQuad> ReadDrawQuad(const Message* m,
                                              PickleIterator* iter) {
@@ -680,6 +693,14 @@ void ParamTraits<cc::CompositorFrameAck>::Log(const param_type& p,
 void ParamTraits<cc::DelegatedFrameData>::Write(Message* m,
                                                 const param_type& p) {
   DCHECK_NE(0u, p.render_pass_list.size());
+
+  size_t to_reserve = p.resource_list.size() * sizeof(cc::TransferableResource);
+  for (size_t i = 0; i < p.render_pass_list.size(); ++i) {
+    const cc::RenderPass* pass = p.render_pass_list[i];
+    to_reserve += ReserveSizeForRenderPassWrite(*pass);
+  }
+  m->Reserve(to_reserve);
+
   WriteParam(m, p.resource_list);
   WriteParam(m, p.render_pass_list.size());
   for (size_t i = 0; i < p.render_pass_list.size(); ++i)
diff --git a/content/common/cc_messages_unittest.cc b/content/common/cc_messages_unittest.cc
index 9b97b38..2c5637a 100644
--- a/content/common/cc_messages_unittest.cc
+++ b/content/common/cc_messages_unittest.cc
@@ -6,6 +6,8 @@
 
 #include <string.h>
 
+#include <algorithm>
+
 #include "base/command_line.h"
 #include "cc/output/compositor_frame.h"
 #include "content/public/common/content_switches.h"
@@ -555,5 +557,54 @@ TEST_F(CCMessagesTest, Resources) {
   Compare(arbitrary_resource2, frame_out.resource_list[1]);
 }
 
+TEST_F(CCMessagesTest, LargestQuadType) {
+  size_t largest = 0;
+
+  bool done = false;
+  for (int i = 0; !done; ++i) {
+    switch (static_cast<DrawQuad::Material>(i)) {
+      case cc::DrawQuad::CHECKERBOARD:
+        largest = std::max(largest, sizeof(cc::CheckerboardDrawQuad));
+        break;
+      case cc::DrawQuad::DEBUG_BORDER:
+        largest = std::max(largest, sizeof(cc::DebugBorderDrawQuad));
+        break;
+      case cc::DrawQuad::IO_SURFACE_CONTENT:
+        largest = std::max(largest, sizeof(cc::IOSurfaceDrawQuad));
+        break;
+      case cc::DrawQuad::PICTURE_CONTENT:
+        largest = std::max(largest, sizeof(cc::PictureDrawQuad));
+        break;
+      case cc::DrawQuad::TEXTURE_CONTENT:
+        largest = std::max(largest, sizeof(cc::TextureDrawQuad));
+        break;
+      case cc::DrawQuad::RENDER_PASS:
+        largest = std::max(largest, sizeof(cc::RenderPassDrawQuad));
+        break;
+      case cc::DrawQuad::SOLID_COLOR:
+        largest = std::max(largest, sizeof(cc::SolidColorDrawQuad));
+        break;
+      case cc::DrawQuad::TILED_CONTENT:
+        largest = std::max(largest, sizeof(cc::TileDrawQuad));
+        break;
+      case cc::DrawQuad::STREAM_VIDEO_CONTENT:
+        largest = std::max(largest, sizeof(cc::StreamVideoDrawQuad));
+        break;
+      case cc::DrawQuad::YUV_VIDEO_CONTENT:
+        largest = std::max(largest, sizeof(cc::YUVVideoDrawQuad));
+        break;
+      case cc::DrawQuad::INVALID:
+        break;
+      default:
+        done = true;
+    }
+  }
+
+  // Verify the largest DrawQuad type is RenderPassDrawQuad. If this ever
+  // changes, then the ReserveSizeForRenderPassWrite() method needs to be
+  // updated as well to use the new largest quad.
+  EXPECT_EQ(sizeof(RenderPassDrawQuad), largest);
+}
+
 }  // namespace
 }  // namespace content