Pooling.hpp

   1 /* Cycript - Optimizing JavaScript Compiler/Runtime
   2  * Copyright (C) 2009-2015  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 class CYPool;
  39 _finline void *operator new(size_t size, CYPool &pool);
  40 _finline void *operator new [](size_t size, CYPool &pool);
  41
  42 class CYPool {
  43   private:
  44     uint8_t *data_;
  45     size_t size_;
  46     size_t next_;
  47
  48     struct Cleaner {
  49         Cleaner *next_;
  50         void (*code_)(void *);
  51         void *data_;
  52
  53         Cleaner(Cleaner *next, void (*code)(void *), void *data) :
  54             next_(next),
  55             code_(code),
  56             data_(data)
  57         {
  58         }
  59     } *cleaner_;
  60
  61     static _finline size_t align(size_t size) {
  62         // XXX: alignment is more complex than this
  63         return (size + 7) & ~0x3;
  64     }
  65
  66     template <typename Type_>
  67     static void delete_(void *data) {
  68         reinterpret_cast<Type_ *>(data)->~Type_();
  69     }
  70
  71     CYPool(const CYPool &);
  72
  73   public:
  74     CYPool(size_t next = 64) :
  75         data_(NULL),
  76         size_(0),
  77         next_(next),
  78         cleaner_(NULL)
  79     {
  80     }
  81
  82     ~CYPool() {
  83         for (Cleaner *cleaner(cleaner_); cleaner != NULL; ) {
  84             Cleaner *next(cleaner->next_);
  85             (*cleaner->code_)(cleaner->data_);
  86             cleaner = next;
  87         }
  88     }
  89
  90     template <typename Type_>
  91     Type_ *malloc(size_t size) {
  92         size = align(size);
  93
  94         if (size > size_) {
  95             size_ = std::max<size_t>(next_, size + align(sizeof(Cleaner)));
  96             next_ *= 2;
  97             data_ = reinterpret_cast<uint8_t *>(::malloc(size_));
  98             atexit(free, data_);
  99             _assert(size <= size_);
 100         }
 101
 102         void *data(data_);
 103         data_ += size;
 104         size_ -= size;
 105         return reinterpret_cast<Type_ *>(data);
 106     }
 107
 108     char *strdup(const char *data) {
 109         if (data == NULL)
 110             return NULL;
 111         return reinterpret_cast<char *>(memdup(data, strlen(data) + 1));
 112     }
 113
 114     template <typename Type_>
 115     Type_ *memdup(const Type_ *data, size_t size) {
 116         Type_ *copy(malloc<Type_>(size));
 117         memcpy(copy, data, size);
 118         return copy;
 119     }
 120
 121     char *strndup(const char *data, size_t size) {
 122         return strmemdup(data, strnlen(data, size));
 123     }
 124
 125     char *strmemdup(const char *data, size_t size) {
 126         char *copy(malloc<char>(size + 1));
 127         memcpy(copy, data, size);
 128         copy[size] = '\0';
 129         return copy;
 130     }
 131
 132     // XXX: this could be made much more efficient
 133     __attribute__((__sentinel__))
 134     char *strcat(const char *data, ...) {
 135         size_t size(strlen(data)); {
 136             va_list args;
 137             va_start(args, data);
 138
 139             while (const char *arg = va_arg(args, const char *))
 140                 size += strlen(arg);
 141
 142             va_end(args);
 143         }
 144
 145         char *copy(malloc<char>(size + 1)); {
 146             va_list args;
 147             va_start(args, data);
 148
 149             size_t offset(strlen(data));
 150             memcpy(copy, data, offset);
 151
 152             while (const char *arg = va_arg(args, const char *)) {
 153                 size_t size(strlen(arg));
 154                 memcpy(copy + offset, arg, size);
 155                 offset += size;
 156             }
 157
 158             va_end(args);
 159         }
 160
 161         copy[size] = '\0';
 162         return copy;
 163     }
 164
 165     // XXX: most people using this might should use sprintf
 166     char *itoa(long value) {
 167         return sprintf(16, "%ld", value);
 168     }
 169
 170     __attribute__((__format__(__printf__, 3, 4)))
 171     char *sprintf(size_t size, const char *format, ...) {
 172         va_list args;
 173         va_start(args, format);
 174         char *copy(vsprintf(size, format, args));
 175         va_end(args);
 176         return copy;
 177     }
 178
 179     char *vsprintf(size_t size, const char *format, va_list args) {
 180         va_list copy;
 181         va_copy(copy, args);
 182         char buffer[size];
 183         int writ(vsnprintf(buffer, size, format, copy));
 184         va_end(copy);
 185         _assert(writ >= 0);
 186
 187         if (size_t(writ) >= size)
 188             return vsprintf(writ + 1, format, args);
 189         return strmemdup(buffer, writ);
 190     }
 191
 192     void atexit(void (*code)(void *), void *data = NULL);
 193
 194     template <typename Type_>
 195     Type_ &object() {
 196         Type_ *value(new(*this) Type_());
 197         atexit(&delete_<Type_>, value);
 198         return *value;
 199     }
 200 };
 201
 202 _finline void *operator new(size_t size, CYPool &pool) {
 203     return pool.malloc<void>(size);
 204 }
 205
 206 _finline void *operator new [](size_t size, CYPool &pool) {
 207     return pool.malloc<void>(size);
 208 }
 209
 210 _finline void CYPool::atexit(void (*code)(void *), void *data) {
 211     cleaner_ = new(*this) Cleaner(cleaner_, code, data);
 212 }
 213
 214 struct CYData {
 215     CYPool *pool_;
 216     unsigned count_;
 217
 218     CYData() :
 219         count_(1)
 220     {
 221     }
 222
 223     CYData(CYPool &pool) :
 224         pool_(&pool),
 225         count_(_not(unsigned))
 226     {
 227     }
 228
 229     virtual ~CYData() {
 230     }
 231
 232     static void *operator new(size_t size, CYPool &pool) {
 233         void *data(pool.malloc<void>(size));
 234         reinterpret_cast<CYData *>(data)->pool_ = &pool;
 235         return data;
 236     }
 237
 238     static void *operator new(size_t size) {
 239         return operator new(size, *new CYPool());
 240     }
 241
 242     static void operator delete(void *data) {
 243         delete reinterpret_cast<CYData *>(data)->pool_;
 244     }
 245 };
 246
 247 template <typename Type_>
 248 struct CYPoolAllocator {
 249     CYPool *pool_;
 250
 251     typedef Type_ value_type;
 252     typedef value_type *pointer;
 253     typedef const value_type *const_pointer;
 254     typedef value_type &reference;
 255     typedef const value_type &const_reference;
 256     typedef std::size_t size_type;
 257     typedef std::ptrdiff_t difference_type;
 258
 259     CYPoolAllocator() :
 260         pool_(NULL)
 261     {
 262     }
 263
 264     template <typename Right_>
 265     CYPoolAllocator(const CYPoolAllocator<Right_> &rhs) :
 266         pool_(rhs.pool_)
 267     {
 268     }
 269
 270     pointer allocate(size_type size, const void *hint = 0) {
 271         return pool_->malloc<value_type>(size);
 272     }
 273
 274     void deallocate(pointer data, size_type size) {
 275     }
 276
 277     void construct(pointer address, const Type_ &rhs) {
 278         new(address) Type_(rhs);
 279     }
 280
 281     void destroy(pointer address) {
 282         address->~Type_();
 283     }
 284
 285     template <typename Right_>
 286     inline bool operator==(const CYPoolAllocator<Right_> &rhs) {
 287         return pool_ == rhs.pool_;
 288     }
 289
 290     template <typename Right_>
 291     inline bool operator!=(const CYPoolAllocator<Right_> &rhs) {
 292         return !operator==(rhs);
 293     }
 294
 295     template <typename Right_>
 296     struct rebind {
 297         typedef CYPoolAllocator<Right_> other;
 298     };
 299 };
 300
 301 class CYLocalPool :
 302     public CYPool
 303 {
 304   private:
 305     CYLocal<CYPool> local_;
 306
 307   public:
 308     CYLocalPool() :
 309         CYPool(),
 310         local_(this)
 311     {
 312     }
 313 };
 314
 315 #define $pool \
 316     (*CYLocal<CYPool>::Get())
 317
 318 template <>
 319 ::pthread_key_t CYLocal<CYPool>::key_;
 320
 321 #endif/*CYCRIPT_POOLING_HPP*/