gum::SmallObjectAllocator Class Reference

<agrum/base/core/smallObjectAllocator.h> More...

#include <smallObjectAllocator.h>

Collaboration diagram for gum::SmallObjectAllocator:

Public Member Functions
void	displayStats ()
	Displays the number of allocation and deallocation made so far.
Idx	nbAlloc ()
Idx	nbDealloc ()
Allocator / Deallocator
void *	allocate (const size_t &objectSize)
	Allocates a block.
void	deallocate (void *pDeallocatedObject, const size_t &objectSize)
	Deallocates an object.

Static Public Member Functions
static SmallObjectAllocator &	instance ()

Static Public Attributes
static const size_t	GUM_DEFAULT_CHUNK_SIZE = 8096
static const size_t	GUM_DEFAULT_MAX_OBJECT_SIZE = 512

Private Types
using	_Pool_ = HashTable< Size, FixedAllocator* >
	The pool containing FixedAllocator.

Private Attributes
_Pool_	_pool_
std::size_t	_chunkSize_
	The memory that a chunk allocates.
std::size_t	_maxObjectSize_
	The maximal size of an object befor new is called.
std::mutex	_mutex_
Idx	nbAllocation
Idx	nbDeallocation

Constructors / Destructors
	SmallObjectAllocator ()
	Constructor.
	SmallObjectAllocator (const SmallObjectAllocator &)=delete
	Copy Constructor (does nothing since we use a Singleton).
SmallObjectAllocator &	operator= (const SmallObjectAllocator &)
	Operator = (does nothing since we use a Singleton).
virtual	~SmallObjectAllocator ()
	Destructor.

Detailed Description

<agrum/base/core/smallObjectAllocator.h>

Allocates objects of any size

SmallObjectAllocator does so by aggregating several FixedAllocator objects. When SmallObjectAllocator receives an allocation request, it either forwards it to the best matching FixedAllocator object or passes it to the default operator new

Definition at line 76 of file smallObjectAllocator.h.

Member Typedef Documentation

_Pool_

using gum::SmallObjectAllocator::_Pool_ = HashTable< Size, FixedAllocator* >

private

The pool containing FixedAllocator.

Definition at line 159 of file smallObjectAllocator.h.

Constructor & Destructor Documentation

SmallObjectAllocator() [1/2]

INLINE gum::SmallObjectAllocator::SmallObjectAllocator ( )

private

Constructor.

Greater object than maxObjectSize will be forwarded to op new.

Definition at line 73 of file smallObjectAllocator_inl.h.

                                                    :
      _chunkSize_(GUM_DEFAULT_CHUNK_SIZE), _maxObjectSize_(GUM_DEFAULT_MAX_OBJECT_SIZE) {
    _pool_.setKeyUniquenessPolicy(false);
    GUM_CONSTRUCTOR(SmallObjectAllocator);
    nbAllocation   = 0;
    nbDeallocation = 0;
 
    // SmallObjectAllocator::Instance will create a static SmallObjectAllocator and
    // a HashTable that will not be deleted ...
    // so we inform our leak detector not to count those 2 objects
    GUM_DESTRUCTOR(SmallObjectAllocator);
    GUM_DESTRUCTOR(HashTable);
  }

References SmallObjectAllocator(), _chunkSize_, _maxObjectSize_, _pool_, GUM_DEFAULT_CHUNK_SIZE, GUM_DEFAULT_MAX_OBJECT_SIZE, nbAllocation, and nbDeallocation.

Referenced by SmallObjectAllocator(), SmallObjectAllocator(), ~SmallObjectAllocator(), instance(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

SmallObjectAllocator() [2/2]

gum::SmallObjectAllocator::SmallObjectAllocator ( const SmallObjectAllocator & )

privatedelete

Copy Constructor (does nothing since we use a Singleton).

References SmallObjectAllocator().

Here is the call graph for this function:

~SmallObjectAllocator()

INLINE gum::SmallObjectAllocator::~SmallObjectAllocator ( )

virtual

Destructor.

Definition at line 90 of file smallObjectAllocator_inl.h.

                                                     {
    GUM_DESTRUCTOR(SmallObjectAllocator);
    for (_Pool_::iterator pit = _pool_.begin(); pit != _pool_.end(); ++pit)
      delete pit.val();
  }

References SmallObjectAllocator(), and _pool_.

Here is the call graph for this function:

Member Function Documentation

allocate()

void * gum::SmallObjectAllocator::allocate

(

const size_t &

objectSize

)

Allocates a block.

Definition at line 72 of file smallObjectAllocator.cpp.

                                                               {
    // Small Object Allocator called for an object of size equals to 0
    GUM_ASSERT(objectSize > 0);
 
    std::lock_guard< std::mutex > lock(_mutex_);
 
    // If objectSize is greater than maxObjectSize, normal new is called
    if (objectSize > _maxObjectSize_) return new unsigned char[objectSize];
 
    //
    if (!_pool_.exists(Size(objectSize))) {
      // Calcul du nombre de block par chunk pour des objets de cette taille
      std::size_t nb = _chunkSize_ / Size(objectSize);
      if (nb > UCHAR_MAX) nb = UCHAR_MAX;
      auto numBlocks = static_cast< unsigned char >(nb);
 
      auto* newFa = new FixedAllocator(Size(objectSize), numBlocks);
      _pool_.set(Size(objectSize), newFa);
    }
    nbAllocation++;
 
    return _pool_[Size(objectSize)]->allocate();
  }

References _chunkSize_, _maxObjectSize_, _mutex_, _pool_, and nbAllocation.

Referenced by gum::ContingencyTable< Idx, GUM_ELEMENT >::attrAEndSafe(), gum::FusionContext< false >::leaf(), gum::AbstractLeaf::operator new(), gum::ActionSet::operator new(), gum::ArgMaxSet< GUM_SCALAR_VAL, GUM_SCALAR_SEQ >::operator new(), gum::Chi2TestPolicy< GUM_ELEMENT >::operator new(), gum::ComposedLeaf::operator new(), gum::ConcreteLeaf< AttributeSelection, isScalar >::operator new(), gum::GTestPolicy< GUM_ELEMENT >::operator new(), gum::InternalNode::operator new(), gum::ITestPolicy< GUM_ELEMENT >::operator new(), gum::LeafPair::operator new(), gum::LeastSquareTestPolicy< GUM_ELEMENT >::operator new(), gum::Link< T >::operator new(), gum::LinkedList< T >::operator new(), gum::NodeDatabase< AttributeSelection, isScalar >::operator new(), gum::O4DGContext::operator new(), gum::Observation::operator new(), and gum::Parent::operator new().

Here is the caller graph for this function:

deallocate()

INLINE void gum::SmallObjectAllocator::deallocate	(	void *	pDeallocatedObject,
		const size_t &	objectSize )

Deallocates an object.

Parameters

pDeallocatedObject	is the object to be deallocated
objectSize	is the size of that object (useful for faster deallocation)

Definition at line 116 of file smallObjectAllocator_inl.h.

                                                                                                 {
    // Small Object Allocator called for an object of size equals to 0
    GUM_ASSERT(objectSize > 0);
 
    std::lock_guard< std::mutex > lock(_mutex_);
 
    // If objectSize is greater than maxObjectSize, normal new is called
    if (objectSize > _maxObjectSize_) {
      delete[] (unsigned char*)pDeallocatedObject;
      return;
    }
 
    //      std::cout << "Deallocating " << pDeallocatedObject << std::endl;
    _pool_[Size(objectSize)]->deallocate(pDeallocatedObject);
    nbDeallocation++;
  }

References _maxObjectSize_, _mutex_, _pool_, and nbDeallocation.

Referenced by gum::Link< NodeId >::Link(), gum::FusionContext< false >::leafAssociatedPair(), gum::AbstractLeaf::operator delete(), gum::ActionSet::operator delete(), gum::ArgMaxSet< GUM_SCALAR_VAL, GUM_SCALAR_SEQ >::operator delete(), gum::Chi2TestPolicy< GUM_ELEMENT >::operator delete(), gum::ComposedLeaf::operator delete(), gum::ConcreteLeaf< AttributeSelection, isScalar >::operator delete(), gum::GTestPolicy< GUM_ELEMENT >::operator delete(), gum::InternalNode::operator delete(), gum::ITestPolicy< GUM_ELEMENT >::operator delete(), gum::LeafPair::operator delete(), gum::LeastSquareTestPolicy< GUM_ELEMENT >::operator delete(), gum::LinkedList< T >::operator delete(), gum::NodeDatabase< AttributeSelection, isScalar >::operator delete(), gum::O4DGContext::operator delete(), gum::Observation::operator delete(), and gum::Parent::operator delete().

Here is the caller graph for this function:

displayStats()

INLINE void gum::SmallObjectAllocator::displayStats

(

)

Displays the number of allocation and deallocation made so far.

Definition at line 137 of file smallObjectAllocator_inl.h.

                                                 {
    GUM_TRACE("Nb Small Allocation : " << nbAllocation
                                       << " -  Nb Small Deallocation : " << nbDeallocation);
  }

References nbAllocation, and nbDeallocation.

instance()

INLINE SmallObjectAllocator & gum::SmallObjectAllocator::instance ( )

static

Definition at line 96 of file smallObjectAllocator_inl.h.

                                                              {
    static SmallObjectAllocator soa;
 
    return soa;
  }

References SmallObjectAllocator().

Referenced by gum::Link< NodeId >::Link(), gum::ContingencyTable< Idx, GUM_ELEMENT >::attrAEndSafe(), gum::FusionContext< false >::leaf(), gum::FusionContext< false >::leafAssociatedPair(), gum::AbstractLeaf::operator delete(), gum::ActionSet::operator delete(), gum::ArgMaxSet< GUM_SCALAR_VAL, GUM_SCALAR_SEQ >::operator delete(), gum::Chi2TestPolicy< GUM_ELEMENT >::operator delete(), gum::ComposedLeaf::operator delete(), gum::ConcreteLeaf< AttributeSelection, isScalar >::operator delete(), gum::GTestPolicy< GUM_ELEMENT >::operator delete(), gum::InternalNode::operator delete(), gum::ITestPolicy< GUM_ELEMENT >::operator delete(), gum::LeafPair::operator delete(), gum::LeastSquareTestPolicy< GUM_ELEMENT >::operator delete(), gum::LinkedList< T >::operator delete(), gum::NodeDatabase< AttributeSelection, isScalar >::operator delete(), gum::O4DGContext::operator delete(), gum::Observation::operator delete(), gum::Parent::operator delete(), gum::AbstractLeaf::operator new(), gum::ActionSet::operator new(), gum::ArgMaxSet< GUM_SCALAR_VAL, GUM_SCALAR_SEQ >::operator new(), gum::Chi2TestPolicy< GUM_ELEMENT >::operator new(), gum::ComposedLeaf::operator new(), gum::ConcreteLeaf< AttributeSelection, isScalar >::operator new(), gum::GTestPolicy< GUM_ELEMENT >::operator new(), gum::InternalNode::operator new(), gum::ITestPolicy< GUM_ELEMENT >::operator new(), gum::LeafPair::operator new(), gum::LeastSquareTestPolicy< GUM_ELEMENT >::operator new(), gum::Link< T >::operator new(), gum::LinkedList< T >::operator new(), gum::NodeDatabase< AttributeSelection, isScalar >::operator new(), gum::O4DGContext::operator new(), gum::Observation::operator new(), gum::Parent::operator new(), and operator=().

Here is the call graph for this function:

nbAlloc()

INLINE Idx gum::SmallObjectAllocator::nbAlloc

(

)

Definition at line 142 of file smallObjectAllocator_inl.h.

{ return nbAllocation; }

References nbAllocation.

nbDealloc()

INLINE Idx gum::SmallObjectAllocator::nbDealloc

(

)

Definition at line 144 of file smallObjectAllocator_inl.h.

{ return nbDeallocation; }

References nbDeallocation.

operator=()

INLINE SmallObjectAllocator & gum::SmallObjectAllocator::operator= ( const SmallObjectAllocator & )

private

Operator = (does nothing since we use a Singleton).

Definition at line 133 of file smallObjectAllocator_inl.h.

                                                                                        {
    return instance();
  }

References SmallObjectAllocator(), and instance().

Here is the call graph for this function:

Member Data Documentation

_chunkSize_

std::size_t gum::SmallObjectAllocator::_chunkSize_

private

The memory that a chunk allocates.

Definition at line 166 of file smallObjectAllocator.h.

Referenced by SmallObjectAllocator(), and allocate().

_maxObjectSize_

std::size_t gum::SmallObjectAllocator::_maxObjectSize_

private

The maximal size of an object befor new is called.

Definition at line 171 of file smallObjectAllocator.h.

Referenced by SmallObjectAllocator(), allocate(), and deallocate().

_mutex_

std::mutex gum::SmallObjectAllocator::_mutex_

private

Definition at line 174 of file smallObjectAllocator.h.

Referenced by allocate(), and deallocate().

_pool_

_Pool_ gum::SmallObjectAllocator::_pool_

private

Definition at line 161 of file smallObjectAllocator.h.

Referenced by SmallObjectAllocator(), ~SmallObjectAllocator(), allocate(), and deallocate().

GUM_DEFAULT_CHUNK_SIZE

const size_t gum::SmallObjectAllocator::GUM_DEFAULT_CHUNK_SIZE = 8096

static

Parameters

The	default size of chunck of memory. These chuncks are pre-allocated memory space which are then split in small memory space of the size of a small object

Definition at line 83 of file smallObjectAllocator.h.

Referenced by SmallObjectAllocator().

GUM_DEFAULT_MAX_OBJECT_SIZE

const size_t gum::SmallObjectAllocator::GUM_DEFAULT_MAX_OBJECT_SIZE = 512

static

Parameters

The	default maximal size under which an object is considered small. If an object size is over this limit, the normal new allocator is called.

Definition at line 90 of file smallObjectAllocator.h.

Referenced by SmallObjectAllocator().

nbAllocation

Idx gum::SmallObjectAllocator::nbAllocation

private

Definition at line 176 of file smallObjectAllocator.h.

Referenced by SmallObjectAllocator(), allocate(), displayStats(), and nbAlloc().

nbDeallocation

Idx gum::SmallObjectAllocator::nbDeallocation

private

Definition at line 177 of file smallObjectAllocator.h.

Referenced by SmallObjectAllocator(), deallocate(), displayStats(), and nbDealloc().

---

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

• agrum/base/core/smallobjectallocator/smallObjectAllocator.h
• agrum/base/core/smallobjectallocator/smallObjectAllocator.cpp
• agrum/base/core/smallobjectallocator/smallObjectAllocator_inl.h