Version 2.3.10...

src/profile-generator.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 806 matching lines @@
   to_ = to;
 }
 
 
 HeapEntry* HeapGraphEdge::From() {
   return reinterpret_cast<HeapEntry*>(this - child_index_) - 1;
 }
 
 
 void HeapEntry::Init(HeapSnapshot* snapshot,
-                     int children_count,
-                     int retainers_count) {
-  Init(snapshot, kInternal, "", 0, 0, children_count, retainers_count);
-}
-
-
-void HeapEntry::Init(HeapSnapshot* snapshot,
                      Type type,
                      const char* name,
                      uint64_t id,
                      int self_size,
                      int children_count,
                      int retainers_count) {
   snapshot_ = snapshot;
   type_ = type;
   painted_ = kUnpainted;
   calculated_data_index_ = kNoCalculatedData;
@@ skipping 359 matching lines @@
 };
 
 template <> struct SnapshotSizeConstants<8> {
   static const int kExpectedHeapGraphEdgeSize = 24;
   static const int kExpectedHeapEntrySize = 40;
 };
 
 }  // namespace
 
 HeapSnapshot::HeapSnapshot(HeapSnapshotsCollection* collection,
+                           HeapSnapshot::Type type,
                            const char* title,
                            unsigned uid)
     : collection_(collection),
+      type_(type),
       title_(title),
       uid_(uid),
       root_entry_index_(-1),
       raw_entries_(NULL),
       entries_sorted_(false) {
   STATIC_ASSERT(
       sizeof(HeapGraphEdge) ==
       SnapshotSizeConstants<sizeof(void*)>::kExpectedHeapGraphEdgeSize);  // NOLINT
   STATIC_ASSERT(
       sizeof(HeapEntry) ==
@@ skipping 10 matching lines @@
   calculated_data_.Iterate(DisposeCalculatedData);
 }
 
 
 void HeapSnapshot::AllocateEntries(int entries_count,
                                    int children_count,
                                    int retainers_count) {
   ASSERT(raw_entries_ == NULL);
   raw_entries_ = NewArray<char>(
       HeapEntry::EntriesSize(entries_count, children_count, retainers_count));
+#ifdef DEBUG
+  raw_entries_size_ =
+      HeapEntry::EntriesSize(entries_count, children_count, retainers_count);
+#endif
 }
 
 
 HeapEntry* HeapSnapshot::AddEntry(HeapObject* object,
                                   int children_count,
                                   int retainers_count) {
   if (object == kInternalRootObject) {
     ASSERT(root_entry_index_ == -1);
     root_entry_index_ = entries_.length();
-    HeapEntry* entry = GetNextEntryToInit();
-    entry->Init(this, children_count, retainers_count);
-    return entry;
+    ASSERT(retainers_count == 0);
+    return AddEntry(
+        HeapEntry::kInternal, "", 0, 0, children_count, retainers_count);
   } else if (object->IsJSFunction()) {
     JSFunction* func = JSFunction::cast(object);
     SharedFunctionInfo* shared = func->shared();
     String* name = String::cast(shared->name())->length() > 0 ?
         String::cast(shared->name()) : shared->inferred_name();
     return AddEntry(object,
                     HeapEntry::kClosure,
-                    collection_->GetName(name),
+                    collection_->GetFunctionName(name),
                     children_count,
                     retainers_count);
   } else if (object->IsJSObject()) {
     return AddEntry(object,
                     HeapEntry::kObject,
                     collection_->GetName(
                         JSObject::cast(object)->constructor_name()),
                     children_count,
                     retainers_count);
   } else if (object->IsString()) {
     return AddEntry(object,
                     HeapEntry::kString,
                     collection_->GetName(String::cast(object)),
                     children_count,
                     retainers_count);
   } else if (object->IsCode()) {
     return AddEntry(object,
                     HeapEntry::kCode,
                     "",
                     children_count,
                     retainers_count);
   } else if (object->IsSharedFunctionInfo()) {
     SharedFunctionInfo* shared = SharedFunctionInfo::cast(object);
     String* name = String::cast(shared->name())->length() > 0 ?
         String::cast(shared->name()) : shared->inferred_name();
     return AddEntry(object,
                     HeapEntry::kCode,
-                    collection_->GetName(name),
+                    collection_->GetFunctionName(name),
                     children_count,
                     retainers_count);
   } else if (object->IsScript()) {
     Script* script = Script::cast(object);
     return AddEntry(object,
                     HeapEntry::kCode,
                     script->name()->IsString() ?
                     collection_->GetName(String::cast(script->name())) : "",
                     children_count,
                     retainers_count);
@@ skipping 34 matching lines @@
   calculated_data_.Add(HeapEntryCalculatedData());
   return calculated_data_.length() - 1;
 }
 
 
 HeapEntry* HeapSnapshot::AddEntry(HeapObject* object,
                                   HeapEntry::Type type,
                                   const char* name,
                                   int children_count,
                                   int retainers_count) {
+  return AddEntry(type,
+                  name,
+                  collection_->GetObjectId(object->address()),
+                  GetObjectSize(object),
+                  children_count,
+                  retainers_count);
+}
+
+
+HeapEntry* HeapSnapshot::AddEntry(HeapEntry::Type type,
+                                  const char* name,
+                                  uint64_t id,
+                                  int size,
+                                  int children_count,
+                                  int retainers_count) {
   HeapEntry* entry = GetNextEntryToInit();
-  entry->Init(this,
-              type,
-              name,
-              collection_->GetObjectId(object->address()),
-              GetObjectSize(object),
-              children_count,
-              retainers_count);
+  entry->Init(this, type, name, id, size, children_count, retainers_count);
   return entry;
 }
 
 
 HeapEntry* HeapSnapshot::GetNextEntryToInit() {
   if (entries_.length() > 0) {
     HeapEntry* last_entry = entries_.last();
     entries_.Add(reinterpret_cast<HeapEntry*>(
         reinterpret_cast<char*>(last_entry) + last_entry->EntrySize()));
   } else {
     entries_.Add(reinterpret_cast<HeapEntry*>(raw_entries_));
   }
+  ASSERT(reinterpret_cast<char*>(entries_.last()) <
+         (raw_entries_ + raw_entries_size_));
   return entries_.last();
 }
 
 
 int HeapSnapshot::GetObjectSize(HeapObject* obj) {
   return obj->IsJSObject() ?
       CalculateNetworkSize(JSObject::cast(obj)) : obj->Size();
 }
 
 
@@ skipping 149 matching lines @@
   delete *snapshot_ptr;
 }
 
 
 HeapSnapshotsCollection::~HeapSnapshotsCollection() {
   delete token_enumerator_;
   snapshots_.Iterate(DeleteHeapSnapshot);
 }
 
 
-HeapSnapshot* HeapSnapshotsCollection::NewSnapshot(const char* name,
+HeapSnapshot* HeapSnapshotsCollection::NewSnapshot(HeapSnapshot::Type type,
+                                                   const char* name,
                                                    unsigned uid) {
   is_tracking_objects_ = true;  // Start watching for heap objects moves.
-  HeapSnapshot* snapshot = new HeapSnapshot(this, name, uid);
+  HeapSnapshot* snapshot = new HeapSnapshot(this, type, name, uid);
   snapshots_.Add(snapshot);
   HashMap::Entry* entry =
       snapshots_uids_.Lookup(reinterpret_cast<void*>(snapshot->uid()),
                              static_cast<uint32_t>(snapshot->uid()),
                              true);
   ASSERT(entry->value == NULL);
   entry->value = snapshot;
   return snapshot;
 }
 
 
 HeapSnapshot* HeapSnapshotsCollection::GetSnapshot(unsigned uid) {
   HashMap::Entry* entry = snapshots_uids_.Lookup(reinterpret_cast<void*>(uid),
                                                  static_cast<uint32_t>(uid),
                                                  false);
   return entry != NULL ? reinterpret_cast<HeapSnapshot*>(entry->value) : NULL;
 }
 
 
 HeapSnapshotsDiff* HeapSnapshotsCollection::CompareSnapshots(
     HeapSnapshot* snapshot1,
     HeapSnapshot* snapshot2) {
   return comparator_.Compare(snapshot1, snapshot2);
 }
 
 
+HeapEntry *const HeapEntriesMap::kHeapEntryPlaceholder =
+    reinterpret_cast<HeapEntry*>(1);
+
 HeapEntriesMap::HeapEntriesMap()
     : entries_(HeapObjectsMatch),
       entries_count_(0),
       total_children_count_(0),
       total_retainers_count_(0) {
 }
 
 
 HeapEntriesMap::~HeapEntriesMap() {
   for (HashMap::Entry* p = entries_.Start(); p != NULL; p = entries_.Next(p)) {
@@ skipping 28 matching lines @@
   HashMap::Entry* cache_entry = entries_.Lookup(object, Hash(object), true);
   ASSERT(cache_entry->value == NULL);
   cache_entry->value = new EntryInfo(entry);
   ++entries_count_;
 }
 
 
 void HeapEntriesMap::CountReference(HeapObject* from, HeapObject* to,
                                     int* prev_children_count,
                                     int* prev_retainers_count) {
-  HashMap::Entry* from_cache_entry = entries_.Lookup(from, Hash(from), true);
+  HashMap::Entry* from_cache_entry = entries_.Lookup(from, Hash(from), false);
   HashMap::Entry* to_cache_entry = entries_.Lookup(to, Hash(to), false);
   ASSERT(from_cache_entry != NULL);
   ASSERT(to_cache_entry != NULL);
   EntryInfo* from_entry_info =
       reinterpret_cast<EntryInfo*>(Unalias(from_cache_entry->value));
   EntryInfo* to_entry_info =
       reinterpret_cast<EntryInfo*>(Unalias(to_cache_entry->value));
   if (prev_children_count)
     *prev_children_count = from_entry_info->children_count;
   if (prev_retainers_count)
     *prev_retainers_count = to_entry_info->retainers_count;
   ++from_entry_info->children_count;
   ++to_entry_info->retainers_count;
   ++total_children_count_;
   ++total_retainers_count_;
 }
 
 
-template<class Visitor>
-void HeapEntriesMap::UpdateEntries(Visitor* visitor) {
-  for (HashMap::Entry* p = entries_.Start();
-       p != NULL;
-       p = entries_.Next(p)) {
-    if (!IsAlias(p->value)) {
-      EntryInfo* entry_info = reinterpret_cast<EntryInfo*>(p->value);
-      entry_info->entry = visitor->GetEntry(
-          reinterpret_cast<HeapObject*>(p->key),
-          entry_info->children_count,
-          entry_info->retainers_count);
-      entry_info->children_count = 0;
-      entry_info->retainers_count = 0;
-    }
-  }
-}
-
-
 HeapSnapshotGenerator::HeapSnapshotGenerator(HeapSnapshot* snapshot)
     : snapshot_(snapshot),
       collection_(snapshot->collection()),
       filler_(NULL) {
 }
 
-
-HeapEntry *const
-HeapSnapshotGenerator::SnapshotFillerInterface::kHeapEntryPlaceholder =
-    reinterpret_cast<HeapEntry*>(1);
-
 class SnapshotCounter : public HeapSnapshotGenerator::SnapshotFillerInterface {
  public:
   explicit SnapshotCounter(HeapEntriesMap* entries)
       : entries_(entries) { }
   HeapEntry* AddEntry(HeapObject* obj) {
-    entries_->Pair(obj, kHeapEntryPlaceholder);
-    return kHeapEntryPlaceholder;
+    entries_->Pair(obj, HeapEntriesMap::kHeapEntryPlaceholder);
+    return HeapEntriesMap::kHeapEntryPlaceholder;
   }
   void SetElementReference(HeapObject* parent_obj,
                            HeapEntry*,
                            int,
                            Object* child_obj,
                            HeapEntry*) {
     entries_->CountReference(parent_obj, HeapObject::cast(child_obj));
   }
   void SetNamedReference(HeapGraphEdge::Type,
                          HeapObject* parent_obj,
@@ skipping 370 matching lines @@
 void HeapSnapshotGenerator::SetRootReference(Object* child_obj) {
   HeapEntry* child_entry = GetEntry(child_obj);
   ASSERT(child_entry != NULL);
   filler_->SetRootReference(child_obj, child_entry);
 }
 
 
 void HeapSnapshotsDiff::CreateRoots(int additions_count, int deletions_count) {
   raw_additions_root_ =
       NewArray<char>(HeapEntry::EntriesSize(1, additions_count, 0));
-  additions_root()->Init(snapshot2_, additions_count, 0);
+  additions_root()->Init(
+      snapshot2_, HeapEntry::kInternal, "", 0, 0, additions_count, 0);
   raw_deletions_root_ =
       NewArray<char>(HeapEntry::EntriesSize(1, deletions_count, 0));
-  deletions_root()->Init(snapshot1_, deletions_count, 0);
+  deletions_root()->Init(
+      snapshot1_, HeapEntry::kInternal, "", 0, 0, deletions_count, 0);
 }
 
 
 static void DeleteHeapSnapshotsDiff(HeapSnapshotsDiff** diff_ptr) {
   delete *diff_ptr;
 }
 
 HeapSnapshotsComparator::~HeapSnapshotsComparator() {
   diffs_.Iterate(DeleteHeapSnapshotsDiff);
 }
@@ skipping 57 matching lines @@
     HeapEntry* entry = added_entries[i];
     if (entry->painted_reachable())
       diff->AddAddedEntry(add_child_index++, added_entry_index++, entry);
   }
   return diff;
 }
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_LOGGING_AND_PROFILING