blob: 59004380cfcedd6bdb7c43b8c876f1cc2993eab2 [file] [log] [blame]
// Copyright 2013 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/allocation-tracker.h"
#include "src/execution/frames-inl.h"
#include "src/handles/global-handles.h"
#include "src/objects/objects-inl.h"
#include "src/profiler/heap-snapshot-generator-inl.h"
namespace v8 {
namespace internal {
AllocationTraceNode::AllocationTraceNode(
AllocationTraceTree* tree, unsigned function_info_index)
: tree_(tree),
function_info_index_(function_info_index),
total_size_(0),
allocation_count_(0),
id_(tree->next_node_id()) {
}
AllocationTraceNode::~AllocationTraceNode() {
for (AllocationTraceNode* node : children_) delete node;
}
AllocationTraceNode* AllocationTraceNode::FindChild(
unsigned function_info_index) {
for (AllocationTraceNode* node : children_) {
if (node->function_info_index() == function_info_index) return node;
}
return nullptr;
}
AllocationTraceNode* AllocationTraceNode::FindOrAddChild(
unsigned function_info_index) {
AllocationTraceNode* child = FindChild(function_info_index);
if (child == nullptr) {
child = new AllocationTraceNode(tree_, function_info_index);
children_.push_back(child);
}
return child;
}
void AllocationTraceNode::AddAllocation(unsigned size) {
total_size_ += size;
++allocation_count_;
}
void AllocationTraceNode::Print(int indent, AllocationTracker* tracker) {
base::OS::Print("%10u %10u %*c", total_size_, allocation_count_, indent, ' ');
if (tracker != nullptr) {
AllocationTracker::FunctionInfo* info =
tracker->function_info_list()[function_info_index_];
base::OS::Print("%s #%u", info->name, id_);
} else {
base::OS::Print("%u #%u", function_info_index_, id_);
}
base::OS::Print("\n");
indent += 2;
for (AllocationTraceNode* node : children_) {
node->Print(indent, tracker);
}
}
AllocationTraceTree::AllocationTraceTree()
: next_node_id_(1),
root_(this, 0) {
}
AllocationTraceNode* AllocationTraceTree::AddPathFromEnd(
const Vector<unsigned>& path) {
AllocationTraceNode* node = root();
for (unsigned* entry = path.begin() + path.length() - 1;
entry != path.begin() - 1; --entry) {
node = node->FindOrAddChild(*entry);
}
return node;
}
void AllocationTraceTree::Print(AllocationTracker* tracker) {
base::OS::Print("[AllocationTraceTree:]\n");
base::OS::Print("Total size | Allocation count | Function id | id\n");
root()->Print(0, tracker);
}
AllocationTracker::FunctionInfo::FunctionInfo()
: name(""),
function_id(0),
script_name(""),
script_id(0),
line(-1),
column(-1) {
}
void AddressToTraceMap::AddRange(Address start, int size,
unsigned trace_node_id) {
Address end = start + size;
RemoveRange(start, end);
RangeStack new_range(start, trace_node_id);
ranges_.insert(RangeMap::value_type(end, new_range));
}
unsigned AddressToTraceMap::GetTraceNodeId(Address addr) {
RangeMap::const_iterator it = ranges_.upper_bound(addr);
if (it == ranges_.end()) return 0;
if (it->second.start <= addr) {
return it->second.trace_node_id;
}
return 0;
}
void AddressToTraceMap::MoveObject(Address from, Address to, int size) {
unsigned trace_node_id = GetTraceNodeId(from);
if (trace_node_id == 0) return;
RemoveRange(from, from + size);
AddRange(to, size, trace_node_id);
}
void AddressToTraceMap::Clear() {
ranges_.clear();
}
void AddressToTraceMap::Print() {
PrintF("[AddressToTraceMap (%zu): \n", ranges_.size());
for (RangeMap::iterator it = ranges_.begin(); it != ranges_.end(); ++it) {
PrintF("[%p - %p] => %u\n", reinterpret_cast<void*>(it->second.start),
reinterpret_cast<void*>(it->first), it->second.trace_node_id);
}
PrintF("]\n");
}
void AddressToTraceMap::RemoveRange(Address start, Address end) {
RangeMap::iterator it = ranges_.upper_bound(start);
if (it == ranges_.end()) return;
RangeStack prev_range(0, 0);
RangeMap::iterator to_remove_begin = it;
if (it->second.start < start) {
prev_range = it->second;
}
do {
if (it->first > end) {
if (it->second.start < end) {
it->second.start = end;
}
break;
}
++it;
} while (it != ranges_.end());
ranges_.erase(to_remove_begin, it);
if (prev_range.start != 0) {
ranges_.insert(RangeMap::value_type(start, prev_range));
}
}
AllocationTracker::AllocationTracker(HeapObjectsMap* ids, StringsStorage* names)
: ids_(ids),
names_(names),
id_to_function_info_index_(),
info_index_for_other_state_(0) {
FunctionInfo* info = new FunctionInfo();
info->name = "(root)";
function_info_list_.push_back(info);
}
AllocationTracker::~AllocationTracker() {
for (UnresolvedLocation* location : unresolved_locations_) delete location;
for (FunctionInfo* info : function_info_list_) delete info;
}
void AllocationTracker::PrepareForSerialization() {
for (UnresolvedLocation* location : unresolved_locations_) {
location->Resolve();
delete location;
}
unresolved_locations_.clear();
unresolved_locations_.shrink_to_fit();
}
void AllocationTracker::AllocationEvent(Address addr, int size) {
DisallowHeapAllocation no_allocation;
Heap* heap = ids_->heap();
// Mark the new block as FreeSpace to make sure the heap is iterable
// while we are capturing stack trace.
heap->CreateFillerObjectAt(addr, size, ClearRecordedSlots::kNo);
Isolate* isolate = Isolate::FromHeap(heap);
int length = 0;
JavaScriptFrameIterator it(isolate);
while (!it.done() && length < kMaxAllocationTraceLength) {
JavaScriptFrame* frame = it.frame();
SharedFunctionInfo shared = frame->function().shared();
SnapshotObjectId id =
ids_->FindOrAddEntry(shared.address(), shared.Size(), false);
allocation_trace_buffer_[length++] = AddFunctionInfo(shared, id);
it.Advance();
}
if (length == 0) {
unsigned index = functionInfoIndexForVMState(isolate->current_vm_state());
if (index != 0) {
allocation_trace_buffer_[length++] = index;
}
}
AllocationTraceNode* top_node = trace_tree_.AddPathFromEnd(
Vector<unsigned>(allocation_trace_buffer_, length));
top_node->AddAllocation(size);
address_to_trace_.AddRange(addr, size, top_node->id());
}
static uint32_t SnapshotObjectIdHash(SnapshotObjectId id) {
return ComputeUnseededHash(static_cast<uint32_t>(id));
}
unsigned AllocationTracker::AddFunctionInfo(SharedFunctionInfo shared,
SnapshotObjectId id) {
base::HashMap::Entry* entry = id_to_function_info_index_.LookupOrInsert(
reinterpret_cast<void*>(id), SnapshotObjectIdHash(id));
if (entry->value == nullptr) {
FunctionInfo* info = new FunctionInfo();
info->name = names_->GetName(shared.DebugName());
info->function_id = id;
if (shared.script().IsScript()) {
Script script = Script::cast(shared.script());
if (script.name().IsName()) {
Name name = Name::cast(script.name());
info->script_name = names_->GetName(name);
}
info->script_id = script.id();
// Converting start offset into line and column may cause heap
// allocations so we postpone them until snapshot serialization.
unresolved_locations_.push_back(
new UnresolvedLocation(script, shared.StartPosition(), info));
}
entry->value = reinterpret_cast<void*>(function_info_list_.size());
function_info_list_.push_back(info);
}
return static_cast<unsigned>(reinterpret_cast<intptr_t>((entry->value)));
}
unsigned AllocationTracker::functionInfoIndexForVMState(StateTag state) {
if (state != OTHER) return 0;
if (info_index_for_other_state_ == 0) {
FunctionInfo* info = new FunctionInfo();
info->name = "(V8 API)";
info_index_for_other_state_ =
static_cast<unsigned>(function_info_list_.size());
function_info_list_.push_back(info);
}
return info_index_for_other_state_;
}
AllocationTracker::UnresolvedLocation::UnresolvedLocation(Script script,
int start,
FunctionInfo* info)
: start_position_(start), info_(info) {
script_ = script.GetIsolate()->global_handles()->Create(script);
GlobalHandles::MakeWeak(script_.location(), this, &HandleWeakScript,
v8::WeakCallbackType::kParameter);
}
AllocationTracker::UnresolvedLocation::~UnresolvedLocation() {
if (!script_.is_null()) {
GlobalHandles::Destroy(script_.location());
}
}
void AllocationTracker::UnresolvedLocation::Resolve() {
if (script_.is_null()) return;
HandleScope scope(script_->GetIsolate());
info_->line = Script::GetLineNumber(script_, start_position_);
info_->column = Script::GetColumnNumber(script_, start_position_);
}
void AllocationTracker::UnresolvedLocation::HandleWeakScript(
const v8::WeakCallbackInfo<void>& data) {
UnresolvedLocation* loc =
reinterpret_cast<UnresolvedLocation*>(data.GetParameter());
GlobalHandles::Destroy(loc->script_.location());
loc->script_ = Handle<Script>::null();
}
} // namespace internal
} // namespace v8