1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "bench/Benchmark.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkFont.h"
#include "include/core/SkTypeface.h"
#include "include/utils/SkRandom.h"
#include "src/utils/SkCharToGlyphCache.h"
#include "src/utils/SkUTF.h"
enum {
NGLYPHS = 100
};
namespace {
struct Rec {
const SkCharToGlyphCache& fCache;
int fLoops;
const SkFont& fFont;
const SkUnichar* fText;
int fCount;
};
}
typedef void (*TypefaceProc)(const Rec& r);
static void textToGlyphs_proc(const Rec& r) {
uint16_t glyphs[NGLYPHS];
SkASSERT(r.fCount <= NGLYPHS);
for (int i = 0; i < r.fLoops; ++i) {
r.fFont.textToGlyphs(r.fText, r.fCount*4, SkTextEncoding::kUTF32, glyphs, NGLYPHS);
}
}
static void charsToGlyphs_proc(const Rec& r) {
uint16_t glyphs[NGLYPHS];
SkASSERT(r.fCount <= NGLYPHS);
SkTypeface* face = r.fFont.getTypefaceOrDefault();
for (int i = 0; i < r.fLoops; ++i) {
face->unicharsToGlyphs(r.fText, r.fCount, glyphs);
}
}
static void addcache_proc(const Rec& r) {
for (int i = 0; i < r.fLoops; ++i) {
SkCharToGlyphCache cache;
for (int i = 0; i < r.fCount; ++i) {
cache.addCharAndGlyph(r.fText[i], i);
}
}
}
static void findcache_proc(const Rec& r) {
for (int i = 0; i < r.fLoops; ++i) {
for (int i = 0; i < r.fCount; ++i) {
r.fCache.findGlyphIndex(r.fText[i]);
}
}
}
class CMAPBench : public Benchmark {
TypefaceProc fProc;
SkString fName;
SkUnichar fText[NGLYPHS];
SkFont fFont;
SkCharToGlyphCache fCache;
int fCount;
public:
CMAPBench(TypefaceProc proc, const char name[], int count) {
SkASSERT(count <= NGLYPHS);
fProc = proc;
fName.printf("%s_%d", name, count);
fCount = count;
SkRandom rand;
for (int i = 0; i < count; ++i) {
fText[i] = rand.nextU() & 0xFFFF;
fCache.addCharAndGlyph(fText[i], i);
}
fFont.setTypeface(SkTypeface::MakeDefault());
}
bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
const char* onGetName() override {
return fName.c_str();
}
void onDraw(int loops, SkCanvas* canvas) override {
fProc({fCache, loops, fFont, fText, fCount});
}
private:
typedef Benchmark INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
constexpr int SMALL = 10;
DEF_BENCH( return new CMAPBench(textToGlyphs_proc, "font_charToGlyph", SMALL); )
DEF_BENCH( return new CMAPBench(charsToGlyphs_proc, "face_charToGlyph", SMALL); )
DEF_BENCH( return new CMAPBench(addcache_proc, "addcache_charToGlyph", SMALL); )
DEF_BENCH( return new CMAPBench(findcache_proc, "findcache_charToGlyph", SMALL); )
constexpr int BIG = 100;
DEF_BENCH( return new CMAPBench(textToGlyphs_proc, "font_charToGlyph", BIG); )
DEF_BENCH( return new CMAPBench(charsToGlyphs_proc, "face_charToGlyph", BIG); )
DEF_BENCH( return new CMAPBench(addcache_proc, "addcache_charToGlyph", BIG); )
DEF_BENCH( return new CMAPBench(findcache_proc, "findcache_charToGlyph", BIG); )
|
