MemoryPoolAllocator< BaseAllocator > Class Template Reference

Default memory allocator used by the parser and DOM. More...

#include <allocators.h>

Public Member Functions
	MemoryPoolAllocator (size_t chunkSize=kDefaultChunkCapacity, BaseAllocator *baseAllocator=0)
	Constructor with chunkSize.
	MemoryPoolAllocator (void *buffer, size_t size, size_t chunkSize=kDefaultChunkCapacity, BaseAllocator *baseAllocator=0)
	Constructor with user-supplied buffer.
	~MemoryPoolAllocator ()
	Destructor.
void	Clear ()
	Deallocates all memory chunks, excluding the user-supplied buffer.
size_t	Capacity () const
	Computes the total capacity of allocated memory chunks.
size_t	Size () const
	Computes the memory blocks allocated.
void *	Malloc (size_t size)
	Allocates a memory block. (concept Allocator)
void *	Realloc (void *originalPtr, size_t originalSize, size_t newSize)
	Resizes a memory block (concept Allocator)

Static Public Member Functions
static void	Free (void *ptr)
	Frees a memory block (concept Allocator)

Static Public Attributes
static const bool	kNeedFree = false
	Tell users that no need to call Free() with this allocator. (concept Allocator)

Detailed Description

template<typename BaseAllocator = CrtAllocator>
class MemoryPoolAllocator< BaseAllocator >

This allocator allocate memory blocks from pre-allocated memory chunks.

It does not free memory blocks. And Realloc() only allocate new memory.

The memory chunks are allocated by BaseAllocator, which is CrtAllocator by default.

User may also supply a buffer as the first chunk.

If the user-buffer is full then additional chunks are allocated by BaseAllocator.

The user-buffer is not deallocated by this allocator.

Template Parameters

BaseAllocator

the allocator type for allocating memory chunks. Default is CrtAllocator.

Note

implements Allocator concept

Definition at line 115 of file allocators.h.

Constructor & Destructor Documentation

MemoryPoolAllocator() [1/2]

template<typename BaseAllocator = CrtAllocator>

MemoryPoolAllocator< BaseAllocator >::MemoryPoolAllocator ( size_t chunkSize = kDefaultChunkCapacity, BaseAllocator * baseAllocator = 0 )

inline

Parameters

chunkSize	The size of memory chunk. The default is kDefaultChunkSize.
baseAllocator	The allocator for allocating memory chunks.

Definition at line 123 of file allocators.h.

                                                                                                    : 
        chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(0), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
    {
    }

MemoryPoolAllocator() [2/2]

template<typename BaseAllocator = CrtAllocator>

MemoryPoolAllocator< BaseAllocator >::MemoryPoolAllocator ( void * buffer, size_t size, size_t chunkSize = kDefaultChunkCapacity, BaseAllocator * baseAllocator = 0 )

inline

The user buffer will be used firstly. When it is full, memory pool allocates new chunk with chunk size.

The user buffer will not be deallocated when this allocator is destructed.

Parameters

buffer	User supplied buffer.
size	Size of the buffer in bytes. It must at least larger than sizeof(ChunkHeader).
chunkSize	The size of memory chunk. The default is kDefaultChunkSize.
baseAllocator	The allocator for allocating memory chunks.

Definition at line 138 of file allocators.h.

                                                                                                                               :
        chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(buffer), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
    {
        RAPIDJSON_ASSERT(buffer != 0);
        RAPIDJSON_ASSERT(size > sizeof(ChunkHeader));
        chunkHead_ = reinterpret_cast<ChunkHeader*>(buffer);
        chunkHead_->capacity = size - sizeof(ChunkHeader);
        chunkHead_->size = 0;
        chunkHead_->next = 0;
    }

~MemoryPoolAllocator()

template<typename BaseAllocator = CrtAllocator>

MemoryPoolAllocator< BaseAllocator >::~MemoryPoolAllocator ( )

inline

This deallocates all memory chunks, excluding the user-supplied buffer.

Definition at line 152 of file allocators.h.

                           {
        Clear();
        RAPIDJSON_DELETE(ownBaseAllocator_);
    }

Here is the call graph for this function:

Member Function Documentation

Capacity()

template<typename BaseAllocator = CrtAllocator>

size_t MemoryPoolAllocator< BaseAllocator >::Capacity ( ) const

inline

Returns

total capacity in bytes.

Definition at line 171 of file allocators.h.

                            {
        size_t capacity = 0;
        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
            capacity += c->capacity;
        return capacity;
    }

Here is the caller graph for this function:

Clear()

template<typename BaseAllocator = CrtAllocator>

void MemoryPoolAllocator< BaseAllocator >::Clear ( )

inline

Definition at line 158 of file allocators.h.

                 {
        while (chunkHead_ && chunkHead_ != userBuffer_) {
            ChunkHeader* next = chunkHead_->next;
            baseAllocator_->Free(chunkHead_);
            chunkHead_ = next;
        }
        if (chunkHead_ && chunkHead_ == userBuffer_)
            chunkHead_->size = 0; // Clear user buffer
    }

Here is the caller graph for this function:

Free()

template<typename BaseAllocator = CrtAllocator>

static void MemoryPoolAllocator< BaseAllocator >::Free ( void * ptr )

inlinestatic

Definition at line 238 of file allocators.h.

{ (void)ptr; } // Do nothing

Here is the caller graph for this function:

Malloc()

template<typename BaseAllocator = CrtAllocator>

void * MemoryPoolAllocator< BaseAllocator >::Malloc ( size_t size )

inline

Definition at line 189 of file allocators.h.

                              {
        if (!size)
            return NULL;
 
        size = RAPIDJSON_ALIGN(size);
        if (chunkHead_ == 0 || chunkHead_->size + size > chunkHead_->capacity)
            if (!AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size))
                return NULL;
 
        void *buffer = reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size;
        chunkHead_->size += size;
        return buffer;
    }

Here is the caller graph for this function:

Realloc()

template<typename BaseAllocator = CrtAllocator>

void * MemoryPoolAllocator< BaseAllocator >::Realloc ( void * originalPtr, size_t originalSize, size_t newSize )

inline

Definition at line 204 of file allocators.h.

                                                                          {
        if (originalPtr == 0)
            return Malloc(newSize);
 
        if (newSize == 0)
            return NULL;
 
        originalSize = RAPIDJSON_ALIGN(originalSize);
        newSize = RAPIDJSON_ALIGN(newSize);
 
        // Do not shrink if new size is smaller than original
        if (originalSize >= newSize)
            return originalPtr;
 
        // Simply expand it if it is the last allocation and there is sufficient space
        if (originalPtr == reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size - originalSize) {
            size_t increment = static_cast<size_t>(newSize - originalSize);
            if (chunkHead_->size + increment <= chunkHead_->capacity) {
                chunkHead_->size += increment;
                return originalPtr;
            }
        }
 
        // Realloc process: allocate and copy memory, do not free original buffer.
        if (void* newBuffer = Malloc(newSize)) {
            if (originalSize)
                std::memcpy(newBuffer, originalPtr, originalSize);
            return newBuffer;
        }
        else
            return NULL;
    }

Here is the call graph for this function:

Size()

template<typename BaseAllocator = CrtAllocator>

size_t MemoryPoolAllocator< BaseAllocator >::Size ( ) const

inline

Returns

total used bytes.

Definition at line 181 of file allocators.h.

                        {
        size_t size = 0;
        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
            size += c->size;
        return size;
    }

Here is the caller graph for this function:

Member Data Documentation

kNeedFree

template<typename BaseAllocator = CrtAllocator>

const bool MemoryPoolAllocator< BaseAllocator >::kNeedFree = false

static

Definition at line 117 of file allocators.h.

---

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

• libraries/fc/include/fc/crypto/webauthn_json/include/rapidjson/allocators.h