/*

 * 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/.

 */

#include <assert.h>

#include <stdlib.h>

#include <new>

#include "PoolAllocator.h"

#include "Zone.h"

using namespace ke;

PoolAllocator::PoolAllocator()

  : reserved_(NULL),

    last_(NULL)

{

}

PoolAllocator::~PoolAllocator()

{

    unwind(NULL);

    if (reserved_)

        free(reserved_);

}

char *

PoolAllocator::enter()

{

    if (!last_)

        return NULL;

    return last_->ptr;

}

void

PoolAllocator::leave(char *pos)

{

    unwind(pos);

}

void

PoolAllocator::unwind(char *pos)

{

    while (last_) {

        if (pos && pos >= last_->base && pos < last_->end)

            break;

        Pool *prev = last_->prev;

        {

            if (last_->size() <= kMaxReserveSize &&

                (!reserved_ || reserved_->size() < last_->size()))

            {

                if (reserved_)

                    free(reserved_);

                reserved_ = last_;

            } else {

                free(last_);

            }

        }

        last_ = prev;

    }

    if (!last_) {

        assert(!pos);

        return;

    }

    last_->ptr = pos;

}

void *

PoolAllocator::slowAllocate(size_t actualBytes)

{

    size_t bytesNeeded = actualBytes + sizeof(Pool);

    if (bytesNeeded < kDefaultPoolSize)

        bytesNeeded = kDefaultPoolSize;

    Pool *pool;

    if (reserved_ && reserved_->size() >= bytesNeeded) {

        pool = reserved_;

        reserved_ = NULL;

    } else {

        pool = (Pool *)malloc(bytesNeeded);

        if (!pool) {

            ZONE()->reportOutOfMemory();

            return NULL;

        }

        pool->base = (char *)(pool + 1);

        pool->end = (char *)pool + bytesNeeded;

    }

    pool->ptr = pool->base + actualBytes;

    pool->prev = last_;

    last_ = pool;

    return pool->base;

}

void

PoolAllocationPolicy::reportOutOfMemory()

{

    ZONE()->reportOutOfMemory();

}

void

PoolAllocationPolicy::reportAllocationOverflow()

{

    ZONE()->reportError(Message_AllocationOverflow);

}

void *

PoolAllocationPolicy::malloc(size_t bytes)

{

    return ZONE()->pool().allocate(bytes);

}

void

PoolAllocationPolicy::free(void *ptr)

{

}