From 032bfc439fbac7f08f562d6914b960008ce64bd4 Mon Sep 17 00:00:00 2001 From: "danakj@chromium.org" Date: Tue, 29 Oct 2013 22:23:52 +0000 Subject: 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 --- content/common/cc_messages.cc | 21 ++++++++++++++ content/common/cc_messages_unittest.cc | 51 ++++++++++++++++++++++++++++++++++ 2 files changed, 72 insertions(+) (limited to 'content') 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::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 static scoped_ptr ReadDrawQuad(const Message* m, PickleIterator* iter) { @@ -680,6 +693,14 @@ void ParamTraits::Log(const param_type& p, void ParamTraits::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 +#include + #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(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 -- cgit v1.1