server/supernova/utilities/utils.hpp

   1 //  utility functions
   2 //  Copyright (C) 2005-2012  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_UTILS_HPP
  20 #define UTILITIES_UTILS_HPP
  21
  22 #include <cstddef>
  23 #include <cassert>
  24
  25 #include <type_traits>
  26 #include <boost/static_assert.hpp>
  27
  28 #include "boost/noncopyable.hpp"
  29
  30 #include <boost/intrusive_ptr.hpp>
  31 #include <boost/detail/atomic_count.hpp>
  32
  33 #include "branch_hints.hpp"
  34
  35 typedef unsigned int uint;
  36
  37 #include "malloc_aligned.hpp"
  38
  39 #include "function_attributes.h"
  40
  41
  42 namespace nova {
  43
  44 /* we're using some member of the boost namespace */
  45 using boost::noncopyable;
  46 using boost::intrusive_ptr;
  47
  48 /* some basic math functions */
  49 inline bool ispoweroftwo(int i)
  50 {
  51     return (i & (i - 1)) == 0;
  52 }
  53
  54
  55 template <unsigned int n>
  56 struct is_power_of_two
  57 {
  58     static const bool val = (n%2==0) && (is_power_of_two<(n>>1)>::val);
  59 };
  60
  61 template <>
  62 struct is_power_of_two<2>
  63 {
  64     static const bool val = true;
  65 };
  66
  67 inline int log2(int n)
  68 {
  69     if (unlikely(n <= 0))
  70         return(0);
  71
  72 #ifdef __GNUC__
  73     return sizeof(int) * __CHAR_BIT__ - 1 - __builtin_clz( n );
  74 #else
  75     int r = -1;
  76     while (n)
  77     {
  78         r++;
  79         n >>= 1;
  80     }
  81     return r;
  82 #endif
  83 }
  84
  85 inline int nextpoweroftwo(int n)
  86 {
  87     n = n - 1;
  88     const uint bitspace = sizeof(int) * 8 / 2;
  89     for (uint i = 1; i != bitspace; i *= 2)
  90         n = n | (n >> i);
  91
  92     return n + 1;
  93 }
  94
  95 using std::size_t;
  96
  97 /** \brief base class for a callback function */
  98 template <typename t>
  99 class runnable
 100 {
 101 public:
 102     virtual ~runnable(void)
 103     {}
 104
 105     virtual t run(void) = 0;
 106 };
 107
 108 /** \brief tag for denoting a deleteable class */
 109 class deleteable
 110 {};
 111
 112
 113 template <class T>
 114 struct default_deleter
 115 {
 116     void operator()(T * t)
 117     {
 118         delete t;
 119     }
 120 };
 121
 122 struct delayed_deleter
 123 {
 124     template <typename T>
 125     inline void operator()(T *);
 126 };
 127
 128 struct checked_deleter
 129 {
 130     template<class T>
 131     void operator()(T * x) const
 132     {
 133         boost::checked_delete(x);
 134     }
 135 };
 136
 137
 138 template <typename deleter = checked_deleter >
 139 struct intrusive_refcountable:
 140     public noncopyable,
 141     public deleter
 142 {
 143     intrusive_refcountable(void):
 144         use_count_(0)
 145     {}
 146
 147     virtual ~intrusive_refcountable(void)
 148     {}
 149
 150     void add_ref(void)
 151     {
 152         ++use_count_;
 153     }
 154
 155     void release(void)
 156     {
 157         if(--use_count_ == 0)
 158             deleter::operator()(this);
 159     }
 160
 161     inline friend void intrusive_ptr_add_ref(intrusive_refcountable * p)
 162     {
 163         p->add_ref();
 164     }
 165
 166     inline friend void intrusive_ptr_release(intrusive_refcountable * p)
 167     {
 168         p->release();
 169     }
 170
 171     boost::detail::atomic_count use_count_;
 172 };
 173
 174
 175 template <class t, class compare = std::less<t> >
 176 struct compare_by_instance
 177 {
 178     bool operator()(const t * lhs, const t * rhs)
 179     {
 180         assert(lhs and rhs);
 181         compare cmp;
 182         return cmp(*lhs, *rhs);
 183     }
 184 };
 185
 186
 187 PURE inline std::size_t string_hash(const char * str)
 188 {
 189     std::size_t ret = 0;
 190
 191     // sdbm hash ... later try another function!
 192     int c;
 193     while ((c = *str++))
 194         ret = c + (ret << 6) + (ret << 16) - ret;
 195
 196     return ret;
 197 }
 198
 199 struct linear_allocator
 200 {
 201     linear_allocator(char * chunk):
 202         chunk(chunk)
 203     {}
 204
 205     template <typename T>
 206     T * alloc(int count = 1)
 207     {
 208         T * ret = reinterpret_cast<T*>(chunk);
 209         chunk += count * sizeof(T);
 210         return ret;
 211     }
 212
 213 private:
 214     char * chunk;
 215 };
 216
 217 } /* namespace nova */
 218
 219 #endif /* UTILITIES_UTILS_HPP */