Heap profiler: fetch document.URL of global objects.

src/profile-generator.cc

 // Copyright 2011 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 1584 matching lines @@
   if (!obj->IsHeapObject()) return;
   HeapObject* object = HeapObject::cast(obj);
   HashMap::Entry* cache_entry =
       entries_.Lookup(object, HeapEntriesMap::Hash(object), true);
   if (cache_entry->value == NULL) {
     cache_entry->value = HeapEntriesMap::kHeapEntryPlaceholder;
   }
 }
 
 
+const char* HeapObjectsSet::GetTag(Object* obj) {
+  HeapObject* object = HeapObject::cast(obj);
+  HashMap::Entry* cache_entry =
+      entries_.Lookup(object, HeapEntriesMap::Hash(object), false);
+  if (cache_entry != NULL
+      && cache_entry->value != HeapEntriesMap::kHeapEntryPlaceholder) {
+    return reinterpret_cast<const char*>(cache_entry->value);
+  } else {
+    return NULL;
+  }
+}
+
+
+void HeapObjectsSet::SetTag(Object* obj, const char* tag) {
+  if (!obj->IsHeapObject()) return;
+  HeapObject* object = HeapObject::cast(obj);
+  HashMap::Entry* cache_entry =
+      entries_.Lookup(object, HeapEntriesMap::Hash(object), true);
+  cache_entry->value = const_cast<char*>(tag);
+}
+
+
 HeapObject *const V8HeapExplorer::kInternalRootObject =
     reinterpret_cast<HeapObject*>(
         static_cast<intptr_t>(HeapObjectsMap::kInternalRootObjectId));
 HeapObject *const V8HeapExplorer::kGcRootsObject =
     reinterpret_cast<HeapObject*>(
         static_cast<intptr_t>(HeapObjectsMap::kGcRootsObjectId));
 
 
 V8HeapExplorer::V8HeapExplorer(
     HeapSnapshot* snapshot,
@@ skipping 17 matching lines @@
 
 
 HeapEntry* V8HeapExplorer::AddEntry(HeapObject* object,
                                     int children_count,
                                     int retainers_count) {
   if (object == kInternalRootObject) {
     ASSERT(retainers_count == 0);
     return snapshot_->AddRootEntry(children_count);
   } else if (object == kGcRootsObject) {
     return snapshot_->AddGcRootsEntry(children_count, retainers_count);
+  } else if (object->IsJSGlobalObject()) {
+    const char* tag = objects_tags_.GetTag(object);
+    const char* name = collection_->names()->GetName(
+        GetConstructorNameForHeapProfile(
+            JSObject::cast(object)));

[Vitaly Repeshko, 2011/05/29 23:01:34]

nit: Fits on the previous line?

[mnaganov (inactive), 2011/05/30 14:20:42]

Done.

+    if (tag != NULL) {
+      name = collection_->names()->GetFormatted("%s / %s", name, tag);
+    }
+    return AddEntry(object,
+                    HeapEntry::kObject,
+                    name,
+                    children_count,
+                    retainers_count);
   } else if (object->IsJSFunction()) {
     JSFunction* func = JSFunction::cast(object);
     SharedFunctionInfo* shared = func->shared();
     return AddEntry(object,
                     HeapEntry::kClosure,
                     collection_->names()->GetName(String::cast(shared->name())),
                     children_count,
                     retainers_count);
   } else if (object->IsJSRegExp()) {
     JSRegExp* re = JSRegExp::cast(object);
@@ skipping 121 matching lines @@
       generator_->SetHiddenReference(parent_obj_, parent_, next_index_++, *p);
     }
   }
   static void MarkVisitedField(HeapObject* obj, int offset) {
     if (offset < 0) return;
     Address field = obj->address() + offset;
     ASSERT(!Memory::Object_at(field)->IsFailure());
     ASSERT(Memory::Object_at(field)->IsHeapObject());
     *field |= kFailureTag;
   }
+
  private:
   bool CheckVisitedAndUnmark(Object** field) {
     if ((*field)->IsFailure()) {
       intptr_t untagged = reinterpret_cast<intptr_t>(*field) & ~kFailureTagMask;
       *field = reinterpret_cast<Object*>(untagged | kHeapObjectTag);
       ASSERT((*field)->IsHeapObject());
       return true;
     }
     return false;
   }
@@ skipping 406 matching lines @@
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry != NULL) {
     filler_->SetIndexedAutoIndexReference(
         HeapGraphEdge::kElement,
         kGcRootsObject, snapshot_->gc_roots(),
         child_obj, child_entry);
   }
 }
 
 
+class GlobalObjectsCounter : public ObjectVisitor {
+ public:
+  GlobalObjectsCounter() : count_(0) {}
+  void VisitPointers(Object** start, Object** end) {

[Vitaly Repeshko, 2011/05/29 23:01:34]

nit: virtual

[mnaganov (inactive), 2011/05/30 14:20:42]

Done.

+    for (Object** p = start; p < end; p++) {
+      if ((*p)->IsGlobalContext())
+        ++count_;
+    }
+  }
+  int count() { return count_; }
+
+ private:
+  int count_;
+};
+
+
+class GlobalObjectsEnumerator : public ObjectVisitor {
+ public:
+  explicit GlobalObjectsEnumerator(int length)
+      : length_(length),
+        count_(0),
+        objects_(NewArray<Handle<JSGlobalObject> >(length)) {}
+  ~GlobalObjectsEnumerator() {
+    DeleteArray(objects_);
+  }
+  void VisitPointers(Object** start, Object** end) {

[Vitaly Repeshko, 2011/05/29 23:01:34]

nit: virtual

[mnaganov (inactive), 2011/05/30 14:20:42]

Done.

+    for (Object** p = start; count_ < length_ && p < end; p++) {
+      if ((*p)->IsGlobalContext()) {
+        Context* context = Context::cast(*p);
+        JSObject* proxy = context->global_proxy();
+        if (proxy->IsJSGlobalProxy()) {

[Vitaly Repeshko, 2011/05/29 23:01:34]

Given that this loop has more conditions than its above twin, the tail of the
handles array might be left uninitialized.

[mnaganov (inactive), 2011/05/30 14:20:42]

Fixed by eliminating the counter class.

+          Object* global = proxy->map()->prototype();
+          if (global->IsJSGlobalObject())

[Vitaly Repeshko, 2011/05/29 23:01:34]

nit: {}

[mnaganov (inactive), 2011/05/30 14:20:42]

Done.

+            objects_[count_++] =
+                Handle<JSGlobalObject>(JSGlobalObject::cast(global));
+        }
+      }
+    }
+  }
+  int count() { return count_; }
+  Handle<JSGlobalObject>* objects() { return objects_; }
+
+ private:
+  const int length_;
+  int count_;
+  Handle<JSGlobalObject>* objects_;

[Vitaly Repeshko, 2011/05/29 23:01:34]

Can we use a growable collection of handles (e.g. list) and merge the two new
visitors?

[mnaganov (inactive), 2011/05/30 14:20:42]

Sure. Sorry, I forgot about their existence.

+};
+
+
+// Modifies heap. Must not be run during heap traversal.
+void V8HeapExplorer::TagGlobalObjects() {

[Vitaly Repeshko, 2011/05/29 23:01:34]

Random idea. I don't know how flexible we want to be here, but in principle
nothing prevents us from taking a context tagging script from the embedder. In
Chromium it might be useful for non-window contexts.

[mnaganov (inactive), 2011/05/30 14:20:42]

Let's discuss it later.

+  Isolate* isolate = Isolate::Current();
+  GlobalObjectsCounter counter;
+  isolate->global_handles()->IterateAllRoots(&counter);
+  GlobalObjectsEnumerator enumerator(counter.count());
+  isolate->global_handles()->IterateAllRoots(&enumerator);
+  Handle<String> document_string =
+      isolate->factory()->NewStringFromAscii(CStrVector("document"));
+  Handle<String> url_string =
+      isolate->factory()->NewStringFromAscii(CStrVector("URL"));
+  const char** urls = NewArray<const char*>(counter.count());
+  for (int i = 0; i < counter.count(); ++i) {
+    urls[i] = NULL;
+    Handle<JSGlobalObject>& go = enumerator.objects()[i];

[Vitaly Repeshko, 2011/05/29 23:01:34]

Reference is not needed here. "go" is too short.

[mnaganov (inactive), 2011/05/30 14:20:42]

Removed ref. s/go/global_obj/

+    Object* obj_document = go->GetPropertyNoExceptionThrown(*document_string);

[Vitaly Repeshko, 2011/05/29 23:01:34]

This is not safe, because it asserts on failure/exception. Use something like:
Object* obj_document;
if (go->GetProperty(*document_string)->ToObject(&obj_document) &&
    obj_document->IsJSObject()) {
  JSObject* document = JSObject::cast(obj_document);
}

[mnaganov (inactive), 2011/05/30 14:20:42]

Done.

+    if (obj_document->IsJSObject()) {
+      JSObject* document = JSObject::cast(obj_document);
+      Object* obj_url = document->GetProperty(*url_string)->ToObjectUnchecked();

[Vitaly Repeshko, 2011/05/29 23:01:34]

Also asserts on failure/exception.

[mnaganov (inactive), 2011/05/30 14:20:42]

Done.

+      if (obj_url->IsString()) {
+        urls[i] = collection_->names()->GetName(String::cast(obj_url));
+      }
+    }
+  }
+
+  AssertNoAllocation no_allocation;
+  for (int i = 0; i < counter.count(); ++i) {
+    objects_tags_.SetTag(*enumerator.objects()[i], urls[i]);
+  }
+
+  DeleteArray(urls);
+}
+
+
 class GlobalHandlesExtractor : public ObjectVisitor {
  public:
   explicit GlobalHandlesExtractor(NativeObjectsExplorer* explorer)
       : explorer_(explorer) {}
   virtual ~GlobalHandlesExtractor() {}
   virtual void VisitPointers(Object** start, Object** end) {
     UNREACHABLE();
   }
   virtual void VisitEmbedderReference(Object** p, uint16_t class_id) {
     explorer_->VisitSubtreeWrapper(p, class_id);
@@ skipping 222 matching lines @@
                          HeapEntry*) {
     entries_->CountReference(parent_ptr, child_ptr);
   }
   void SetNamedAutoIndexReference(HeapGraphEdge::Type,
                                   HeapThing parent_ptr,
                                   HeapEntry*,
                                   HeapThing child_ptr,
                                   HeapEntry*) {
     entries_->CountReference(parent_ptr, child_ptr);
   }
+
  private:
   HeapEntriesMap* entries_;
 };
 
 
 class SnapshotFiller : public SnapshotFillerInterface {
  public:
   explicit SnapshotFiller(HeapSnapshot* snapshot, HeapEntriesMap* entries)
       : snapshot_(snapshot),
         collection_(snapshot->collection()),
@@ skipping 51 matching lines @@
                                   HeapEntry* child_entry) {
     int child_index, retainer_index;
     entries_->CountReference(
         parent_ptr, child_ptr, &child_index, &retainer_index);
     parent_entry->SetNamedReference(type,
                               child_index,
                               collection_->names()->GetName(child_index + 1),
                               child_entry,
                               retainer_index);
   }
+
  private:
   HeapSnapshot* snapshot_;
   HeapSnapshotsCollection* collection_;
   HeapEntriesMap* entries_;
 };
 
 
 bool HeapSnapshotGenerator::GenerateSnapshot() {
+  v8_heap_explorer_.TagGlobalObjects();
+
   AssertNoAllocation no_alloc;
 
   SetProgressTotal(4);  // 2 passes + dominators + sizes.
 
   // Pass 1. Iterate heap contents to count entries and references.
   if (!CountEntriesAndReferences()) return false;
 
   // Allocate and fill entries in the snapshot, allocate references.
   snapshot_->AllocateEntries(entries_.entries_count(),
                              entries_.total_children_count(),
@@ skipping 549 matching lines @@
 
 
 String* GetConstructorNameForHeapProfile(JSObject* object) {
   if (object->IsJSFunction()) return HEAP->closure_symbol();
   return object->constructor_name();
 }
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_LOGGING_AND_PROFILING