cc/tiles/gpu_image_decode_cache_perftest.cc

   1 // Copyright 2017 The Chromium Authors
   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 <memory>
   6 #include <vector>
   7
   8 #include "base/timer/lap_timer.h"
   9 #include "cc/paint/draw_image.h"
  10 #include "cc/paint/paint_image_builder.h"
  11 #include "cc/raster/tile_task.h"
  12 #include "cc/tiles/gpu_image_decode_cache.h"
  13 #include "components/viz/test/test_in_process_context_provider.h"
  14 #include "gpu/command_buffer/client/raster_interface.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16 #include "testing/perf/perf_result_reporter.h"
  17 #include "third_party/skia/include/core/SkSurface.h"
  18 #include "third_party/skia/include/gpu/GrDirectContext.h"
  19
  20 namespace cc {
  21 namespace {
  22
  23 static const int kTimeLimitMillis = 2000;
  24 static const int kWarmupRuns = 5;
  25 static const int kTimeCheckInterval = 10;
  26 static const int kCacheSize = 128 * 1024 * 1024;
  27
  28 sk_sp<SkImage> CreateImage(int width, int height) {
  29   SkBitmap bitmap;
  30   bitmap.allocPixels(SkImageInfo::MakeS32(width, height, kPremul_SkAlphaType));
  31   return SkImage::MakeFromBitmap(bitmap);
  32 }
  33
  34 SkM44 CreateMatrix(const SkSize& scale) {
  35   return SkM44::Scale(scale.width(), scale.height());
  36 }
  37
  38 enum class TestMode { kGpu, kSw };
  39
  40 class GpuImageDecodeCachePerfTest
  41     : public testing::Test,
  42       public testing::WithParamInterface<TestMode> {
  43  public:
  44   GpuImageDecodeCachePerfTest()
  45       : timer_(kWarmupRuns,
  46                base::Milliseconds(kTimeLimitMillis),
  47                kTimeCheckInterval),
  48         context_provider_(
  49             base::MakeRefCounted<viz::TestInProcessContextProvider>(
  50                 ParamToTestContextType(GetParam()),
  51                 /*support_locking=*/false)) {}
  52
  53   void SetUp() override {
  54     gpu::ContextResult result = context_provider_->BindToCurrentThread();
  55     ASSERT_EQ(result, gpu::ContextResult::kSuccess);
  56     cache_ = std::make_unique<GpuImageDecodeCache>(
  57         context_provider_.get(), UseTransferCache(), kRGBA_8888_SkColorType,
  58         kCacheSize, MaxTextureSize(), nullptr);
  59   }
  60
  61  protected:
  62   size_t MaxTextureSize() const {
  63     switch (GetParam()) {
  64       case TestMode::kGpu:
  65         return 4096;
  66       case TestMode::kSw:
  67         return 0;
  68     }
  69   }
  70
  71   bool UseTransferCache() const { return GetParam() == TestMode::kGpu; }
  72
  73   const char* ParamName() const {
  74     switch (GetParam()) {
  75       case TestMode::kGpu:
  76         return "GPU";
  77       case TestMode::kSw:
  78         return "SW";
  79     }
  80   }
  81
  82   viz::TestContextType ParamToTestContextType(TestMode mode) {
  83     switch (mode) {
  84       case TestMode::kGpu:
  85         return viz::TestContextType::kGpuRaster;
  86       case TestMode::kSw:
  87         return viz::TestContextType::kSoftwareRaster;
  88     }
  89   }
  90
  91   perf_test::PerfResultReporter SetUpReporter(
  92       const std::string& metric_suffix) {
  93     perf_test::PerfResultReporter reporter("gpu_image_decode_cache",
  94                                            ParamName());
  95     reporter.RegisterImportantMetric(metric_suffix, "runs/s");
  96     return reporter;
  97   }
  98
  99   base::LapTimer timer_;
 100   scoped_refptr<viz::TestInProcessContextProvider> context_provider_;
 101   std::unique_ptr<GpuImageDecodeCache> cache_;
 102 };
 103
 104 INSTANTIATE_TEST_SUITE_P(P,
 105                          GpuImageDecodeCachePerfTest,
 106                          testing::Values(TestMode::kGpu, TestMode::kSw));
 107
 108 TEST_P(GpuImageDecodeCachePerfTest, DecodeWithColorConversion) {
 109   timer_.Reset();
 110   do {
 111     DrawImage image(
 112         PaintImageBuilder::WithDefault()
 113             .set_id(PaintImage::GetNextId())
 114             .set_image(CreateImage(1024, 2048), PaintImage::GetNextContentId())
 115             .TakePaintImage(),
 116         false, SkIRect::MakeWH(1024, 2048), PaintFlags::FilterQuality::kMedium,
 117         CreateMatrix(SkSize::Make(1.0f, 1.0f)), 0u,
 118         TargetColorParams(gfx::ColorSpace::CreateXYZD50()));
 119
 120     DecodedDrawImage decoded_image = cache_->GetDecodedImageForDraw(image);
 121     cache_->DrawWithImageFinished(image, decoded_image);
 122     timer_.NextLap();
 123   } while (!timer_.HasTimeLimitExpired());
 124
 125   perf_test::PerfResultReporter reporter =
 126       SetUpReporter("_with_color_conversion");
 127   reporter.AddResult("_with_color_conversion", timer_.LapsPerSecond());
 128 }
 129
 130 using GpuImageDecodeCachePerfTestNoSw = GpuImageDecodeCachePerfTest;
 131 INSTANTIATE_TEST_SUITE_P(P,
 132                          GpuImageDecodeCachePerfTestNoSw,
 133                          testing::Values(TestMode::kGpu));
 134
 135 TEST_P(GpuImageDecodeCachePerfTestNoSw, DecodeWithMips) {
 136   // Surface to render into.
 137   auto surface = SkSurface::MakeRenderTarget(
 138       context_provider_->GrContext(), SkBudgeted::kNo,
 139       SkImageInfo::MakeN32Premul(2048, 2048));
 140
 141   timer_.Reset();
 142   do {
 143     DrawImage image(
 144         PaintImageBuilder::WithDefault()
 145             .set_id(PaintImage::GetNextId())
 146             .set_image(CreateImage(1024, 2048), PaintImage::GetNextContentId())
 147             .TakePaintImage(),
 148         false, SkIRect::MakeWH(1024, 2048), PaintFlags::FilterQuality::kMedium,
 149         CreateMatrix(SkSize::Make(0.6f, 0.6f)), 0u, TargetColorParams());
 150
 151     DecodedDrawImage decoded_image = cache_->GetDecodedImageForDraw(image);
 152
 153     cache_->DrawWithImageFinished(image, decoded_image);
 154     timer_.NextLap();
 155   } while (!timer_.HasTimeLimitExpired());
 156
 157   perf_test::PerfResultReporter reporter = SetUpReporter("_with_mips");
 158   reporter.AddResult("_with_mips", timer_.LapsPerSecond());
 159 }
 160
 161 TEST_P(GpuImageDecodeCachePerfTest, AcquireExistingImages) {
 162   timer_.Reset();
 163   DrawImage image(
 164       PaintImageBuilder::WithDefault()
 165           .set_id(PaintImage::GetNextId())
 166           .set_image(CreateImage(1024, 2048), PaintImage::GetNextContentId())
 167           .TakePaintImage(),
 168       false, SkIRect::MakeWH(1024, 2048), PaintFlags::FilterQuality::kMedium,
 169       CreateMatrix(SkSize::Make(1.0f, 1.0f)), 0u,
 170       TargetColorParams(gfx::ColorSpace::CreateXYZD50()));
 171
 172   DecodedDrawImage decoded_image = cache_->GetDecodedImageForDraw(image);
 173   cache_->DrawWithImageFinished(image, decoded_image);
 174
 175   do {
 176     decoded_image = cache_->GetDecodedImageForDraw(image);
 177     cache_->DrawWithImageFinished(image, decoded_image);
 178     timer_.NextLap();
 179   } while (!timer_.HasTimeLimitExpired());
 180
 181   perf_test::PerfResultReporter reporter =
 182       SetUpReporter("_acquire_existing_images");
 183   reporter.AddResult("_acquire_existing_images", timer_.LapsPerSecond());
 184 }
 185
 186 }  // namespace
 187 }  // namespace cc