AllocatorPool.h

Go to the documentation of this file.

// ============================================================================
// ============================================================================

//
// ********************************************************************
// * DISCLAIMER                                                       *
// *                                                                  *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in:                      *
// *   http://cern.ch/geant4/license                                  *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.                                                             *
// *                                                                  *
// * This  code  implementation is the  intellectual property  of the *
// * GEANT4 collaboration.                                            *
// * By copying,  distributing  or modifying the Program (or any work *
// * based  on  the Program)  you indicate  your  acceptance of  this *
// * statement, and all its terms.                                    *
// ********************************************************************
//
// -------------------------------------------------------------------
//      GEANT 4 class header file
//
// Class description:
//
// Class implementing a memory pool for fast allocation and deallocation
// of memory chunks.  The size of the chunks for small allocated objects
// is fixed to 1Kb and takes into account of memory alignment; for large
// objects it is set to 10 times the object's size.
// The implementation is derived from: B.Stroustrup, The C++ Programming
// Language, Third Edition.

//           -------------- G4AllocatorPool ----------------
//
// Author: G.Cosmo (CERN), November 2000
// -------------------------------------------------------------------

#ifndef GAUDIKERNEL_AllocatorPool_h
#define GAUDIKERNEL_AllocatorPool_h 1

#include <memory>
#include "GaudiKernel/Kernel.h"

namespace GaudiUtils
{
  class GAUDI_API AllocatorPool final
  {
  public:

    explicit AllocatorPool( unsigned int n=0 );
    ~AllocatorPool();
    AllocatorPool(const AllocatorPool& right);
    inline void* Alloc();
    inline void  Free( void* b );
    inline unsigned int  Size() const;
    void  Reset();

  private:

    AllocatorPool& operator= (const AllocatorPool& right);

  private:

    struct PoolLink final
    {
      PoolLink* next = nullptr;
    };
    class PoolChunk final
    {
    public:
      explicit PoolChunk(unsigned int sz)
        : size(sz), mem{new char[size]}  {}
      const unsigned int size;
      std::unique_ptr<char[]> mem;
      PoolChunk* next = nullptr;
    };

    void Grow();

  private:

    const unsigned int esize;
    const unsigned int csize;
    PoolChunk* chunks = nullptr;
    PoolLink* head = nullptr;
    int nchunks = 0;
  };

} // end of namespace GaudiUtils



// ************************************************************
// Alloc
// ************************************************************
//
inline void*
GaudiUtils::AllocatorPool::Alloc()
{
  if ( head==0 ) { Grow(); }
  PoolLink* p = head;  // return first element
  head = p->next;
  return p;
}

// ************************************************************
// Free
// ************************************************************
//
inline void
GaudiUtils::AllocatorPool::Free( void* b )
{
  PoolLink* p = static_cast<PoolLink*>(b);
  p->next = head;        // put b back as first element
  head = p;
}

// ************************************************************
// Size
// ************************************************************
//
inline unsigned int
GaudiUtils::AllocatorPool::Size() const
{
  return nchunks*csize;
}


// ============================================================================
// The END
// ============================================================================
#endif
// ============================================================================