/*

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