1 // Copyright (C) 2000, 2001 Stephen Cleary
2 //
3 // Distributed under the Boost Software License, Version 1.0. (See
4 // accompanying file LICENSE_1_0.txt or copy at
5 // http://www.boost.org/LICENSE_1_0.txt)
6 //
7 // See http://www.boost.org for updates, documentation, and revision history.
8 
9 #ifndef BOOST_SINGLETON_POOL_HPP
10 #define BOOST_SINGLETON_POOL_HPP
11 
12 #include <boost/pool/poolfwd.hpp>
13 
14 // boost::pool
15 #include <boost/pool/pool.hpp>
16 // boost::details::pool::singleton_default
17 #include <boost/pool/detail/singleton.hpp>
18 // boost::details::pool::guard
19 #include <boost/pool/detail/guard.hpp>
20 
21 namespace boost {
22 
23 //
24 // The singleton_pool class allows other pool interfaces for types of the same
25 //   size to share the same pool
26 //
27 template <typename Tag, unsigned RequestedSize,
28     typename UserAllocator,
29     typename Mutex,
30     unsigned NextSize>
31 struct singleton_pool
32 {
33   public:
34     typedef Tag tag;
35     typedef Mutex mutex;
36     typedef UserAllocator user_allocator;
37     typedef typename pool<UserAllocator>::size_type size_type;
38     typedef typename pool<UserAllocator>::difference_type difference_type;
39 
40     BOOST_STATIC_CONSTANT(unsigned, requested_size = RequestedSize);
41     BOOST_STATIC_CONSTANT(unsigned, next_size = NextSize);
42 
43   private:
44     struct pool_type: Mutex
45     {
46       pool<UserAllocator> p;
pool_typeboost::singleton_pool::pool_type47       pool_type():p(RequestedSize, NextSize) { }
48     };
49 
50     typedef details::pool::singleton_default<pool_type> singleton;
51 
52     singleton_pool();
53 
54   public:
mallocboost::singleton_pool55     static void * malloc()
56     {
57       pool_type & p = singleton::instance();
58       details::pool::guard<Mutex> g(p);
59       return p.p.malloc();
60     }
ordered_mallocboost::singleton_pool61     static void * ordered_malloc()
62     {
63       pool_type & p = singleton::instance();
64       details::pool::guard<Mutex> g(p);
65       return p.p.ordered_malloc();
66     }
ordered_mallocboost::singleton_pool67     static void * ordered_malloc(const size_type n)
68     {
69       pool_type & p = singleton::instance();
70       details::pool::guard<Mutex> g(p);
71       return p.p.ordered_malloc(n);
72     }
is_fromboost::singleton_pool73     static bool is_from(void * const ptr)
74     {
75       pool_type & p = singleton::instance();
76       details::pool::guard<Mutex> g(p);
77       return p.p.is_from(ptr);
78     }
freeboost::singleton_pool79     static void free(void * const ptr)
80     {
81       pool_type & p = singleton::instance();
82       details::pool::guard<Mutex> g(p);
83       p.p.free(ptr);
84     }
ordered_freeboost::singleton_pool85     static void ordered_free(void * const ptr)
86     {
87       pool_type & p = singleton::instance();
88       details::pool::guard<Mutex> g(p);
89       p.p.ordered_free(ptr);
90     }
freeboost::singleton_pool91     static void free(void * const ptr, const size_type n)
92     {
93       pool_type & p = singleton::instance();
94       details::pool::guard<Mutex> g(p);
95       p.p.free(ptr, n);
96     }
ordered_freeboost::singleton_pool97     static void ordered_free(void * const ptr, const size_type n)
98     {
99       pool_type & p = singleton::instance();
100       details::pool::guard<Mutex> g(p);
101       p.p.ordered_free(ptr, n);
102     }
release_memoryboost::singleton_pool103     static bool release_memory()
104     {
105       pool_type & p = singleton::instance();
106       details::pool::guard<Mutex> g(p);
107       return p.p.release_memory();
108     }
purge_memoryboost::singleton_pool109     static bool purge_memory()
110     {
111       pool_type & p = singleton::instance();
112       details::pool::guard<Mutex> g(p);
113       return p.p.purge_memory();
114     }
115 };
116 
117 } // namespace boost
118 
119 #endif
120