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

#ifndef RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY
#define RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY (64 * 1024)
#endif

// 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)
      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;
  }

  void *Realloc(void *originalPtr, size_t originalSize, size_t newSize) {
    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;
  }

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

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


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

  static const int kDefaultChunkCapacity =
      RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY;  


  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_