alloctracker.cc

Go to the documentation of this file.

#include "ion/base/alloctracker.h"

#include <stdlib.h>  // For malloc() and free().

#include "ion/base/allocator.h"
#include "ion/base/stlalloc/allocmap.h"

#if !defined(ION_ALLOC_TRACKER_DEFINED)
# error alloctracker.cc requires the --track-allocations build option.
#endif




namespace {

static ion::base::AllocTracker* GetTracker() {
  return ion::base::AllocTracker::GetMutableInstance();
}

template <typename T>
static T* CreateWithPlacementNew() {
  void* ptr = malloc(sizeof(T));
  return new(ptr) T;
}

}  // anonymous namespace

namespace ion {
namespace base {




class AllocTracker::Helper {
 public:
  Helper()
      : internal_allocator_(CreateWithPlacementNew<InternalAllocator>()),
        size_map_(internal_allocator_) {}
  ~Helper() {}

  void AddSize(void* ptr, size_t size) {
    size_map_[ptr] = size;
  }
  size_t FindAndRemoveSize(void* ptr) {
    size_t bytes = 0;
    SizeMap::iterator it = size_map_.find(ptr);
    if (it != size_map_.end()) {
      bytes = it->second;
      size_map_.erase(it);
    }
    return bytes;
  }

 private:
  class InternalAllocator : public ion::base::Allocator {
   public:
    virtual void* Allocate(size_t size) {
      if (AllocTracker* tracker = GetTracker()) {
        return tracker->New(size, kInternalAlloc);
      } else {
        return malloc(size);
      }
    }
    virtual void Deallocate(void* ptr) {
      GetTracker()->Delete(ptr, kInternalAlloc);
    }

   protected:
    virtual ~InternalAllocator() {}
  };
  typedef ion::base::SharedPtr<InternalAllocator> InternalAllocatorPtr;

  InternalAllocatorPtr internal_allocator_;

  typedef ion::base::AllocMap<void*, size_t> SizeMap;
  SizeMap size_map_;
};




AllocTracker* AllocTracker::GetMutableInstance() {
  static AllocTracker* tracker = CreateWithPlacementNew<AllocTracker>();
  return tracker;
}

const AllocTracker& AllocTracker::GetInstance() {
  return *GetMutableInstance();
}

AllocTracker::AllocTracker() {
  helper_.reset(CreateWithPlacementNew<Helper>());
}

AllocTracker::~AllocTracker() {
}

void AllocTracker::SetBaseline() {
  baseline_counts_ = all_counts_;
}

void* AllocTracker::New(std::size_t size, AllocType type) {
  void* ptr = malloc(size);

  TypeCounts &all_c = all_counts_.counts[type];
  TypeCounts &open_c = open_counts_.counts[type];
  ++all_c.allocs;
  all_c.bytes += size;
  ++open_c.allocs;
  open_c.bytes += size;

  if (type != kInternalAlloc)
    helper_->AddSize(ptr, size);

  return ptr;
}

void AllocTracker::Delete(void* ptr, AllocType type) {
  size_t bytes = type == kInternalAlloc ? 0 : helper_->FindAndRemoveSize(ptr);

  TypeCounts &open_c = open_counts_.counts[type];
  if (open_c.allocs)
    --open_c.allocs;
  if (open_c.bytes >= bytes)
    open_c.bytes -= bytes;

  free(ptr);
}

}  // namespace base
}  // namespace ion




using ion::base::AllocTracker;

void* operator new(std::size_t size) {
  return GetTracker()->New(size, AllocTracker::kNonArrayAlloc);
}

void* operator new[](std::size_t size) {
  return GetTracker()->New(size, AllocTracker::kArrayAlloc);
}

void operator delete(void* ptr) {
  GetTracker()->Delete(ptr, AllocTracker::kNonArrayAlloc);
}

void operator delete[](void* ptr) {
  GetTracker()->Delete(ptr, AllocTracker::kArrayAlloc);
}