cc/tiles/software_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 <vector>
   6
   7 #include "base/timer/lap_timer.h"
   8 #include "cc/paint/draw_image.h"
   9 #include "cc/paint/paint_image_builder.h"
  10 #include "cc/raster/tile_task.h"
  11 #include "cc/tiles/software_image_decode_cache.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13 #include "testing/perf/perf_result_reporter.h"
  14
  15 namespace cc {
  16 namespace {
  17
  18 static const int kTimeLimitMillis = 2000;
  19 static const int kWarmupRuns = 5;
  20 static const int kTimeCheckInterval = 10;
  21
  22 sk_sp<SkImage> CreateImage(int width, int height) {
  23   SkBitmap bitmap;
  24   bitmap.allocPixels(SkImageInfo::MakeN32Premul(width, height));
  25   return SkImage::MakeFromBitmap(bitmap);
  26 }
  27
  28 SkM44 CreateMatrix(const SkSize& scale) {
  29   return SkM44::Scale(scale.width(), scale.height());
  30 }
  31
  32 class SoftwareImageDecodeCachePerfTest : public testing::Test {
  33  public:
  34   SoftwareImageDecodeCachePerfTest()
  35       : timer_(kWarmupRuns,
  36                base::Milliseconds(kTimeLimitMillis),
  37                kTimeCheckInterval) {}
  38
  39   void RunFromImage() {
  40     PaintFlags::FilterQuality qualities[] = {
  41         PaintFlags::FilterQuality::kNone, PaintFlags::FilterQuality::kLow,
  42         PaintFlags::FilterQuality::kMedium, PaintFlags::FilterQuality::kHigh};
  43     std::pair<SkIRect, SkIRect> image_rect_subrect[] = {
  44         std::make_pair(SkIRect::MakeWH(100, 100), SkIRect::MakeWH(100, 100)),
  45         std::make_pair(SkIRect::MakeWH(100, 100), SkIRect::MakeWH(50, 50)),
  46         std::make_pair(SkIRect::MakeWH(100, 100), SkIRect::MakeWH(1000, 1000))};
  47     std::pair<float, float> scales[] = {
  48         std::make_pair(1.f, 1.f), std::make_pair(0.5f, 0.5f),
  49         std::make_pair(2.f, 2.f), std::make_pair(0.5f, 1.5f)};
  50
  51     std::vector<DrawImage> images;
  52     for (auto& quality : qualities) {
  53       for (auto& rect_subrect : image_rect_subrect) {
  54         auto& rect = rect_subrect.first;
  55         auto& subrect = rect_subrect.second;
  56         for (auto& scale : scales) {
  57           images.emplace_back(
  58               PaintImageBuilder::WithDefault()
  59                   .set_id(PaintImage::GetNextId())
  60                   .set_image(CreateImage(rect.width(), rect.height()),
  61                              PaintImage::GetNextContentId())
  62                   .TakePaintImage(),
  63               false, subrect, quality,
  64               CreateMatrix(SkSize::Make(scale.first, scale.second)), 0u,
  65               TargetColorParams());
  66         }
  67       }
  68     }
  69
  70     timer_.Reset();
  71     do {
  72       for (auto& image : images) {
  73         SoftwareImageDecodeCache::CacheKey::FromDrawImage(image,
  74                                                           kN32_SkColorType);
  75       }
  76       timer_.NextLap();
  77     } while (!timer_.HasTimeLimitExpired());
  78
  79     perf_test::PerfResultReporter reporter("software_image_decode_cache",
  80                                            "fromdrawimage");
  81     reporter.RegisterImportantMetric("", "runs/s");
  82     reporter.AddResult("", timer_.LapsPerSecond());
  83   }
  84
  85  private:
  86   base::LapTimer timer_;
  87 };
  88
  89 TEST_F(SoftwareImageDecodeCachePerfTest, FromDrawImage) {
  90   RunFromImage();
  91 }
  92
  93 }  // namespace
  94 }  // namespace cc