/deps/v8/src/heap-snapshot-generator.h - Diff - CSE2410 Fall 2014 Bounce - CS Projects

Revision f230a1cf deps/v8/src/heap-snapshot-generator.h

     namespace v8 {
     namespace internal {
     class AllocationTracker;
     class AllocationTraceNode;
     class HeapEntry;
     class HeapSnapshot;
-...
       void SnapshotGenerationFinished();
       SnapshotObjectId FindEntry(Address addr);
       SnapshotObjectId FindOrAddEntry(Address addr, unsigned int size);
       void MoveObject(Address from, Address to);
       SnapshotObjectId FindOrAddEntry(Address addr,
                                       unsigned int size,
                                       bool accessed = true);
       void MoveObject(Address from, Address to, int size);
       void NewObject(Address addr, int size);
       void UpdateObjectSize(Address addr, int size);
       SnapshotObjectId last_assigned_id() const {
         return next_id_ - kObjectIdStep;
+      }
-...
       static const SnapshotObjectId kGcRootsFirstSubrootId;
       static const SnapshotObjectId kFirstAvailableObjectId;
       int FindUntrackedObjects();
       void UpdateHeapObjectsMap();
      private:
       struct EntryInfo {
       EntryInfo(SnapshotObjectId id, Address addr, unsigned int size)
-...
         uint32_t count;
       };
       void UpdateHeapObjectsMap();
       void RemoveDeadEntries();
       SnapshotObjectId next_id_;
-...
       SnapshotObjectId PushHeapObjectsStats(OutputStream* stream) {
         return ids_.PushHeapObjectsStats(stream);
+      }
       void StartHeapObjectsTracking() { is_tracking_objects_ = true; }
       void StopHeapObjectsTracking() { ids_.StopHeapObjectsTracking(); }
       void StartHeapObjectsTracking();
       void StopHeapObjectsTracking();
       HeapSnapshot* NewSnapshot(const char* name, unsigned uid);
       void SnapshotGenerationFinished(HeapSnapshot* snapshot);
-...
       void RemoveSnapshot(HeapSnapshot* snapshot);
       StringsStorage* names() { return &names_; }
       AllocationTracker* allocation_tracker() { return allocation_tracker_; }
       SnapshotObjectId FindObjectId(Address object_addr) {
         return ids_.FindEntry(object_addr);
-...
         return ids_.FindOrAddEntry(object_addr, object_size);
+      }
       Handle<HeapObject> FindHeapObjectById(SnapshotObjectId id);
       void ObjectMoveEvent(Address from, Address to) { ids_.MoveObject(from, to); }
       void ObjectMoveEvent(Address from, Address to, int size) {
         ids_.MoveObject(from, to, size);
+      }
       void NewObjectEvent(Address addr, int size);
       void UpdateObjectSizeEvent(Address addr, int size) {
         ids_.UpdateObjectSize(addr, size);
+      }
       SnapshotObjectId last_assigned_id() const {
         return ids_.last_assigned_id();
+      }
       size_t GetUsedMemorySize() const;
       int FindUntrackedObjects() { return ids_.FindUntrackedObjects(); }
       void UpdateHeapObjectsMap() { ids_.UpdateHeapObjectsMap(); }
      private:
       bool is_tracking_objects_;  // Whether tracking object moves is needed.
       List<HeapSnapshot*> snapshots_;
       StringsStorage names_;
       // Mapping from HeapObject addresses to objects' uids.
       HeapObjectsMap ids_;
       AllocationTracker* allocation_tracker_;
       DISALLOW_COPY_AND_ASSIGN(HeapSnapshotsCollection);
     };
-...
      public:
       explicit HeapSnapshotJSONSerializer(HeapSnapshot* snapshot)
           : snapshot_(snapshot),
             strings_(ObjectsMatch),
             strings_(StringsMatch),
             next_node_id_(1),
             next_string_id_(1),
             writer_(NULL) {
-...
       void Serialize(v8::OutputStream* stream);
      private:
       INLINE(static bool ObjectsMatch(void* key1, void* key2)) {
         return key1 == key2;
       INLINE(static bool StringsMatch(void* key1, void* key2)) {
         return strcmp(reinterpret_cast<char*>(key1),
                       reinterpret_cast<char*>(key2)) == 0;
+      }
       INLINE(static uint32_t ObjectHash(const void* key)) {
         return ComputeIntegerHash(
             static_cast<uint32_t>(reinterpret_cast<uintptr_t>(key)),
             v8::internal::kZeroHashSeed);
       INLINE(static uint32_t StringHash(const void* string)) {
         const char* s = reinterpret_cast<const char*>(string);
         int len = static_cast<int>(strlen(s));
         return StringHasher::HashSequentialString(
             s, len, v8::internal::kZeroHashSeed);
+      }
       int GetStringId(const char* s);
-...
       void SerializeNode(HeapEntry* entry);
       void SerializeNodes();
       void SerializeSnapshot();
       void SerializeTraceTree();
       void SerializeTraceNode(AllocationTraceNode* node);
       void SerializeTraceNodeInfos();
       void SerializeString(const unsigned char* s);
       void SerializeStrings();
       void SortHashMap(HashMap* map, List<HashMap::Entry*>* sorted_entries);
       static const int kEdgeFieldsCount;
       static const int kNodeFieldsCount;

Also available in: Unified diff