Revision: 19718
Author: [email protected]
Date: Fri Mar 7 11:32:01 2014 UTC
Log: Allocation tracker: add separate entry for allocations via V8 API
When object is creating via native V8 API calls JS callstack is empty and
the allocation is indistinguishable from say compiler allocations. This
change adds a separate entry for such allocations.
Since FunctionInfo not necessarily corresponds to a heap object they are
now referred to using their index in the list of all FunctionInfos.
BUG=chromium:277984
LOG=N
[email protected], [email protected]
Review URL: https://codereview.chromium.org/177203002
http://code.google.com/p/v8/source/detail?r=19718
Modified:
/branches/bleeding_edge/src/allocation-tracker.cc
/branches/bleeding_edge/src/allocation-tracker.h
/branches/bleeding_edge/src/heap-snapshot-generator.cc
/branches/bleeding_edge/test/cctest/test-heap-profiler.cc
=======================================
--- /branches/bleeding_edge/src/allocation-tracker.cc Tue Feb 18 11:30:38
2014 UTC
+++ /branches/bleeding_edge/src/allocation-tracker.cc Fri Mar 7 11:32:01
2014 UTC
@@ -36,9 +36,9 @@
namespace internal {
AllocationTraceNode::AllocationTraceNode(
- AllocationTraceTree* tree, SnapshotObjectId shared_function_info_id)
+ AllocationTraceTree* tree, unsigned function_info_index)
: tree_(tree),
- function_id_(shared_function_info_id),
+ function_info_index_(function_info_index),
total_size_(0),
allocation_count_(0),
id_(tree->next_node_id()) {
@@ -50,19 +50,21 @@
}
-AllocationTraceNode* AllocationTraceNode::FindChild(SnapshotObjectId id) {
+AllocationTraceNode* AllocationTraceNode::FindChild(
+ unsigned function_info_index) {
for (int i = 0; i < children_.length(); i++) {
AllocationTraceNode* node = children_[i];
- if (node->function_id() == id) return node;
+ if (node->function_info_index() == function_info_index) return node;
}
return NULL;
}
-AllocationTraceNode* AllocationTraceNode::FindOrAddChild(SnapshotObjectId
id) {
- AllocationTraceNode* child = FindChild(id);
+AllocationTraceNode* AllocationTraceNode::FindOrAddChild(
+ unsigned function_info_index) {
+ AllocationTraceNode* child = FindChild(function_info_index);
if (child == NULL) {
- child = new AllocationTraceNode(tree_, id);
+ child = new AllocationTraceNode(tree_, function_info_index);
children_.Add(child);
}
return child;
@@ -78,17 +80,11 @@
void AllocationTraceNode::Print(int indent, AllocationTracker* tracker) {
OS::Print("%10u %10u %*c", total_size_, allocation_count_, indent, ' ');
if (tracker != NULL) {
- const char* name = "<unknown function>";
- if (function_id_ != 0) {
- AllocationTracker::FunctionInfo* info =
- tracker->GetFunctionInfo(function_id_);
- if (info != NULL) {
- name = info->name;
- }
- }
- OS::Print("%s #%u", name, id_);
+ AllocationTracker::FunctionInfo* info =
+ tracker->function_info_list()[function_info_index_];
+ OS::Print("%s #%u", info->name, id_);
} else {
- OS::Print("%u #%u", function_id_, id_);
+ OS::Print("%u #%u", function_info_index_, id_);
}
OS::Print("\n");
indent += 2;
@@ -109,9 +105,9 @@
AllocationTraceNode* AllocationTraceTree::AddPathFromEnd(
- const Vector<SnapshotObjectId>& path) {
+ const Vector<unsigned>& path) {
AllocationTraceNode* node = root();
- for (SnapshotObjectId* entry = path.start() + path.length() - 1;
+ for (unsigned* entry = path.start() + path.length() - 1;
entry != path.start() - 1;
--entry) {
node = node->FindOrAddChild(*entry);
@@ -125,6 +121,7 @@
OS::Print("Total size | Allocation count | Function id | id\n");
root()->Print(0, tracker);
}
+
void AllocationTracker::DeleteUnresolvedLocation(
UnresolvedLocation** location) {
@@ -134,6 +131,7 @@
AllocationTracker::FunctionInfo::FunctionInfo()
: name(""),
+ function_id(0),
script_name(""),
script_id(0),
line(-1),
@@ -144,23 +142,28 @@
static bool AddressesMatch(void* key1, void* key2) {
return key1 == key2;
}
+
+
+void AllocationTracker::DeleteFunctionInfo(FunctionInfo** info) {
+ delete *info;
+}
AllocationTracker::AllocationTracker(
HeapObjectsMap* ids, StringsStorage* names)
: ids_(ids),
names_(names),
- id_to_function_info_(AddressesMatch) {
+ id_to_function_info_index_(AddressesMatch),
+ info_index_for_other_state_(0) {
+ FunctionInfo* info = new FunctionInfo();
+ info->name = "(root)";
+ function_info_list_.Add(info);
}
AllocationTracker::~AllocationTracker() {
unresolved_locations_.Iterate(DeleteUnresolvedLocation);
- for (HashMap::Entry* p = id_to_function_info_.Start();
- p != NULL;
- p = id_to_function_info_.Next(p)) {
- delete reinterpret_cast<AllocationTracker::FunctionInfo* >(p->value);
- }
+ function_info_list_.Iterate(&DeleteFunctionInfo);
}
@@ -193,12 +196,17 @@
SharedFunctionInfo* shared = frame->function()->shared();
SnapshotObjectId id = ids_->FindOrAddEntry(
shared->address(), shared->Size(), false);
- allocation_trace_buffer_[length++] = id;
- AddFunctionInfo(shared, id);
+ 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<SnapshotObjectId>(allocation_trace_buffer_, length));
+ Vector<unsigned>(allocation_trace_buffer_, length));
top_node->AddAllocation(size);
}
@@ -209,24 +217,14 @@
}
-AllocationTracker::FunctionInfo* AllocationTracker::GetFunctionInfo(
- SnapshotObjectId id) {
- HashMap::Entry* entry = id_to_function_info_.Lookup(
- reinterpret_cast<void*>(id), SnapshotObjectIdHash(id), false);
- if (entry == NULL) {
- return NULL;
- }
- return reinterpret_cast<FunctionInfo*>(entry->value);
-}
-
-
-void AllocationTracker::AddFunctionInfo(SharedFunctionInfo* shared,
- SnapshotObjectId id) {
- HashMap::Entry* entry = id_to_function_info_.Lookup(
+unsigned AllocationTracker::AddFunctionInfo(SharedFunctionInfo* shared,
+ SnapshotObjectId id) {
+ HashMap::Entry* entry = id_to_function_info_index_.Lookup(
reinterpret_cast<void*>(id), SnapshotObjectIdHash(id), true);
if (entry->value == NULL) {
FunctionInfo* info = new FunctionInfo();
info->name = names_->GetFunctionName(shared->DebugName());
+ info->function_id = id;
if (shared->script()->IsScript()) {
Script* script = Script::cast(shared->script());
if (script->name()->IsName()) {
@@ -241,8 +239,22 @@
shared->start_position(),
info));
}
- entry->value = info;
+ entry->value = reinterpret_cast<void*>(function_info_list_.length());
+ function_info_list_.Add(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_ = function_info_list_.length();
+ function_info_list_.Add(info);
}
+ return info_index_for_other_state_;
}
=======================================
--- /branches/bleeding_edge/src/allocation-tracker.h Wed Dec 18 08:09:37
2013 UTC
+++ /branches/bleeding_edge/src/allocation-tracker.h Fri Mar 7 11:32:01
2014 UTC
@@ -38,13 +38,13 @@
class AllocationTraceNode {
public:
AllocationTraceNode(AllocationTraceTree* tree,
- SnapshotObjectId shared_function_info_id);
+ unsigned function_info_index);
~AllocationTraceNode();
- AllocationTraceNode* FindChild(SnapshotObjectId shared_function_info_id);
- AllocationTraceNode* FindOrAddChild(SnapshotObjectId
shared_function_info_id);
+ AllocationTraceNode* FindChild(unsigned function_info_index);
+ AllocationTraceNode* FindOrAddChild(unsigned function_info_index);
void AddAllocation(unsigned size);
- SnapshotObjectId function_id() const { return function_id_; }
+ unsigned function_info_index() const { return function_info_index_; }
unsigned allocation_size() const { return total_size_; }
unsigned allocation_count() const { return allocation_count_; }
unsigned id() const { return id_; }
@@ -54,7 +54,7 @@
private:
AllocationTraceTree* tree_;
- SnapshotObjectId function_id_;
+ unsigned function_info_index_;
unsigned total_size_;
unsigned allocation_count_;
unsigned id_;
@@ -68,7 +68,7 @@
public:
AllocationTraceTree();
~AllocationTraceTree();
- AllocationTraceNode* AddPathFromEnd(const Vector<SnapshotObjectId>&
path);
+ AllocationTraceNode* AddPathFromEnd(const Vector<unsigned>& path);
AllocationTraceNode* root() { return &root_; }
unsigned next_node_id() { return next_node_id_++; }
void Print(AllocationTracker* tracker);
@@ -86,6 +86,7 @@
struct FunctionInfo {
FunctionInfo();
const char* name;
+ SnapshotObjectId function_id;
const char* script_name;
int script_id;
int line;
@@ -99,11 +100,14 @@
void AllocationEvent(Address addr, int size);
AllocationTraceTree* trace_tree() { return &trace_tree_; }
- HashMap* id_to_function_info() { return &id_to_function_info_; }
- FunctionInfo* GetFunctionInfo(SnapshotObjectId id);
+ const List<FunctionInfo*>& function_info_list() const {
+ return function_info_list_;
+ }
private:
- void AddFunctionInfo(SharedFunctionInfo* info, SnapshotObjectId id);
+ unsigned AddFunctionInfo(SharedFunctionInfo* info, SnapshotObjectId id);
+ static void DeleteFunctionInfo(FunctionInfo** info);
+ unsigned functionInfoIndexForVMState(StateTag state);
class UnresolvedLocation {
public:
@@ -125,9 +129,11 @@
HeapObjectsMap* ids_;
StringsStorage* names_;
AllocationTraceTree trace_tree_;
- SnapshotObjectId allocation_trace_buffer_[kMaxAllocationTraceLength];
- HashMap id_to_function_info_;
+ unsigned allocation_trace_buffer_[kMaxAllocationTraceLength];
+ List<FunctionInfo*> function_info_list_;
+ HashMap id_to_function_info_index_;
List<UnresolvedLocation*> unresolved_locations_;
+ unsigned info_index_for_other_state_;
DISALLOW_COPY_AND_ASSIGN(AllocationTracker);
};
=======================================
--- /branches/bleeding_edge/src/heap-snapshot-generator.cc Fri Mar 7
10:12:17 2014 UTC
+++ /branches/bleeding_edge/src/heap-snapshot-generator.cc Fri Mar 7
11:32:01 2014 UTC
@@ -2878,7 +2878,7 @@
JSON_S("column")) ","
JSON_S("trace_node_fields") ":" JSON_A(
JSON_S("id") ","
- JSON_S("function_id") ","
+ JSON_S("function_info_index") ","
JSON_S("count") ","
JSON_S("size") ","
JSON_S("children"))));
@@ -2893,7 +2893,7 @@
uint32_t count = 0;
AllocationTracker* tracker = snapshot_->profiler()->allocation_tracker();
if (tracker) {
- count = tracker->id_to_function_info()->occupancy();
+ count = tracker->function_info_list().length();
}
writer_->AddNumber(count);
}
@@ -2926,7 +2926,7 @@
int buffer_pos = 0;
buffer_pos = utoa(node->id(), buffer, buffer_pos);
buffer[buffer_pos++] = ',';
- buffer_pos = utoa(node->function_id(), buffer, buffer_pos);
+ buffer_pos = utoa(node->function_info_index(), buffer, buffer_pos);
buffer[buffer_pos++] = ',';
buffer_pos = utoa(node->allocation_count(), buffer, buffer_pos);
buffer[buffer_pos++] = ',';
@@ -2968,22 +2968,18 @@
6 * MaxDecimalDigitsIn<sizeof(unsigned)>::kUnsigned // NOLINT
+ 6 + 1 + 1;
EmbeddedVector<char, kBufferSize> buffer;
- HashMap* id_to_function_info = tracker->id_to_function_info();
+ const List<AllocationTracker::FunctionInfo*>& list =
+ tracker->function_info_list();
bool first_entry = true;
- for (HashMap::Entry* p = id_to_function_info->Start();
- p != NULL;
- p = id_to_function_info->Next(p)) {
- SnapshotObjectId id =
- static_cast<SnapshotObjectId>(reinterpret_cast<intptr_t>(p->key));
- AllocationTracker::FunctionInfo* info =
- reinterpret_cast<AllocationTracker::FunctionInfo* >(p->value);
+ for (int i = 0; i < list.length(); i++) {
+ AllocationTracker::FunctionInfo* info = list[i];
int buffer_pos = 0;
if (first_entry) {
first_entry = false;
} else {
buffer[buffer_pos++] = ',';
}
- buffer_pos = utoa(id, buffer, buffer_pos);
+ buffer_pos = utoa(info->function_id, buffer, buffer_pos);
buffer[buffer_pos++] = ',';
buffer_pos = utoa(GetStringId(info->name), buffer, buffer_pos);
buffer[buffer_pos++] = ',';
=======================================
--- /branches/bleeding_edge/test/cctest/test-heap-profiler.cc Tue Feb 18
15:57:44 2014 UTC
+++ /branches/bleeding_edge/test/cctest/test-heap-profiler.cc Fri Mar 7
11:32:01 2014 UTC
@@ -2216,8 +2216,9 @@
Vector<AllocationTraceNode*> children = node->children();
node = NULL;
for (int j = 0; j < children.length(); j++) {
- v8::SnapshotObjectId id = children[j]->function_id();
- AllocationTracker::FunctionInfo* info = tracker->GetFunctionInfo(id);
+ unsigned index = children[j]->function_info_index();
+ AllocationTracker::FunctionInfo* info =
+ tracker->function_info_list()[index];
if (info && strcmp(info->name, name) == 0) {
node = children[j];
break;
@@ -2362,6 +2363,34 @@
heap_profiler->StopTrackingHeapObjects();
}
}
+
+
+TEST(TrackV8ApiAllocation) {
+ v8::HandleScope scope(v8::Isolate::GetCurrent());
+ LocalContext env;
+
+ v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
+ const char* names[] = { "(V8 API)" };
+ heap_profiler->StartTrackingHeapObjects(true);
+
+ v8::Handle<v8::Object> o1 = v8::Object::New(env->GetIsolate());
+ o1->Clone();
+
+ AllocationTracker* tracker =
+
reinterpret_cast<i::HeapProfiler*>(heap_profiler)->allocation_tracker();
+ CHECK_NE(NULL, tracker);
+ // Resolve all function locations.
+ tracker->PrepareForSerialization();
+ // Print for better diagnostics in case of failure.
+ tracker->trace_tree()->Print(tracker);
+
+ AllocationTraceNode* node =
+ FindNode(tracker, Vector<const char*>(names, ARRAY_SIZE(names)));
+ CHECK_NE(NULL, node);
+ CHECK_GE(node->allocation_count(), 2);
+ CHECK_GE(node->allocation_size(), 4 * node->allocation_count());
+ heap_profiler->StopTrackingHeapObjects();
+}
TEST(ArrayBufferAndArrayBufferView) {
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
