allocatable.cc

Go to the documentation of this file.

#include "ion/base/allocatable.h"

#include <vector>

#include "base/integral_types.h"
#include "ion/base/invalid.h"
#include "ion/base/lockguards.h"
#include "ion/base/staticsafedeclare.h"
#include "ion/base/threadlocalobject.h"

namespace ion {
namespace base {




class Allocatable::Helper {
 public:
  Helper()
      : placement_allocator_(NULL) {}

  void AddAllocationData(const void* memory_ptr, size_t size,
                         Allocator* allocator) {
    const void* end_ptr = reinterpret_cast<const uint8*>(memory_ptr) + size;
    allocations_.push_back(AllocationData(MemoryRange(memory_ptr, end_ptr),
                                          allocator, AllocationData::kNew));
  }

  void AddPlacementAllocationData(const void* memory_ptr, size_t size,
                                  Allocator* allocator) {
    const void* end_ptr = reinterpret_cast<const uint8*>(memory_ptr) + size;
    allocations_.push_back(AllocationData(MemoryRange(memory_ptr, end_ptr),
                                          allocator,
                                          AllocationData::kPlacement));
  }

  void AddDeallocationData(const void *memory_ptr, Allocator* allocator) {
    deallocations_.push_back(DeallocationData(memory_ptr, allocator));
  }

  bool FindAllocationData(const void* instance_ptr, Allocator** allocator_out,
                          const void** memory_ptr_out);

  const AllocatorPtr FindDeallocationData(const void* memory_ptr);

  Allocator* GetPlacementAllocator() {
    return placement_allocator_;
  }

  void SetPlacementAllocator(Allocator* allocator) {
    placement_allocator_ = allocator;
  }

 private:
  struct MemoryRange {
    MemoryRange(const void* min_in, const void* max_in)
        : min_address(min_in), max_address(max_in) {}
    const void* min_address;
    const void* max_address;
  };

  struct AllocationData {
    enum AllocationType {
      kNew,
      kPlacement
    };
    AllocationData(const MemoryRange& memory_range_in, Allocator* allocator_in,
                   AllocationType allocation_type_in)
        : memory_range(memory_range_in),
          allocator(allocator_in),
          allocation_type(allocation_type_in) {}
    MemoryRange memory_range;
    Allocator* allocator;
    AllocationType allocation_type;
  };

  struct DeallocationData {
    DeallocationData(const void* memory_ptr_in, Allocator* allocator_in)
        : memory_ptr(memory_ptr_in), allocator(allocator_in) {}
    const void* memory_ptr;
    AllocatorPtr allocator;
  };

  std::vector<AllocationData> allocations_;
  std::vector<DeallocationData> deallocations_;
  Allocator* placement_allocator_;
};

bool Allocatable::Helper::FindAllocationData(const void* instance_ptr,
                                             Allocator** allocator_out,
                                             const void** memory_ptr_out) {
  const size_t num_allocations = allocations_.size();
  for (size_t i = 0; i < num_allocations; ++i) {
    AllocationData& ad = allocations_[i];
    const void* memory_start = ad.memory_range.min_address;
    const void* memory_end = ad.memory_range.max_address;
    if (memory_start <= instance_ptr && instance_ptr < memory_end) {
      *allocator_out = ad.allocator;
      *memory_ptr_out =
          ad.allocation_type == AllocationData::kNew ? memory_start : NULL;
      *memory_ptr_out = memory_start;
      allocations_.erase(allocations_.begin() + i);
      return true;
    }
  }
  if (placement_allocator_) {
    *allocator_out = placement_allocator_;
    *memory_ptr_out = NULL;
    return true;
  }
  return false;
}

const AllocatorPtr Allocatable::Helper::FindDeallocationData(
    const void* memory_ptr) {
  DCHECK(memory_ptr);
  const size_t num_deallocations = deallocations_.size();
  AllocatorPtr allocator;
  for (size_t i = 0; i < num_deallocations; ++i) {
    DeallocationData& dd = deallocations_[i];
    if (dd.memory_ptr == memory_ptr) {
      allocator = dd.allocator;
      deallocations_.erase(deallocations_.begin() + i);
      break;
    }
  }
  DCHECK(allocator.Get());
  return allocator;
}




Allocatable::Allocatable() {
  Construct();
}

Allocatable::Allocatable(const Allocatable&) {
  Construct();
}

void Allocatable::Construct() {
  Allocator* allocator;
  const void* memory_ptr;
  if (GetHelper()->FindAllocationData(this, &allocator, &memory_ptr)) {
    allocator_.Reset(allocator);
    memory_ptr_ = memory_ptr;
  } else {
    memory_ptr_ = NULL;
  }
}

Allocatable::Allocatable(const AllocatorPtr& allocator_in)
    : allocator_(allocator_in), memory_ptr_(NULL) {
  Allocator* allocator;
  const void* memory_ptr;
  (void)allocator;
  (void)memory_ptr;
  DCHECK(!GetHelper()->FindAllocationData(this, &allocator, &memory_ptr))
      << "Allocatable can take an AllocatorPtr in its constructor only when "
         "created on the stack";
}

Allocatable::~Allocatable() {
  if (memory_ptr_)
    GetHelper()->AddDeallocationData(memory_ptr_, allocator_.Get());
}

void* Allocatable::New(size_t size, const AllocatorPtr& allocator) {
  const AllocatorPtr& a = AllocationManager::GetNonNullAllocator(allocator);
  DCHECK(a.Get());
  void* memory_ptr = a->AllocateMemory(size);
  if (memory_ptr)
    GetHelper()->AddAllocationData(memory_ptr, size, a.Get());

  return memory_ptr;
}

void Allocatable::Delete(void* memory_ptr) {
  if (memory_ptr) {
    AllocatorPtr allocator = GetHelper()->FindDeallocationData(memory_ptr);
    DCHECK(allocator.Get());
    allocator->DeallocateMemory(memory_ptr);
  }
}

void* Allocatable::PlacementNew(size_t size, const AllocatorPtr& allocator,
                                void* memory_ptr) {
  if (memory_ptr)
    GetHelper()->AddPlacementAllocationData(memory_ptr, size, allocator.Get());
  return memory_ptr;
}

Allocator* Allocatable::GetPlacementAllocator() {
  return GetHelper()->GetPlacementAllocator();
}

void Allocatable::SetPlacementAllocator(Allocator* allocator) {
  GetHelper()->SetPlacementAllocator(allocator);
}

Allocatable::Helper* Allocatable::GetHelper() {
  ION_DECLARE_SAFE_STATIC_POINTER(ThreadLocalObject<Helper>, s_helper);
  return s_helper->Get();
}

}  // namespace base
}  // namespace ion