allocators.h

Go to the documentation of this file.

// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef RAPIDJSON_ALLOCATORS_H_
#define RAPIDJSON_ALLOCATORS_H_

#include "rapidjson.h"

RAPIDJSON_NAMESPACE_BEGIN

// Allocator

// CrtAllocator


class CrtAllocator {
public:
 static const bool kNeedFree = true;
 void* Malloc(size_t size) { 
 if (size) // behavior of malloc(0) is implementation defined.
 return std::malloc(size);
 else
 return NULL; // standardize to returning NULL.
 }
 void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
 (void)originalSize;
 if (newSize == 0) {
 std::free(originalPtr);
 return NULL;
 }
 return std::realloc(originalPtr, newSize);
 }
 static void Free(void *ptr) { std::free(ptr); }
};

// MemoryPoolAllocator


template <typename BaseAllocator = CrtAllocator>
class MemoryPoolAllocator {
public:
 static const bool kNeedFree = false; 


 MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : 
 chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(0), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
 {
 }


 MemoryPoolAllocator(void *buffer, size_t size, size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) :
 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() {
 Clear();
 RAPIDJSON_DELETE(ownBaseAllocator_);
 }

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


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


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

 void* Malloc(size_t size) {
 if (!size)
 return NULL;

 size = RAPIDJSON_ALIGN(size);
 if (chunkHead_ == 0 || chunkHead_->size + size > chunkHead_->capacity)
 AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size);

 void *buffer = reinterpret_cast<char *>(chunkHead_ + 1) + chunkHead_->size;
 chunkHead_->size += size;
 return buffer;
 }

 void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
 if (originalPtr == 0)
 return Malloc(newSize);

 if (newSize == 0)
 return NULL;

 // 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 == (char *)(chunkHead_ + 1) + chunkHead_->size - originalSize) {
 size_t increment = static_cast<size_t>(newSize - originalSize);
 increment = RAPIDJSON_ALIGN(increment);
 if (chunkHead_->size + increment <= chunkHead_->capacity) {
 chunkHead_->size += increment;
 return originalPtr;
 }
 }

 // Realloc process: allocate and copy memory, do not free original buffer.
 void* newBuffer = Malloc(newSize);
 RAPIDJSON_ASSERT(newBuffer != 0); // Do not handle out-of-memory explicitly.
 if (originalSize)
 std::memcpy(newBuffer, originalPtr, originalSize);
 return newBuffer;
 }

 static void Free(void *ptr) { (void)ptr; } // Do nothing

private:
 MemoryPoolAllocator(const MemoryPoolAllocator& rhs) /* = delete */;
 MemoryPoolAllocator& operator=(const MemoryPoolAllocator& rhs) /* = delete */;


 void AddChunk(size_t capacity) {
 if (!baseAllocator_)
 ownBaseAllocator_ = baseAllocator_ = RAPIDJSON_NEW(BaseAllocator());
 ChunkHeader* chunk = reinterpret_cast<ChunkHeader*>(baseAllocator_->Malloc(sizeof(ChunkHeader) + capacity));
 chunk->capacity = capacity;
 chunk->size = 0;
 chunk->next = chunkHead_;
 chunkHead_ = chunk;
 }

 static const int kDefaultChunkCapacity = 64 * 1024; 


 struct ChunkHeader {
 size_t capacity; 
 size_t size; 
 ChunkHeader *next; 
 };

 ChunkHeader *chunkHead_; 
 size_t chunk_capacity_; 
 void *userBuffer_; 
 BaseAllocator* baseAllocator_; 
 BaseAllocator* ownBaseAllocator_; 
};

RAPIDJSON_NAMESPACE_END

#endif // RAPIDJSON_ENCODINGS_H_