server/supernova/utilities/static_allocator.hpp

   1 //  static allocator class
   2 //  Copyright (C) 2008 Tim Blechmann
   3 //
   4 //  This program is free software; you can redistribute it and/or modify
   5 //  it under the terms of the GNU General Public License as published by
   6 //  the Free Software Foundation; either version 2 of the License, or
   7 //  (at your option) any later version.
   8 //
   9 //  This program is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 //  GNU General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU General Public License
  15 //  along with this program; see the file COPYING.  If not, write to
  16 //  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17 //  Boston, MA 02111-1307, USA.
  18
  19 #ifndef UTILITIES_STATIC_ALLOCATOR_HPP
  20 #define UTILITIES_STATIC_ALLOCATOR_HPP
  21
  22 extern "C"
  23 {
  24 #include "tlsf.h"
  25 }
  26
  27 #include <exception>
  28
  29 #include <boost/array.hpp>
  30 #include <boost/noncopyable.hpp>
  31 #include <boost/static_assert.hpp>
  32 #include <boost/mpl/arithmetic.hpp>
  33 #include <boost/mpl/modulus.hpp>
  34
  35 #include "nova-tt/spin_lock.hpp"
  36 #include "nova-tt/dummy_mutex.hpp"
  37
  38 namespace nova
  39 {
  40
  41 /** constant-sized, pooled memory allocator based on TLSF allocator
  42  *
  43  *  \todo this violates the allocator requirement in 20.1.5, paragraph 4
  44  *        objects have to be freed using the same instance that was used
  45  *        to allocate them.
  46  *
  47  *  */
  48 template <class T,
  49           std::size_t count,
  50           bool blocking = false>
  51 class static_allocator
  52 #if 1
  53     :
  54     boost::noncopyable
  55 #endif
  56 {
  57     static const std::size_t bytes = 2 * count * sizeof(T) + 4096 * 2;
  58
  59     BOOST_STATIC_ASSERT((boost::mpl::modulus<boost::mpl::int_<bytes>, boost::mpl::int_<sizeof(long)> >::value == 0));
  60
  61     static const std::size_t poolsize = bytes/sizeof(long);
  62
  63     typedef typename boost::mpl::if_c<blocking,
  64                                       spin_lock,
  65                                       dummy_mutex>::type mutex_type;
  66
  67     typedef typename mutex_type::scoped_lock scoped_lock;
  68
  69     struct data:
  70         mutex_type
  71     {
  72 #if 0
  73         data(void){}
  74
  75         data(data const & rhs)
  76         {
  77             pool = rhs.pool;
  78         }
  79 #endif
  80
  81         boost::array<long, poolsize> pool;
  82     };
  83
  84 public:
  85     typedef std::size_t size_type;
  86     typedef std::ptrdiff_t difference_type;
  87     typedef T*        pointer;
  88     typedef const T*  const_pointer;
  89     typedef T&        reference;
  90     typedef const T&  const_reference;
  91     typedef T         value_type;
  92
  93     template <class U> struct rebind
  94     {
  95         typedef static_allocator<U, count, blocking> other;
  96     };
  97
  98     static_allocator(void) throw()
  99     {
 100         data_.pool.assign(0);
 101         init_memory_pool(bytes, data_.pool.begin());
 102     }
 103
 104 #if 0
 105     template <class U, std::size_t bytes_, bool b>
 106     static_allocator(static_allocator<U, bytes_, b> const & rhs) throw()
 107     {
 108         data_.pool.assign(0);
 109         init_memory_pool(bytes, data_.pool.begin());
 110     }
 111 #endif
 112
 113     ~static_allocator() throw()
 114     {
 115         destroy_memory_pool(data_.pool.begin());
 116     }
 117
 118     pointer address(reference x) const
 119     {
 120         return &x;
 121     }
 122
 123     const_pointer address(const_reference x) const
 124     {
 125         return &x;
 126     }
 127
 128     pointer allocate(size_type n,
 129                      const_pointer hint = 0)
 130     {
 131         scoped_lock lock(data_);
 132         pointer ret = static_cast<pointer>(malloc_ex(n * sizeof(T), data_.pool.begin()));
 133
 134         if (ret == 0)
 135             throw std::bad_alloc();
 136
 137         return ret;
 138     }
 139
 140     void deallocate(pointer p, size_type n)
 141     {
 142         scoped_lock lock(data_);
 143         free_ex(p, data_.pool.begin());
 144     }
 145
 146     size_type max_size() const throw()
 147     {
 148         return count;
 149     }
 150
 151     void construct(pointer p, const T& val)
 152     {
 153         ::new(p) T(val);
 154     }
 155
 156     void destroy(pointer p)
 157     {
 158         p->~T();
 159     }
 160
 161 private:
 162     data data_;
 163 /*     boost::array<long, poolsize> pool; */
 164 };
 165
 166
 167 template<typename T, std::size_t ts, bool tb, typename U, std::size_t us, bool ub>
 168 bool operator==( static_allocator<T, ts, tb> const& left, static_allocator<U, us, ub> const& right )
 169 {
 170     return !(left != right);
 171 }
 172
 173 template<typename T, std::size_t ts, bool tb, typename U, std::size_t us, bool ub>
 174 bool operator!=( static_allocator<T, ts, tb> const& left, static_allocator<U, us, ub> const& right )
 175 {
 176     return true;
 177 }
 178
 179
 180 } /* namespace nova */
 181
 182 #endif /* UTILITIES_STATIC_ALLOCATOR_HPP */
 183