skia/ext/image_operations_bench.cc

   1 // Copyright (c) 2011 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 // This small program is used to measure the performance of the various
   6 // resize algorithms offered by the ImageOperations::Resize function.
   7 // It will generate an empty source bitmap, and rescale it to specified
   8 // dimensions. It will repeat this operation multiple time to get more accurate
   9 // average throughput. Because it uses elapsed time to do its math, it is only
  10 // accurate on an idle system (but that approach was deemed more accurate
  11 // than the use of the times() call.
  12 // To present a single number in MB/s, it calculates the 'speed' by taking
  13 // source surface + destination surface and dividing by the elapsed time.
  14 // This number is somewhat reasonable way to measure this, given our current
  15 // implementation which somewhat scales this way.
  16
  17 #include <stdio.h>
  18
  19 #include "base/basictypes.h"
  20 #include "base/command_line.h"
  21 #include "base/format_macros.h"
  22 #include "base/strings/string_number_conversions.h"
  23 #include "base/strings/string_split.h"
  24 #include "base/strings/string_util.h"
  25 #include "base/strings/utf_string_conversions.h"
  26 #include "base/time/time.h"
  27 #include "skia/ext/image_operations.h"
  28 #include "third_party/skia/include/core/SkBitmap.h"
  29 #include "third_party/skia/include/core/SkRect.h"
  30
  31 namespace {
  32
  33 struct StringMethodPair {
  34   const char* name;
  35   skia::ImageOperations::ResizeMethod method;
  36 };
  37 #define ADD_METHOD(x) { #x, skia::ImageOperations::RESIZE_##x }
  38 const StringMethodPair resize_methods[] = {
  39   ADD_METHOD(GOOD),
  40   ADD_METHOD(BETTER),
  41   ADD_METHOD(BEST),
  42   ADD_METHOD(BOX),
  43   ADD_METHOD(HAMMING1),
  44   ADD_METHOD(LANCZOS2),
  45   ADD_METHOD(LANCZOS3),
  46   ADD_METHOD(SUBPIXEL)
  47 };
  48
  49 // converts a string into one of the image operation method to resize.
  50 // Returns true on success, false otherwise.
  51 bool StringToMethod(const std::string& arg,
  52                     skia::ImageOperations::ResizeMethod* method) {
  53   for (size_t i = 0; i < arraysize(resize_methods); ++i) {
  54     if (base::strcasecmp(arg.c_str(), resize_methods[i].name) == 0) {
  55       *method = resize_methods[i].method;
  56       return true;
  57     }
  58   }
  59   return false;
  60 }
  61
  62 const char* MethodToString(skia::ImageOperations::ResizeMethod method) {
  63   for (size_t i = 0; i < arraysize(resize_methods); ++i) {
  64     if (method == resize_methods[i].method) {
  65       return resize_methods[i].name;
  66     }
  67   }
  68   return "unknown";
  69 }
  70
  71 // Prints all supported resize methods
  72 void PrintMethods() {
  73   bool print_comma = false;
  74   for (size_t i = 0; i < arraysize(resize_methods); ++i) {
  75     if (print_comma) {
  76       printf(",");
  77     } else {
  78       print_comma = true;
  79     }
  80     printf(" %s", resize_methods[i].name);
  81   }
  82 }
  83
  84 // Returns the number of bytes that the bitmap has. This number is different
  85 // from what SkBitmap::getSize() returns since it does not take into account
  86 // the stride. The difference between the stride and the width can be large
  87 // because of the alignment constraints on bitmaps created for SRB scaling
  88 // (32 pixels) as seen on GTV platforms. Using this metric instead of the
  89 // getSize seemed to be a more accurate representation of the work done (even
  90 // though in terms of memory bandwidth that might be similar because of the
  91 // cache line size).
  92 int GetBitmapSize(const SkBitmap* bitmap) {
  93   return bitmap->height() * bitmap->bytesPerPixel() * bitmap->width();
  94 }
  95
  96 // Simple class to represent dimensions of a bitmap (width, height).
  97 class Dimensions {
  98  public:
  99   Dimensions()
 100       : width_(0),
 101         height_(0) {}
 102
 103   void set(int w, int h) {
 104     width_ = w;
 105     height_ = h;
 106   }
 107
 108   int width() const {
 109     return width_;
 110   }
 111
 112   int height() const {
 113     return height_;
 114   }
 115
 116   bool IsValid() const {
 117     return (width_ > 0 && height_ > 0);
 118   }
 119
 120   // On failure, will set its state in such a way that IsValid will return
 121   // false.
 122   void FromString(const std::string& arg) {
 123     std::vector<std::string> strings;
 124     base::SplitString(std::string(arg), 'x', &strings);
 125     if (strings.size() != 2 ||
 126         base::StringToInt(strings[0], &width_) == false ||
 127         base::StringToInt(strings[1], &height_) == false) {
 128       width_ = -1;  // force the dimension object to be invalid.
 129     }
 130   }
 131  private:
 132   int width_;
 133   int height_;
 134 };
 135
 136 // main class used for the benchmarking.
 137 class Benchmark {
 138  public:
 139   static const int kDefaultNumberIterations;
 140   static const skia::ImageOperations::ResizeMethod kDefaultResizeMethod;
 141
 142   Benchmark()
 143       : num_iterations_(kDefaultNumberIterations),
 144         method_(kDefaultResizeMethod) {}
 145
 146   // Returns true if command line parsing was successful, false otherwise.
 147   bool ParseArgs(const base::CommandLine* command_line);
 148
 149   // Returns true if successful, false otherwise.
 150   bool Run() const;
 151
 152   static void Usage();
 153  private:
 154   int num_iterations_;
 155   skia::ImageOperations::ResizeMethod method_;
 156   Dimensions source_;
 157   Dimensions dest_;
 158 };
 159
 160 // static
 161 const int Benchmark::kDefaultNumberIterations = 1024;
 162 const skia::ImageOperations::ResizeMethod Benchmark::kDefaultResizeMethod =
 163       skia::ImageOperations::RESIZE_LANCZOS3;
 164
 165 // argument management
 166 void Benchmark::Usage() {
 167   printf("image_operations_bench -source wxh -destination wxh "
 168          "[-iterations i] [-method m] [-help]\n"
 169          "  -source wxh: specify source width and height\n"
 170          "  -destination wxh: specify destination width and height\n"
 171          "  -iter i: perform i iterations (default:%d)\n"
 172          "  -method m: use method m (default:%s), which can be:",
 173          Benchmark::kDefaultNumberIterations,
 174          MethodToString(Benchmark::kDefaultResizeMethod));
 175   PrintMethods();
 176   printf("\n  -help: prints this help and exits\n");
 177 }
 178
 179 bool Benchmark::ParseArgs(const base::CommandLine* command_line) {
 180   const base::CommandLine::SwitchMap& switches = command_line->GetSwitches();
 181   bool fNeedHelp = false;
 182
 183   for (base::CommandLine::SwitchMap::const_iterator iter = switches.begin();
 184        iter != switches.end();
 185        ++iter) {
 186     const std::string& s = iter->first;
 187     std::string value;
 188 #if defined(OS_WIN)
 189     value = base::WideToUTF8(iter->second);
 190 #else
 191     value = iter->second;
 192 #endif
 193     if (s == "source") {
 194       source_.FromString(value);
 195     } else if (s == "destination") {
 196       dest_.FromString(value);
 197     } else if (s == "iterations") {
 198       if (base::StringToInt(value, &num_iterations_) == false) {
 199         fNeedHelp = true;
 200       }
 201     } else if (s == "method") {
 202       if (!StringToMethod(value, &method_)) {
 203         printf("Invalid method '%s' specified\n", value.c_str());
 204         fNeedHelp = true;
 205       }
 206     } else {
 207       fNeedHelp = true;
 208     }
 209   }
 210
 211   if (num_iterations_ <= 0) {
 212     printf("Invalid number of iterations: %d\n", num_iterations_);
 213     fNeedHelp = true;
 214   }
 215   if (!source_.IsValid()) {
 216     printf("Invalid source dimensions specified\n");
 217     fNeedHelp = true;
 218   }
 219   if (!dest_.IsValid()) {
 220     printf("Invalid dest dimensions specified\n");
 221     fNeedHelp = true;
 222   }
 223   if (fNeedHelp == true) {
 224     return false;
 225   }
 226   return true;
 227 }
 228
 229 // actual benchmark.
 230 bool Benchmark::Run() const {
 231   SkBitmap source;
 232   source.allocN32Pixels(source_.width(), source_.height());
 233   source.eraseARGB(0, 0, 0, 0);
 234
 235   SkBitmap dest;
 236
 237   const base::TimeTicks start = base::TimeTicks::Now();
 238
 239   for (int i = 0; i < num_iterations_; ++i) {
 240     dest = skia::ImageOperations::Resize(source,
 241                                          method_,
 242                                          dest_.width(), dest_.height());
 243   }
 244
 245   const int64 elapsed_us = (base::TimeTicks::Now() - start).InMicroseconds();
 246
 247   const uint64 num_bytes = static_cast<uint64>(num_iterations_) *
 248       (GetBitmapSize(&source) + GetBitmapSize(&dest));
 249
 250   printf("%" PRIu64 " MB/s,\telapsed = %" PRIu64 " source=%d dest=%d\n",
 251          static_cast<uint64>(elapsed_us == 0 ? 0 : num_bytes / elapsed_us),
 252          static_cast<uint64>(elapsed_us),
 253          GetBitmapSize(&source), GetBitmapSize(&dest));
 254
 255   return true;
 256 }
 257
 258 // A small class to automatically call Reset on the global command line to
 259 // avoid nasty valgrind complaints for the leak of the global command line.
 260 class CommandLineAutoReset {
 261  public:
 262   CommandLineAutoReset(int argc, char** argv) {
 263     base::CommandLine::Init(argc, argv);
 264   }
 265   ~CommandLineAutoReset() {
 266     base::CommandLine::Reset();
 267   }
 268
 269   const base::CommandLine* Get() const {
 270     return base::CommandLine::ForCurrentProcess();
 271   }
 272 };
 273
 274 }  // namespace
 275
 276 int main(int argc, char** argv) {
 277   Benchmark bench;
 278   CommandLineAutoReset command_line(argc, argv);
 279
 280   if (!bench.ParseArgs(command_line.Get())) {
 281     Benchmark::Usage();
 282     return 1;
 283   }
 284
 285   if (!bench.Run()) {
 286     printf("Failed to run benchmark\n");
 287     return 1;
 288   }
 289
 290   return 0;
 291 }