source: proiecte/swift/trunk/lib/hoard-371/src/heaplayers/zoneheap.h @ 176

/* -*- C++ -*- */

/**
 * @class ZoneHeap
 * @brief A zone (or arena, or region) based allocator.
 * @author Emery Berger
 * @date June 2000
 *
 * Uses the superclass to obtain large chunks of memory that are only
 * returned when the heap itself is destroyed.
 *
*/

#ifndef _ZONEHEAP_H_
#define _ZONEHEAP_H_

#include <assert.h>

namespace HL {

  template <class Super, size_t ChunkSize>
  class ZoneHeap : public Super {
  public:

    ZoneHeap (void)
      : sizeRemaining (-1),
        currentArena (NULL),
        pastArenas (NULL)
    {}

    ~ZoneHeap (void)
    {
      // printf ("deleting arenas!\n");
      // Delete all of our arenas.
      Arena * ptr = pastArenas;
      while (ptr != NULL) {
        void * oldPtr = (void *) ptr;
        ptr = ptr->nextArena;
        //printf ("deleting %x\n", ptr);
        Super::free (oldPtr);
      }
      if (currentArena != NULL)
        //printf ("deleting %x\n", currentArena);
        Super::free (currentArena);
    }

    inline void * malloc (size_t sz) {
      void * ptr = zoneMalloc (sz);
      return ptr;
    }

    /// Free in a zone allocator is a no-op.
    inline void free (void *) {}

    /// Remove in a zone allocator is a no-op.
    inline int remove (void *) { return 0; }


  private:

    inline static size_t align (int sz) {
      return (sz + (sizeof(double) - 1)) & ~(sizeof(double) - 1);
    }

    inline void * zoneMalloc (size_t sz) {
      void * ptr;
      // Round up size to an aligned value.
      sz = align (sz);
      // Get more space in our arena if there's not enough room in this one.
      if ((currentArena == NULL) || (sizeRemaining < (int) sz)) {
        // First, add this arena to our past arena list.
        if (currentArena != NULL) {
          currentArena->nextArena = pastArenas;
          pastArenas = currentArena;
        }
        // Now get more memory.
        size_t allocSize = ChunkSize;
        if (allocSize < sz) {
          allocSize = sz;
        }
        currentArena =
          (Arena *) Super::malloc (allocSize + sizeof(Arena));
        if (currentArena == NULL) {
          return NULL;
        }
        currentArena->arenaSpace = (char *) (currentArena + 1);
        currentArena->nextArena = NULL;
        sizeRemaining = ChunkSize;
      }
      // Bump the pointer and update the amount of memory remaining.
      sizeRemaining -= sz;
      ptr = currentArena->arenaSpace;
      currentArena->arenaSpace += sz;
      assert (ptr != NULL);
      return ptr;
    }
  
    class Arena {
    public:
      Arena * nextArena;
      char * arenaSpace;
      double _dummy; // For alignment.
    };
    
    /// Space left in the current arena.
    long sizeRemaining;

    /// The current arena.
    Arena * currentArena;

    /// A linked list of past arenas.
    Arena * pastArenas;
  };

}

#endif