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     size_t raster_task_limit_bytes = 32 * 1024 * 1024;  // 16-64MB in practice.
  45     tile_manager_ =
  46         make_scoped_ptr(new FakeTileManager(&tile_manager_client_,
  47                                             resource_provider_.get(),
  48                                             raster_task_limit_bytes));
  49     picture_pile_ = FakePicturePileImpl::CreatePile();
  50   }
  51
  52   GlobalStateThatImpactsTilePriority GlobalStateForTest() {
  53     GlobalStateThatImpactsTilePriority state;
  54     gfx::Size tile_size = settings_.default_tile_size;
  55     state.soft_memory_limit_in_bytes =
  56         10000u * 4u *
  57         static_cast<size_t>(tile_size.width() * tile_size.height());
  58     state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes;
  59     state.num_resources_limit = 10000;
  60     state.memory_limit_policy = ALLOW_ANYTHING;
  61     state.tree_priority = SMOOTHNESS_TAKES_PRIORITY;
  62     return state;
  63   }
  64
  65   virtual void TearDown() OVERRIDE {
  66     tile_manager_.reset(NULL);
  67     picture_pile_ = NULL;
  68   }
  69
  70   TilePriority GetTilePriorityFromBin(ManagedTileBin bin) {
  71     switch (bin) {
  72       case NOW_AND_READY_TO_DRAW_BIN:
  73       case NOW_BIN:
  74         return TilePriorityForNowBin();
  75       case SOON_BIN:
  76         return TilePriorityForSoonBin();
  77       case EVENTUALLY_AND_ACTIVE_BIN:
  78       case EVENTUALLY_BIN:
  79         return TilePriorityForEventualBin();
  80       case AT_LAST_BIN:
  81       case AT_LAST_AND_ACTIVE_BIN:
  82       case NEVER_BIN:
  83         return TilePriority();
  84       default:
  85         NOTREACHED();
  86         return TilePriority();
  87     }
  88   }
  89
  90   ManagedTileBin GetNextBin(ManagedTileBin bin) {
  91     switch (bin) {
  92       case NOW_AND_READY_TO_DRAW_BIN:
  93       case NOW_BIN:
  94         return SOON_BIN;
  95       case SOON_BIN:
  96         return EVENTUALLY_BIN;
  97       case EVENTUALLY_AND_ACTIVE_BIN:
  98       case EVENTUALLY_BIN:
  99         return NEVER_BIN;
 100       case AT_LAST_BIN:
 101       case AT_LAST_AND_ACTIVE_BIN:
 102       case NEVER_BIN:
 103         return NOW_BIN;
 104       default:
 105         NOTREACHED();
 106         return NEVER_BIN;
 107     }
 108   }
 109
 110   void CreateBinTiles(int count, ManagedTileBin bin, TileBinVector* tiles) {
 111     for (int i = 0; i < count; ++i) {
 112       scoped_refptr<Tile> tile =
 113           tile_manager_->CreateTile(picture_pile_.get(),
 114                                     settings_.default_tile_size,
 115                                     gfx::Rect(),
 116                                     gfx::Rect(),
 117                                     1.0,
 118                                     0,
 119                                     0,
 120                                     Tile::USE_LCD_TEXT);
 121       tile->SetPriority(ACTIVE_TREE, GetTilePriorityFromBin(bin));
 122       tile->SetPriority(PENDING_TREE, GetTilePriorityFromBin(bin));
 123       tiles->push_back(std::make_pair(tile, bin));
 124     }
 125   }
 126
 127   void CreateTiles(int count, TileBinVector* tiles) {
 128     // Roughly an equal amount of all bins.
 129     int count_per_bin = count / NUM_BINS;
 130     CreateBinTiles(count_per_bin, NOW_BIN, tiles);
 131     CreateBinTiles(count_per_bin, SOON_BIN, tiles);
 132     CreateBinTiles(count_per_bin, EVENTUALLY_BIN, tiles);
 133     CreateBinTiles(count - 3 * count_per_bin, NEVER_BIN, tiles);
 134   }
 135
 136   void RunManageTilesTest(const std::string& test_name,
 137                           unsigned tile_count,
 138                           int priority_change_percent) {
 139     DCHECK_GE(tile_count, 100u);
 140     DCHECK_GE(priority_change_percent, 0);
 141     DCHECK_LE(priority_change_percent, 100);
 142     TileBinVector tiles;
 143     CreateTiles(tile_count, &tiles);
 144     timer_.Reset();
 145     do {
 146       if (priority_change_percent > 0) {
 147         for (unsigned i = 0; i < tile_count;
 148              i += 100 / priority_change_percent) {
 149           Tile* tile = tiles[i].first.get();
 150           ManagedTileBin bin = GetNextBin(tiles[i].second);
 151           tile->SetPriority(ACTIVE_TREE, GetTilePriorityFromBin(bin));
 152           tile->SetPriority(PENDING_TREE, GetTilePriorityFromBin(bin));
 153           tiles[i].second = bin;
 154         }
 155       }
 156
 157       tile_manager_->ManageTiles(GlobalStateForTest());
 158       tile_manager_->UpdateVisibleTiles();
 159       timer_.NextLap();
 160     } while (!timer_.HasTimeLimitExpired());
 161
 162     perf_test::PrintResult(
 163         "manage_tiles", "", test_name, timer_.LapsPerSecond(), "runs/s", true);
 164   }
 165
 166  private:
 167   FakeTileManagerClient tile_manager_client_;
 168   LayerTreeSettings settings_;
 169   scoped_ptr<FakeTileManager> tile_manager_;
 170   scoped_refptr<FakePicturePileImpl> picture_pile_;
 171   FakeOutputSurfaceClient output_surface_client_;
 172   scoped_ptr<FakeOutputSurface> output_surface_;
 173   scoped_ptr<ResourceProvider> resource_provider_;
 174   LapTimer timer_;
 175 };
 176
 177 TEST_F(TileManagerPerfTest, ManageTiles) {
 178   RunManageTilesTest("100_0", 100, 0);
 179   RunManageTilesTest("1000_0", 1000, 0);
 180   RunManageTilesTest("10000_0", 10000, 0);
 181   RunManageTilesTest("100_10", 100, 10);
 182   RunManageTilesTest("1000_10", 1000, 10);
 183   RunManageTilesTest("10000_10", 10000, 10);
 184   RunManageTilesTest("100_100", 100, 100);
 185   RunManageTilesTest("1000_100", 1000, 100);
 186   RunManageTilesTest("10000_100", 10000, 100);
 187 }
 188
 189 }  // namespace
 190
 191 }  // namespace cc