stc/exp/ml_stc_linux_make_v1.0/include/boost/smart_ptr/detail/quick_allocator.hpp

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