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