C++ profiles processor: wire up to VM.

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 16 matching lines @@
 
 #ifdef ENABLE_CPP_PROFILES_PROCESSOR
 
 #include "v8.h"
 
 #include "profile-generator-inl.h"
 
 namespace v8 {
 namespace internal {
 
+
+const char* CodeEntry::kEmptyNamePrefix = "";
+const int CodeEntry::kNoLineNumberInfo = -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\n",
+  OS::Print("%5u %5u %*c %s%s\n",
             total_ticks_, self_ticks_,
             indent, ' ',
+            entry_ != NULL ? entry_->name_prefix() : "",
             entry_ != NULL ? entry_->name() : "");
   for (HashMap::Entry* p = children_.Start();
        p != NULL;
        p = children_.Next(p)) {
     reinterpret_cast<ProfileNode*>(p->value)->Print(indent + 2);
   }
 }
 
 
 namespace {
@@ skipping 274 matching lines @@
                                                 false);
   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),
                                    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,
                                    "",
-                                   kNoLineNumberInfo);
+                                   CodeEntry::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);
+  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),
                                    "",
-                                   kNoLineNumberInfo);
+                                   CodeEntry::kNoLineNumberInfo);
   code_entries_.Add(entry);
   return entry;
 }
 
 
 const char* CpuProfilesCollection::GetName(String* name) {
   if (name->IsString()) {
     char* c_name =
         name->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL).Detach();
     HashMap::Entry* cache_entry =
@@ skipping 15 matching lines @@
 
 const char* CpuProfilesCollection::GetName(int args_count) {
   ASSERT(args_count >= 0);
   if (args_count_names_.length() <= args_count) {
     args_count_names_.AddBlock(
         NULL, args_count - args_count_names_.length() + 1);
   }
   if (args_count_names_[args_count] == NULL) {
     const int kMaximumNameLength = 32;
     char* name = NewArray<char>(kMaximumNameLength);
-    OS::SNPrintF(Vector<char>(name, kMaximumNameLength),
-                 "args_count: %d", args_count);
+    OS::SNPrintF(Vector<char>(name, kMaximumNameLength), "%d", args_count);
     args_count_names_[args_count] = name;
   }
   return args_count_names_[args_count];
 }
 
 
 void CpuProfilesCollection::AddPathToCurrentProfiles(
     const Vector<CodeEntry*>& path) {
   // As starting / stopping profiles is rare relatively to this
   // method, we don't bother minimizing the duration of lock holding,
@@ skipping 37 matching lines @@
        ++stack_pos) {
     *entry++ = code_map_.FindEntry(*stack_pos);
   }
 
   profiles_->AddPathToCurrentProfiles(entries);
 }
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_CPP_PROFILES_PROCESSOR