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 199