/*

  * Copyright (C) 2012 David Anderson

  *

  * This file is part of JITCraft.

  *

  * JITCraft is free software: you can redistribute it and/or modify it under

  * the terms of the GNU General Public License as published by the Free

  * Software Foundation, either version 3 of the License, or (at your option)

  * any later version.

  * 

  * Foobar is distributed in the hope that it will be useful, but WITHOUT ANY

  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License along with

  * JITCraft. If not, see http://www.gnu.org/licenses/.

  */

 #ifndef _include_jitcraft_pool_allocator_h_

 #define _include_jitcraft_pool_allocator_h_

 #include <new>

 #include <stddef.h>

 #include <limits.h>

 #include "Utility.h"

 namespace jc {

 // Allocates memory in chunks that are not freed until the entire allocator

 // is freed. This is intended for use with large, temporary data structures.

 class PoolAllocator

 {

     friend class PoolAllocationScope;

     struct Pool {

         char *base;

         char *ptr;

         char *end;

         Pool *prev;

         size_t size() const {

             return size_t(end - base);

         }

     };

     static const size_t kDefaultPoolSize = 8 * 1024;

     static const size_t kMaxReserveSize = 64 * 1024;

   private:

     Pool *reserved_;

     Pool *last_;

   private:

     void unwind(char *pos);

     void *slowAllocate(size_t actualBytes);

   public:

     PoolAllocator();

     ~PoolAllocator();

     void *allocate(size_t bytes) {

         // Guarantee malloc alignment.

         size_t actualBytes = Align(bytes, kMallocAlignment);

         if (!last_ || (size_t(last_->end - last_->ptr) < actualBytes))

             return slowAllocate(actualBytes);

         char *ptr = last_->ptr;

         last_->ptr += actualBytes;

         return ptr;

     }

     char *enter();

     void leave(char *position);

 };

 class PoolScope

 {

     PoolAllocator &pool_;

     char *position_;

   public:

     PoolScope(PoolAllocator &allocator)

       : pool_(allocator),

         position_(allocator.enter())

     {

     }

     ~PoolScope()

     {

         pool_.leave(position_);

     }

 };

 class PoolObject

 {

   public:

     void *operator new(size_t size, PoolAllocator &pool) {

         return pool.allocate(size);

     }

     void *operator new [](size_t size, PoolAllocator &pool) {

         return pool.allocate(size);

     }

     // Using delete on pool-allocated objects is illegal.

     void operator delete(void *ptr, PoolAllocator &pool) {

         assert(false);

     }

     void operator delete [](void *ptr, PoolAllocator &pool) {

         assert(false);

     }

 };

 // Simple vector<> lookalike that can use the pool allocator.

 template <typename T>

 class PoolList : public PoolObject

 {

     T *t_;

     size_t length_;

     size_t max_;

   private:

     void ensure(PoolAllocator &pool, size_t n) {

         if (max_ - length_ >= n)

             return;

         size_t newMax = max_;

         if (newMax == 0)

             newMax = 8;

         while (newMax - length_ < n) {

             // Make sure the request does not overflow.

             if (newMax >= INT_MAX)

                 throw std::bad_alloc();

             newMax *= 2;

         }

         // Ensure no overflow.

         if (newMax > UINT_MAX / sizeof(T))

             throw std::bad_alloc();

         T *new_ = (T *)pool.allocate(newMax * sizeof(T));

         for (size_t i = 0; i < length_; i++)

             new (&new_[i]) T(t_[i]);

         t_ = new_;

         max_ = newMax;

     }

   public:

     PoolList()

       : t_(NULL),

         length_(NULL),

         max_(NULL)

     {

     }

   public:

     void append(PoolAllocator &pool, const T &t) {

         ensure(pool, 1);

         new (&t_[length_]) T(t);

         length_++;

     }

     size_t length() const {

         return length_;

     }

     T &at(size_t i) {

         assert(i < length());

         return t_[i];

     }

 };

 }

 #endif // _include_jitcraft_pool_allocator_h_