/usr/include/boost/pool/singleton_pool.hpp is in libboost1.55-dev 1.55.0+dfsg-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 | // Copyright (C) 2000, 2001 Stephen Cleary
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org for updates, documentation, and revision history.
#ifndef BOOST_SINGLETON_POOL_HPP
#define BOOST_SINGLETON_POOL_HPP
/*!
\file
\brief The <tt>singleton_pool</tt> class allows other pool interfaces
for types of the same size to share the same underlying pool.
\details Header singleton_pool.hpp provides a template class <tt>singleton_pool</tt>,
which provides access to a pool as a singleton object.
*/
#include <boost/pool/poolfwd.hpp>
// boost::pool
#include <boost/pool/pool.hpp>
// boost::details::pool::guard
#include <boost/pool/detail/guard.hpp>
#include <boost/type_traits/aligned_storage.hpp>
namespace boost {
/*!
The singleton_pool class allows other pool interfaces
for types of the same size to share the same pool. Template
parameters are as follows:
<b>Tag</b> User-specified type to uniquely identify this pool: allows different unbounded sets of singleton pools to exist.
<b>RequestedSize</b> The size of each chunk returned by member function <tt>malloc()</tt>.
<B>UserAllocator</b> User allocator, default = default_user_allocator_new_delete.
<b>Mutex</B> This class is the type of mutex to use to protect simultaneous access to the underlying Pool.
Can be any Boost.Thread Mutex type or <tt>boost::details::pool::null_mutex</tt>.
It is exposed so that users may declare some singleton pools normally (i.e., with synchronization), but
some singleton pools without synchronization (by specifying <tt>boost::details::pool::null_mutex</tt>) for efficiency reasons.
The member typedef <tt>mutex</tt> exposes the value of this template parameter. The default for this
parameter is boost::details::pool::default_mutex which is a synonym for either <tt>boost::details::pool::null_mutex</tt>
(when threading support is turned off in the compiler (so BOOST_HAS_THREADS is not set), or threading support
has ben explicitly disabled with BOOST_DISABLE_THREADS (Boost-wide disabling of threads) or BOOST_POOL_NO_MT (this library only))
or for <tt>boost::mutex</tt> (when threading support is enabled in the compiler).
<B>NextSize</b> The value of this parameter is passed to the underlying Pool when it is created and
specifies the number of chunks to allocate in the first allocation request (defaults to 32).
The member typedef <tt>static const value next_size</tt> exposes the value of this template parameter.
<b>MaxSize</B>The value of this parameter is passed to the underlying Pool when it is created and
specifies the maximum number of chunks to allocate in any single allocation request (defaults to 0).
<b>Notes:</b>
The underlying pool <i>p</i> referenced by the static functions
in singleton_pool is actually declared in a way that is:
1 Thread-safe if there is only one thread running before main() begins and after main() ends
-- all of the static functions of singleton_pool synchronize their access to p.
2 Guaranteed to be constructed before it is used --
thus, the simple static object in the synopsis above would actually be an incorrect implementation.
The actual implementation to guarantee this is considerably more complicated.
3 Note too that a different underlying pool p exists
for each different set of template parameters,
including implementation-specific ones.
4 The underlying pool is constructed "as if" by:
pool<UserAllocator> p(RequestedSize, NextSize, MaxSize);
\attention
The underlying pool constructed by the singleton
<b>is never freed</b>. This means that memory allocated
by a singleton_pool can be still used after main() has
completed, but may mean that some memory checking programs
will complain about leaks from singleton_pool.
*/
template <typename Tag,
unsigned RequestedSize,
typename UserAllocator,
typename Mutex,
unsigned NextSize,
unsigned MaxSize >
class singleton_pool
{
public:
typedef Tag tag; /*!< The Tag template parameter uniquely
identifies this pool and allows
different unbounded sets of singleton pools to exist.
For example, the pool allocators use two tag classes to ensure that the
two different allocator types never share the same underlying singleton pool.
Tag is never actually used by singleton_pool.
*/
typedef Mutex mutex; //!< The type of mutex used to synchonise access to this pool (default <tt>details::pool::default_mutex</tt>).
typedef UserAllocator user_allocator; //!< The user-allocator used by this pool, default = <tt>default_user_allocator_new_delete</tt>.
typedef typename pool<UserAllocator>::size_type size_type; //!< size_type of user allocator.
typedef typename pool<UserAllocator>::difference_type difference_type; //!< difference_type of user allocator.
BOOST_STATIC_CONSTANT(unsigned, requested_size = RequestedSize); //!< The size of each chunk allocated by this pool.
BOOST_STATIC_CONSTANT(unsigned, next_size = NextSize); //!< The number of chunks to allocate on the first allocation.
private:
singleton_pool();
#ifndef BOOST_DOXYGEN
struct pool_type: public Mutex, public pool<UserAllocator>
{
pool_type() : pool<UserAllocator>(RequestedSize, NextSize, MaxSize) {}
}; // struct pool_type: Mutex
#else
//
// This is invoked when we build with Doxygen only:
//
public:
static pool<UserAllocator> p; //!< For exposition only!
#endif
public:
static void * malloc BOOST_PREVENT_MACRO_SUBSTITUTION()
{ //! Equivalent to SingletonPool::p.malloc(); synchronized.
pool_type & p = get_pool();
details::pool::guard<Mutex> g(p);
return (p.malloc)();
}
static void * ordered_malloc()
{ //! Equivalent to SingletonPool::p.ordered_malloc(); synchronized.
pool_type & p = get_pool();
details::pool::guard<Mutex> g(p);
return p.ordered_malloc();
}
static void * ordered_malloc(const size_type n)
{ //! Equivalent to SingletonPool::p.ordered_malloc(n); synchronized.
pool_type & p = get_pool();
details::pool::guard<Mutex> g(p);
return p.ordered_malloc(n);
}
static bool is_from(void * const ptr)
{ //! Equivalent to SingletonPool::p.is_from(chunk); synchronized.
//! \returns true if chunk is from SingletonPool::is_from(chunk)
pool_type & p = get_pool();
details::pool::guard<Mutex> g(p);
return p.is_from(ptr);
}
static void free BOOST_PREVENT_MACRO_SUBSTITUTION(void * const ptr)
{ //! Equivalent to SingletonPool::p.free(chunk); synchronized.
pool_type & p = get_pool();
details::pool::guard<Mutex> g(p);
(p.free)(ptr);
}
static void ordered_free(void * const ptr)
{ //! Equivalent to SingletonPool::p.ordered_free(chunk); synchronized.
pool_type & p = get_pool();
details::pool::guard<Mutex> g(p);
p.ordered_free(ptr);
}
static void free BOOST_PREVENT_MACRO_SUBSTITUTION(void * const ptr, const size_type n)
{ //! Equivalent to SingletonPool::p.free(chunk, n); synchronized.
pool_type & p = get_pool();
details::pool::guard<Mutex> g(p);
(p.free)(ptr, n);
}
static void ordered_free(void * const ptr, const size_type n)
{ //! Equivalent to SingletonPool::p.ordered_free(chunk, n); synchronized.
pool_type & p = get_pool();
details::pool::guard<Mutex> g(p);
p.ordered_free(ptr, n);
}
static bool release_memory()
{ //! Equivalent to SingletonPool::p.release_memory(); synchronized.
pool_type & p = get_pool();
details::pool::guard<Mutex> g(p);
return p.release_memory();
}
static bool purge_memory()
{ //! Equivalent to SingletonPool::p.purge_memory(); synchronized.
pool_type & p = get_pool();
details::pool::guard<Mutex> g(p);
return p.purge_memory();
}
private:
typedef boost::aligned_storage<sizeof(pool_type), boost::alignment_of<pool_type>::value> storage_type;
static storage_type storage;
static pool_type& get_pool()
{
static bool f = false;
if(!f)
{
// This code *must* be called before main() starts,
// and when only one thread is executing.
f = true;
new (&storage) pool_type;
}
// The following line does nothing else than force the instantiation
// of singleton<T>::create_object, whose constructor is
// called before main() begins.
create_object.do_nothing();
return *static_cast<pool_type*>(static_cast<void*>(&storage));
}
struct object_creator
{
object_creator()
{ // This constructor does nothing more than ensure that instance()
// is called before main() begins, thus creating the static
// T object before multithreading race issues can come up.
singleton_pool<Tag, RequestedSize, UserAllocator, Mutex, NextSize, MaxSize>::get_pool();
}
inline void do_nothing() const
{
}
};
static object_creator create_object;
}; // struct singleton_pool
template <typename Tag,
unsigned RequestedSize,
typename UserAllocator,
typename Mutex,
unsigned NextSize,
unsigned MaxSize >
typename singleton_pool<Tag, RequestedSize, UserAllocator, Mutex, NextSize, MaxSize>::storage_type singleton_pool<Tag, RequestedSize, UserAllocator, Mutex, NextSize, MaxSize>::storage;
template <typename Tag,
unsigned RequestedSize,
typename UserAllocator,
typename Mutex,
unsigned NextSize,
unsigned MaxSize >
typename singleton_pool<Tag, RequestedSize, UserAllocator, Mutex, NextSize, MaxSize>::object_creator singleton_pool<Tag, RequestedSize, UserAllocator, Mutex, NextSize, MaxSize>::create_object;
} // namespace boost
#endif
|