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 // 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     char *strdup(const char *data) {
 119         if (data == NULL)
 120             return NULL;
 121         return reinterpret_cast<char *>(memdup(data, strlen(data) + 1, 1));
 122     }
 123
 124     template <typename Type_>
 125     Type_ *memdup(const Type_ *data, size_t size, size_t alignment = CYAlignment) {
 126         Type_ *copy(malloc<Type_>(size, alignment));
 127         memcpy(copy, data, size);
 128         return copy;
 129     }
 130
 131     char *strndup(const char *data, size_t size) {
 132         return strmemdup(data, strnlen(data, size));
 133     }
 134
 135     char *strmemdup(const char *data, size_t size) {
 136         char *copy(malloc<char>(size + 1, 1));
 137         memcpy(copy, data, size);
 138         copy[size] = '\0';
 139         return copy;
 140     }
 141
 142     // XXX: this could be made much more efficient
 143     __attribute__((__sentinel__))
 144     char *strcat(const char *data, ...) {
 145         size_t size(strlen(data)); {
 146             va_list args;
 147             va_start(args, data);
 148
 149             while (const char *arg = va_arg(args, const char *))
 150                 size += strlen(arg);
 151
 152             va_end(args);
 153         }
 154
 155         char *copy(malloc<char>(size + 1, 1)); {
 156             va_list args;
 157             va_start(args, data);
 158
 159             size_t offset(strlen(data));
 160             memcpy(copy, data, offset);
 161
 162             while (const char *arg = va_arg(args, const char *)) {
 163                 size_t size(strlen(arg));
 164                 memcpy(copy + offset, arg, size);
 165                 offset += size;
 166             }
 167
 168             va_end(args);
 169         }
 170
 171         copy[size] = '\0';
 172         return copy;
 173     }
 174
 175     // XXX: most people using this might should use sprintf
 176     char *itoa(long value) {
 177         return sprintf(16, "%ld", value);
 178     }
 179
 180     __attribute__((__format__(__printf__, 3, 4)))
 181     char *sprintf(size_t size, const char *format, ...) {
 182         va_list args;
 183         va_start(args, format);
 184         char *copy(vsprintf(size, format, args));
 185         va_end(args);
 186         return copy;
 187     }
 188
 189     char *vsprintf(size_t size, const char *format, va_list args) {
 190         va_list copy;
 191         va_copy(copy, args);
 192         char buffer[size];
 193         int writ(vsnprintf(buffer, size, format, copy));
 194         va_end(copy);
 195         _assert(writ >= 0);
 196
 197         if (size_t(writ) >= size)
 198             return vsprintf(writ + 1, format, args);
 199         return strmemdup(buffer, writ);
 200     }
 201
 202     void atexit(void (*code)(void *), void *data = NULL);
 203
 204     template <typename Type_>
 205     Type_ &object() {
 206         Type_ *value(new(*this) Type_());
 207         atexit(&delete_<Type_>, value);
 208         return *value;
 209     }
 210 };
 211
 212 _finline void *operator new(size_t size, CYPool &pool) {
 213     return pool.malloc<void>(size);
 214 }
 215
 216 _finline void *operator new [](size_t size, CYPool &pool) {
 217     return pool.malloc<void>(size);
 218 }
 219
 220 _finline void CYPool::atexit(void (*code)(void *), void *data) {
 221     cleaner_ = new(*this) Cleaner(cleaner_, code, data);
 222 }
 223
 224 struct CYData {
 225     CYPool *pool_;
 226     unsigned count_;
 227
 228     CYData() :
 229         count_(1)
 230     {
 231     }
 232
 233     CYData(CYPool &pool) :
 234         pool_(&pool),
 235         count_(_not(unsigned))
 236     {
 237     }
 238
 239     virtual ~CYData() {
 240     }
 241
 242     static void *operator new(size_t size, CYPool &pool) {
 243         void *data(pool.malloc<void>(size));
 244         reinterpret_cast<CYData *>(data)->pool_ = &pool;
 245         return data;
 246     }
 247
 248     static void *operator new(size_t size) {
 249         return operator new(size, *new CYPool());
 250     }
 251
 252     static void operator delete(void *data) {
 253         delete reinterpret_cast<CYData *>(data)->pool_;
 254     }
 255 };
 256
 257 template <typename Type_>
 258 struct CYPoolAllocator {
 259     CYPool *pool_;
 260
 261     typedef Type_ value_type;
 262     typedef value_type *pointer;
 263     typedef const value_type *const_pointer;
 264     typedef value_type &reference;
 265     typedef const value_type &const_reference;
 266     typedef std::size_t size_type;
 267     typedef std::ptrdiff_t difference_type;
 268
 269     CYPoolAllocator() :
 270         pool_(NULL)
 271     {
 272     }
 273
 274     template <typename Right_>
 275     CYPoolAllocator(const CYPoolAllocator<Right_> &rhs) :
 276         pool_(rhs.pool_)
 277     {
 278     }
 279
 280     pointer allocate(size_type size, const void *hint = 0) {
 281         return pool_->malloc<value_type>(size);
 282     }
 283
 284     void deallocate(pointer data, size_type size) {
 285     }
 286
 287     void construct(pointer address, const Type_ &rhs) {
 288         new(address) Type_(rhs);
 289     }
 290
 291     void destroy(pointer address) {
 292         address->~Type_();
 293     }
 294
 295     template <typename Right_>
 296     inline bool operator==(const CYPoolAllocator<Right_> &rhs) {
 297         return pool_ == rhs.pool_;
 298     }
 299
 300     template <typename Right_>
 301     inline bool operator!=(const CYPoolAllocator<Right_> &rhs) {
 302         return !operator==(rhs);
 303     }
 304
 305     template <typename Right_>
 306     struct rebind {
 307         typedef CYPoolAllocator<Right_> other;
 308     };
 309 };
 310
 311 class CYLocalPool :
 312     public CYPool
 313 {
 314   private:
 315     CYLocal<CYPool> local_;
 316
 317   public:
 318     CYLocalPool() :
 319         CYPool(),
 320         local_(this)
 321     {
 322     }
 323 };
 324
 325 #define $pool \
 326     (*CYLocal<CYPool>::Get())
 327
 328 template <>
 329 ::pthread_key_t CYLocal<CYPool>::key_;
 330
 331 #endif/*CYCRIPT_POOLING_HPP*/