LWPool Class Reference

#include <LWPool.h>

Collaboration diagram for LWPool:

Public Member Functions
	LWPool (unsigned chunksize)
	~LWPool ()
char *	acquire ()
char *	acquireClean ()
void	release (char *)
void	erase ()
long long	getMemDishedOut () const
long long	getMemOwned () const

Static Public Member Functions
static long long	getMotherMemOwned ()
static void	forceCleanupMotherPool ()

Private Member Functions
	LWPool (const LWPool &)
LWPool &	operator= (const LWPool &)
LWPoolArea *	grow ()
void	freeArea (LWPoolArea *)
unsigned	growSize () const
unsigned	chunkSize () const
void	init ()
bool	belongsInArea (char *, LWPoolArea *) const
char *	searchAcquire ()
LWPoolArea *	findArea (char *)
bool	isMotherPool () const
	LWPool (unsigned chunksize, unsigned growsize)

Static Private Member Functions
static LWPool *	getMotherPool ()

Private Attributes
const unsigned	m_chunksize
const unsigned	m_growsize
unsigned	m_nchunksPerArea
std::vector< LWPoolArea * >	m_areas
LWPoolArea *	m_likelyNonEmptyArea
LWPoolArea *	m_likelyReleaseArea
std::mutex	m_mutex

Detailed Description

Definition at line 24 of file LWPool.h.

Constructor & Destructor Documentation

LWPool() [1/3]

LWPool::LWPool

(

unsigned

chunksize

)

Definition at line 32 of file LWPool.cxx.

  : m_chunksize(chunksize),
    m_growsize(LWPool::getMotherPool()->chunkSize())
{
  //Normal constructor
  init();
}

~LWPool()

LWPool::~LWPool

(

)

Definition at line 61 of file LWPool.cxx.

{
  erase();
}

LWPool() [2/3]

LWPool::LWPool ( const LWPool &  )

private

LWPool() [3/3]

LWPool::LWPool ( unsigned  chunksize, unsigned  growsize  )

private

Definition at line 41 of file LWPool.cxx.

  : m_chunksize(chunksize),
    m_growsize(ngrowsize)
{
  //Mother pool constructor
  init();
}

Member Function Documentation

acquire()

char* LWPool::acquire

(

)

acquireClean()

char * LWPool::acquireClean

(

)

Definition at line 105 of file LWPool.cxx.

{
  char * c = acquire();
  memset(c,0,m_chunksize);
  return c;
}

belongsInArea()

bool LWPool::belongsInArea ( char *  , LWPoolArea *    ) const

private

chunkSize()

unsigned LWPool::chunkSize ( ) const

inlineprivate

Definition at line 54 of file LWPool.h.

{ return m_chunksize; }

erase()

void LWPool::erase

(

)

Definition at line 67 of file LWPool.cxx.

{
  std::scoped_lock lock (m_mutex);
  for (LWPoolArea* a : m_areas) {
    char * c = reinterpret_cast<char*>(a);
    if (isMotherPool())
      delete[] c;
    else
      getMotherPool()->release(c);
  }
  m_areas.clear();
  m_likelyNonEmptyArea = nullptr;
  m_likelyReleaseArea = nullptr;
}

findArea()

LWPoolArea * LWPool::findArea ( char *  c )

private

Definition at line 131 of file LWPool.cxx.

{
  //Figure out which area (if any), we belong in. For reasons of cpu
  //and (in particular) cache-efficiency we do not actually ask the
  //classes themselves, rather we just look at their addresses (since
  //their addresses marks the beginning of the pool-areas also):
 
  std::vector<LWPoolArea*>::iterator areaIt =
    std::lower_bound(m_areas.begin(),m_areas.end(),reinterpret_cast<void*>(c));
  LWPoolArea* a(areaIt==m_areas.end()?m_areas.back():*(--areaIt));
  assert(a&&a->belongsInArea(c)&&"Trying to release chunk back to a mem-pool from which it was never acquired");
  assert(reinterpret_cast<char*>(a)<c&&c<reinterpret_cast<char*>(a)+m_growsize);
  return a;
}

forceCleanupMotherPool()

void LWPool::forceCleanupMotherPool ( )

static

Definition at line 206 of file LWPool.cxx.

{
  getMotherPool()->erase();
}

freeArea()

void LWPool::freeArea ( LWPoolArea *  a )

private

Definition at line 174 of file LWPool.cxx.

{
  assert(!m_areas.empty());
 
  if (m_likelyNonEmptyArea==a)
    m_likelyNonEmptyArea = 0;
  if (m_likelyReleaseArea==a)
    m_likelyReleaseArea = 0;
 
  //Find index of the area (fixme: use binary search!):
  unsigned i(0);
  const unsigned nareasplusone(m_areas.size()+1);
  for (;i<nareasplusone;++i) {
    if (a==m_areas.at(i))
      break;
  }
  assert(i<m_areas.size());
  const unsigned nareasminusone(nareasplusone-2);
  if (i<nareasminusone) {
    //This is not the last area in the list, so move those above down by one:
    for (unsigned j=i;j<nareasminusone;++j)
      m_areas.at(j) = m_areas.at(j+1);
  }
  m_areas.resize(nareasminusone);
  char * c = reinterpret_cast<char*>(a);
  if (isMotherPool())
    delete[] c;
  else
    getMotherPool()->release(c);
}

getMemDishedOut()

long long LWPool::getMemDishedOut

(

)

const

Definition at line 96 of file LWPool.cxx.

                                        {
  std::scoped_lock lock (m_mutex);
  long long l(0);
  for (LWPoolArea* a : m_areas)
    l += a->getMemDishedOut();
  return l;
}

getMemOwned()

long long LWPool::getMemOwned

(

)

const

Definition at line 89 of file LWPool.cxx.

{
  std::scoped_lock lock (m_mutex);
  return m_growsize*m_areas.size();
}

getMotherMemOwned()

long long LWPool::getMotherMemOwned ( )

static

Definition at line 83 of file LWPool.cxx.

{
  return getMotherPool()->getMemOwned();
}

getMotherPool()

LWPool * LWPool::getMotherPool ( )

staticprivate

Definition at line 20 of file LWPool.cxx.

{
  //The mother pool parameters determine the growth
  //dynamics of all pools:
  static constexpr unsigned extra = sizeof(LWPool)+sizeof(LWPoolAreaBookKeeper)+8;
  static constexpr unsigned poolgrow = 16384+extra;
  static constexpr unsigned motherpoolgrow = poolgrow*32+extra;
  static LWPool mother ATLAS_THREAD_SAFE (poolgrow,motherpoolgrow);
  return &mother;
}

grow()

LWPoolArea * LWPool::grow ( )

private

Definition at line 147 of file LWPool.cxx.

{
  char * c(0);
  if (isMotherPool()) {
    LWHISTMALLOC(m_growsize);
    c = new char[m_growsize];
  } else {
    c = getMotherPool()->acquire();
  }
  assert(c);
  LWPoolArea * a = LWPoolArea::create( m_chunksize, c, m_growsize, m_nchunksPerArea);
 
  if (m_nchunksPerArea==UINT_MAX)
    m_nchunksPerArea = a->totalNumberOfChunks();
 
  unsigned debug(m_areas.capacity());
  m_areas.push_back(a);
  if (debug!=m_areas.capacity())
    LWHISTMALLOC(sizeof(m_areas.at(0))*m_areas.capacity());
  sort(m_areas.begin(),m_areas.end());//always keep sorted
  //fixme: make slightly faster by manually inserting and moving up mem.
  m_likelyNonEmptyArea = a;
 
  return a;
}

growSize()

unsigned LWPool::growSize ( ) const

inlineprivate

Definition at line 53 of file LWPool.h.

{ return m_growsize; }

init()

void LWPool::init ( )

private

Definition at line 50 of file LWPool.cxx.

{
  m_likelyNonEmptyArea = 0;
  m_likelyReleaseArea = 0;
  m_nchunksPerArea = UINT_MAX;
  assert(m_chunksize>=1);
  LWHISTMALLOC(sizeof(m_areas[0])*16);
  m_areas.reserve(16);
}

isMotherPool()

bool LWPool::isMotherPool ( ) const

inlineprivate

Definition at line 61 of file LWPool.h.

{ return this==getMotherPool(); }

operator=()

LWPool& LWPool::operator= ( const LWPool &  )

private

release()

void LWPool::release

(

char *

)

searchAcquire()

char * LWPool::searchAcquire ( )

private

Definition at line 113 of file LWPool.cxx.

{
  m_likelyNonEmptyArea = 0;
  for (LWPoolArea* a : m_areas) {
    char * c = a->acquire();
    if (c) {
      m_likelyNonEmptyArea = a;
      return c;
    }
  }
 
  //3) All areas empty - create a new area:
  m_likelyNonEmptyArea = grow();
  assert(m_likelyNonEmptyArea);
  return m_likelyNonEmptyArea->acquire();
}

Member Data Documentation

m_areas

std::vector<LWPoolArea*> LWPool::m_areas

private

Definition at line 43 of file LWPool.h.

m_chunksize

const unsigned LWPool::m_chunksize

private

Definition at line 40 of file LWPool.h.

m_growsize

const unsigned LWPool::m_growsize

private

Definition at line 41 of file LWPool.h.

m_likelyNonEmptyArea

LWPoolArea* LWPool::m_likelyNonEmptyArea

private

Definition at line 44 of file LWPool.h.

m_likelyReleaseArea

LWPoolArea* LWPool::m_likelyReleaseArea

private

Definition at line 45 of file LWPool.h.

m_mutex

std::mutex LWPool::m_mutex

mutableprivate

Definition at line 46 of file LWPool.h.

m_nchunksPerArea

unsigned LWPool::m_nchunksPerArea

private

Definition at line 42 of file LWPool.h.

---

The documentation for this class was generated from the following files:

• LWPool.h
• LWPool.cxx