1//
2// Copyright (c) 2002-2010 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//
29extern angle::PoolAllocator *GetGlobalPoolAllocator();
30extern 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//
39template <class T>
40class 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_
103