OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2012 Google Inc. | 2 * Copyright 2012 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "GrMemoryPool.h" | 8 #include "GrMemoryPool.h" |
9 | 9 |
10 #ifdef SK_DEBUG | 10 #ifdef SK_DEBUG |
11 #define VALIDATE this->validate() | 11 #define VALIDATE this->validate() |
12 #else | 12 #else |
13 #define VALIDATE | 13 #define VALIDATE |
14 #endif | 14 #endif |
15 | 15 |
16 GrMemoryPool::GrMemoryPool(size_t preallocSize, size_t minAllocSize) { | 16 GrMemoryPool::GrMemoryPool(size_t preallocSize, size_t minAllocSize) { |
17 SkDEBUGCODE(fAllocationCnt = 0); | 17 SkDEBUGCODE(fAllocationCnt = 0); |
| 18 SkDEBUGCODE(fAllocBlockCnt = 0); |
18 | 19 |
19 minAllocSize = SkTMax<size_t>(minAllocSize, 1 << 10); | 20 minAllocSize = SkTMax<size_t>(minAllocSize, 1 << 10); |
20 fMinAllocSize = GrSizeAlignUp(minAllocSize + kPerAllocPad, kAlignment), | 21 fMinAllocSize = GrSizeAlignUp(minAllocSize + kPerAllocPad, kAlignment), |
21 fPreallocSize = GrSizeAlignUp(preallocSize + kPerAllocPad, kAlignment); | 22 fPreallocSize = GrSizeAlignUp(preallocSize + kPerAllocPad, kAlignment); |
22 fPreallocSize = SkTMax(fPreallocSize, fMinAllocSize); | 23 fPreallocSize = SkTMax(fPreallocSize, fMinAllocSize); |
| 24 fSize = fPreallocSize; |
23 | 25 |
24 fHead = CreateBlock(fPreallocSize); | 26 fHead = CreateBlock(fPreallocSize); |
25 fTail = fHead; | 27 fTail = fHead; |
26 fHead->fNext = NULL; | 28 fHead->fNext = NULL; |
27 fHead->fPrev = NULL; | 29 fHead->fPrev = NULL; |
28 VALIDATE; | 30 VALIDATE; |
29 }; | 31 }; |
30 | 32 |
31 GrMemoryPool::~GrMemoryPool() { | 33 GrMemoryPool::~GrMemoryPool() { |
32 VALIDATE; | 34 VALIDATE; |
(...skipping 10 matching lines...) Expand all Loading... |
43 if (fTail->fFreeSize < size) { | 45 if (fTail->fFreeSize < size) { |
44 size_t blockSize = size; | 46 size_t blockSize = size; |
45 blockSize = SkTMax<size_t>(blockSize, fMinAllocSize); | 47 blockSize = SkTMax<size_t>(blockSize, fMinAllocSize); |
46 BlockHeader* block = CreateBlock(blockSize); | 48 BlockHeader* block = CreateBlock(blockSize); |
47 | 49 |
48 block->fPrev = fTail; | 50 block->fPrev = fTail; |
49 block->fNext = NULL; | 51 block->fNext = NULL; |
50 SkASSERT(NULL == fTail->fNext); | 52 SkASSERT(NULL == fTail->fNext); |
51 fTail->fNext = block; | 53 fTail->fNext = block; |
52 fTail = block; | 54 fTail = block; |
| 55 fSize += block->fSize; |
| 56 SkDEBUGCODE(++fAllocBlockCnt); |
53 } | 57 } |
54 SkASSERT(fTail->fFreeSize >= size); | 58 SkASSERT(fTail->fFreeSize >= size); |
55 intptr_t ptr = fTail->fCurrPtr; | 59 intptr_t ptr = fTail->fCurrPtr; |
56 // We stash a pointer to the block header, just before the allocated space, | 60 // We stash a pointer to the block header, just before the allocated space, |
57 // so that we can decrement the live count on delete in constant time. | 61 // so that we can decrement the live count on delete in constant time. |
58 *reinterpret_cast<BlockHeader**>(ptr) = fTail; | 62 *reinterpret_cast<BlockHeader**>(ptr) = fTail; |
59 ptr += kPerAllocPad; | 63 ptr += kPerAllocPad; |
60 fTail->fPrevPtr = fTail->fCurrPtr; | 64 fTail->fPrevPtr = fTail->fCurrPtr; |
61 fTail->fCurrPtr += size; | 65 fTail->fCurrPtr += size; |
62 fTail->fFreeSize -= size; | 66 fTail->fFreeSize -= size; |
63 fTail->fLiveCount += 1; | 67 fTail->fLiveCount += 1; |
| 68 |
64 SkDEBUGCODE(++fAllocationCnt); | 69 SkDEBUGCODE(++fAllocationCnt); |
65 VALIDATE; | 70 VALIDATE; |
66 return reinterpret_cast<void*>(ptr); | 71 return reinterpret_cast<void*>(ptr); |
67 } | 72 } |
68 | 73 |
69 void GrMemoryPool::release(void* p) { | 74 void GrMemoryPool::release(void* p) { |
70 VALIDATE; | 75 VALIDATE; |
71 intptr_t ptr = reinterpret_cast<intptr_t>(p) - kPerAllocPad; | 76 intptr_t ptr = reinterpret_cast<intptr_t>(p) - kPerAllocPad; |
72 BlockHeader* block = *reinterpret_cast<BlockHeader**>(ptr); | 77 BlockHeader* block = *reinterpret_cast<BlockHeader**>(ptr); |
73 if (1 == block->fLiveCount) { | 78 if (1 == block->fLiveCount) { |
74 // the head block is special, it is reset rather than deleted | 79 // the head block is special, it is reset rather than deleted |
75 if (fHead == block) { | 80 if (fHead == block) { |
76 fHead->fCurrPtr = reinterpret_cast<intptr_t>(fHead) + | 81 fHead->fCurrPtr = reinterpret_cast<intptr_t>(fHead) + kHeaderSize; |
77 kHeaderSize; | |
78 fHead->fLiveCount = 0; | 82 fHead->fLiveCount = 0; |
79 fHead->fFreeSize = fPreallocSize; | 83 fHead->fFreeSize = fPreallocSize; |
80 } else { | 84 } else { |
81 BlockHeader* prev = block->fPrev; | 85 BlockHeader* prev = block->fPrev; |
82 BlockHeader* next = block->fNext; | 86 BlockHeader* next = block->fNext; |
83 SkASSERT(prev); | 87 SkASSERT(prev); |
84 prev->fNext = next; | 88 prev->fNext = next; |
85 if (next) { | 89 if (next) { |
86 next->fPrev = prev; | 90 next->fPrev = prev; |
87 } else { | 91 } else { |
88 SkASSERT(fTail == block); | 92 SkASSERT(fTail == block); |
89 fTail = prev; | 93 fTail = prev; |
90 } | 94 } |
| 95 fSize -= block->fSize; |
91 DeleteBlock(block); | 96 DeleteBlock(block); |
| 97 SkDEBUGCODE(fAllocBlockCnt--); |
92 } | 98 } |
93 } else { | 99 } else { |
94 --block->fLiveCount; | 100 --block->fLiveCount; |
95 // Trivial reclaim: if we're releasing the most recent allocation, reuse
it | 101 // Trivial reclaim: if we're releasing the most recent allocation, reuse
it |
96 if (block->fPrevPtr == ptr) { | 102 if (block->fPrevPtr == ptr) { |
97 block->fFreeSize += (block->fCurrPtr - block->fPrevPtr); | 103 block->fFreeSize += (block->fCurrPtr - block->fPrevPtr); |
98 block->fCurrPtr = block->fPrevPtr; | 104 block->fCurrPtr = block->fPrevPtr; |
99 } | 105 } |
100 } | 106 } |
101 SkDEBUGCODE(--fAllocationCnt); | 107 SkDEBUGCODE(--fAllocationCnt); |
102 VALIDATE; | 108 VALIDATE; |
103 } | 109 } |
104 | 110 |
105 GrMemoryPool::BlockHeader* GrMemoryPool::CreateBlock(size_t size) { | 111 GrMemoryPool::BlockHeader* GrMemoryPool::CreateBlock(size_t size) { |
| 112 size_t paddedSize = size + kHeaderSize; |
106 BlockHeader* block = | 113 BlockHeader* block = |
107 reinterpret_cast<BlockHeader*>(sk_malloc_throw(size + kHeaderSize)); | 114 reinterpret_cast<BlockHeader*>(sk_malloc_throw(paddedSize)); |
108 // we assume malloc gives us aligned memory | 115 // we assume malloc gives us aligned memory |
109 SkASSERT(!(reinterpret_cast<intptr_t>(block) % kAlignment)); | 116 SkASSERT(!(reinterpret_cast<intptr_t>(block) % kAlignment)); |
110 block->fLiveCount = 0; | 117 block->fLiveCount = 0; |
111 block->fFreeSize = size; | 118 block->fFreeSize = size; |
112 block->fCurrPtr = reinterpret_cast<intptr_t>(block) + kHeaderSize; | 119 block->fCurrPtr = reinterpret_cast<intptr_t>(block) + kHeaderSize; |
113 block->fPrevPtr = 0; // gcc warns on assigning NULL to an intptr_t. | 120 block->fPrevPtr = 0; // gcc warns on assigning NULL to an intptr_t. |
| 121 block->fSize = paddedSize; |
114 return block; | 122 return block; |
115 } | 123 } |
116 | 124 |
117 void GrMemoryPool::DeleteBlock(BlockHeader* block) { | 125 void GrMemoryPool::DeleteBlock(BlockHeader* block) { |
118 sk_free(block); | 126 sk_free(block); |
119 } | 127 } |
120 | 128 |
121 void GrMemoryPool::validate() { | 129 void GrMemoryPool::validate() { |
122 #ifdef SK_DEBUG | 130 #ifdef SK_DEBUG |
123 BlockHeader* block = fHead; | 131 BlockHeader* block = fHead; |
(...skipping 26 matching lines...) Expand all Loading... |
150 if (!block->fLiveCount) { | 158 if (!block->fLiveCount) { |
151 SkASSERT(ptrOffset == kHeaderSize); | 159 SkASSERT(ptrOffset == kHeaderSize); |
152 SkASSERT(userStart == block->fCurrPtr); | 160 SkASSERT(userStart == block->fCurrPtr); |
153 } else { | 161 } else { |
154 SkASSERT(block == *reinterpret_cast<BlockHeader**>(userStart)); | 162 SkASSERT(block == *reinterpret_cast<BlockHeader**>(userStart)); |
155 } | 163 } |
156 prev = block; | 164 prev = block; |
157 } while ((block = block->fNext)); | 165 } while ((block = block->fNext)); |
158 SkASSERT(allocCount == fAllocationCnt); | 166 SkASSERT(allocCount == fAllocationCnt); |
159 SkASSERT(prev == fTail); | 167 SkASSERT(prev == fTail); |
| 168 SkASSERT(fAllocBlockCnt != 0 || fSize == fPreallocSize); |
160 #endif | 169 #endif |
161 } | 170 } |
OLD | NEW |