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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkResourceCache_DEFINED
#define SkResourceCache_DEFINED
#include "SkBitmap.h"
class SkDiscardableMemory;
class SkMipMap;
/**
* Cache object for bitmaps (with possible scale in X Y as part of the key).
*
* Multiple caches can be instantiated, but each instance is not implicitly
* thread-safe, so if a given instance is to be shared across threads, the
* caller must manage the access itself (e.g. via a mutex).
*
* As a convenience, a global instance is also defined, which can be safely
* access across threads via the static methods (e.g. FindAndLock, etc.).
*/
class SkResourceCache {
public:
struct Key {
// Call this to access your private contents. Must not use the address after calling init()
void* writableContents() { return this + 1; }
// must call this after your private data has been written.
// length must be a multiple of 4
void init(size_t length);
// This is only valid after having called init().
uint32_t hash() const { return fHash; }
bool operator==(const Key& other) const {
const uint32_t* a = this->as32();
const uint32_t* b = other.as32();
for (int i = 0; i < fCount32; ++i) {
if (a[i] != b[i]) {
return false;
}
}
return true;
}
private:
// store fCount32 first, so we don't consider it in operator<
int32_t fCount32; // 2 + user contents count32
uint32_t fHash;
/* uint32_t fContents32[] */
const uint32_t* as32() const { return (const uint32_t*)this; }
const uint32_t* as32SkipCount() const { return this->as32() + 1; }
};
struct Rec {
typedef SkResourceCache::Key Key;
Rec() : fLockCount(1) {}
virtual ~Rec() {}
uint32_t getHash() const { return this->getKey().hash(); }
virtual const Key& getKey() const = 0;
virtual size_t bytesUsed() const = 0;
// for SkTDynamicHash::Traits
static uint32_t Hash(const Key& key) { return key.hash(); }
static const Key& GetKey(const Rec& rec) { return rec.getKey(); }
private:
Rec* fNext;
Rec* fPrev;
int32_t fLockCount;
int32_t fPad;
friend class SkResourceCache;
};
typedef const Rec* ID;
/**
* Returns a locked/pinned SkDiscardableMemory instance for the specified
* number of bytes, or NULL on failure.
*/
typedef SkDiscardableMemory* (*DiscardableFactory)(size_t bytes);
/*
* The following static methods are thread-safe wrappers around a global
* instance of this cache.
*/
static const Rec* FindAndLock(const Key& key);
static const Rec* AddAndLock(Rec*);
static void Add(Rec*);
static void Unlock(ID);
static size_t GetTotalBytesUsed();
static size_t GetTotalByteLimit();
static size_t SetTotalByteLimit(size_t newLimit);
static size_t SetSingleAllocationByteLimit(size_t);
static size_t GetSingleAllocationByteLimit();
/**
* Use this allocator for bitmaps, so they can use ashmem when available.
* Returns NULL if the ResourceCache has not been initialized with a DiscardableFactory.
*/
static SkBitmap::Allocator* GetAllocator();
/**
* Call SkDebugf() with diagnostic information about the state of the cache
*/
static void Dump();
///////////////////////////////////////////////////////////////////////////
/**
* Construct the cache to call DiscardableFactory when it
* allocates memory for the pixels. In this mode, the cache has
* not explicit budget, and so methods like getTotalBytesUsed()
* and getTotalByteLimit() will return 0, and setTotalByteLimit
* will ignore its argument and return 0.
*/
SkResourceCache(DiscardableFactory);
/**
* Construct the cache, allocating memory with malloc, and respect the
* byteLimit, purging automatically when a new image is added to the cache
* that pushes the total bytesUsed over the limit. Note: The limit can be
* changed at runtime with setTotalByteLimit.
*/
explicit SkResourceCache(size_t byteLimit);
~SkResourceCache();
const Rec* findAndLock(const Key& key);
const Rec* addAndLock(Rec*);
void add(Rec*);
/**
* Given a non-null ID ptr returned by either findAndLock or addAndLock,
* this releases the associated resources to be available to be purged
* if needed. After this, the cached bitmap should no longer be
* referenced by the caller.
*/
void unlock(ID);
size_t getTotalBytesUsed() const { return fTotalBytesUsed; }
size_t getTotalByteLimit() const { return fTotalByteLimit; }
/**
* This is respected by SkBitmapProcState::possiblyScaleImage.
* 0 is no maximum at all; this is the default.
* setSingleAllocationByteLimit() returns the previous value.
*/
size_t setSingleAllocationByteLimit(size_t maximumAllocationSize);
size_t getSingleAllocationByteLimit() const;
/**
* Set the maximum number of bytes available to this cache. If the current
* cache exceeds this new value, it will be purged to try to fit within
* this new limit.
*/
size_t setTotalByteLimit(size_t newLimit);
SkBitmap::Allocator* allocator() const { return fAllocator; };
/**
* Call SkDebugf() with diagnostic information about the state of the cache
*/
void dump() const;
private:
Rec* fHead;
Rec* fTail;
class Hash;
Hash* fHash;
DiscardableFactory fDiscardableFactory;
// the allocator is NULL or one that matches discardables
SkBitmap::Allocator* fAllocator;
size_t fTotalBytesUsed;
size_t fTotalByteLimit;
size_t fSingleAllocationByteLimit;
int fCount;
void purgeRec(Rec*);
void purgeAsNeeded();
// linklist management
void moveToHead(Rec*);
void addToHead(Rec*);
void detach(Rec*);
void init(); // called by constructors
#ifdef SK_DEBUG
void validate() const;
#else
void validate() const {}
#endif
};
#endif
|
