/*

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

#define _include_jitcraft_spaces_h_

#include "Utility.h"

#include "Platform.h"

namespace jc {

static const size_t kObjectAlignment = 8;

// The heap stack is designed for structures which are known to not escape the

// program stack, and can thus be quickly allocated in a LIFO manner.

// 

class HeapStack

{

    OS::AlignableMapping map_;

    Address buffer_;

    Address pos_;

    Address end_;

  private:

    static const size_t kStackSize = 1024 * 1024;

  public:

    HeapStack();

    ~HeapStack();

    bool initialize();

  public:

    Address position() const {

        return pos_;

    }

    inline Address allocate(size_t nbytes);

    inline void unwind(Address to);

};

class HeapChunk

{

    HeapChunk *next_;

    // Base address, from OS::AlignableMapping.

    Address base_;

    // End of the allocated region.

    Address end_;

    // Current allocation point.

    Address cursor_;

  public:

    static const size_t kMaxObjectSize = 1 * kGB;

    static const size_t kDefaultSize = 256 * kKB;

    static const size_t kAlignment = 256 * kKB;

    // All objects must be allocated in the first kAlignment bytes of the

    // chunk. Every object is at least 8 bytes (kPointerAlignment), so we

    // reserve one mark bit for every possible object address in the chunk

    // (including, for simplicity, unallocatable addresses at the start).

    //

    // The number of mark bits needed is:

    //

    // MaxObjectsPerChunk = kAlignment / kPointerAlignment 

    //                    = 32KB

    //

    // The number of bytes needed for these mark bits is:

    //

    // NumMarkBytes       = MaxObjectsPerChunk / 8

    //                    = 4KB

    //

    // The number of uint32s needed to store these bytes is:

    //

    // NumMarkWords       = NumMarkBytes / sizeof(uint32)

    //                    = 1024

    static const size_t kMaxObjectsPerChunk = kAlignment / kObjectAlignment;

    static const size_t kMarkBits = kMaxObjectsPerChunk;

    static const size_t kMarkBytes = kMarkBits / 8;

    static const size_t kMarkWords = kMarkBytes / sizeof(uint32);

    static inline size_t offsetToMarkBits()

    {

        return Align(sizeof(HeapChunk), kObjectAlignment);

    }

    static inline size_t offsetToFirst()

    {

        assert(IsAligned(kMarkBytes, kObjectAlignment));

        return offsetToMarkBits() + kMarkBytes;

    }

  public:

    static HeapChunk *New(HeapChunk *prev, size_t size);

    static void Destroy(HeapChunk *chunk);

  public:

    inline Address allocate(size_t nbytes);

    HeapChunk *next() {

        return next_;

    }

    Address base() {

        return base_;

    }

    Address end() {

        return end_;

    }

    size_t size() {

        return end() - base();

    }

    Address first() {

        return reinterpret_cast<Address>(this) + offsetToFirst();

    }

    uint32 *markBits() {

        return reinterpret_cast<uint32 *>(reinterpret_cast<Address>(this) +

                                          offsetToMarkBits());

    }

};

class OldSpace

{

    HeapChunk *first_;

    HeapChunk *last_;

  public:

    OldSpace();

    ~OldSpace();

    bool initialize();

  public:

    inline Address allocate(size_t nbytes);

    Address allocateSlow(size_t nbytes);

};

}

#endif // _include_jitcraft_spaces_h_