/*

 * 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"

#include "Vector.h"

namespace ke {

// 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 *rawAllocate(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;

    }

    template <typename T>

    T *alloc(size_t count = 1) {

        void *ptr = rawAllocate(count * sizeof(T));

        if (!ptr)

            return NULL;

        return reinterpret_cast<T *>(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.rawAllocate(size);

    }

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

        return pool.rawAllocate(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);

    }

};

class PoolAllocationPolicy

{

  protected:

    void reportAllocationOverflow();

    void reportOutOfMemory();

  public:

    void *malloc(size_t bytes);

    void free(void *ptr);

};

template <typename T>

class PoolList

  : public Vector<T, PoolAllocationPolicy>,

    public PoolObject

{

  public:

    PoolList()

      : Vector<T, PoolAllocationPolicy>(PoolAllocationPolicy())

    {

    }

};

}

#endif // _include_jitcraft_pool_allocator_h_