PoolAlloc.h (3298B)
1 // 2 // Copyright 2002 The ANGLE Project Authors. All rights reserved. 3 // Use of this source code is governed by a BSD-style license that can be 4 // found in the LICENSE file. 5 // 6 7 #ifndef COMPILER_TRANSLATOR_POOLALLOC_H_ 8 #define COMPILER_TRANSLATOR_POOLALLOC_H_ 9 10 // 11 // This header defines the pool_allocator class that allows STL containers 12 // to use the angle::PoolAllocator class by using the pool_allocator 13 // class as the allocator (second) template argument. 14 // 15 // It also defines functions for managing the GlobalPoolAllocator used by the compiler. 16 // 17 18 #include <stddef.h> 19 #include <string.h> 20 #include <vector> 21 22 #include "common/PoolAlloc.h" 23 24 // 25 // There could potentially be many pools with pops happening at 26 // different times. But a simple use is to have a global pop 27 // with everyone using the same global allocator. 28 // 29 extern angle::PoolAllocator *GetGlobalPoolAllocator(); 30 extern void SetGlobalPoolAllocator(angle::PoolAllocator *poolAllocator); 31 32 // 33 // This STL compatible allocator is intended to be used as the allocator 34 // parameter to templatized STL containers, like vector and map. 35 // 36 // It will use the pools for allocation, and not 37 // do any deallocation, but will still do destruction. 38 // 39 template <class T> 40 class pool_allocator 41 { 42 public: 43 typedef size_t size_type; 44 typedef ptrdiff_t difference_type; 45 typedef T *pointer; 46 typedef const T *const_pointer; 47 typedef T &reference; 48 typedef const T &const_reference; 49 typedef T value_type; 50 51 template <class Other> 52 struct rebind 53 { 54 typedef pool_allocator<Other> other; 55 }; 56 pointer address(reference x) const { return &x; } 57 const_pointer address(const_reference x) const { return &x; } 58 59 pool_allocator() {} 60 61 template <class Other> 62 pool_allocator(const pool_allocator<Other> &p) 63 {} 64 65 template <class Other> 66 pool_allocator<T> &operator=(const pool_allocator<Other> &p) 67 { 68 return *this; 69 } 70 71 #if defined(__SUNPRO_CC) && !defined(_RWSTD_ALLOCATOR) 72 // libCStd on some platforms have a different allocate/deallocate interface. 73 // Caller pre-bakes sizeof(T) into 'n' which is the number of bytes to be 74 // allocated, not the number of elements. 75 void *allocate(size_type n) { return getAllocator().allocate(n); } 76 void *allocate(size_type n, const void *) { return getAllocator().allocate(n); } 77 void deallocate(void *, size_type) {} 78 #else 79 pointer allocate(size_type n) 80 { 81 return static_cast<pointer>(getAllocator().allocate(n * sizeof(T))); 82 } 83 pointer allocate(size_type n, const void *) 84 { 85 return static_cast<pointer>(getAllocator().allocate(n * sizeof(T))); 86 } 87 void deallocate(pointer, size_type) {} 88 #endif // _RWSTD_ALLOCATOR 89 90 void construct(pointer p, const T &val) { new ((void *)p) T(val); } 91 void destroy(pointer p) { p->T::~T(); } 92 93 bool operator==(const pool_allocator &rhs) const { return true; } 94 bool operator!=(const pool_allocator &rhs) const { return false; } 95 96 size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); } 97 size_type max_size(int size) const { return static_cast<size_type>(-1) / size; } 98 99 angle::PoolAllocator &getAllocator() const { return *GetGlobalPoolAllocator(); } 100 }; 101 102 #endif // COMPILER_TRANSLATOR_POOLALLOC_H_