src/external/3rd/library/platform/utils/Base/TemplateBlockAllocator.h

   1 #ifndef BLOCK_ALLOCATOR_H
   2 #define BLOCK_ALLOCATOR_H
   3
   4 #if defined _MT || defined _REENTRANT
   5 #   define USE_ALLOCATOR_MUTEX
   6 #endif
   7
   8
   9 #include <new>
  10 #include "Mutex.h"
  11
  12 #ifdef EXTERNAL_DISTRO
  13 namespace NAMESPACE
  14 {
  15
  16 #endif
  17 namespace Base
  18 {
  19     template<int BLOCK_SIZE>
  20     class CBlockAllocator
  21     {
  22
  23         private:
  24             class Node
  25             {
  26                 public:
  27                     Node *   mNext;
  28                     unsigned mBuffer[(BLOCK_SIZE-1)/sizeof(unsigned)+1];
  29             };
  30
  31         public:
  32             CBlockAllocator() :
  33                 mMemoryBlockCount(0),
  34                 mNodesAllocated(0),
  35                 mNodesUsed(0),
  36                 mUnusedList(0)
  37             {
  38                 for (int block=0; block<MAX_BLOCK_COUNT; block++)
  39                     mMemoryBlock[block] = 0;
  40                 Allocate();
  41             }
  42
  43             ~CBlockAllocator()
  44             {
  45                 for (int block=0; block<MAX_BLOCK_COUNT; block++)
  46                     delete[] mMemoryBlock[block];
  47             }
  48
  49             void * Allocate()
  50             {
  51 #ifdef USE_ALLOCATOR_MUTEX
  52                 mMutex.Lock();
  53 #endif
  54             void * data;
  55
  56             Node * node = mUnusedList;
  57             mUnusedList = node->mNext;
  58             node->mNext = (Node *)1;
  59
  60             data = node->mBuffer;
  61
  62             mNodesUsed++;
  63
  64 #ifdef USE_ALLOCATOR_MUTEX
  65                 mMutex.Unlock();
  66 #endif
  67
  68             return data;
  69             }
  70
  71             void Deallocate(void * data)
  72             {
  73                 if (!data)
  74                     return;
  75
  76                 char * memoryPtr = reinterpret_cast<char *>(data) - sizeof(Node *);
  77                 Node * node = reinterpret_cast<Node *>(memoryPtr);
  78
  79 #ifdef USE_ALLOCATOR_MUTEX
  80                 mMutex.Lock();
  81 #endif
  82
  83                 node->mNext = mUnusedList;
  84                 mUnusedList = node;
  85                 mNodesUsed--;
  86
  87 #ifdef USE_ALLOCATOR_MUTEX
  88                 mMutex.Unlock();
  89 #endif
  90             }
  91
  92             template<class T> T * Construct(const T & object)
  93             {
  94                 T * objectPtr;
  95
  96 #ifdef USE_ALLOCATOR_MUTEX
  97                 mMutex.Lock();
  98 #endif
  99                 if (sizeof(T) > BLOCK_SIZE || (!mUnusedList && !Allocate()))
 100                 {
 101                     char * memoryPtr = reinterpret_cast<char *>(new unsigned[(sizeof(Node *)+sizeof(T)-1)/sizeof(unsigned)+1]);
 102                     objectPtr = reinterpret_cast<T *>(memoryPtr+sizeof(Node *));
 103
 104                     *reinterpret_cast<unsigned *>(memoryPtr) = 0;
 105                 }
 106                 else
 107                 {
 108                     Node * node = mUnusedList;
 109                     mUnusedList = node->mNext;
 110                     node->mNext = (Node *)1;
 111
 112                     objectPtr = reinterpret_cast<T *>(node->mBuffer);
 113
 114                     mNodesUsed++;
 115                 }
 116
 117                 new (objectPtr) T(object);
 118
 119 #ifdef USE_ALLOCATOR_MUTEX
 120                 mMutex.Unlock();
 121 #endif
 122                 return objectPtr;
 123             }
 124
 125             template<class T> void Destroy(T * object)
 126             {
 127                 if (!object)
 128                     return;
 129
 130                 char * memoryPtr = reinterpret_cast<char *>(object) - sizeof(Node *);
 131                 Node * node = reinterpret_cast<Node *>(memoryPtr);
 132
 133                 object->~T();
 134
 135 #ifdef USE_ALLOCATOR_MUTEX
 136                 mMutex.Lock();
 137 #endif
 138                 if (node->mNext == 0)
 139                     delete []memoryPtr;
 140                 else
 141                 {
 142                     node->mNext = mUnusedList;
 143                     mUnusedList = node;
 144                     mNodesUsed--;
 145                 }
 146 #ifdef USE_ALLOCATOR_MUTEX
 147                 mMutex.Unlock();
 148 #endif
 149             }
 150
 151             template<class T> T * FastConstruct(const T & object)
 152             {
 153                 T * objectPtr;
 154
 155                 if (sizeof(T) > BLOCK_SIZE || (!mUnusedList && !Allocate()))
 156                 {
 157                     char * memoryPtr = reinterpret_cast<char *>(new unsigned[(sizeof(Node *)+sizeof(T)-1)/sizeof(unsigned)+1]);
 158                     objectPtr = reinterpret_cast<T *>(memoryPtr+sizeof(Node *));
 159
 160                     *reinterpret_cast<unsigned *>(memoryPtr) = 0;
 161                 }
 162                 else
 163                 {
 164                     Node * node = mUnusedList;
 165                     mUnusedList = node->mNext;
 166                     node->mNext = (Node *)1;
 167
 168                     objectPtr = reinterpret_cast<T *>(node->mBuffer);
 169
 170                     mNodesUsed++;
 171                 }
 172
 173                 new (objectPtr) T(object);
 174
 175                 return objectPtr;
 176             }
 177
 178             template<class T> void FastDestroy(T * object)
 179             {
 180                 if (!object)
 181                     return;
 182
 183                 char * memoryPtr = reinterpret_cast<char *>(object) - sizeof(Node *);
 184                 Node * node = reinterpret_cast<Node *>(memoryPtr);
 185
 186                 object->~T();
 187
 188                 if (node->mNext == 0)
 189                     delete []memoryPtr;
 190                 else
 191                 {
 192                     node->mNext = mUnusedList;
 193                     mUnusedList = node;
 194                     mNodesUsed--;
 195                 }
 196             }
 197
 198                     bool Allocate()
 199             {
 200                 if (mMemoryBlockCount == MAX_BLOCK_COUNT)
 201                     return false;
 202
 203                 unsigned count = (mNodesAllocated ? mNodesAllocated : 32);
 204
 205                 Node* newMemoryBlock = new Node[count];
 206                 for (unsigned i=0; i<count-1; i++)
 207                                     newMemoryBlock[i].mNext = &newMemoryBlock[i+1];
 208                             newMemoryBlock[count-1].mNext = mUnusedList;
 209
 210                 mUnusedList = newMemoryBlock;
 211                 mMemoryBlock[mMemoryBlockCount++] = newMemoryBlock;
 212                 mNodesAllocated += count;
 213
 214                 return true;
 215                 };
 216
 217         private:
 218             enum { MAX_BLOCK_COUNT = 32 };
 219
 220             void *           mMemoryBlock[MAX_BLOCK_COUNT];
 221             unsigned         mMemoryBlockCount;
 222             unsigned         mNodesAllocated;
 223             unsigned         mNodesUsed;
 224             Node *           mUnusedList;
 225
 226 #ifdef USE_ALLOCATOR_MUTEX
 227             Base::CMutex     mMutex;
 228 #endif
 229     };
 230
 231
 232 };
 233
 234 #ifdef EXTERNAL_DISTRO
 235 };
 236 #endif
 237
 238 #endif  //  BLOCK_ALLOCATOR_H