Arena.H

Go to the documentation of this file.

/*   _______              __
    / ___/ /  ___  __ _  / /  ___
   / /__/ _ \/ _ \/  V \/ _ \/ _ \
   \___/_//_/\___/_/_/_/_.__/\___/
*/
// CHOMBO Copyright (c) 2000-2004, The Regents of the University of
// California, through Lawrence Berkeley National Laboratory (subject to
// receipt of any required approvals from U.S. Dept. of Energy).  All
// rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// (1) Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// (2) Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// (3) Neither the name of Lawrence Berkeley National Laboratory, U.S.
// Dept. of Energy nor the names of its contributors may be used to endorse
// or promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// You are under no obligation whatsoever to provide any bug fixes,
// patches, or upgrades to the features, functionality or performance of
// the source code ("Enhancements") to anyone; however, if you choose to
// make your Enhancements available either publicly, or directly to
// Lawrence Berkeley National Laboratory, without imposing a separate
// written license agreement for such Enhancements, then you hereby grant
// the following license: a non-exclusive, royalty-free perpetual license
// to install, use, modify, prepare derivative works, incorporate into
// other computer software, distribute, and sublicense such Enhancements or
// derivative works thereof, in binary and source code form.
//
// TRADEMARKS. Product and company names mentioned herein may be the
// trademarks of their respective owners.  Any rights not expressly granted
// herein are reserved.
//

#ifndef _ARENA_H_
#define _ARENA_H_

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

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


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);
};

#include <cstddef>
#include <set>
#include <vector>
using std::set;


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);

    void* calloc(size_t a_nmemb,
                 size_t a_size);

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

    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;

#endif /*CH_ARENA*/

---