src/cc/resources/tile_manager_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 "base/time/time.h"
   6 #include "cc/resources/tile.h"
   7 #include "cc/resources/tile_priority.h"
   8 #include "cc/test/fake_output_surface.h"
   9 #include "cc/test/fake_output_surface_client.h"
  10 #include "cc/test/fake_picture_pile_impl.h"
  11 #include "cc/test/fake_tile_manager.h"
  12 #include "cc/test/fake_tile_manager_client.h"
  13 #include "cc/test/lap_timer.h"
  14 #include "cc/test/test_tile_priorities.h"
  15
  16 #include "testing/gtest/include/gtest/gtest.h"
  17 #include "testing/perf/perf_test.h"
  18
  19 namespace cc {
  20
  21 namespace {
  22
  23 static const int kTimeLimitMillis = 2000;
  24 static const int kWarmupRuns = 5;
  25 static const int kTimeCheckInterval = 10;
  26
  27 class TileManagerPerfTest : public testing::Test {
  28  public:
  29   typedef std::vector<std::pair<scoped_refptr<Tile>, ManagedTileBin> >
  30       TileBinVector;
  31
  32   TileManagerPerfTest()
  33       : timer_(kWarmupRuns,
  34                base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
  35                kTimeCheckInterval) {}
  36
  37   // Overridden from testing::Test:
  38   virtual void SetUp() OVERRIDE {
  39     output_surface_ = FakeOutputSurface::Create3d();
  40     CHECK(output_surface_->BindToClient(&output_surface_client_));
  41
  42     resource_provider_ =
  43         ResourceProvider::Create(output_surface_.get(), NULL, 0, false, 1);
  44     tile_manager_ = make_scoped_ptr(
  45         new FakeTileManager(&tile_manager_client_, resource_provider_.get()));
  46     picture_pile_ = FakePicturePileImpl::CreatePile();
  47   }
  48
  49   GlobalStateThatImpactsTilePriority GlobalStateForTest() {
  50     GlobalStateThatImpactsTilePriority state;
  51     gfx::Size tile_size = settings_.default_tile_size;
  52     state.memory_limit_in_bytes =
  53         10000u * 4u *
  54         static_cast<size_t>(tile_size.width() * tile_size.height());
  55     state.num_resources_limit = 10000;
  56     state.memory_limit_policy = ALLOW_ANYTHING;
  57     state.tree_priority = SMOOTHNESS_TAKES_PRIORITY;
  58     return state;
  59   }
  60
  61   virtual void TearDown() OVERRIDE {
  62     tile_manager_.reset(NULL);
  63     picture_pile_ = NULL;
  64   }
  65
  66   TilePriority GetTilePriorityFromBin(ManagedTileBin bin) {
  67     switch (bin) {
  68       case NOW_AND_READY_TO_DRAW_BIN:
  69       case NOW_BIN:
  70         return TilePriorityForNowBin();
  71       case SOON_BIN:
  72         return TilePriorityForSoonBin();
  73       case EVENTUALLY_AND_ACTIVE_BIN:
  74       case EVENTUALLY_BIN:
  75         return TilePriorityForEventualBin();
  76       case AT_LAST_BIN:
  77       case AT_LAST_AND_ACTIVE_BIN:
  78       case NEVER_BIN:
  79         return TilePriority();
  80       default:
  81         NOTREACHED();
  82         return TilePriority();
  83     }
  84   }
  85
  86   ManagedTileBin GetNextBin(ManagedTileBin bin) {
  87     switch (bin) {
  88       case NOW_AND_READY_TO_DRAW_BIN:
  89       case NOW_BIN:
  90         return SOON_BIN;
  91       case SOON_BIN:
  92         return EVENTUALLY_BIN;
  93       case EVENTUALLY_AND_ACTIVE_BIN:
  94       case EVENTUALLY_BIN:
  95         return NEVER_BIN;
  96       case AT_LAST_BIN:
  97       case AT_LAST_AND_ACTIVE_BIN:
  98       case NEVER_BIN:
  99         return NOW_BIN;
 100       default:
 101         NOTREACHED();
 102         return NEVER_BIN;
 103     }
 104   }
 105
 106   void CreateBinTiles(int count, ManagedTileBin bin, TileBinVector* tiles) {
 107     for (int i = 0; i < count; ++i) {
 108       scoped_refptr<Tile> tile =
 109           tile_manager_->CreateTile(picture_pile_.get(),
 110                                     settings_.default_tile_size,
 111                                     gfx::Rect(),
 112                                     gfx::Rect(),
 113                                     1.0,
 114                                     0,
 115                                     0,
 116                                     true);
 117       tile->SetPriority(ACTIVE_TREE, GetTilePriorityFromBin(bin));
 118       tile->SetPriority(PENDING_TREE, GetTilePriorityFromBin(bin));
 119       tiles->push_back(std::make_pair(tile, bin));
 120     }
 121   }
 122
 123   void CreateTiles(int count, TileBinVector* tiles) {
 124     // Roughly an equal amount of all bins.
 125     int count_per_bin = count / NUM_BINS;
 126     CreateBinTiles(count_per_bin, NOW_BIN, tiles);
 127     CreateBinTiles(count_per_bin, SOON_BIN, tiles);
 128     CreateBinTiles(count_per_bin, EVENTUALLY_BIN, tiles);
 129     CreateBinTiles(count - 3 * count_per_bin, NEVER_BIN, tiles);
 130   }
 131
 132   void RunManageTilesTest(const std::string& test_name,
 133                           unsigned tile_count,
 134                           int priority_change_percent) {
 135     DCHECK_GE(tile_count, 100u);
 136     DCHECK_GE(priority_change_percent, 0);
 137     DCHECK_LE(priority_change_percent, 100);
 138     TileBinVector tiles;
 139     CreateTiles(tile_count, &tiles);
 140     timer_.Reset();
 141     do {
 142       if (priority_change_percent > 0) {
 143         for (unsigned i = 0;
 144              i < tile_count;
 145              i += 100 / priority_change_percent) {
 146           Tile* tile = tiles[i].first.get();
 147           ManagedTileBin bin = GetNextBin(tiles[i].second);
 148           tile->SetPriority(ACTIVE_TREE, GetTilePriorityFromBin(bin));
 149           tile->SetPriority(PENDING_TREE, GetTilePriorityFromBin(bin));
 150           tiles[i].second = bin;
 151         }
 152       }
 153
 154       tile_manager_->ManageTiles(GlobalStateForTest());
 155       tile_manager_->CheckForCompletedTasks();
 156       timer_.NextLap();
 157     } while (!timer_.HasTimeLimitExpired());
 158
 159     perf_test::PrintResult("manage_tiles", "", test_name,
 160                            timer_.LapsPerSecond(), "runs/s", true);
 161   }
 162
 163  private:
 164   FakeTileManagerClient tile_manager_client_;
 165   LayerTreeSettings settings_;
 166   scoped_ptr<FakeTileManager> tile_manager_;
 167   scoped_refptr<FakePicturePileImpl> picture_pile_;
 168   FakeOutputSurfaceClient output_surface_client_;
 169   scoped_ptr<FakeOutputSurface> output_surface_;
 170   scoped_ptr<ResourceProvider> resource_provider_;
 171   LapTimer timer_;
 172 };
 173
 174 TEST_F(TileManagerPerfTest, ManageTiles) {
 175   RunManageTilesTest("100_0", 100, 0);
 176   RunManageTilesTest("1000_0", 1000, 0);
 177   RunManageTilesTest("10000_0", 10000, 0);
 178   RunManageTilesTest("100_10", 100, 10);
 179   RunManageTilesTest("1000_10", 1000, 10);
 180   RunManageTilesTest("10000_10", 10000, 10);
 181   RunManageTilesTest("100_100", 100, 100);
 182   RunManageTilesTest("1000_100", 1000, 100);
 183   RunManageTilesTest("10000_100", 10000, 100);
 184 }
 185
 186 }  // namespace
 187
 188 }  // namespace cc