OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright 2014 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 SkFreeList_DEFINED | |
9 #define SkFreeList_DEFINED | |
10 | |
11 #include "SkTInternalSList.h" | |
12 | |
13 /** | |
14 * An implementation of a self growing pool of objects. | |
15 * It maintains a pool of fully initialized objects. If an attempt is made to | |
16 * acquire one, and there are none left, it makes some more. | |
17 * It does not automatically reclaim them, they have to be given back to it. | |
18 * Constructors will be called on objects allocated by the pool at allocation | |
19 * time. | |
20 * All allocated objects will be destroyed and memory will be reclaimed when | |
21 * the pool is destroyed, so the pool must survive longer than you are using | |
22 * any item taken from it. | |
23 */ | |
24 template<typename T, int numItemsPerBlock = 4096/sizeof(T)> class SkTObjectPool
{ | |
25 public: | |
26 SkTObjectPool() {} | |
27 ~SkTObjectPool() { | |
28 while (!fBlocks.isEmpty()) { | |
29 SkDELETE(fBlocks.pop()); | |
30 } | |
31 } | |
32 | |
33 /** | |
34 * Get an item from the pool. | |
35 * If the pool has no free items, it will allocate and construct some more. | |
36 * The returned item is only valid as long as the pool has not been | |
37 * destroyed, at that point all memory allocated by grow will have been | |
38 * reclaimed. | |
39 * This method is *not* thread safe. | |
40 */ | |
41 T* acquire() { | |
42 if (fAvailable.isEmpty()) { | |
43 grow(); | |
44 } | |
45 return fAvailable.pop(); | |
46 } | |
47 | |
48 /** | |
49 * Release an item into the pool. | |
50 * The item does not have to have come from the pool, but if it did not | |
51 * it must have a lifetime greater than the pool does. | |
52 * This method is *not* thread safe. | |
53 */ | |
54 void release(T* entry) { | |
55 fAvailable.push(entry); | |
56 } | |
57 | |
58 /** | |
59 * Takes all the items from an SkTInternalSList and adds them back to this | |
60 * pool. The other list will be left empty. | |
61 */ | |
62 void releaseAll(SkTInternalSList<T>* other) { | |
63 fAvailable.pushAll(other); | |
64 } | |
65 | |
66 /** | |
67 * Returns the number of items immediately available without having to | |
68 * construct any new ones. | |
69 */ | |
70 int available() const { return fAvailable.getCount(); } | |
71 | |
72 /** | |
73 * Returns the number of blocks of items the pool has allocated so far. | |
74 */ | |
75 int blocks() const { return fBlocks.getCount(); } | |
76 | |
77 /** | |
78 * Returns the number of items allocated by the pool in total. | |
79 */ | |
80 int allocated() const { return fBlocks.getCount() * numItemsPerBlock; } | |
81 | |
82 private: | |
83 /** | |
84 * The type for a new block of entries for the list. | |
85 */ | |
86 struct Block { | |
87 T entries[numItemsPerBlock]; | |
88 SK_DECLARE_INTERNAL_SLIST_INTERFACE(Block); | |
89 }; | |
90 SkTInternalSList<Block> fBlocks; | |
91 SkTInternalSList<T> fAvailable; | |
92 | |
93 /** | |
94 * When the free list runs out of items, this method is called to allocate | |
95 * a new block of them. | |
96 * It calls the constructors and then pushes the nodes into the available | |
97 * list. | |
98 */ | |
99 void grow() { | |
100 Block* block = SkNEW(Block); | |
101 fBlocks.push(block); | |
102 for(int index = 0; index < numItemsPerBlock; ++index) { | |
103 fAvailable.push(&block->entries[index]); | |
104 } | |
105 } | |
106 | |
107 }; | |
108 | |
109 #endif | |
OLD | NEW |