LWPoolArea Class Reference

#include <LWPoolArea.h>

Collaboration diagram for LWPoolArea:

Public Member Functions
char *	acquire ()
void	release (char *c)
bool	isUnused () const
long long	getMemDishedOut () const
long long	getMemUnusedButAllocated () const
bool	belongsInArea (char *c) const
unsigned	totalNumberOfChunks () const

Static Public Member Functions
static LWPoolArea *	create (unsigned chunksize, char *mem, unsigned length_of_mem, unsigned nchunks=UINT_MAX)

Private Member Functions
	LWPoolArea (const LWPoolArea &)
LWPoolArea &	operator= (const LWPoolArea &)
	LWPoolArea (unsigned chunksize, unsigned nchunks)
	~LWPoolArea ()

Static Private Member Functions
static unsigned	calcNChunks (unsigned chunksize, unsigned length_of_mem)

Private Attributes
const unsigned	m_chunksize
const unsigned	m_nchunks
LWPoolAreaBookKeeper *	m_bookkeep
char *	m_area

Detailed Description

Definition at line 25 of file LWPoolArea.h.

Constructor & Destructor Documentation

LWPoolArea() [1/2]

LWPoolArea::LWPoolArea ( const LWPoolArea &  )

private

LWPoolArea() [2/2]

LWPoolArea::LWPoolArea ( unsigned  chunksize, unsigned  nchunks  )

private

~LWPoolArea()

LWPoolArea::~LWPoolArea ( )

inlineprivate

Definition at line 60 of file LWPoolArea.h.

{}//Not needed - can simply release

Member Function Documentation

acquire()

char* LWPoolArea::acquire

(

)

belongsInArea()

bool LWPoolArea::belongsInArea

(

char *

c

)

const

calcNChunks()

unsigned LWPoolArea::calcNChunks ( unsigned  chunksize, unsigned  length_of_mem  )

staticprivate

Definition at line 21 of file LWPoolArea.cxx.

{
  assert(chunksize<UINT_MAX);
  unsigned nchunks;
  //ntotbytes will be used like this:
  //
  // [The AllocArea class]
  // [The book-keeper class + the internal fields in the book-keeper class]
  // [area=nchunks*chunksize][<chunksize bytes]
  //
  // The difficult part is the second field, which depends on nchunks.
 
  //1) Trivially remove the bytes needed for AllocArea:
  const unsigned ntotbytes = length_of_mem-sizeof(LWPoolArea);
 
  //2) Get an upper limit for nchunks, assuming the internal book-keeper fields are zero length:
  nchunks = ntotbytes/chunksize;
 
  //3) How many bytes, if any, are we in the red now?
 
  int balance = ntotbytes - nchunks*chunksize - LWPoolAreaBookKeeper::nBytesNeededForCreate(nchunks);
  if (balance<0) {
    nchunks -= (-balance)/chunksize;
    //Should be ok now, but now we might have undershot a bit, since
    //the number of internal bins might have come down! Jeeesus...:
    while (ntotbytes >= nchunks*chunksize + LWPoolAreaBookKeeper::nBytesNeededForCreate(nchunks))
      ++nchunks;
    --nchunks;
  }
  assert(ntotbytes >= nchunks*chunksize + LWPoolAreaBookKeeper::nBytesNeededForCreate(nchunks));
#ifndef NDEBUG
  long wastage = ntotbytes - nchunks*chunksize-LWPoolAreaBookKeeper::nBytesNeededForCreate(nchunks);
  assert(wastage>=0);
  assert(wastage<std::max(9l,long(chunksize+sizeof(LWPoolAreaBookKeeper::BitField))));
  if (wastage*1.0>0.05*ntotbytes||wastage>640) {
    std::cout<<"LWHist MemPool (chunksize: "<<chunksize<<") WARNING: Wasting "
         <<wastage<<" bytes per area ("<<(wastage*100.0/ntotbytes)<<" %)"<<std::endl;
 
    std::cout<<"chunksize "<<chunksize<<": totsize:"<<length_of_mem<<std::endl;
    std::cout<<"chunksize "<<chunksize<<": sizeof(LWPoolArea):"<<sizeof(LWPoolArea)<<std::endl;
    std::cout<<"chunksize "<<chunksize<<": bytes for bookkeep:"<<LWPoolAreaBookKeeper::nBytesNeededForCreate(nchunks)<<std::endl;
    unsigned bytes_useful(nchunks*chunksize);
    unsigned bytes_overhead(length_of_mem-bytes_useful);
    std::cout<<"chunksize "<<chunksize<<": nchunks:"<<nchunks<<" => "<<bytes_useful<<" bytes"<<std::endl;
    std::cout<<"chunksize "<<chunksize<<": rounding wastage:"<<wastage<<std::endl;
    std::cout<<"chunksize "<<chunksize<<": total overhead:"
         <<bytes_overhead<<" ("<<bytes_overhead*100.0/bytes_useful<<"% ~ "
         <<bytes_overhead*CHAR_BIT*1.0/nchunks<<" bits/chunk)"<<std::endl;
  }
#endif
  return nchunks;
 
}

create()

static LWPoolArea* LWPoolArea::create ( unsigned  chunksize, char *  mem, unsigned  length_of_mem, unsigned  nchunks = UINT_MAX  )

static

getMemDishedOut()

long long LWPoolArea::getMemDishedOut

(

)

const

getMemUnusedButAllocated()

long long LWPoolArea::getMemUnusedButAllocated

(

)

const

isUnused()

bool LWPoolArea::isUnused

(

)

const

operator=()

LWPoolArea& LWPoolArea::operator= ( const LWPoolArea &  )

private

release()

void LWPoolArea::release

(

char *

c

)

totalNumberOfChunks()

unsigned LWPoolArea::totalNumberOfChunks ( ) const

inline

Definition at line 52 of file LWPoolArea.h.

{ return m_nchunks; }

Member Data Documentation

m_area

char* LWPoolArea::m_area

private

Definition at line 64 of file LWPoolArea.h.

m_bookkeep

LWPoolAreaBookKeeper* LWPoolArea::m_bookkeep

private

Definition at line 63 of file LWPoolArea.h.

m_chunksize

const unsigned LWPoolArea::m_chunksize

private

Definition at line 61 of file LWPoolArea.h.

m_nchunks

const unsigned LWPoolArea::m_nchunks

private

Definition at line 62 of file LWPoolArea.h.

---

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

• LWPoolArea.h
• LWPoolArea.cxx