]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | #ifndef BOOST_SMART_PTR_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED |
2 | #define BOOST_SMART_PTR_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED | |
3 | ||
4 | // MS compatible compilers support #pragma once | |
5 | ||
6 | #if defined(_MSC_VER) && (_MSC_VER >= 1020) | |
7 | # pragma once | |
8 | #endif | |
9 | ||
10 | // | |
11 | // detail/quick_allocator.hpp | |
12 | // | |
13 | // Copyright (c) 2003 David Abrahams | |
14 | // Copyright (c) 2003 Peter Dimov | |
15 | // | |
16 | // Distributed under the Boost Software License, Version 1.0. (See | |
17 | // accompanying file LICENSE_1_0.txt or copy at | |
18 | // http://www.boost.org/LICENSE_1_0.txt) | |
19 | // | |
20 | ||
21 | #include <boost/config.hpp> | |
22 | ||
23 | #include <boost/smart_ptr/detail/lightweight_mutex.hpp> | |
24 | #include <boost/type_traits/type_with_alignment.hpp> | |
25 | #include <boost/type_traits/alignment_of.hpp> | |
26 | ||
27 | #include <new> // ::operator new, ::operator delete | |
28 | #include <cstddef> // std::size_t | |
29 | ||
30 | namespace boost | |
31 | { | |
32 | ||
33 | namespace detail | |
34 | { | |
35 | ||
36 | template<unsigned size, unsigned align_> union freeblock | |
37 | { | |
38 | typedef typename boost::type_with_alignment<align_>::type aligner_type; | |
39 | aligner_type aligner; | |
40 | char bytes[size]; | |
41 | freeblock * next; | |
42 | }; | |
43 | ||
44 | template<unsigned size, unsigned align_> struct allocator_impl | |
45 | { | |
46 | typedef freeblock<size, align_> block; | |
47 | ||
48 | // It may seem odd to use such small pages. | |
49 | // | |
50 | // However, on a typical Windows implementation that uses | |
51 | // the OS allocator, "normal size" pages interact with the | |
52 | // "ordinary" operator new, slowing it down dramatically. | |
53 | // | |
54 | // 512 byte pages are handled by the small object allocator, | |
55 | // and don't interfere with ::new. | |
56 | // | |
57 | // The other alternative is to use much bigger pages (1M.) | |
58 | // | |
59 | // It is surprisingly easy to hit pathological behavior by | |
60 | // varying the page size. g++ 2.96 on Red Hat Linux 7.2, | |
61 | // for example, passionately dislikes 496. 512 seems OK. | |
62 | ||
63 | #if defined(BOOST_QA_PAGE_SIZE) | |
64 | ||
65 | enum { items_per_page = BOOST_QA_PAGE_SIZE / size }; | |
66 | ||
67 | #else | |
68 | ||
69 | enum { items_per_page = 512 / size }; // 1048560 / size | |
70 | ||
71 | #endif | |
72 | ||
73 | #ifdef BOOST_HAS_THREADS | |
74 | ||
75 | static lightweight_mutex & mutex() | |
76 | { | |
77 | static freeblock< sizeof( lightweight_mutex ), boost::alignment_of< lightweight_mutex >::value > fbm; | |
78 | static lightweight_mutex * pm = new( &fbm ) lightweight_mutex; | |
79 | return *pm; | |
80 | } | |
81 | ||
82 | static lightweight_mutex * mutex_init; | |
83 | ||
84 | #endif | |
85 | ||
86 | static block * free; | |
87 | static block * page; | |
88 | static unsigned last; | |
89 | ||
90 | static inline void * alloc() | |
91 | { | |
92 | #ifdef BOOST_HAS_THREADS | |
93 | lightweight_mutex::scoped_lock lock( mutex() ); | |
94 | #endif | |
95 | if(block * x = free) | |
96 | { | |
97 | free = x->next; | |
98 | return x; | |
99 | } | |
100 | else | |
101 | { | |
102 | if(last == items_per_page) | |
103 | { | |
104 | // "Listen to me carefully: there is no memory leak" | |
105 | // -- Scott Meyers, Eff C++ 2nd Ed Item 10 | |
106 | page = ::new block[items_per_page]; | |
107 | last = 0; | |
108 | } | |
109 | ||
110 | return &page[last++]; | |
111 | } | |
112 | } | |
113 | ||
114 | static inline void * alloc(std::size_t n) | |
115 | { | |
116 | if(n != size) // class-specific new called for a derived object | |
117 | { | |
118 | return ::operator new(n); | |
119 | } | |
120 | else | |
121 | { | |
122 | #ifdef BOOST_HAS_THREADS | |
123 | lightweight_mutex::scoped_lock lock( mutex() ); | |
124 | #endif | |
125 | if(block * x = free) | |
126 | { | |
127 | free = x->next; | |
128 | return x; | |
129 | } | |
130 | else | |
131 | { | |
132 | if(last == items_per_page) | |
133 | { | |
134 | page = ::new block[items_per_page]; | |
135 | last = 0; | |
136 | } | |
137 | ||
138 | return &page[last++]; | |
139 | } | |
140 | } | |
141 | } | |
142 | ||
143 | static inline void dealloc(void * pv) | |
144 | { | |
145 | if(pv != 0) // 18.4.1.1/13 | |
146 | { | |
147 | #ifdef BOOST_HAS_THREADS | |
148 | lightweight_mutex::scoped_lock lock( mutex() ); | |
149 | #endif | |
150 | block * pb = static_cast<block *>(pv); | |
151 | pb->next = free; | |
152 | free = pb; | |
153 | } | |
154 | } | |
155 | ||
156 | static inline void dealloc(void * pv, std::size_t n) | |
157 | { | |
158 | if(n != size) // class-specific delete called for a derived object | |
159 | { | |
160 | ::operator delete(pv); | |
161 | } | |
162 | else if(pv != 0) // 18.4.1.1/13 | |
163 | { | |
164 | #ifdef BOOST_HAS_THREADS | |
165 | lightweight_mutex::scoped_lock lock( mutex() ); | |
166 | #endif | |
167 | block * pb = static_cast<block *>(pv); | |
168 | pb->next = free; | |
169 | free = pb; | |
170 | } | |
171 | } | |
172 | }; | |
173 | ||
174 | #ifdef BOOST_HAS_THREADS | |
175 | ||
176 | template<unsigned size, unsigned align_> | |
177 | lightweight_mutex * allocator_impl<size, align_>::mutex_init = &allocator_impl<size, align_>::mutex(); | |
178 | ||
179 | #endif | |
180 | ||
181 | template<unsigned size, unsigned align_> | |
182 | freeblock<size, align_> * allocator_impl<size, align_>::free = 0; | |
183 | ||
184 | template<unsigned size, unsigned align_> | |
185 | freeblock<size, align_> * allocator_impl<size, align_>::page = 0; | |
186 | ||
187 | template<unsigned size, unsigned align_> | |
188 | unsigned allocator_impl<size, align_>::last = allocator_impl<size, align_>::items_per_page; | |
189 | ||
190 | template<class T> | |
191 | struct quick_allocator: public allocator_impl< sizeof(T), boost::alignment_of<T>::value > | |
192 | { | |
193 | }; | |
194 | ||
195 | } // namespace detail | |
196 | ||
197 | } // namespace boost | |
198 | ||
199 | #endif // #ifndef BOOST_SMART_PTR_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED |