SkGlyphCacheBench.cpp 3.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116
  1. /*
  2. * Copyright 2015 Google Inc.
  3. *
  4. * Use of this source code is governed by a BSD-style license that can be
  5. * found in the LICENSE file.
  6. */
  7. #include "src/core/SkStrike.h"
  8. #include "bench/Benchmark.h"
  9. #include "include/core/SkCanvas.h"
  10. #include "include/core/SkGraphics.h"
  11. #include "include/core/SkTypeface.h"
  12. #include "src/core/SkStrikeCache.h"
  13. #include "src/core/SkStrikeSpec.h"
  14. #include "src/core/SkTaskGroup.h"
  15. #include "tools/ToolUtils.h"
  16. static void do_font_stuff(SkFont* font) {
  17. SkPaint defaultPaint;
  18. for (SkScalar i = 8; i < 64; i++) {
  19. font->setSize(i);
  20. auto strikeSpec = SkStrikeSpec::MakeMask(
  21. *font, defaultPaint, SkSurfaceProps(0, kUnknown_SkPixelGeometry),
  22. SkScalerContextFlags::kNone, SkMatrix::I());
  23. SkPackedGlyphID glyphs['z'];
  24. for (int c = ' '; c < 'z'; c++) {
  25. glyphs[c] = SkPackedGlyphID{font->unicharToGlyph(c)};
  26. }
  27. constexpr size_t glyphCount = 'z' - ' ';
  28. SkSpan<const SkPackedGlyphID> glyphIDs{&glyphs[SkTo<int>(' ')], glyphCount};
  29. SkBulkGlyphMetricsAndImages images{strikeSpec};
  30. for (int lookups = 0; lookups < 10; lookups++) {
  31. (void)images.glyphs(glyphIDs);
  32. }
  33. }
  34. }
  35. class SkGlyphCacheBasic : public Benchmark {
  36. public:
  37. explicit SkGlyphCacheBasic(size_t cacheSize) : fCacheSize(cacheSize) { }
  38. protected:
  39. const char* onGetName() override {
  40. fName.printf("SkGlyphCacheBasic%dK", (int)(fCacheSize >> 10));
  41. return fName.c_str();
  42. }
  43. bool isSuitableFor(Backend backend) override {
  44. return backend == kNonRendering_Backend;
  45. }
  46. void onDraw(int loops, SkCanvas*) override {
  47. size_t oldCacheLimitSize = SkGraphics::GetFontCacheLimit();
  48. SkGraphics::SetFontCacheLimit(fCacheSize);
  49. SkFont font;
  50. font.setEdging(SkFont::Edging::kAntiAlias);
  51. font.setSubpixel(true);
  52. font.setTypeface(ToolUtils::create_portable_typeface("serif", SkFontStyle::Italic()));
  53. for (int work = 0; work < loops; work++) {
  54. do_font_stuff(&font);
  55. }
  56. SkGraphics::SetFontCacheLimit(oldCacheLimitSize);
  57. }
  58. private:
  59. typedef Benchmark INHERITED;
  60. const size_t fCacheSize;
  61. SkString fName;
  62. };
  63. class SkGlyphCacheStressTest : public Benchmark {
  64. public:
  65. explicit SkGlyphCacheStressTest(int cacheSize) : fCacheSize(cacheSize) { }
  66. protected:
  67. const char* onGetName() override {
  68. fName.printf("SkGlyphCacheStressTest%dK", (int)(fCacheSize >> 10));
  69. return fName.c_str();
  70. }
  71. bool isSuitableFor(Backend backend) override {
  72. return backend == kNonRendering_Backend;
  73. }
  74. void onDraw(int loops, SkCanvas*) override {
  75. size_t oldCacheLimitSize = SkGraphics::GetFontCacheLimit();
  76. SkGraphics::SetFontCacheLimit(fCacheSize);
  77. sk_sp<SkTypeface> typefaces[] = {
  78. ToolUtils::create_portable_typeface("serif", SkFontStyle::Italic()),
  79. ToolUtils::create_portable_typeface("sans-serif", SkFontStyle::Italic())};
  80. for (int work = 0; work < loops; work++) {
  81. SkTaskGroup().batch(16, [&](int threadIndex) {
  82. SkFont font;
  83. font.setEdging(SkFont::Edging::kAntiAlias);
  84. font.setSubpixel(true);
  85. font.setTypeface(typefaces[threadIndex % 2]);
  86. do_font_stuff(&font);
  87. });
  88. }
  89. SkGraphics::SetFontCacheLimit(oldCacheLimitSize);
  90. }
  91. private:
  92. typedef Benchmark INHERITED;
  93. const size_t fCacheSize;
  94. SkString fName;
  95. };
  96. DEF_BENCH( return new SkGlyphCacheBasic(256 * 1024); )
  97. DEF_BENCH( return new SkGlyphCacheBasic(32 * 1024 * 1024); )
  98. DEF_BENCH( return new SkGlyphCacheStressTest(256 * 1024); )
  99. DEF_BENCH( return new SkGlyphCacheStressTest(32 * 1024 * 1024); )