diff options
author | benjaminwagner <benjaminwagner@google.com> | 2016-02-05 07:02:38 -0800 |
---|---|---|
committer | Commit bot <commit-bot@chromium.org> | 2016-02-05 07:02:38 -0800 |
commit | f49c75a8f1eacf8e6cb19ce0dcc1cc9bcbf1f96e (patch) | |
tree | 54f07f63610fd7533a92fce949b97531a6cf875c /include | |
parent | 001cc1f41be1e6fce39f0cc1426a1497909d91cd (diff) |
Move Google3-specific stack limitation logic to template classes.
Remove #ifdefs in other files.
Reapplies https://codereview.chromium.org/1656143003; removing the implicit constructors for GLPtr and GLPtrAlias resolves the build issue on Android.
Also reverts https://codereview.chromium.org/1663013004
Does not change the public API.
TBR=reed
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1666203002
Review URL: https://codereview.chromium.org/1666203002
Diffstat (limited to 'include')
-rw-r--r-- | include/core/SkTypes.h | 51 | ||||
-rw-r--r-- | include/gpu/gl/GrGLInterface.h | 6 | ||||
-rw-r--r-- | include/private/SkTemplates.h | 46 |
3 files changed, 68 insertions, 35 deletions
diff --git a/include/core/SkTypes.h b/include/core/SkTypes.h index 0d31efc6cc..4592168bd4 100644 --- a/include/core/SkTypes.h +++ b/include/core/SkTypes.h @@ -606,17 +606,16 @@ private: #define SkAutoMalloc(...) SK_REQUIRE_LOCAL_VAR(SkAutoMalloc) /** - * Manage an allocated block of memory. If the requested size is <= kSize, then - * the allocation will come from the stack rather than the heap. This object - * is the sole manager of the lifetime of the block, so the caller must not - * call sk_free() or delete on the block. + * Manage an allocated block of memory. If the requested size is <= kSizeRequested (or slightly + * more), then the allocation will come from the stack rather than the heap. This object is the + * sole manager of the lifetime of the block, so the caller must not call sk_free() or delete on + * the block. */ -template <size_t kSize> class SkAutoSMalloc : SkNoncopyable { +template <size_t kSizeRequested> class SkAutoSMalloc : SkNoncopyable { public: /** - * Creates initially empty storage. get() returns a ptr, but it is to - * a zero-byte allocation. Must call reset(size) to return an allocated - * block. + * Creates initially empty storage. get() returns a ptr, but it is to a zero-byte allocation. + * Must call reset(size) to return an allocated block. */ SkAutoSMalloc() { fPtr = fStorage; @@ -624,9 +623,8 @@ public: } /** - * Allocate a block of the specified size. If size <= kSize, then the - * allocation will come from the stack, otherwise it will be dynamically - * allocated. + * Allocate a block of the specified size. If size <= kSizeRequested (or slightly more), then + * the allocation will come from the stack, otherwise it will be dynamically allocated. */ explicit SkAutoSMalloc(size_t size) { fPtr = fStorage; @@ -635,8 +633,8 @@ public: } /** - * Free the allocated block (if any). If the block was small enought to - * have been allocated on the stack (size <= kSize) then this does nothing. + * Free the allocated block (if any). If the block was small enough to have been allocated on + * the stack, then this does nothing. */ ~SkAutoSMalloc() { if (fPtr != (void*)fStorage) { @@ -645,18 +643,16 @@ public: } /** - * Return the allocated block. May return non-null even if the block is - * of zero size. Since this may be on the stack or dynamically allocated, - * the caller must not call sk_free() on it, but must rely on SkAutoSMalloc - * to manage it. + * Return the allocated block. May return non-null even if the block is of zero size. Since + * this may be on the stack or dynamically allocated, the caller must not call sk_free() on it, + * but must rely on SkAutoSMalloc to manage it. */ void* get() const { return fPtr; } /** - * Return a new block of the requested size, freeing (as necessary) any - * previously allocated block. As with the constructor, if size <= kSize - * then the return block may be allocated locally, rather than from the - * heap. + * Return a new block of the requested size, freeing (as necessary) any previously allocated + * block. As with the constructor, if size <= kSizeRequested (or slightly more) then the return + * block may be allocated locally, rather than from the heap. */ void* reset(size_t size, SkAutoMalloc::OnShrink shrink = SkAutoMalloc::kAlloc_OnShrink, @@ -686,9 +682,20 @@ public: } private: + // Align up to 32 bits. + static const size_t kSizeAlign4 = SkAlign4(kSizeRequested); +#if defined(GOOGLE3) + // Stack frame size is limited for GOOGLE3. 4k is less than the actual max, but some functions + // have multiple large stack allocations. + static const size_t kMaxBytes = 4 * 1024; + static const size_t kSize = kSizeRequested > kMaxBytes ? kMaxBytes : kSizeAlign4; +#else + static const size_t kSize = kSizeAlign4; +#endif + void* fPtr; size_t fSize; // can be larger than the requested size (see kReuse) - uint32_t fStorage[(kSize + 3) >> 2]; + uint32_t fStorage[kSize >> 2]; }; // Can't guard the constructor because it's a template class. diff --git a/include/gpu/gl/GrGLInterface.h b/include/gpu/gl/GrGLInterface.h index 31429a8ebc..5fa31eda94 100644 --- a/include/gpu/gl/GrGLInterface.h +++ b/include/gpu/gl/GrGLInterface.h @@ -109,7 +109,8 @@ private: template <typename FNPTR_TYPE> class GLPtr { public: GLPtr() : fPtr(NULL) {} - GLPtr operator=(FNPTR_TYPE ptr) { fPtr = ptr; return *this; } + GLPtr(const GLPtr&) = delete; + GLPtr& operator=(FNPTR_TYPE ptr) { fPtr = ptr; return *this; } operator FNPTR_TYPE() const { return fPtr; } private: FNPTR_TYPE fPtr; @@ -119,7 +120,8 @@ private: // they're updated to use the Functions struct. template <typename FNPTR_TYPE> class GLPtrAlias { public: - GLPtrAlias(GLPtr<FNPTR_TYPE>* base) : fBase(base) {} + explicit GLPtrAlias(GLPtr<FNPTR_TYPE>* base) : fBase(base) {} + GLPtrAlias(const GLPtrAlias&) = delete; void operator=(FNPTR_TYPE ptr) { *fBase = ptr; } private: GLPtr<FNPTR_TYPE>* fBase; diff --git a/include/private/SkTemplates.h b/include/private/SkTemplates.h index 496cf42733..e36910e814 100644 --- a/include/private/SkTemplates.h +++ b/include/private/SkTemplates.h @@ -164,9 +164,9 @@ private: SkDEBUGCODE(int fCount;) }; -/** Wraps SkAutoTArray, with room for up to N elements preallocated +/** Wraps SkAutoTArray, with room for kCountRequested elements preallocated. */ -template <int N, typename T> class SkAutoSTArray : SkNoncopyable { +template <int kCountRequested, typename T> class SkAutoSTArray : SkNoncopyable { public: /** Initialize with no objects */ SkAutoSTArray() { @@ -195,13 +195,13 @@ public: } if (fCount != count) { - if (fCount > N) { + if (fCount > kCount) { // 'fArray' was allocated last time so free it now SkASSERT((T*) fStorage != fArray); sk_free(fArray); } - if (count > N) { + if (count > kCount) { const uint64_t size64 = sk_64_mul(count, sizeof(T)); const size_t size = static_cast<size_t>(size64); if (size != size64) { @@ -240,10 +240,21 @@ public: } private: +#if defined(GOOGLE3) + // Stack frame size is limited for GOOGLE3. 4k is less than the actual max, but some functions + // have multiple large stack allocations. + static const int kMaxBytes = 4 * 1024; + static const int kCount = kCountRequested * sizeof(T) > kMaxBytes + ? kMaxBytes / sizeof(T) + : kCountRequested; +#else + static const int kCount = kCountRequested; +#endif + int fCount; T* fArray; // since we come right after fArray, fStorage should be properly aligned - char fStorage[N * sizeof(T)]; + char fStorage[kCount * sizeof(T)]; }; /** Manages an array of T elements, freeing the array in the destructor. @@ -317,12 +328,12 @@ private: T* fPtr; }; -template <size_t N, typename T> class SkAutoSTMalloc : SkNoncopyable { +template <size_t kCountRequested, typename T> class SkAutoSTMalloc : SkNoncopyable { public: SkAutoSTMalloc() : fPtr(fTStorage) {} SkAutoSTMalloc(size_t count) { - if (count > N) { + if (count > kCount) { fPtr = (T*)sk_malloc_flags(count * sizeof(T), SK_MALLOC_THROW | SK_MALLOC_TEMP); } else { fPtr = fTStorage; @@ -340,7 +351,7 @@ public: if (fPtr != fTStorage) { sk_free(fPtr); } - if (count > N) { + if (count > kCount) { fPtr = (T*)sk_malloc_throw(count * sizeof(T)); } else { fPtr = fTStorage; @@ -368,10 +379,10 @@ public: // Reallocs the array, can be used to shrink the allocation. Makes no attempt to be intelligent void realloc(size_t count) { - if (count > N) { + if (count > kCount) { if (fPtr == fTStorage) { fPtr = (T*)sk_malloc_throw(count * sizeof(T)); - memcpy(fPtr, fTStorage, N * sizeof(T)); + memcpy(fPtr, fTStorage, kCount * sizeof(T)); } else { fPtr = (T*)sk_realloc_throw(fPtr, count * sizeof(T)); } @@ -381,9 +392,22 @@ public: } private: + // Since we use uint32_t storage, we might be able to get more elements for free. + static const size_t kCountWithPadding = SkAlign4(kCountRequested*sizeof(T)) / sizeof(T); +#if defined(GOOGLE3) + // Stack frame size is limited for GOOGLE3. 4k is less than the actual max, but some functions + // have multiple large stack allocations. + static const size_t kMaxBytes = 4 * 1024; + static const size_t kCount = kCountRequested * sizeof(T) > kMaxBytes + ? kMaxBytes / sizeof(T) + : kCountWithPadding; +#else + static const size_t kCount = kCountWithPadding; +#endif + T* fPtr; union { - uint32_t fStorage32[(N*sizeof(T) + 3) >> 2]; + uint32_t fStorage32[SkAlign4(kCount*sizeof(T)) >> 2]; T fTStorage[1]; // do NOT want to invoke T::T() }; }; |