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

revert TLS change (until we impl windows backend)

Browse Source 
git-svn-id: http://skia.googlecode.com/svn/trunk@3858 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
reed@google.com 2012-05-07 19:27:18 +00:00
parent 09dcf754ff
commit 82d447d4f1
2 changed files with 7 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
include/core/SkGraphics.h
View File

@ -65,29 +65,6 @@ public:
*/
static void SetFlags(const char* flags);
/**
* Return the max number of bytes that should be used by the thread-local
* font cache.
* If the cache needs to allocate more, it will purge previous entries.
* This max can be changed by calling SetFontCacheLimit().
*
* If this thread has never called SetTLSFontCacheLimit, or has called it
* with 0, then this thread is using the shared font cache. In that case,
* this function will always return 0, and the caller may want to call
* GetFontCacheLimit.
*/
static size_t GetTLSFontCacheLimit();
/**
* Specify the max number of bytes that should be used by the thread-local
* font cache. If this value is zero (the default), then this thread will
* share the global font cache and its limit.
*
* This function returns the previous setting, as if GetFontCacheLimit()
* had be called before the new limit was set.
*/
static size_t SetTLSFontCacheLimit(size_t bytes);
private:
/** This is automatically called by SkGraphics::Init(), and must be
implemented by the host OS. This allows the host OS to register a callback

57
src/core/SkGlyphCache.cpp
View File

@ -11,7 +11,6 @@
#include "SkGraphics.h"
#include "SkPaint.h"
#include "SkTemplates.h"
#include "SkTLS.h"
//#define SPEW_PURGE_STATUS
//#define USE_CACHE_HASH
@ -415,27 +414,17 @@ void SkGlyphCache::invokeAndRemoveAuxProcs() {
class SkGlyphCache_Globals {
public:
enum UseMutex {
kNo_UseMutex, // thread-local cache
kYes_UseMutex, // shared cache
};
SkGlyphCache_Globals(UseMutex um) {
SkGlyphCache_Globals() {
fHead = NULL;
fTotalMemoryUsed = 0;
fFontCacheLimit = SK_DEFAULT_FONT_CACHE_LIMIT;
fMutex = (kYes_UseMutex == um) ? SkNEW(SkMutex) : NULL;
#ifdef USE_CACHE_HASH
sk_bzero(fHash, sizeof(fHash));
#endif
}
~SkGlyphCache_Globals() {
SkDELETE(fMutex);
}
SkMutex* fMutex;
SkMutex fMutex;
SkGlyphCache* fHead;
size_t fTotalMemoryUsed;
#ifdef USE_CACHE_HASH
@ -451,27 +440,8 @@ public:
size_t getFontCacheLimit() const { return fFontCacheLimit; }
size_t setFontCacheLimit(size_t limit);
// can return NULL
static SkGlyphCache_Globals* FindTLS() {
return (SkGlyphCache_Globals*)SkTLS::Find(CreateTLS);
}
static SkGlyphCache_Globals& GetTLS() {
return *(SkGlyphCache_Globals*)SkTLS::Get(CreateTLS, DeleteTLS);
}
static void DeleteTLS() { SkTLS::Delete(CreateTLS); }
private:
size_t fFontCacheLimit;
static void* CreateTLS() {
return SkNEW_ARGS(SkGlyphCache_Globals, (kNo_UseMutex));
}
static void DeleteTLS(void* ptr) {
SkDELETE((SkGlyphCache_Globals*)ptr);
}
};
size_t SkGlyphCache_Globals::setFontCacheLimit(size_t newLimit) {
@ -485,8 +455,9 @@ size_t SkGlyphCache_Globals::setFontCacheLimit(size_t newLimit) {
size_t currUsed = fTotalMemoryUsed;
if (currUsed > newLimit) {
SkAutoMutexAcquire ac(fMutex);
fMutex.acquire();
SkGlyphCache::InternalFreeCache(this, currUsed - newLimit);
fMutex.release();
}
return prevLimit;
}
@ -494,15 +465,14 @@ size_t SkGlyphCache_Globals::setFontCacheLimit(size_t newLimit) {
// Returns the shared globals
static SkGlyphCache_Globals& getSharedGlobals() {
// we leak this, so we don't incur any shutdown cost of the destructor
static SkGlyphCache_Globals* gGlobals = SkNEW_ARGS(SkGlyphCache_Globals,
(SkGlyphCache_Globals::kYes_UseMutex));
static SkGlyphCache_Globals* gGlobals = new SkGlyphCache_Globals;
return *gGlobals;
}
// Returns the TLS globals (if set), or the shared globals
static SkGlyphCache_Globals& getGlobals() {
SkGlyphCache_Globals* tls = SkGlyphCache_Globals::FindTLS();
return tls ? *tls : getSharedGlobals();
// TODO: Check TLS for local globals...
return getSharedGlobals();
}
void SkGlyphCache::VisitAllCaches(bool (*proc)(SkGlyphCache*, void*),
@ -728,16 +698,3 @@ void SkGraphics::PurgeFontCache() {
SkTypefaceCache::PurgeAll();
}
size_t SkGraphics::GetTLSFontCacheLimit() {
const SkGlyphCache_Globals* tls = SkGlyphCache_Globals::FindTLS();
return tls ? tls->getFontCacheLimit() : 0;
}
size_t SkGraphics::SetTLSFontCacheLimit(size_t bytes) {
if (0 == bytes) {
SkGlyphCache_Globals::DeleteTLS();
} else {
SkGlyphCache_Globals::GetTLS().setFontCacheLimit(bytes);
}
}