blob: e5aa7c554ed9efdef9bcf53ec7db4a3539618a91 [file] [log] [blame]
// Copyright 2009-2010 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/profiler/heap-profiler.h"
#include "src/api.h"
#include "src/debug/debug.h"
#include "src/heap/heap-inl.h"
#include "src/profiler/allocation-tracker.h"
#include "src/profiler/heap-snapshot-generator-inl.h"
#include "src/profiler/sampling-heap-profiler.h"
namespace v8 {
namespace internal {
HeapProfiler::HeapProfiler(Heap* heap)
: ids_(new HeapObjectsMap(heap)),
names_(new StringsStorage()),
is_tracking_object_moves_(false) {}
HeapProfiler::~HeapProfiler() = default;
void HeapProfiler::DeleteAllSnapshots() {
snapshots_.clear();
names_.reset(new StringsStorage());
}
void HeapProfiler::RemoveSnapshot(HeapSnapshot* snapshot) {
snapshots_.erase(
std::find_if(snapshots_.begin(), snapshots_.end(),
[&](const std::unique_ptr<HeapSnapshot>& entry) {
return entry.get() == snapshot;
}));
}
void HeapProfiler::DefineWrapperClass(
uint16_t class_id, v8::HeapProfiler::WrapperInfoCallback callback) {
DCHECK_NE(class_id, v8::HeapProfiler::kPersistentHandleNoClassId);
if (wrapper_callbacks_.size() <= class_id) {
wrapper_callbacks_.insert(wrapper_callbacks_.end(),
class_id - wrapper_callbacks_.size() + 1,
nullptr);
}
wrapper_callbacks_[class_id] = callback;
}
v8::RetainedObjectInfo* HeapProfiler::ExecuteWrapperClassCallback(
uint16_t class_id, Object** wrapper) {
if (wrapper_callbacks_.size() <= class_id) return nullptr;
return wrapper_callbacks_[class_id](
class_id, Utils::ToLocal(Handle<Object>(wrapper)));
}
void HeapProfiler::SetGetRetainerInfosCallback(
v8::HeapProfiler::GetRetainerInfosCallback callback) {
get_retainer_infos_callback_ = callback;
}
v8::HeapProfiler::RetainerInfos HeapProfiler::GetRetainerInfos(
Isolate* isolate) {
v8::HeapProfiler::RetainerInfos infos;
if (get_retainer_infos_callback_ != nullptr)
infos =
get_retainer_infos_callback_(reinterpret_cast<v8::Isolate*>(isolate));
return infos;
}
void HeapProfiler::AddBuildEmbedderGraphCallback(
v8::HeapProfiler::BuildEmbedderGraphCallback callback, void* data) {
build_embedder_graph_callbacks_.push_back({callback, data});
}
void HeapProfiler::RemoveBuildEmbedderGraphCallback(
v8::HeapProfiler::BuildEmbedderGraphCallback callback, void* data) {
auto it = std::find(build_embedder_graph_callbacks_.begin(),
build_embedder_graph_callbacks_.end(),
std::make_pair(callback, data));
if (it != build_embedder_graph_callbacks_.end())
build_embedder_graph_callbacks_.erase(it);
}
void HeapProfiler::BuildEmbedderGraph(Isolate* isolate,
v8::EmbedderGraph* graph) {
for (const auto& cb : build_embedder_graph_callbacks_) {
cb.first(reinterpret_cast<v8::Isolate*>(isolate), graph, cb.second);
}
}
HeapSnapshot* HeapProfiler::TakeSnapshot(
v8::ActivityControl* control,
v8::HeapProfiler::ObjectNameResolver* resolver) {
HeapSnapshot* result = new HeapSnapshot(this);
{
HeapSnapshotGenerator generator(result, control, resolver, heap());
if (!generator.GenerateSnapshot()) {
delete result;
result = nullptr;
} else {
snapshots_.emplace_back(result);
}
}
ids_->RemoveDeadEntries();
is_tracking_object_moves_ = true;
heap()->isolate()->debug()->feature_tracker()->Track(
DebugFeatureTracker::kHeapSnapshot);
return result;
}
bool HeapProfiler::StartSamplingHeapProfiler(
uint64_t sample_interval, int stack_depth,
v8::HeapProfiler::SamplingFlags flags) {
if (sampling_heap_profiler_.get()) {
return false;
}
sampling_heap_profiler_.reset(new SamplingHeapProfiler(
heap(), names_.get(), sample_interval, stack_depth, flags));
return true;
}
void HeapProfiler::StopSamplingHeapProfiler() {
sampling_heap_profiler_.reset();
}
v8::AllocationProfile* HeapProfiler::GetAllocationProfile() {
if (sampling_heap_profiler_.get()) {
return sampling_heap_profiler_->GetAllocationProfile();
} else {
return nullptr;
}
}
void HeapProfiler::StartHeapObjectsTracking(bool track_allocations) {
ids_->UpdateHeapObjectsMap();
is_tracking_object_moves_ = true;
DCHECK(!allocation_tracker_);
if (track_allocations) {
allocation_tracker_.reset(new AllocationTracker(ids_.get(), names_.get()));
heap()->AddHeapObjectAllocationTracker(this);
heap()->isolate()->debug()->feature_tracker()->Track(
DebugFeatureTracker::kAllocationTracking);
}
}
SnapshotObjectId HeapProfiler::PushHeapObjectsStats(OutputStream* stream,
int64_t* timestamp_us) {
return ids_->PushHeapObjectsStats(stream, timestamp_us);
}
void HeapProfiler::StopHeapObjectsTracking() {
ids_->StopHeapObjectsTracking();
if (allocation_tracker_) {
allocation_tracker_.reset();
heap()->RemoveHeapObjectAllocationTracker(this);
}
}
int HeapProfiler::GetSnapshotsCount() {
return static_cast<int>(snapshots_.size());
}
HeapSnapshot* HeapProfiler::GetSnapshot(int index) {
return snapshots_.at(index).get();
}
SnapshotObjectId HeapProfiler::GetSnapshotObjectId(Handle<Object> obj) {
if (!obj->IsHeapObject())
return v8::HeapProfiler::kUnknownObjectId;
return ids_->FindEntry(HeapObject::cast(*obj)->address());
}
void HeapProfiler::ObjectMoveEvent(Address from, Address to, int size) {
base::LockGuard<base::Mutex> guard(&profiler_mutex_);
bool known_object = ids_->MoveObject(from, to, size);
if (!known_object && allocation_tracker_) {
allocation_tracker_->address_to_trace()->MoveObject(from, to, size);
}
}
void HeapProfiler::AllocationEvent(Address addr, int size) {
DisallowHeapAllocation no_allocation;
if (allocation_tracker_) {
allocation_tracker_->AllocationEvent(addr, size);
}
}
void HeapProfiler::UpdateObjectSizeEvent(Address addr, int size) {
ids_->UpdateObjectSize(addr, size);
}
Handle<HeapObject> HeapProfiler::FindHeapObjectById(SnapshotObjectId id) {
HeapObject* object = nullptr;
HeapIterator iterator(heap(), HeapIterator::kFilterUnreachable);
// Make sure that object with the given id is still reachable.
for (HeapObject* obj = iterator.next(); obj != nullptr;
obj = iterator.next()) {
if (ids_->FindEntry(obj->address()) == id) {
DCHECK_NULL(object);
object = obj;
// Can't break -- kFilterUnreachable requires full heap traversal.
}
}
return object != nullptr ? Handle<HeapObject>(object, isolate())
: Handle<HeapObject>();
}
void HeapProfiler::ClearHeapObjectMap() {
ids_.reset(new HeapObjectsMap(heap()));
if (!allocation_tracker_) is_tracking_object_moves_ = false;
}
Heap* HeapProfiler::heap() const { return ids_->heap(); }
void HeapProfiler::QueryObjects(Handle<Context> context,
debug::QueryObjectPredicate* predicate,
PersistentValueVector<v8::Object>* objects) {
// We should return accurate information about live objects, so we need to
// collect all garbage first.
heap()->CollectAllAvailableGarbage(
GarbageCollectionReason::kLowMemoryNotification);
heap()->CollectAllGarbage(Heap::kMakeHeapIterableMask,
GarbageCollectionReason::kHeapProfiler);
HeapIterator heap_iterator(heap());
HeapObject* heap_obj;
while ((heap_obj = heap_iterator.next()) != nullptr) {
if (!heap_obj->IsJSObject() || heap_obj->IsExternal(isolate())) continue;
v8::Local<v8::Object> v8_obj(
Utils::ToLocal(handle(JSObject::cast(heap_obj), isolate())));
if (!predicate->Filter(v8_obj)) continue;
objects->Append(v8_obj);
}
}
} // namespace internal
} // namespace v8