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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrTextBlobCache_DEFINED
#define GrTextBlobCache_DEFINED
#include "GrAtlasTextContext.h"
#include "SkTDynamicHash.h"
#include "SkTextBlobRunIterator.h"
class GrTextBlobCache {
public:
/**
* The callback function used by the cache when it is still over budget after a purge. The
* passed in 'data' is the same 'data' handed to setOverbudgetCallback.
*/
typedef void (*PFOverBudgetCB)(void* data);
GrTextBlobCache(PFOverBudgetCB cb, void* data)
: fPool(kPreAllocSize, kMinGrowthSize)
, fCallback(cb)
, fData(data)
, fBudget(kDefaultBudget) {
SkASSERT(cb && data);
}
~GrTextBlobCache();
// creates an uncached blob
GrAtlasTextBlob* createBlob(int glyphCount, int runCount, size_t maxVASize);
GrAtlasTextBlob* createBlob(const SkTextBlob* blob, size_t maxVAStride) {
int glyphCount = 0;
int runCount = 0;
BlobGlyphCount(&glyphCount, &runCount, blob);
GrAtlasTextBlob* cacheBlob = this->createBlob(glyphCount, runCount, maxVAStride);
return cacheBlob;
}
static void SetupCacheBlobKey(GrAtlasTextBlob* cacheBlob,
const GrAtlasTextBlob::Key& key,
const SkMaskFilter::BlurRec& blurRec,
const SkPaint& paint) {
cacheBlob->fKey = key;
if (key.fHasBlur) {
cacheBlob->fBlurRec = blurRec;
}
if (key.fStyle != SkPaint::kFill_Style) {
cacheBlob->fStrokeInfo.fFrameWidth = paint.getStrokeWidth();
cacheBlob->fStrokeInfo.fMiterLimit = paint.getStrokeMiter();
cacheBlob->fStrokeInfo.fJoin = paint.getStrokeJoin();
}
}
GrAtlasTextBlob* createCachedBlob(const SkTextBlob* blob,
const GrAtlasTextBlob::Key& key,
const SkMaskFilter::BlurRec& blurRec,
const SkPaint& paint,
size_t maxVAStride) {
int glyphCount = 0;
int runCount = 0;
BlobGlyphCount(&glyphCount, &runCount, blob);
GrAtlasTextBlob* cacheBlob = this->createBlob(glyphCount, runCount, maxVAStride);
SetupCacheBlobKey(cacheBlob, key, blurRec, paint);
this->add(cacheBlob);
return cacheBlob;
}
GrAtlasTextBlob* find(const GrAtlasTextBlob::Key& key) {
return fCache.find(key);
}
void remove(GrAtlasTextBlob* blob) {
fCache.remove(blob->fKey);
fBlobList.remove(blob);
blob->unref();
}
void add(GrAtlasTextBlob* blob) {
fCache.add(blob);
fBlobList.addToHead(blob);
this->checkPurge(blob);
}
void makeMRU(GrAtlasTextBlob* blob) {
if (fBlobList.head() == blob) {
return;
}
fBlobList.remove(blob);
fBlobList.addToHead(blob);
}
void freeAll();
// TODO move to SkTextBlob
static void BlobGlyphCount(int* glyphCount, int* runCount, const SkTextBlob* blob) {
SkTextBlobRunIterator itCounter(blob);
for (; !itCounter.done(); itCounter.next(), (*runCount)++) {
*glyphCount += itCounter.glyphCount();
}
}
void setBudget(size_t budget) {
fBudget = budget;
this->checkPurge();
}
private:
typedef SkTInternalLList<GrAtlasTextBlob> BitmapBlobList;
void checkPurge(GrAtlasTextBlob* blob = nullptr) {
// If we are overbudget, then unref until we are below budget again
if (fPool.size() > fBudget) {
BitmapBlobList::Iter iter;
iter.init(fBlobList, BitmapBlobList::Iter::kTail_IterStart);
GrAtlasTextBlob* lruBlob = nullptr;
while (fPool.size() > fBudget && (lruBlob = iter.get()) && lruBlob != blob) {
fCache.remove(lruBlob->fKey);
// Backup the iterator before removing and unrefing the blob
iter.prev();
fBlobList.remove(lruBlob);
lruBlob->unref();
}
// If we break out of the loop with lruBlob == blob, then we haven't purged enough
// use the call back and try to free some more. If we are still overbudget after this,
// then this single textblob is over our budget
if (blob && lruBlob == blob) {
(*fCallback)(fData);
}
#ifdef SPEW_BUDGET_MESSAGE
if (fPool.size() > fBudget) {
SkDebugf("Single textblob is larger than our whole budget");
}
#endif
}
}
// Budget was chosen to be ~4 megabytes. The min alloc and pre alloc sizes in the pool are
// based off of the largest cached textblob I have seen in the skps(a couple of kilobytes).
static const int kPreAllocSize = 1 << 17;
static const int kMinGrowthSize = 1 << 17;
static const int kDefaultBudget = 1 << 22;
BitmapBlobList fBlobList;
SkTDynamicHash<GrAtlasTextBlob, GrAtlasTextBlob::Key> fCache;
GrMemoryPool fPool;
PFOverBudgetCB fCallback;
void* fData;
size_t fBudget;
};
#endif
|
