Pooling.hpp

   1 /* Cycript - The Truly Universal Scripting Language
   2  * Copyright (C) 2009-2016  Jay Freeman (saurik)
   3 */
   4
   5 /* GNU Affero General Public License, Version 3 {{{ */
   6 /*
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as published by
   9  * the Free Software Foundation, either version 3 of the License, or
  10  * (at your option) any later version.
  11
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 **/
  20 /* }}} */
  21
  22 #ifndef CYCRIPT_POOLING_HPP
  23 #define CYCRIPT_POOLING_HPP
  24
  25 #include <cstdarg>
  26 #include <cstdio>
  27 #include <cstdlib>
  28 #include <cstring>
  29
  30 #include <algorithm>
  31
  32 #include <stdint.h>
  33
  34 #include "Exception.hpp"
  35 #include "Local.hpp"
  36 #include "Standard.hpp"
  37
  38 // XXX: std::aligned_storage and alignof
  39 static const size_t CYAlignment(sizeof(void *));
  40
  41 template <typename Type_>
  42 static void CYAlign(Type_ &data, size_t size) {
  43     data = reinterpret_cast<Type_>((reinterpret_cast<uintptr_t>(data) + (size - 1)) & ~static_cast<uintptr_t>(size - 1));
  44 }
  45
  46 class CYPool;
  47 _finline void *operator new(size_t size, CYPool &pool);
  48 _finline void *operator new [](size_t size, CYPool &pool);
  49
  50 class CYPool {
  51   private:
  52     uint8_t *data_;
  53     size_t size_;
  54     size_t next_;
  55
  56     struct Cleaner {
  57         Cleaner *next_;
  58         void (*code_)(void *);
  59         void *data_;
  60
  61         Cleaner(Cleaner *next, void (*code)(void *), void *data) :
  62             next_(next),
  63             code_(code),
  64             data_(data)
  65         {
  66         }
  67     } *cleaner_;
  68
  69     template <typename Type_>
  70     static void delete_(void *data) {
  71         reinterpret_cast<Type_ *>(data)->~Type_();
  72     }
  73
  74     CYPool(const CYPool &);
  75
  76   public:
  77     CYPool(size_t next = 64) :
  78         data_(NULL),
  79         size_(0),
  80         next_(next),
  81         cleaner_(NULL)
  82     {
  83     }
  84
  85     ~CYPool() {
  86         for (Cleaner *cleaner(cleaner_); cleaner != NULL; ) {
  87             Cleaner *next(cleaner->next_);
  88             (*cleaner->code_)(cleaner->data_);
  89             cleaner = next;
  90         }
  91     }
  92
  93     template <typename Type_>
  94     Type_ *malloc(size_t size, size_t alignment = CYAlignment) {
  95         uint8_t *end(data_);
  96         CYAlign(end, alignment);
  97         end += size;
  98
  99         if (size_t(end - data_) > size_) {
 100             size_t need(sizeof(Cleaner));
 101             CYAlign(need, alignment);
 102             need += size;
 103             size_ = std::max<size_t>(next_, need);
 104             next_ *= 2;
 105             data_ = reinterpret_cast<uint8_t *>(::malloc(size_));
 106             atexit(free, data_);
 107             _assert(size <= size_);
 108         }
 109
 110         uint8_t *data(data_);
 111         CYAlign(data, alignment);
 112         end = data + size;
 113         size_ -= end - data_;
 114         data_ = end;
 115         return reinterpret_cast<Type_ *>(data);
 116     }
 117
 118     template <typename Type_>
 119     Type_ *calloc(size_t count, size_t size, size_t alignment = CYAlignment) {
 120         Type_ *data(malloc<Type_>(count * size, alignment));
 121         memset(data, 0, count * size);
 122         return data;
 123     }
 124
 125     char *strdup(const char *data) {
 126         if (data == NULL)
 127             return NULL;
 128         return memdup(data, strlen(data) + 1, 1);
 129     }
 130
 131     template <typename Type_>
 132     Type_ *memdup(const Type_ *data, size_t size, size_t alignment = CYAlignment) {
 133         Type_ *copy(malloc<Type_>(size, alignment));
 134         memcpy(copy, data, size);
 135         return copy;
 136     }
 137
 138     char *strndup(const char *data, size_t size) {
 139         return strmemdup(data, strnlen(data, size));
 140     }
 141
 142     char *strmemdup(const char *data, size_t size) {
 143         char *copy(malloc<char>(size + 1, 1));
 144         memcpy(copy, data, size);
 145         copy[size] = '\0';
 146         return copy;
 147     }
 148
 149     // XXX: this could be made much more efficient
 150     __attribute__((__sentinel__))
 151     char *strcat(const char *data, ...) {
 152         size_t size(strlen(data)); {
 153             va_list args;
 154             va_start(args, data);
 155
 156             while (const char *arg = va_arg(args, const char *))
 157                 size += strlen(arg);
 158
 159             va_end(args);
 160         }
 161
 162         char *copy(malloc<char>(size + 1, 1)); {
 163             va_list args;
 164             va_start(args, data);
 165
 166             size_t offset(strlen(data));
 167             memcpy(copy, data, offset);
 168
 169             while (const char *arg = va_arg(args, const char *)) {
 170                 size_t size(strlen(arg));
 171                 memcpy(copy + offset, arg, size);
 172                 offset += size;
 173             }
 174
 175             va_end(args);
 176         }
 177
 178         copy[size] = '\0';
 179         return copy;
 180     }
 181
 182     // XXX: most people using this might should use sprintf
 183     char *itoa(long value) {
 184         return sprintf(16, "%ld", value);
 185     }
 186
 187     __attribute__((__format__(__printf__, 3, 4)))
 188     char *sprintf(size_t size, const char *format, ...) {
 189         va_list args;
 190         va_start(args, format);
 191         char *copy(vsprintf(size, format, args));
 192         va_end(args);
 193         return copy;
 194     }
 195
 196     char *vsprintf(size_t size, const char *format, va_list args) {
 197         va_list copy;
 198         va_copy(copy, args);
 199         char buffer[size];
 200         int writ(vsnprintf(buffer, size, format, copy));
 201         va_end(copy);
 202         _assert(writ >= 0);
 203
 204         if (size_t(writ) >= size)
 205             return vsprintf(writ + 1, format, args);
 206         return strmemdup(buffer, writ);
 207     }
 208
 209     void atexit(void (*code)(void *), void *data = NULL);
 210
 211     template <typename Type_>
 212     Type_ &object() {
 213         Type_ *value(new(*this) Type_());
 214         atexit(&delete_<Type_>, value);
 215         return *value;
 216     }
 217 };
 218
 219 _finline void *operator new(size_t size, CYPool &pool) {
 220     return pool.malloc<void>(size);
 221 }
 222
 223 _finline void *operator new [](size_t size, CYPool &pool) {
 224     return pool.malloc<void>(size);
 225 }
 226
 227 _finline void CYPool::atexit(void (*code)(void *), void *data) {
 228     cleaner_ = new(*this) Cleaner(cleaner_, code, data);
 229 }
 230
 231 struct CYData {
 232     CYPool *pool_;
 233     unsigned count_;
 234
 235     CYData() :
 236         count_(1)
 237     {
 238     }
 239
 240     CYData(CYPool &pool) :
 241         pool_(&pool),
 242         count_(_not(unsigned))
 243     {
 244     }
 245
 246     virtual ~CYData() {
 247     }
 248
 249     static void *operator new(size_t size, CYPool &pool) {
 250         void *data(pool.malloc<void>(size));
 251         reinterpret_cast<CYData *>(data)->pool_ = &pool;
 252         return data;
 253     }
 254
 255     static void *operator new(size_t size) {
 256         return operator new(size, *new CYPool());
 257     }
 258
 259     static void operator delete(void *data) {
 260         delete reinterpret_cast<CYData *>(data)->pool_;
 261     }
 262 };
 263
 264 template <typename Type_>
 265 struct CYPoolAllocator {
 266     CYPool *pool_;
 267
 268     typedef Type_ value_type;
 269     typedef value_type *pointer;
 270     typedef const value_type *const_pointer;
 271     typedef value_type &reference;
 272     typedef const value_type &const_reference;
 273     typedef std::size_t size_type;
 274     typedef std::ptrdiff_t difference_type;
 275
 276     CYPoolAllocator() :
 277         pool_(NULL)
 278     {
 279     }
 280
 281     template <typename Right_>
 282     CYPoolAllocator(const CYPoolAllocator<Right_> &rhs) :
 283         pool_(rhs.pool_)
 284     {
 285     }
 286
 287     pointer allocate(size_type size, const void *hint = 0) {
 288         return pool_->malloc<value_type>(size);
 289     }
 290
 291     void deallocate(pointer data, size_type size) {
 292     }
 293
 294     void construct(pointer address, const Type_ &rhs) {
 295         new(address) Type_(rhs);
 296     }
 297
 298     void destroy(pointer address) {
 299         address->~Type_();
 300     }
 301
 302     template <typename Right_>
 303     inline bool operator==(const CYPoolAllocator<Right_> &rhs) {
 304         return pool_ == rhs.pool_;
 305     }
 306
 307     template <typename Right_>
 308     inline bool operator!=(const CYPoolAllocator<Right_> &rhs) {
 309         return !operator==(rhs);
 310     }
 311
 312     template <typename Right_>
 313     struct rebind {
 314         typedef CYPoolAllocator<Right_> other;
 315     };
 316 };
 317
 318 class CYLocalPool :
 319     public CYPool
 320 {
 321   private:
 322     CYLocal<CYPool> local_;
 323
 324   public:
 325     CYLocalPool() :
 326         CYPool(),
 327         local_(this)
 328     {
 329     }
 330 };
 331
 332 #define $pool \
 333     (*CYLocal<CYPool>::Get())
 334
 335 template <>
 336 ::pthread_key_t CYLocal<CYPool>::key_;
 337
 338 #endif/*CYCRIPT_POOLING_HPP*/