From a294be24040262d530c54dc01fc322132c5d2a24 Mon Sep 17 00:00:00 2001 From: Hal Canary Date: Wed, 19 Apr 2017 13:17:59 -0400 Subject: SkDiscardableMemoryPool: modernize * Use unique_ptr, sk_sp, SkAutoFree, using. * Rely on thread-safe static global initializion. Change-Id: I7c14e0e57622163b1b81b97a218b816fe6d02926 Reviewed-on: https://skia-review.googlesource.com/13818 Commit-Queue: Hal Canary Reviewed-by: Herb Derby --- src/lazy/SkDiscardableMemoryPool.cpp | 68 +++++++++++++++--------------------- src/lazy/SkDiscardableMemoryPool.h | 3 +- 2 files changed, 30 insertions(+), 41 deletions(-) (limited to 'src/lazy') diff --git a/src/lazy/SkDiscardableMemoryPool.cpp b/src/lazy/SkDiscardableMemoryPool.cpp index 8a6cb526b3..aeba34bb04 100644 --- a/src/lazy/SkDiscardableMemoryPool.cpp +++ b/src/lazy/SkDiscardableMemoryPool.cpp @@ -5,13 +5,13 @@ * found in the LICENSE file. */ -#include "SkDiscardableMemory.h" #include "SkDiscardableMemoryPool.h" -#include "SkImageGenerator.h" +#include "SkDiscardableMemory.h" +#include "SkMakeUnique.h" #include "SkMalloc.h" #include "SkMutex.h" -#include "SkOnce.h" #include "SkTInternalLList.h" +#include "SkTemplates.h" // Note: // A PoolDiscardableMemory is memory that is counted in a pool. @@ -33,7 +33,10 @@ public: DiscardableMemoryPool(size_t budget, SkBaseMutex* mutex = nullptr); ~DiscardableMemoryPool() override; - SkDiscardableMemory* create(size_t bytes) override; + std::unique_ptr make(size_t bytes); + SkDiscardableMemory* create(size_t bytes) override { + return this->make(bytes).release(); // TODO: change API + } size_t getRAMUsed() override; void setRAMBudget(size_t budget) override; @@ -61,7 +64,7 @@ private: /** Function called to free memory if needed */ void dumpDownTo(size_t budget); /** called by DiscardableMemoryPool upon destruction */ - void free(PoolDiscardableMemory* dm); + void removeFromPool(PoolDiscardableMemory* dm); /** called by DiscardableMemoryPool::lock() */ bool lock(PoolDiscardableMemory* dm); /** called by DiscardableMemoryPool::unlock() */ @@ -78,8 +81,7 @@ private: */ class PoolDiscardableMemory : public SkDiscardableMemory { public: - PoolDiscardableMemory(DiscardableMemoryPool* pool, - void* pointer, size_t bytes); + PoolDiscardableMemory(sk_sp pool, SkAutoFree pointer, size_t bytes); ~PoolDiscardableMemory() override; bool lock() override; void* data() override; @@ -87,29 +89,24 @@ public: friend class DiscardableMemoryPool; private: SK_DECLARE_INTERNAL_LLIST_INTERFACE(PoolDiscardableMemory); - DiscardableMemoryPool* const fPool; + sk_sp fPool; bool fLocked; - void* fPointer; + SkAutoFree fPointer; const size_t fBytes; }; -PoolDiscardableMemory::PoolDiscardableMemory(DiscardableMemoryPool* pool, - void* pointer, +PoolDiscardableMemory::PoolDiscardableMemory(sk_sp pool, + SkAutoFree pointer, size_t bytes) - : fPool(pool) - , fLocked(true) - , fPointer(pointer) - , fBytes(bytes) { + : fPool(std::move(pool)), fLocked(true), fPointer(std::move(pointer)), fBytes(bytes) { SkASSERT(fPool != nullptr); SkASSERT(fPointer != nullptr); SkASSERT(fBytes > 0); - fPool->ref(); } PoolDiscardableMemory::~PoolDiscardableMemory() { SkASSERT(!fLocked); // contract for SkDiscardableMemory - fPool->free(this); - fPool->unref(); + fPool->removeFromPool(this); } bool PoolDiscardableMemory::lock() { @@ -119,7 +116,7 @@ bool PoolDiscardableMemory::lock() { void* PoolDiscardableMemory::data() { SkASSERT(fLocked); // contract for SkDiscardableMemory - return fPointer; + return fPointer.get(); } void PoolDiscardableMemory::unlock() { @@ -153,14 +150,13 @@ void DiscardableMemoryPool::dumpDownTo(size_t budget) { if (fUsed <= budget) { return; } - typedef SkTInternalLList::Iter Iter; + using Iter = SkTInternalLList::Iter; Iter iter; PoolDiscardableMemory* cur = iter.init(fList, Iter::kTail_IterStart); while ((fUsed > budget) && (cur)) { if (!cur->fLocked) { PoolDiscardableMemory* dm = cur; SkASSERT(dm->fPointer != nullptr); - sk_free(dm->fPointer); dm->fPointer = nullptr; SkASSERT(fUsed >= dm->fBytes); fUsed -= dm->fBytes; @@ -174,25 +170,23 @@ void DiscardableMemoryPool::dumpDownTo(size_t budget) { } } -SkDiscardableMemory* DiscardableMemoryPool::create(size_t bytes) { - void* addr = sk_malloc_flags(bytes, 0); +std::unique_ptr DiscardableMemoryPool::make(size_t bytes) { + SkAutoFree addr(sk_malloc_flags(bytes, 0)); if (nullptr == addr) { return nullptr; } - PoolDiscardableMemory* dm = new PoolDiscardableMemory(this, addr, bytes); + auto dm = skstd::make_unique(sk_ref_sp(this), std::move(addr), bytes); SkAutoMutexAcquire autoMutexAcquire(fMutex); - fList.addToHead(dm); + fList.addToHead(dm.get()); fUsed += bytes; this->dumpDownTo(fBudget); - return dm; + return std::move(dm); } -void DiscardableMemoryPool::free(PoolDiscardableMemory* dm) { +void DiscardableMemoryPool::removeFromPool(PoolDiscardableMemory* dm) { SkAutoMutexAcquire autoMutexAcquire(fMutex); // This is called by dm's destructor. if (dm->fPointer != nullptr) { - sk_free(dm->fPointer); - dm->fPointer = nullptr; SkASSERT(fUsed >= dm->fBytes); fUsed -= dm->fBytes; fList.remove(dm); @@ -242,18 +236,14 @@ void DiscardableMemoryPool::dumpPool() { } // namespace -SkDiscardableMemoryPool* SkDiscardableMemoryPool::Create(size_t size, SkBaseMutex* mutex) { - return new DiscardableMemoryPool(size, mutex); +sk_sp SkDiscardableMemoryPool::Make(size_t size, SkBaseMutex* mutex) { + return sk_make_sp(size, mutex); } -SK_DECLARE_STATIC_MUTEX(gMutex); - SkDiscardableMemoryPool* SkGetGlobalDiscardableMemoryPool() { - static SkOnce once; - static SkDiscardableMemoryPool* global; - once([]{ - global = SkDiscardableMemoryPool::Create(SK_DEFAULT_GLOBAL_DISCARDABLE_MEMORY_POOL_SIZE, - &gMutex); - }); + static SkBaseMutex gMutex; + // Intentionally leak this global pool. + static SkDiscardableMemoryPool* global = + new DiscardableMemoryPool(SK_DEFAULT_GLOBAL_DISCARDABLE_MEMORY_POOL_SIZE, &gMutex); return global; } diff --git a/src/lazy/SkDiscardableMemoryPool.h b/src/lazy/SkDiscardableMemoryPool.h index 92ba48bcb4..f7beaad581 100644 --- a/src/lazy/SkDiscardableMemoryPool.h +++ b/src/lazy/SkDiscardableMemoryPool.h @@ -52,8 +52,7 @@ public: * the pool works. * Without mutex, will be not be thread safe. */ - static SkDiscardableMemoryPool* Create( - size_t size, SkBaseMutex* mutex = nullptr); + static sk_sp Make(size_t size, SkBaseMutex* mutex = nullptr); }; /** -- cgit v1.2.3