Version 2.3.10...

src/profile-generator.h

 // 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 49 matching lines @@
 
 
 // Provides a storage of strings allocated in C++ heap, to hold them
 // forever, even if they disappear from JS heap or external storage.
 class StringsStorage {
  public:
   StringsStorage();
   ~StringsStorage();
 
   const char* GetName(String* name);
+  inline const char* GetFunctionName(String* name);
+  inline const char* GetFunctionName(const char* name);
 
  private:
   INLINE(static bool StringsMatch(void* key1, void* key2)) {
     return strcmp(reinterpret_cast<char*>(key1),
                   reinterpret_cast<char*>(key2)) == 0;
   }
 
   // Mapping of strings by String::Hash to const char* strings.
   HashMap names_;
 
@@ skipping 211 matching lines @@
   CodeEntry* NewCodeEntry(Logger::LogEventsAndTags tag, const char* name);
   CodeEntry* NewCodeEntry(Logger::LogEventsAndTags tag,
                           const char* name_prefix, String* name);
   CodeEntry* NewCodeEntry(Logger::LogEventsAndTags tag, int args_count);
   CodeEntry* NewCodeEntry(int security_token_id);
 
   // Called from profile generator thread.
   void AddPathToCurrentProfiles(const Vector<CodeEntry*>& path);
 
  private:
-  INLINE(const char* GetFunctionName(String* name));
-  INLINE(const char* GetFunctionName(const char* name));
   const char* GetName(int args_count);
+  const char* GetFunctionName(String* name) {
+    return function_and_resource_names_.GetFunctionName(name);
+  }
+  const char* GetFunctionName(const char* name) {
+    return function_and_resource_names_.GetFunctionName(name);
+  }
   List<CpuProfile*>* GetProfilesList(int security_token_id);
   int TokenToIndex(int security_token_id);
 
   INLINE(static bool UidsMatch(void* key1, void* key2)) {
     return key1 == key2;
   }
 
   StringsStorage function_and_resource_names_;
   // Mapping from args_count (int) to char* strings.
   List<char*> args_count_names_;
@@ skipping 177 matching lines @@
   enum Type {
     kInternal = v8::HeapGraphNode::kInternal,
     kArray = v8::HeapGraphNode::kArray,
     kString = v8::HeapGraphNode::kString,
     kObject = v8::HeapGraphNode::kObject,
     kCode = v8::HeapGraphNode::kCode,
     kClosure = v8::HeapGraphNode::kClosure
   };
 
   HeapEntry() { }
-  void Init(HeapSnapshot* snapshot, int children_count, int retainers_count);
   void Init(HeapSnapshot* snapshot,
             Type type,
             const char* name,
             uint64_t id,
             int self_size,
             int children_count,
             int retainers_count);
 
   HeapSnapshot* snapshot() { return snapshot_; }
   Type type() { return static_cast<Type>(type_); }
@@ skipping 121 matching lines @@
 class HeapSnapshotsCollection;
 class HeapSnapshotsDiff;
 
 // HeapSnapshot represents a single heap snapshot. It is stored in
 // HeapSnapshotsCollection, which is also a factory for
 // HeapSnapshots. All HeapSnapshots share strings copied from JS heap
 // to be able to return them even if they were collected.
 // HeapSnapshotGenerator fills in a HeapSnapshot.
 class HeapSnapshot {
  public:
+  enum Type {
+    kFull = v8::HeapSnapshot::kFull,
+    kAggregated = v8::HeapSnapshot::kAggregated
+  };
+
   HeapSnapshot(HeapSnapshotsCollection* collection,
+               Type type,
                const char* title,
                unsigned uid);
   ~HeapSnapshot();
 
   HeapSnapshotsCollection* collection() { return collection_; }
+  Type type() { return type_; }
   const char* title() { return title_; }
   unsigned uid() { return uid_; }
   HeapEntry* root() { return entries_[root_entry_index_]; }
 
   void AllocateEntries(
       int entries_count, int children_count, int retainers_count);
   HeapEntry* AddEntry(
       HeapObject* object, int children_count, int retainers_count);
   bool WillAddEntry(HeapObject* object);
+  HeapEntry* AddEntry(HeapEntry::Type type,
+                      const char* name,
+                      uint64_t id,
+                      int size,
+                      int children_count,
+                      int retainers_count);
   int AddCalculatedData();
   HeapEntryCalculatedData& GetCalculatedData(int index) {
     return calculated_data_[index];
   }
   void ClearPaint();
   HeapSnapshotsDiff* CompareWith(HeapSnapshot* snapshot);
   List<HeapEntry*>* GetSortedEntriesList();
   template<class Visitor>
   void IterateEntries(Visitor* visitor) { entries_.Iterate(visitor); }
 
   void Print(int max_depth);
   void PrintEntriesSize();
 
   static HeapObject *const kInternalRootObject;
 
  private:
   HeapEntry* AddEntry(HeapObject* object,
                       HeapEntry::Type type,
                       const char* name,
                       int children_count,
                       int retainers_count);
   HeapEntry* GetNextEntryToInit();
   static int GetObjectSize(HeapObject* obj);
   static int CalculateNetworkSize(JSObject* obj);
 
   HeapSnapshotsCollection* collection_;
+  Type type_;
   const char* title_;
   unsigned uid_;
   int root_entry_index_;
   char* raw_entries_;
   List<HeapEntry*> entries_;
   bool entries_sorted_;
   List<HeapEntryCalculatedData> calculated_data_;
+#ifdef DEBUG
+  int raw_entries_size_;
+#endif
 
   friend class HeapSnapshotTester;
 
   DISALLOW_COPY_AND_ASSIGN(HeapSnapshot);
 };
 
 
 class HeapObjectsMap {
  public:
   HeapObjectsMap();
@@ skipping 84 matching lines @@
 };
 
 
 class HeapSnapshotsCollection {
  public:
   HeapSnapshotsCollection();
   ~HeapSnapshotsCollection();
 
   bool is_tracking_objects() { return is_tracking_objects_; }
 
-  HeapSnapshot* NewSnapshot(const char* name, unsigned uid);
+  HeapSnapshot* NewSnapshot(
+      HeapSnapshot::Type type, const char* name, unsigned uid);
   void SnapshotGenerationFinished() { ids_.SnapshotGenerationFinished(); }
   List<HeapSnapshot*>* snapshots() { return &snapshots_; }
   HeapSnapshot* GetSnapshot(unsigned uid);
 
   const char* GetName(String* name) { return names_.GetName(name); }
+  const char* GetFunctionName(String* name) {
+    return names_.GetFunctionName(name);
+  }
 
   TokenEnumerator* token_enumerator() { return token_enumerator_; }
 
   uint64_t GetObjectId(Address addr) { return ids_.FindObject(addr); }
   void ObjectMoveEvent(Address from, Address to) { ids_.MoveObject(from, to); }
 
   HeapSnapshotsDiff* CompareSnapshots(HeapSnapshot* snapshot1,
                                       HeapSnapshot* snapshot2);
 
  private:
@@ skipping 30 matching lines @@
   void CountReference(HeapObject* from, HeapObject* to,
                       int* prev_children_count = NULL,
                       int* prev_retainers_count = NULL);
   template<class Visitor>
   void UpdateEntries(Visitor* visitor);
 
   int entries_count() { return entries_count_; }
   int total_children_count() { return total_children_count_; }
   int total_retainers_count() { return total_retainers_count_; }
 
+  static HeapEntry *const kHeapEntryPlaceholder;
+
  private:
   struct EntryInfo {
     explicit EntryInfo(HeapEntry* entry)
         : entry(entry), children_count(0), retainers_count(0) { }
     HeapEntry* entry;
     int children_count;
     int retainers_count;
   };
 
   uint32_t Hash(HeapObject* object) {
@@ skipping 35 matching lines @@
                                      Object* child_obj,
                                      HeapEntry* child_entry) = 0;
     virtual void SetNamedReference(HeapGraphEdge::Type type,
                                    HeapObject* parent_obj,
                                    HeapEntry* parent_entry,
                                    const char* reference_name,
                                    Object* child_obj,
                                    HeapEntry* child_entry) = 0;
     virtual void SetRootReference(Object* child_obj,
                                   HeapEntry* child_entry) = 0;
-
-    static HeapEntry *const kHeapEntryPlaceholder;
   };
 
   explicit HeapSnapshotGenerator(HeapSnapshot* snapshot);
   void GenerateSnapshot();
 
  private:
   HeapEntry* GetEntry(Object* obj);
   int GetGlobalSecurityToken();
   int GetObjectSecurityToken(HeapObject* obj);
   void ExtractReferences(HeapObject* obj);
@@ skipping 27 matching lines @@
   friend class IndexedReferencesExtractor;
 
   DISALLOW_COPY_AND_ASSIGN(HeapSnapshotGenerator);
 };
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 #endif  // V8_PROFILE_GENERATOR_H_