AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove count budget from resource cache

Browse Source 
Review URL: http://codereview.appspot.com/6312052/



git-svn-id: http://skia.googlecode.com/svn/trunk@4287 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
bsalomon@google.com 2012-06-21 19:48:32 +00:00
parent c778cda14c
commit 8f7e1dac5c
5 changed files with 39 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
include/gpu/GrContext.h
View File

@ -83,11 +83,6 @@ public:
*/
void freeGpuResources();
/**
* Returns the number of bytes of GPU memory hosted by the texture cache.
*/
size_t getGpuTextureCacheBytes() const;
///////////////////////////////////////////////////////////////////////////
// Textures
@ -212,25 +207,28 @@ public:
int height) const;
/**
* Return the current texture cache limits.
*
* @param maxTextures If non-null, returns maximum number of textures that
* can be held in the cache.
* @param maxTextureBytes If non-null, returns maximum number of bytes of
* texture memory that can be held in the cache.
* Return the current texture cache budget in bytes.
*/
void getTextureCacheLimits(int* maxTextures, size_t* maxTextureBytes) const;
size_t getTextureCacheBudget() const;
/**
* Specify the texture cache limits. If the current cache exceeds either
* of these, it will be purged (LRU) to keep the cache within these limits.
* Specify the texture cache budget. If the current cache size exceeds the
* budget it will immediately be purged to be within the budget.
*
* @param maxTextures The maximum number of textures that can be held in
* the cache.
* @param maxTextureBytes The maximum number of bytes of texture memory
* that can be held in the cache.
*/
void setTextureCacheLimits(int maxTextures, size_t maxTextureBytes);
void setTextureCacheBudget(size_t maxTextureBytes);
// DEPRECATED, this will be deleted soon.
void setTextureCacheLimits(int ignored, size_t maxTextureBytes) {
this->setTextureCacheBudget(maxTextureBytes);
}
/**
* Returns the current number of bytes of GPU memory hosted by the texture
* cache.
*/
size_t getGpuTextureCacheBytes() const;
/**
* Return the max width or height of a texture supported by the current gpu

15
src/gpu/GrContext.cpp
View File

@ -46,8 +46,7 @@
#define GR_DEBUG_PARTIAL_COVERAGE_CHECK 0
#endif
static const size_t MAX_TEXTURE_CACHE_COUNT = 256;
static const size_t MAX_TEXTURE_CACHE_BYTES = 16 * 1024 * 1024;
static const size_t kDefaultTextureCacheBudget = 16 * 1024 * 1024;
static const size_t DRAW_BUFFER_VBPOOL_BUFFER_SIZE = 1 << 15;
static const int DRAW_BUFFER_VBPOOL_PREALLOC_BUFFERS = 4;
@ -541,13 +540,12 @@ GrTexture* GrContext::createUncachedTexture(const GrTextureDesc& descIn,
return fGpu->createTexture(descCopy, srcData, rowBytes);
}
void GrContext::getTextureCacheLimits(int* maxTextures,
size_t* maxTextureBytes) const {
fTextureCache->getLimits(maxTextures, maxTextureBytes);
size_t GrContext::getTextureCacheBudget() const {
return fTextureCache->getBudget();
}
void GrContext::setTextureCacheLimits(int maxTextures, size_t maxTextureBytes) {
fTextureCache->setLimits(maxTextures, maxTextureBytes);
void GrContext::setTextureCacheBudget(size_t maxTextureBytes) {
fTextureCache->setBudget(maxTextureBytes);
}
int GrContext::getMaxTextureSize() const {
@ -1731,8 +1729,7 @@ GrContext::GrContext(GrGpu* gpu) {
fPathRendererChain = NULL;
fSoftwarePathRenderer = NULL;
fTextureCache = new GrResourceCache(MAX_TEXTURE_CACHE_COUNT,
MAX_TEXTURE_CACHE_BYTES);
fTextureCache = new GrResourceCache(kDefaultTextureCacheBudget);
fFontCache = new GrFontCache(fGpu);
fLastDrawCategory = kUnbuffered_DrawCategory;

27
src/gpu/GrResourceCache.cpp
View File

@ -34,9 +34,8 @@ void GrResourceEntry::validate() const {
///////////////////////////////////////////////////////////////////////////////
GrResourceCache::GrResourceCache(int maxCount, size_t maxBytes) :
fMaxCount(maxCount),
fMaxBytes(maxBytes) {
GrResourceCache::GrResourceCache(size_t maxBytes) {
fMaxBytes = maxBytes;
fEntryCount = 0;
fUnlockedEntryCount = 0;
fEntryBytes = 0;
@ -53,19 +52,9 @@ GrResourceCache::~GrResourceCache() {
this->removeAll();
}
void GrResourceCache::getLimits(int* maxResources, size_t* maxResourceBytes) const{
if (maxResources) {
*maxResources = fMaxCount;
}
if (maxResourceBytes) {
*maxResourceBytes = fMaxBytes;
}
}
void GrResourceCache::setBudget(size_t maxResourceBytes) {
bool smaller = maxResourceBytes < fMaxBytes;
void GrResourceCache::setLimits(int maxResources, size_t maxResourceBytes) {
bool smaller = (maxResources < fMaxCount) || (maxResourceBytes < fMaxBytes);
fMaxCount = maxResources;
fMaxBytes = maxResourceBytes;
if (smaller) {
@ -223,6 +212,7 @@ void GrResourceCache::reattachAndUnlock(GrResourceEntry* entry) {
fClientDetachedCount -= 1;
fEntryCount -= 1;
size_t size = entry->resource()->sizeInBytes();
GrAssert(size > 0);
fClientDetachedBytes -= size;
fEntryBytes -= size;
}
@ -261,7 +251,7 @@ void GrResourceCache::purgeAsNeeded() {
GrResourceEntry* entry = fTail;
while (entry && fUnlockedEntryCount) {
GrAutoResourceCacheValidate atcv(this);
if (fEntryCount <= fMaxCount && fEntryBytes <= fMaxBytes) {
if (fEntryBytes <= fMaxBytes) {
withinBudget = true;
break;
}
@ -297,9 +287,7 @@ void GrResourceCache::removeAll() {
// entry out. Instead change the budget and purge.
int savedMaxBytes = fMaxBytes;
int savedMaxCount = fMaxCount;
fMaxBytes = (size_t) -1;
fMaxCount = 0;
fMaxBytes = 0;
this->purgeAsNeeded();
#if GR_DEBUG
@ -316,7 +304,6 @@ void GrResourceCache::removeAll() {
#endif
fMaxBytes = savedMaxBytes;
fMaxCount = savedMaxCount;
}
///////////////////////////////////////////////////////////////////////////////

28
src/gpu/GrResourceCache.h
View File

@ -194,29 +194,22 @@ private:
*/
class GrResourceCache {
public:
GrResourceCache(int maxCount, size_t maxBytes);
GrResourceCache(size_t maxResourceBytes);
~GrResourceCache();
/**
* Return the current resource cache limits.
*
* @param maxResource If non-null, returns maximum number of resources
* that can be held in the cache.
* @param maxBytes If non-null, returns maximum number of bytes of
* gpu memory that can be held in the cache.
* Returns the cache budget in bytes.
*/
void getLimits(int* maxResources, size_t* maxBytes) const;
size_t getBudget() const { return fMaxBytes; }
/**
* Specify the resource cache limits. If the current cache exceeds either
* of these, it will be purged (LRU) to keep the cache within these limits.
* Specify the resource cache budget in bytes of GPU memory. If the current
* cache exceeds the budget it will be purged to be within the budget.
*
* @param maxResources The maximum number of resources that can be held in
* the cache.
* @param maxBytes The maximum number of bytes of resource memory that
* can be held in the cache.
* @param maxResourceBytes The maximum number of bytes of GPU memory that
* can be held in the cache.
*/
void setLimits(int maxResource, size_t maxResourceBytes);
void setBudget(size_t maxResourceBytes);
/**
* Returns the number of bytes consumed by cached resources.
@ -241,8 +234,8 @@ public:
* Create a new entry, based on the specified key and resource, and return
* its "locked" entry.
*
* Ownership of the resource is transferred to the Entry, which will unref()
* it when we are purged or deleted.
* Ownership of the resource is transferred to the Entry, which will
* unref() it when we are purged or deleted.
*/
GrResourceEntry* createAndLock(const GrResourceKey&, GrResource*);
@ -294,7 +287,6 @@ private:
GrResourceEntry* fTail;
// our budget, used in purgeAsNeeded()
int fMaxCount;
size_t fMaxBytes;
// our current stats, related to our budget

3
src/gpu/SkGpuDevice.cpp
View File

@ -1152,8 +1152,7 @@ bool SkGpuDevice::shouldTileBitmap(const SkBitmap& bitmap,
// assumption here is that sw bitmap size is a good proxy for its size as
// a texture
size_t bmpSize = bitmap.getSize();
size_t cacheSize;
fContext->getTextureCacheLimits(NULL, &cacheSize);
size_t cacheSize = fContext->getTextureCacheBudget();
if (bmpSize < cacheSize / 2) {
return false;
}