]>
Commit | Line | Data |
---|---|---|
ba9d552e BK |
1 | // Allocator details. |
2 | ||
3 | // Copyright (C) 2004 Free Software Foundation, Inc. | |
4 | // | |
5 | // This file is part of the GNU ISO C++ Library. This library is free | |
6 | // software; you can redistribute it and/or modify it under the | |
7 | // terms of the GNU General Public License as published by the | |
8 | // Free Software Foundation; either version 2, or (at your option) | |
9 | // any later version. | |
10 | ||
11 | // This library is distributed in the hope that it will be useful, | |
12 | // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | // GNU General Public License for more details. | |
15 | ||
16 | // You should have received a copy of the GNU General Public License along | |
17 | // with this library; see the file COPYING. If not, write to the Free | |
18 | // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, | |
19 | // USA. | |
20 | ||
21 | // As a special exception, you may use this file as part of a free software | |
22 | // library without restriction. Specifically, if other files instantiate | |
23 | // templates or use macros or inline functions from this file, or you compile | |
24 | // this file and link it with other files to produce an executable, this | |
25 | // file does not by itself cause the resulting executable to be covered by | |
26 | // the GNU General Public License. This exception does not however | |
27 | // invalidate any other reasons why the executable file might be covered by | |
28 | // the GNU General Public License. | |
29 | ||
30 | // | |
31 | // ISO C++ 14882: | |
32 | // | |
33 | ||
34 | #include <bits/c++config.h> | |
35 | #include <memory> | |
36 | #include <ext/mt_allocator.h> | |
37 | #include <ext/pool_allocator.h> | |
38 | ||
838d4309 | 39 | namespace __gnu_internal |
ba9d552e | 40 | { |
838d4309 BK |
41 | __glibcxx_mutex_define_initialized(palloc_init_mutex); |
42 | } | |
ba9d552e | 43 | |
838d4309 BK |
44 | namespace __gnu_cxx |
45 | { | |
46 | // Definitions for __pool_alloc_base. | |
2832d07b BK |
47 | __pool_base::_Obj* volatile* |
48 | __pool_base::_M_get_free_list(size_t __bytes) | |
49 | { | |
50 | size_t __i = ((__bytes + (size_t)_S_align - 1) / (size_t)_S_align - 1); | |
838d4309 | 51 | return _S_free_list + __i; |
2832d07b BK |
52 | } |
53 | ||
f65d3201 | 54 | mutex_type& |
838d4309 BK |
55 | __pool_base::_M_get_mutex() |
56 | { return __gnu_internal::palloc_init_mutex; } | |
57 | ||
2832d07b BK |
58 | // Allocate memory in large chunks in order to avoid fragmenting the |
59 | // heap too much. Assume that __n is properly aligned. We hold the | |
60 | // allocation lock. | |
61 | char* | |
62 | __pool_base::_M_allocate_chunk(size_t __n, int& __nobjs) | |
63 | { | |
64 | char* __result; | |
65 | size_t __total_bytes = __n * __nobjs; | |
66 | size_t __bytes_left = _S_end_free - _S_start_free; | |
67 | ||
68 | if (__bytes_left >= __total_bytes) | |
69 | { | |
70 | __result = _S_start_free; | |
71 | _S_start_free += __total_bytes; | |
72 | return __result ; | |
73 | } | |
74 | else if (__bytes_left >= __n) | |
75 | { | |
76 | __nobjs = (int)(__bytes_left / __n); | |
77 | __total_bytes = __n * __nobjs; | |
78 | __result = _S_start_free; | |
79 | _S_start_free += __total_bytes; | |
80 | return __result; | |
81 | } | |
82 | else | |
83 | { | |
84 | // Try to make use of the left-over piece. | |
85 | if (__bytes_left > 0) | |
86 | { | |
87 | _Obj* volatile* __free_list = _M_get_free_list(__bytes_left); | |
88 | ((_Obj*)(void*)_S_start_free)->_M_free_list_link = *__free_list; | |
89 | *__free_list = (_Obj*)(void*)_S_start_free; | |
90 | } | |
91 | ||
92 | size_t __bytes_to_get = (2 * __total_bytes | |
93 | + _M_round_up(_S_heap_size >> 4)); | |
94 | _S_start_free = static_cast<char*>(::operator new(__bytes_to_get)); | |
95 | if (_S_start_free == 0) | |
96 | { | |
2832d07b BK |
97 | // Try to make do with what we have. That can't hurt. We |
98 | // do not try smaller requests, since that tends to result | |
99 | // in disaster on multi-process machines. | |
838d4309 | 100 | size_t __i = __n; |
2832d07b BK |
101 | for (; __i <= (size_t) _S_max_bytes; __i += (size_t) _S_align) |
102 | { | |
838d4309 BK |
103 | _Obj* volatile* __free_list = _M_get_free_list(__i); |
104 | _Obj* __p = *__free_list; | |
2832d07b BK |
105 | if (__p != 0) |
106 | { | |
838d4309 | 107 | *__free_list = __p->_M_free_list_link; |
2832d07b BK |
108 | _S_start_free = (char*)__p; |
109 | _S_end_free = _S_start_free + __i; | |
110 | return _M_allocate_chunk(__n, __nobjs); | |
111 | // Any leftover piece will eventually make it to the | |
112 | // right free list. | |
113 | } | |
114 | } | |
115 | _S_end_free = 0; // In case of exception. | |
838d4309 | 116 | |
2832d07b BK |
117 | // This should either throw an exception or remedy the situation. |
118 | // Thus we assume it succeeded. | |
838d4309 | 119 | _S_start_free = static_cast<char*>(::operator new(__bytes_to_get)); |
2832d07b BK |
120 | } |
121 | _S_heap_size += __bytes_to_get; | |
122 | _S_end_free = _S_start_free + __bytes_to_get; | |
123 | return _M_allocate_chunk(__n, __nobjs); | |
124 | } | |
125 | } | |
126 | ||
127 | // Returns an object of size __n, and optionally adds to "size | |
128 | // __n"'s free list. We assume that __n is properly aligned. We | |
129 | // hold the allocation lock. | |
130 | void* | |
131 | __pool_base::_M_refill(size_t __n) | |
132 | { | |
133 | int __nobjs = 20; | |
134 | char* __chunk = _M_allocate_chunk(__n, __nobjs); | |
135 | _Obj* volatile* __free_list; | |
136 | _Obj* __result; | |
137 | _Obj* __current_obj; | |
138 | _Obj* __next_obj; | |
2832d07b | 139 | |
838d4309 | 140 | if (__nobjs == 1) |
2832d07b BK |
141 | return __chunk; |
142 | __free_list = _M_get_free_list(__n); | |
143 | ||
144 | // Build free list in chunk. | |
145 | __result = (_Obj*)(void*)__chunk; | |
146 | *__free_list = __next_obj = (_Obj*)(void*)(__chunk + __n); | |
838d4309 | 147 | for (int __i = 1; ; __i++) |
2832d07b BK |
148 | { |
149 | __current_obj = __next_obj; | |
150 | __next_obj = (_Obj*)(void*)((char*)__next_obj + __n); | |
151 | if (__nobjs - 1 == __i) | |
152 | { | |
838d4309 | 153 | __current_obj->_M_free_list_link = 0; |
2832d07b BK |
154 | break; |
155 | } | |
156 | else | |
838d4309 | 157 | __current_obj->_M_free_list_link = __next_obj; |
2832d07b BK |
158 | } |
159 | return __result; | |
160 | } | |
161 | ||
162 | __pool_base::_Obj* volatile __pool_base::_S_free_list[_S_free_list_size]; | |
163 | ||
164 | char* __pool_base::_S_start_free = 0; | |
165 | ||
166 | char* __pool_base::_S_end_free = 0; | |
167 | ||
168 | size_t __pool_base::_S_heap_size = 0; | |
ba9d552e | 169 | } // namespace __gnu_cxx |