Arena.H

Go to the documentation of this file.

#ifdef CH_LANG_CC
/*
*      _______              __
*     / ___/ /  ___  __ _  / /  ___
*    / /__/ _ \/ _ \/  V \/ _ \/ _ \
*    \___/_//_/\___/_/_/_/_.__/\___/
*    Please refer to Copyright.txt, in Chombo's root directory.
*/
#endif

#ifndef _ARENA_H_
#define _ARENA_H_

#include <cstddef>

#ifdef CH_USE_MEMORY_TRACKING
#include <list>
#include <cstddef>
#endif

#include <set>
#include <vector>
#include "BaseNamespaceHeader.H"

#ifdef CH_USE_MEMORY_TRACKING
class Arena;
typedef std::list<Arena*> ArenaList;
#endif

using std::set;


class Arena
{
public:

  Arena();


  virtual ~Arena();

  virtual void* alloc(size_t a_sz) = 0;

  virtual void free(void* a_pt) = 0;

  static size_t align(size_t a_sz);

  typedef void (*FP)();

#ifdef CH_USE_MEMORY_TRACKING

  long int bytes;
  long int peak;
  static ArenaList* arenaList_;
  char name_[120];
#endif


protected:
    //
    // Types used by align().
    //
#ifndef DOXYGEN

    union Word
    {
        void*  p;
        double d;
        long   l;
        FP     f;
    };
#endif
};

//
// Inlines.
//

inline size_t Arena::align (size_t a_s)
{
    size_t x = a_s + sizeof(Word) - 1;
    x -= x % sizeof(Word);
    return x;
}


class BArena: public Arena
{
public:

  BArena(const char* a_name = "unnamed");

  virtual void* alloc (size_t a_sz);

  virtual void free (void* a_pt);
};


class CArena: public Arena
{
public:
    CArena(size_t a_hunk_size = 0);

    virtual ~CArena();

    virtual void* alloc(size_t a_nbytes);

    virtual void free(void* a_vp);

#if 0

    void* calloc(size_t a_nmemb,
                 size_t a_size);

    void* realloc (void*  a_ptr,
                   size_t a_size);
#endif

    enum { DefaultHunkSize = 1024*1024 };


protected:
    //
    // The nodes in our free list and block list.
    //
#ifndef DOXYGEN
    class Node
    {
    public:
      //
      // The default constructor.
      //
      Node()
        :
        m_block(0),
        m_size(0)
      {}
      //
      // Another constructor.
      //
      Node(void* a_block, size_t a_size)
        :
        m_block(a_block),
        m_size(a_size)
      {}
      //
      // The copy constructor.
      //
      Node(const Node& a_rhs)
        :
        m_block(a_rhs.m_block),
        m_size(a_rhs.m_size)
      {}
      //
      // The copy assignment constructor.
      //
      Node& operator = (const Node& a_rhs)
      {
          m_block = a_rhs.m_block;
          m_size  = a_rhs.m_size;
          return *this;
      }
      //
      // The "less-than" operator.
      //
      bool operator < (const Node& a_rhs) const
      {
          return m_block < a_rhs.m_block;
      }
      //
      // The equality operator.
      //
      bool operator == (const Node& a_rhs) const
      {
          return m_block == a_rhs.m_block;
      }
      //
      // The block address.
      //
      void* block() const
      {
        return m_block;
      }
      //
      // Set block address.
      //
      void block (void* a_blk)
      {
        m_block = a_blk;
      }
      //
      // The size of the memory block.
      //
      size_t size() const
      {
        return m_size;
      }
      //
      // Set size.
      //
      void size(size_t a_sz)
      {
        m_size = a_sz;
      }


    private:
        //
        // The block of memory we reference.
        //
        void* m_block;
        //
        // The size of the block we represent.
        //
        size_t m_size;
    };

    //
    // The type of our freelist and blocklist.
    // We use a set sorted from lo to hi memory addresses.
    //
    typedef set < Node > NL;

    //
    // The list of blocks allocated via ::operator new().
    //
    std::vector<void*> m_alloc;

    //
    // The free list of allocated but not currently used blocks.
    // Maintained in lo to hi memory sorted order.
    //
    NL m_freelist;

    //
    // The list of busy blocks.
    // A block is either on the freelist or on the blocklist, but not on both.
    //
    NL m_busylist;

    //
    // The minimal size of hunks to request via ::operator new().
    //
    size_t m_hunk;
#endif


private:
    //
    // Disallowed.
    //
    CArena (const CArena& a_rhs);
    CArena& operator= (const CArena& a_rhs);
};

//
// The Arena used by BaseFab code.
//
extern Arena* The_FAB_Arena;

#include "BaseNamespaceFooter.H"
#endif /*CH_ARENA*/

---