src/v8/src/heap-profiler.cc

   1 // Copyright 2009-2010 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "src/v8.h"
   6
   7 #include "src/heap-profiler.h"
   8
   9 #include "src/allocation-tracker.h"
  10 #include "src/heap-snapshot-generator-inl.h"
  11
  12 namespace v8 {
  13 namespace internal {
  14
  15 HeapProfiler::HeapProfiler(Heap* heap)
  16     : ids_(new HeapObjectsMap(heap)),
  17       names_(new StringsStorage(heap)),
  18       next_snapshot_uid_(1),
  19       is_tracking_object_moves_(false) {
  20 }
  21
  22
  23 static void DeleteHeapSnapshot(HeapSnapshot** snapshot_ptr) {
  24   delete *snapshot_ptr;
  25 }
  26
  27
  28 HeapProfiler::~HeapProfiler() {
  29   snapshots_.Iterate(DeleteHeapSnapshot);
  30   snapshots_.Clear();
  31 }
  32
  33
  34 void HeapProfiler::DeleteAllSnapshots() {
  35   snapshots_.Iterate(DeleteHeapSnapshot);
  36   snapshots_.Clear();
  37   names_.Reset(new StringsStorage(heap()));
  38 }
  39
  40
  41 void HeapProfiler::RemoveSnapshot(HeapSnapshot* snapshot) {
  42   snapshots_.RemoveElement(snapshot);
  43 }
  44
  45
  46 void HeapProfiler::DefineWrapperClass(
  47     uint16_t class_id, v8::HeapProfiler::WrapperInfoCallback callback) {
  48   DCHECK(class_id != v8::HeapProfiler::kPersistentHandleNoClassId);
  49   if (wrapper_callbacks_.length() <= class_id) {
  50     wrapper_callbacks_.AddBlock(
  51         NULL, class_id - wrapper_callbacks_.length() + 1);
  52   }
  53   wrapper_callbacks_[class_id] = callback;
  54 }
  55
  56
  57 v8::RetainedObjectInfo* HeapProfiler::ExecuteWrapperClassCallback(
  58     uint16_t class_id, Object** wrapper) {
  59   if (wrapper_callbacks_.length() <= class_id) return NULL;
  60   return wrapper_callbacks_[class_id](
  61       class_id, Utils::ToLocal(Handle<Object>(wrapper)));
  62 }
  63
  64
  65 HeapSnapshot* HeapProfiler::TakeSnapshot(
  66     const char* name,
  67     v8::ActivityControl* control,
  68     v8::HeapProfiler::ObjectNameResolver* resolver) {
  69   HeapSnapshot* result = new HeapSnapshot(this, name, next_snapshot_uid_++);
  70   {
  71     HeapSnapshotGenerator generator(result, control, resolver, heap());
  72     if (!generator.GenerateSnapshot()) {
  73       delete result;
  74       result = NULL;
  75     } else {
  76       snapshots_.Add(result);
  77     }
  78   }
  79   ids_->RemoveDeadEntries();
  80   is_tracking_object_moves_ = true;
  81   return result;
  82 }
  83
  84
  85 HeapSnapshot* HeapProfiler::TakeSnapshot(
  86     String* name,
  87     v8::ActivityControl* control,
  88     v8::HeapProfiler::ObjectNameResolver* resolver) {
  89   return TakeSnapshot(names_->GetName(name), control, resolver);
  90 }
  91
  92
  93 void HeapProfiler::StartHeapObjectsTracking(bool track_allocations) {
  94   ids_->UpdateHeapObjectsMap();
  95   is_tracking_object_moves_ = true;
  96   DCHECK(!is_tracking_allocations());
  97   if (track_allocations) {
  98     allocation_tracker_.Reset(new AllocationTracker(ids_.get(), names_.get()));
  99     heap()->DisableInlineAllocation();
 100   }
 101 }
 102
 103
 104 SnapshotObjectId HeapProfiler::PushHeapObjectsStats(OutputStream* stream) {
 105   return ids_->PushHeapObjectsStats(stream);
 106 }
 107
 108
 109 void HeapProfiler::StopHeapObjectsTracking() {
 110   ids_->StopHeapObjectsTracking();
 111   if (is_tracking_allocations()) {
 112     allocation_tracker_.Reset(NULL);
 113     heap()->EnableInlineAllocation();
 114   }
 115 }
 116
 117
 118 size_t HeapProfiler::GetMemorySizeUsedByProfiler() {
 119   size_t size = sizeof(*this);
 120   size += names_->GetUsedMemorySize();
 121   size += ids_->GetUsedMemorySize();
 122   size += GetMemoryUsedByList(snapshots_);
 123   for (int i = 0; i < snapshots_.length(); ++i) {
 124     size += snapshots_[i]->RawSnapshotSize();
 125   }
 126   return size;
 127 }
 128
 129
 130 int HeapProfiler::GetSnapshotsCount() {
 131   return snapshots_.length();
 132 }
 133
 134
 135 HeapSnapshot* HeapProfiler::GetSnapshot(int index) {
 136   return snapshots_.at(index);
 137 }
 138
 139
 140 SnapshotObjectId HeapProfiler::GetSnapshotObjectId(Handle<Object> obj) {
 141   if (!obj->IsHeapObject())
 142     return v8::HeapProfiler::kUnknownObjectId;
 143   return ids_->FindEntry(HeapObject::cast(*obj)->address());
 144 }
 145
 146
 147 void HeapProfiler::ObjectMoveEvent(Address from, Address to, int size) {
 148   bool known_object = ids_->MoveObject(from, to, size);
 149   if (!known_object && !allocation_tracker_.is_empty()) {
 150     allocation_tracker_->address_to_trace()->MoveObject(from, to, size);
 151   }
 152 }
 153
 154
 155 void HeapProfiler::AllocationEvent(Address addr, int size) {
 156   DisallowHeapAllocation no_allocation;
 157   if (!allocation_tracker_.is_empty()) {
 158     allocation_tracker_->AllocationEvent(addr, size);
 159   }
 160 }
 161
 162
 163 void HeapProfiler::UpdateObjectSizeEvent(Address addr, int size) {
 164   ids_->UpdateObjectSize(addr, size);
 165 }
 166
 167
 168 void HeapProfiler::SetRetainedObjectInfo(UniqueId id,
 169                                          RetainedObjectInfo* info) {
 170   // TODO(yurus, marja): Don't route this information through GlobalHandles.
 171   heap()->isolate()->global_handles()->SetRetainedObjectInfo(id, info);
 172 }
 173
 174
 175 Handle<HeapObject> HeapProfiler::FindHeapObjectById(SnapshotObjectId id) {
 176   HeapObject* object = NULL;
 177   HeapIterator iterator(heap(), HeapIterator::kFilterUnreachable);
 178   // Make sure that object with the given id is still reachable.
 179   for (HeapObject* obj = iterator.next();
 180        obj != NULL;
 181        obj = iterator.next()) {
 182     if (ids_->FindEntry(obj->address()) == id) {
 183       DCHECK(object == NULL);
 184       object = obj;
 185       // Can't break -- kFilterUnreachable requires full heap traversal.
 186     }
 187   }
 188   return object != NULL ? Handle<HeapObject>(object) : Handle<HeapObject>();
 189 }
 190
 191
 192 void HeapProfiler::ClearHeapObjectMap() {
 193   ids_.Reset(new HeapObjectsMap(heap()));
 194   if (!is_tracking_allocations()) is_tracking_object_moves_ = false;
 195 }
 196
 197
 198 } }  // namespace v8::internal