OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright 2010 Google Inc. |
| 3 * |
| 4 * Use of this source code is governed by a BSD-style license that can be |
| 5 * found in the LICENSE file. |
| 6 */ |
| 7 |
| 8 #ifndef SkGlyphCache_Globals_DEFINED |
| 9 #define SkGlyphCache_Globals_DEFINED |
| 10 |
| 11 #include "SkGlyphCache.h" |
| 12 #include "SkTLS.h" |
| 13 |
| 14 #ifndef SK_DEFAULT_FONT_CACHE_COUNT_LIMIT |
| 15 #define SK_DEFAULT_FONT_CACHE_COUNT_LIMIT 256 |
| 16 #endif |
| 17 |
| 18 #ifndef SK_DEFAULT_FONT_CACHE_LIMIT |
| 19 #define SK_DEFAULT_FONT_CACHE_LIMIT (2 * 1024 * 1024) |
| 20 #endif |
| 21 |
| 22 /////////////////////////////////////////////////////////////////////////////// |
| 23 |
| 24 class SkMutex; |
| 25 |
| 26 class SkGlyphCache_Globals { |
| 27 public: |
| 28 enum UseMutex { |
| 29 kNo_UseMutex, // thread-local cache |
| 30 kYes_UseMutex // shared cache |
| 31 }; |
| 32 |
| 33 SkGlyphCache_Globals(UseMutex um) { |
| 34 fHead = NULL; |
| 35 fTotalMemoryUsed = 0; |
| 36 fCacheSizeLimit = SK_DEFAULT_FONT_CACHE_LIMIT; |
| 37 fCacheCount = 0; |
| 38 fCacheCountLimit = SK_DEFAULT_FONT_CACHE_COUNT_LIMIT; |
| 39 |
| 40 fMutex = (kYes_UseMutex == um) ? SkNEW(SkMutex) : NULL; |
| 41 } |
| 42 |
| 43 ~SkGlyphCache_Globals() { |
| 44 SkGlyphCache* cache = fHead; |
| 45 while (cache) { |
| 46 SkGlyphCache* next = cache->fNext; |
| 47 SkDELETE(cache); |
| 48 cache = next; |
| 49 } |
| 50 |
| 51 SkDELETE(fMutex); |
| 52 } |
| 53 |
| 54 SkMutex* fMutex; |
| 55 |
| 56 SkGlyphCache* internalGetHead() const { return fHead; } |
| 57 SkGlyphCache* internalGetTail() const; |
| 58 |
| 59 size_t getTotalMemoryUsed() const { return fTotalMemoryUsed; } |
| 60 int getCacheCountUsed() const { return fCacheCount; } |
| 61 |
| 62 #ifdef SK_DEBUG |
| 63 void validate() const; |
| 64 #else |
| 65 void validate() const {} |
| 66 #endif |
| 67 |
| 68 int getCacheCountLimit() const { return fCacheCountLimit; } |
| 69 int setCacheCountLimit(int limit); |
| 70 |
| 71 size_t getCacheSizeLimit() const { return fCacheSizeLimit; } |
| 72 size_t setCacheSizeLimit(size_t limit); |
| 73 |
| 74 // returns true if this cache is over-budget either due to size limit |
| 75 // or count limit. |
| 76 bool isOverBudget() const { |
| 77 return fCacheCount > fCacheCountLimit || |
| 78 fTotalMemoryUsed > fCacheSizeLimit; |
| 79 } |
| 80 |
| 81 void purgeAll(); // does not change budget |
| 82 |
| 83 // call when a glyphcache is available for caching (i.e. not in use) |
| 84 void attachCacheToHead(SkGlyphCache*); |
| 85 |
| 86 // can only be called when the mutex is already held |
| 87 void internalDetachCache(SkGlyphCache*); |
| 88 void internalAttachCacheToHead(SkGlyphCache*); |
| 89 |
| 90 // can return NULL |
| 91 static SkGlyphCache_Globals* FindTLS() { |
| 92 return (SkGlyphCache_Globals*)SkTLS::Find(CreateTLS); |
| 93 } |
| 94 |
| 95 static SkGlyphCache_Globals& GetTLS() { |
| 96 return *(SkGlyphCache_Globals*)SkTLS::Get(CreateTLS, DeleteTLS); |
| 97 } |
| 98 |
| 99 static void DeleteTLS() { SkTLS::Delete(CreateTLS); } |
| 100 |
| 101 private: |
| 102 SkGlyphCache* fHead; |
| 103 size_t fTotalMemoryUsed; |
| 104 size_t fCacheSizeLimit; |
| 105 int32_t fCacheCountLimit; |
| 106 int32_t fCacheCount; |
| 107 |
| 108 // Checkout budgets, modulated by the specified min-bytes-needed-to-purge, |
| 109 // and attempt to purge caches to match. |
| 110 // Returns number of bytes freed. |
| 111 size_t internalPurge(size_t minBytesNeeded = 0); |
| 112 |
| 113 static void* CreateTLS() { |
| 114 return SkNEW_ARGS(SkGlyphCache_Globals, (kNo_UseMutex)); |
| 115 } |
| 116 |
| 117 static void DeleteTLS(void* ptr) { |
| 118 SkDELETE((SkGlyphCache_Globals*)ptr); |
| 119 } |
| 120 }; |
| 121 |
| 122 #endif |
OLD | NEW |