content/common/cc_messages_perftest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/common/cc_messages.h"
   6
   7 #include "base/test/launcher/unit_test_launcher.h"
   8 #include "base/test/test_suite.h"
   9 #include "cc/output/compositor_frame.h"
  10 #include "ipc/ipc_message.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12 #include "testing/perf/perf_test.h"
  13
  14 using cc::CompositorFrame;
  15 using cc::DelegatedFrameData;
  16 using cc::DrawQuad;
  17 using cc::PictureDrawQuad;
  18 using cc::RenderPass;
  19 using cc::SharedQuadState;
  20
  21 namespace content {
  22 namespace {
  23
  24 static const int kTimeLimitMillis = 2000;
  25 static const int kNumWarmupRuns = 20;
  26 static const int kTimeCheckInterval = 10;
  27
  28 class CCMessagesPerfTest : public testing::Test {
  29  protected:
  30   static void RunTest(std::string test_name, const CompositorFrame& frame) {
  31     for (int i = 0; i < kNumWarmupRuns; ++i) {
  32       IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
  33       IPC::ParamTraits<CompositorFrame>::Write(&msg, frame);
  34     }
  35
  36     base::TimeTicks start = base::TimeTicks::Now();
  37     base::TimeTicks end =
  38         start + base::TimeDelta::FromMilliseconds(kTimeLimitMillis);
  39     base::TimeDelta min_time;
  40     int count = 0;
  41     while (start < end) {
  42       for (int i = 0; i < kTimeCheckInterval; ++i) {
  43         IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
  44         IPC::ParamTraits<CompositorFrame>::Write(&msg, frame);
  45         ++count;
  46       }
  47
  48       base::TimeTicks now = base::TimeTicks::Now();
  49       if (now - start < min_time || min_time == base::TimeDelta())
  50         min_time = now - start;
  51       start = base::TimeTicks::Now();
  52     }
  53
  54     perf_test::PrintResult(
  55         "min_frame_serialization_time",
  56         "",
  57         test_name,
  58         min_time.InMillisecondsF() / kTimeCheckInterval * 1000,
  59         "us",
  60         true);
  61   }
  62 };
  63
  64 TEST_F(CCMessagesPerfTest, DelegatedFrame_ManyQuads_1_4000) {
  65   scoped_ptr<CompositorFrame> frame(new CompositorFrame);
  66
  67   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
  68   render_pass->CreateAndAppendSharedQuadState();
  69   for (int i = 0; i < 4000; ++i) {
  70     PictureDrawQuad* quad =
  71         render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
  72     quad->shared_quad_state = render_pass->shared_quad_state_list.back();
  73   }
  74
  75   frame->delegated_frame_data.reset(new DelegatedFrameData);
  76   frame->delegated_frame_data->render_pass_list.push_back(render_pass.Pass());
  77
  78   RunTest("DelegatedFrame_ManyQuads_1_4000", *frame);
  79 }
  80
  81 TEST_F(CCMessagesPerfTest, DelegatedFrame_ManyQuads_1_100000) {
  82   scoped_ptr<CompositorFrame> frame(new CompositorFrame);
  83
  84   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
  85   render_pass->CreateAndAppendSharedQuadState();
  86   for (int i = 0; i < 100000; ++i) {
  87     PictureDrawQuad* quad =
  88         render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
  89     quad->shared_quad_state = render_pass->shared_quad_state_list.back();
  90   }
  91
  92   frame->delegated_frame_data.reset(new DelegatedFrameData);
  93   frame->delegated_frame_data->render_pass_list.push_back(render_pass.Pass());
  94
  95   RunTest("DelegatedFrame_ManyQuads_1_100000", *frame);
  96 }
  97
  98 TEST_F(CCMessagesPerfTest, DelegatedFrame_ManyQuads_4000_4000) {
  99   scoped_ptr<CompositorFrame> frame(new CompositorFrame);
 100
 101   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 102   for (int i = 0; i < 4000; ++i) {
 103     render_pass->CreateAndAppendSharedQuadState();
 104     PictureDrawQuad* quad =
 105         render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
 106     quad->shared_quad_state = render_pass->shared_quad_state_list.back();
 107   }
 108
 109   frame->delegated_frame_data.reset(new DelegatedFrameData);
 110   frame->delegated_frame_data->render_pass_list.push_back(render_pass.Pass());
 111
 112   RunTest("DelegatedFrame_ManyQuads_4000_4000", *frame);
 113 }
 114
 115 TEST_F(CCMessagesPerfTest, DelegatedFrame_ManyQuads_100000_100000) {
 116   scoped_ptr<CompositorFrame> frame(new CompositorFrame);
 117
 118   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 119   for (int i = 0; i < 100000; ++i) {
 120     render_pass->CreateAndAppendSharedQuadState();
 121     PictureDrawQuad* quad =
 122         render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
 123     quad->shared_quad_state = render_pass->shared_quad_state_list.back();
 124   }
 125
 126   frame->delegated_frame_data.reset(new DelegatedFrameData);
 127   frame->delegated_frame_data->render_pass_list.push_back(render_pass.Pass());
 128
 129   RunTest("DelegatedFrame_ManyQuads_100000_100000", *frame);
 130 }
 131
 132 TEST_F(CCMessagesPerfTest,
 133        DelegatedFrame_ManyRenderPasses_10000_100) {
 134   scoped_ptr<CompositorFrame> frame(new CompositorFrame);
 135   frame->delegated_frame_data.reset(new DelegatedFrameData);
 136
 137   for (int i = 0; i < 1000; ++i) {
 138     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 139     for (int j = 0; j < 100; ++j) {
 140       render_pass->CreateAndAppendSharedQuadState();
 141       PictureDrawQuad* quad =
 142           render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
 143       quad->shared_quad_state = render_pass->shared_quad_state_list.back();
 144     }
 145     frame->delegated_frame_data->render_pass_list.push_back(render_pass.Pass());
 146   }
 147
 148   RunTest("DelegatedFrame_ManyRenderPasses_10000_100", *frame);
 149 }
 150
 151 }  // namespace
 152 }  // namespace content