nanoflann::PooledAllocator Class Reference

#include <nanoflann.hpp>

Collaboration diagram for nanoflann::PooledAllocator:

Public Member Functions
	PooledAllocator (const size_t blocksize_=BLOCKSIZE)
	Default constructor.
	~PooledAllocator ()
	Destructor.
void	free_all ()
	Frees all allocated memory chunks.
void *	malloc (const size_t req_size)
	Returns a pointer to a piece of new memory of the given size in bytes allocated from the pool.
template<typename T >
T *	allocate (const size_t count=1)
	Allocates (using this pool) a generic type T.

Public Attributes
size_t	usedMemory
size_t	wastedMemory

Detailed Description

Definition at line 532 of file nanoflann.hpp.

Constructor & Destructor Documentation

PooledAllocator()

nanoflann::PooledAllocator::PooledAllocator ( const size_t blocksize_ = BLOCKSIZE )

inline

Default constructor.

Initializes a new pool.

Definition at line 557 of file nanoflann.hpp.

      : blocksize(blocksize_) {
    internal_init();
  }

~PooledAllocator()

nanoflann::PooledAllocator::~PooledAllocator ( )

inline

Destructor.

Frees all the memory allocated in this pool.

Definition at line 565 of file nanoflann.hpp.

                     {
    free_all();
  }

Member Function Documentation

allocate()

template<typename T >

T * nanoflann::PooledAllocator::allocate ( const size_t count = 1 )

inline

Allocates (using this pool) a generic type T.

Params: count = number of instances to allocate. Returns: pointer (of type T*) to memory buffer

Definition at line 636 of file nanoflann.hpp.

                                      {
    T* mem = (T*) this->malloc(sizeof(T) * count);
    return mem;
  }

free_all()

void nanoflann::PooledAllocator::free_all ( )

inline

Frees all allocated memory chunks.

Definition at line 570 of file nanoflann.hpp.

                  {
    while (base != NULL) {
      void *prev = *((void**) base); /* Get pointer to prev block. */
      ::free(base);
      base = prev;
    }
    internal_init();
  }

malloc()

void * nanoflann::PooledAllocator::malloc ( const size_t req_size )

inline

Returns a pointer to a piece of new memory of the given size in bytes allocated from the pool.

Definition at line 583 of file nanoflann.hpp.

                                      {
    /* Round size up to a multiple of wordsize.  The following expression
     only works for WORDSIZE that is a power of 2, by masking last bits of
     incremented size to zero.
     */
    const size_t size = (req_size + (WORDSIZE - 1)) & ~(WORDSIZE - 1);
 
    /* Check whether a new block must be allocated.  Note that the first word
     of a block is reserved for a pointer to the previous block.
     */
    if (size > remaining) {
 
      wastedMemory += remaining;
 
      /* Allocate new storage. */
      const size_t blocksize =
          (size + sizeof(void*) + (WORDSIZE - 1) > BLOCKSIZE) ?
              size + sizeof(void*) + (WORDSIZE - 1) : BLOCKSIZE;
 
      // use the standard C malloc to allocate memory
      void* m = ::malloc(blocksize);
      if (!m) {
        fprintf(stderr, "Failed to allocate memory.\n");
        return NULL;
      }
 
      /* Fill first word of new block with pointer to previous block. */
      ((void**) m)[0] = base;
      base = m;
 
      size_t shift = 0;
      //int size_t = (WORDSIZE - ( (((size_t)m) + sizeof(void*)) & (WORDSIZE-1))) & (WORDSIZE-1);
 
      remaining = blocksize - sizeof(void*) - shift;
      loc = ((char*) m + sizeof(void*) + shift);
    }
    void* rloc = loc;
    loc = (char*) loc + size;
    remaining -= size;
 
    usedMemory += size;
 
    return rloc;
  }

References nanoflann::BLOCKSIZE, and nanoflann::WORDSIZE.

Member Data Documentation

usedMemory

size_t nanoflann::PooledAllocator::usedMemory

Definition at line 551 of file nanoflann.hpp.

wastedMemory

size_t nanoflann::PooledAllocator::wastedMemory

Definition at line 552 of file nanoflann.hpp.

---

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

• src/particles/subgrid3DLegacyFramework/contactDetection/nanoflann.hpp