C++ profiler: publish the new API, make compatible with WebKit / Chromium.

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 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef ENABLE_CPP_PROFILES_PROCESSOR
 
 #include "v8.h"
 
 #include "profile-generator-inl.h"
 
+#include "../include/v8-profiler.h"
+
 namespace v8 {
 namespace internal {
 
 
 const char* CodeEntry::kEmptyNamePrefix = "";
-const int CodeEntry::kNoLineNumberInfo = -1;
+unsigned long CodeEntry::next_call_uid_ = 1;
 
 
 ProfileNode* ProfileNode::FindChild(CodeEntry* entry) {
   HashMap::Entry* map_entry =
       children_.Lookup(entry, CodeEntryHash(entry), false);
   return map_entry != NULL ?
       reinterpret_cast<ProfileNode*>(map_entry->value) : NULL;
 }
 
 
 ProfileNode* ProfileNode::FindOrAddChild(CodeEntry* entry) {
   HashMap::Entry* map_entry =
       children_.Lookup(entry, CodeEntryHash(entry), true);
   if (map_entry->value == NULL) {
     // New node added.
     ProfileNode* new_node = new ProfileNode(entry);
     map_entry->value = new_node;
     children_list_.Add(new_node);
   }
   return reinterpret_cast<ProfileNode*>(map_entry->value);
 }
 
 
 void ProfileNode::Print(int indent) {
-  OS::Print("%5u %5u %*c %s%s\n",
+  OS::Print("%5u %5u %*c %s%s",
             total_ticks_, self_ticks_,
             indent, ' ',
-            entry_ != NULL ? entry_->name_prefix() : "",
-            entry_ != NULL ? entry_->name() : "");
+            entry_->name_prefix(),
+            entry_->name());
+  if (entry_->resource_name()[0] != '\0')
+    OS::Print(" %s:%d", entry_->resource_name(), entry_->line_number());
+  OS::Print("\n");
   for (HashMap::Entry* p = children_.Start();
        p != NULL;
        p = children_.Next(p)) {
     reinterpret_cast<ProfileNode*>(p->value)->Print(indent + 2);
   }
 }
 
 
 namespace {
 
 class DeleteNodesCallback {
  public:
   void AfterAllChildrenTraversed(ProfileNode* node) {
     delete node;
   }
 
   void AfterChildTraversed(ProfileNode*, ProfileNode*) { }
 };
 
 }  // namespace
 
 
+ProfileTree::ProfileTree()
+    : root_entry_(Logger::FUNCTION_TAG, "", "(root)", "", 0),
+      root_(new ProfileNode(&root_entry_)) {
+}
+
+
 ProfileTree::~ProfileTree() {
   DeleteNodesCallback cb;
   TraverseBreadthFirstPostOrder(&cb);
 }
 
 
 void ProfileTree::AddPathFromEnd(const Vector<CodeEntry*>& path) {
   ProfileNode* node = root_;
   for (CodeEntry** entry = path.start() + path.length() - 1;
        entry != path.start() - 1;
@@ skipping 252 matching lines @@
   return entry != NULL ? reinterpret_cast<CpuProfile*>(entry->value) : NULL;
 }
 
 
 CodeEntry* CpuProfilesCollection::NewCodeEntry(Logger::LogEventsAndTags tag,
                                                String* name,
                                                String* resource_name,
                                                int line_number) {
   CodeEntry* entry = new CodeEntry(tag,
                                    CodeEntry::kEmptyNamePrefix,
-                                   GetName(name),
+                                   GetFunctionName(name),
                                    GetName(resource_name),
                                    line_number);
   code_entries_.Add(entry);
   return entry;
 }
 
 
 CodeEntry* CpuProfilesCollection::NewCodeEntry(Logger::LogEventsAndTags tag,
                                                const char* name) {
   CodeEntry* entry = new CodeEntry(tag,
                                    CodeEntry::kEmptyNamePrefix,
                                    name,
                                    "",
-                                   CodeEntry::kNoLineNumberInfo);
+                                   v8::CpuProfileNode::kNoLineNumberInfo);
   code_entries_.Add(entry);
   return entry;
 }
 
 
 CodeEntry* CpuProfilesCollection::NewCodeEntry(Logger::LogEventsAndTags tag,
                                                const char* name_prefix,
                                                String* name) {
   CodeEntry* entry = new CodeEntry(tag,
                                    name_prefix,
                                    GetName(name),
                                    "",
-                                   CodeEntry::kNoLineNumberInfo);
+                                   v8::CpuProfileNode::kNoLineNumberInfo);
   code_entries_.Add(entry);
   return entry;
 }
 
 
 CodeEntry* CpuProfilesCollection::NewCodeEntry(Logger::LogEventsAndTags tag,
                                                int args_count) {
   CodeEntry* entry = new CodeEntry(tag,
                                    "args_count: ",
                                    GetName(args_count),
                                    "",
-                                   CodeEntry::kNoLineNumberInfo);
+                                   v8::CpuProfileNode::kNoLineNumberInfo);
   code_entries_.Add(entry);
   return entry;
 }
 
 
+const char* CpuProfilesCollection::GetFunctionName(String* name) {
+  const char* maybe_empty_name = GetName(name);
+  return strlen(maybe_empty_name) > 0 ?
+      maybe_empty_name : "(anonymous function)";
+}
+
+
 const char* CpuProfilesCollection::GetName(String* name) {
   if (name->IsString()) {
     char* c_name =
         name->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL).Detach();
     HashMap::Entry* cache_entry =
         function_and_resource_names_.Lookup(c_name,
                                             name->Hash(),
                                             true);
     if (cache_entry->value == NULL) {
       // New entry added.
@@ skipping 30 matching lines @@
   // method, we don't bother minimizing the duration of lock holding,
   // e.g. copying contents of the list to a local vector.
   current_profiles_semaphore_->Wait();
   for (int i = 0; i < current_profiles_.length(); ++i) {
     current_profiles_[i]->AddPath(path);
   }
   current_profiles_semaphore_->Signal();
 }
 
 
+
 ProfileGenerator::ProfileGenerator(CpuProfilesCollection* profiles)
-    : profiles_(profiles) {
+    : profiles_(profiles),
+      program_entry_(
+          profiles->NewCodeEntry(Logger::FUNCTION_TAG, "(program)")) {
 }
 
 
 void ProfileGenerator::RecordTickSample(const TickSample& sample) {
-  // Allocate space for stack frames + pc + function.
-  ScopedVector<CodeEntry*> entries(sample.frames_count + 2);
+  // Allocate space for stack frames + pc + function + (program).
+  ScopedVector<CodeEntry*> entries(sample.frames_count + 3);
   CodeEntry** entry = entries.start();
   *entry++ = code_map_.FindEntry(sample.pc);
 
   if (sample.function != NULL) {
     *entry = code_map_.FindEntry(sample.function);
     if (*entry != NULL && !(*entry)->is_js_function()) {
       *entry = NULL;
     } else {
       CodeEntry* pc_entry = *entries.start();
       if (pc_entry == NULL || pc_entry->is_js_function())
         *entry = NULL;
     }
     entry++;
   } else {
     *entry++ = NULL;
   }
 
   for (const Address *stack_pos = sample.stack,
          *stack_end = stack_pos + sample.frames_count;
        stack_pos != stack_end;
        ++stack_pos) {
     *entry++ = code_map_.FindEntry(*stack_pos);
   }
 
+  // WebKit CPU profiles visualization requires "(program)" to be the
+  // topmost entry.
+  *entry++ = FLAG_prof_browser_mode ? program_entry_ : NULL;
+
   profiles_->AddPathToCurrentProfiles(entries);
 }
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_CPP_PROFILES_PROCESSOR