HeapProfiler: for the test purposes we would like to trace object movements.

src/heap-snapshot-generator.cc

 // Copyright 2013 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 413 matching lines @@
       int to_entry_info_index =
           static_cast<int>(reinterpret_cast<intptr_t>(to_entry->value));
       entries_.at(to_entry_info_index).addr = NULL;
     }
     int from_entry_info_index =
         static_cast<int>(reinterpret_cast<intptr_t>(from_value));
     entries_.at(from_entry_info_index).addr = to;
     // Size of an object can change during its life, so to keep information
     // about the object in entries_ consistent, we have to adjust size when the
     // object is migrated.
+    if (FLAG_heap_profiler_trace_objects) {
+      PrintF("Move object from %p to %p old size %6d new size %6d\n",
+             from,
+             to,
+             entries_.at(from_entry_info_index).size,
+             object_size);
+    }
     entries_.at(from_entry_info_index).size = object_size;
     to_entry->value = from_value;
   }
 }
 
 
 void HeapObjectsMap::NewObject(Address addr, int size) {
+  if (FLAG_heap_profiler_trace_objects) {
+    PrintF("New object         : %p %6d. Next address is %p\n",
+            addr,
+            size,
+            addr + size);
+  }
   ASSERT(addr != NULL);
   FindOrAddEntry(addr, size, false);
 }
 
 
 void HeapObjectsMap::UpdateObjectSize(Address addr, int size) {
   FindOrAddEntry(addr, size, false);
 }
 
 
@@ skipping 12 matching lines @@
                                                 unsigned int size,
                                                 bool accessed) {
   ASSERT(static_cast<uint32_t>(entries_.length()) > entries_map_.occupancy());
   HashMap::Entry* entry = entries_map_.Lookup(addr, ComputePointerHash(addr),
                                               true);
   if (entry->value != NULL) {
     int entry_index =
         static_cast<int>(reinterpret_cast<intptr_t>(entry->value));
     EntryInfo& entry_info = entries_.at(entry_index);
     entry_info.accessed = accessed;
+    if (FLAG_heap_profiler_trace_objects) {
+      PrintF("Update object size : %p with old size %d and new size %d\n",
+             addr,
+             entry_info.size,
+             size);
+    }
     entry_info.size = size;
     return entry_info.id;
   }
   entry->value = reinterpret_cast<void*>(entries_.length());
   SnapshotObjectId id = next_id_;
   next_id_ += kObjectIdStep;
   entries_.Add(EntryInfo(id, addr, size, accessed));
   ASSERT(static_cast<uint32_t>(entries_.length()) > entries_map_.occupancy());
   return id;
 }
 
 
 void HeapObjectsMap::StopHeapObjectsTracking() {
   time_intervals_.Clear();
 }
 
 
 void HeapObjectsMap::UpdateHeapObjectsMap() {
+  if (FLAG_heap_profiler_trace_objects) {
+    PrintF("Begin HeapObjectsMap::UpdateHeapObjectsMap. map has %d entries.\n",
+           entries_map_.occupancy());
+  }
   heap_->CollectAllGarbage(Heap::kMakeHeapIterableMask,
                           "HeapSnapshotsCollection::UpdateHeapObjectsMap");
   HeapIterator iterator(heap_);
   for (HeapObject* obj = iterator.next();
        obj != NULL;
        obj = iterator.next()) {
     FindOrAddEntry(obj->address(), obj->Size());
+    if (FLAG_heap_profiler_trace_objects) {
+      PrintF("Update object      : %p %6d. Next address is %p\n",

[yurys, 2013/10/17 13:20:54]

Next address -> End address?

[loislo, 2013/10/17 13:34:13]

We don't need to know the end address. 
Usually we would like to know what would be the address of the next object in
the memory. With proposed implementation we will simple search for an address
and see the object with the address and the previous object. It is very useful
information for the allocations folding case.

+            obj->address(),

[yurys, 2013/10/17 13:20:54]

style: wrong alignment

[loislo, 2013/10/17 13:34:13]

Done.

+            obj->Size(),
+            obj->address() + obj->Size());
+    }
   }
   RemoveDeadEntries();
+  if (FLAG_heap_profiler_trace_objects) {
+    PrintF("End HeapObjectsMap::UpdateHeapObjectsMap. map has %d entries.\n",
+            entries_map_.occupancy());
+  }
 }
 
 
+namespace {
+
+
+struct HeapObjectInfo {
+  HeapObjectInfo(HeapObject* obj, size_t expected_size)
+    : obj(obj),
+      expected_size(expected_size) {
+  }
+
+  HeapObject* obj;
+  int expected_size;
+
+  bool isValid() const { return expected_size == obj->Size(); }

[yurys, 2013/10/17 13:20:54]

style: IsValid

[loislo, 2013/10/17 13:34:13]

Done.

+
+  void Print() const {
+    if (expected_size == 0)

[yurys, 2013/10/17 13:20:54]

Please add {}.

[loislo, 2013/10/17 13:34:13]

Done.

+      PrintF("Untracked object : %p %6d. Next address is %p\n",
+             obj->address(),
+             obj->Size(),
+             obj->address() + obj->Size());
+    else if (obj->Size() != expected_size) {
+      PrintF("Wrong size %6d: %p %6d. Next address is %p\n",
+             expected_size,
+             obj->address(),
+             obj->Size(),
+             obj->address() + obj->Size());
+    } else {
+      PrintF("Good object      : %p %6d. Next address is %p\n",
+             obj->address(),
+             expected_size,
+             obj->address() + obj->Size());
+    }
+  }
+};
+
+
+static int comparer(const HeapObjectInfo* a, const HeapObjectInfo* b) {

[yurys, 2013/10/17 13:20:54]

comparer -> comparator

I'd also make it a member of HeapObjectInfo.

+  return a->obj - b->obj;

[alph, 2013/10/17 13:17:25]

might need a static cast on x64.

[loislo, 2013/10/17 13:34:13]

It is working fine on x64 and ia32

+}
+
+
+}  // namespace
+
+
 int HeapObjectsMap::FindUntrackedObjects() {
+  List<HeapObjectInfo> heap_objects(1000);
+
   HeapIterator iterator(heap_);
   int untracked = 0;
   for (HeapObject* obj = iterator.next();
        obj != NULL;
        obj = iterator.next()) {
     HashMap::Entry* entry = entries_map_.Lookup(
       obj->address(), ComputePointerHash(obj->address()), false);
     if (entry == NULL) {
+      if (FLAG_heap_profiler_trace_objects)

[yurys, 2013/10/17 13:20:54]

Please use {}.

[loislo, 2013/10/17 13:34:13]

Done.

+        heap_objects.Add(HeapObjectInfo(obj, 0));
       untracked++;
     } else {
       int entry_index = static_cast<int>(
           reinterpret_cast<intptr_t>(entry->value));
       EntryInfo& entry_info = entries_.at(entry_index);
-      CHECK_EQ(obj->Size(), static_cast<int>(entry_info.size));

[alph, 2013/10/17 13:17:25]

Why did you remove the size check?

[loislo, 2013/10/17 13:34:13]

reverted

+      if (FLAG_heap_profiler_trace_objects) {
+        heap_objects.Add(HeapObjectInfo(obj,
+                         static_cast<int>(entry_info.size)));
+      } else {
+        untracked++;

[yurys, 2013/10/17 13:20:54]

untracked++ should be called if sizes don't match regardless of the flag state.

[loislo, 2013/10/17 13:34:13]

Done.

+      }
     }
   }
+  if (FLAG_heap_profiler_trace_objects) {
+    PrintF("Begin HeapObjectsMap::FindUntrackedObjects. %d entries in map.\n",
+           entries_map_.occupancy());
+    heap_objects.Sort(comparer);
+    int last_printed_object = -1;
+    bool print_next_object = false;
+    for (int i = 0; i< heap_objects.length(); ++i) {

[alph, 2013/10/17 13:17:25]

nit: missing space at i<

[loislo, 2013/10/17 13:34:13]

Done.

+      const HeapObjectInfo& object_info = heap_objects[i];
+      if (!object_info.isValid()) {
+        if (last_printed_object != i - 1) {
+          if (i > 0) {
+            PrintF("%d objects were skipped\n", i - 1 - last_printed_object);
+            heap_objects[i - 1].Print();
+          }
+        }
+        object_info.Print();
+        last_printed_object = i;
+        print_next_object = true;
+      } else if (print_next_object) {
+        object_info.Print();
+        print_next_object = false;
+        last_printed_object = i;
+      }
+    }
+    if (last_printed_object < heap_objects.length() - 1) {
+      PrintF("Last %d objects were skipped\n",
+             heap_objects.length() - 1 - last_printed_object);
+    }
+    PrintF("End HeapObjectsMap::FindUntrackedObjects. %d entries in map.\n",
+           entries_map_.occupancy());
+  }
   return untracked;
 }
 
 
 SnapshotObjectId HeapObjectsMap::PushHeapObjectsStats(OutputStream* stream) {
   UpdateHeapObjectsMap();
   time_intervals_.Add(TimeInterval(next_id_));
   int prefered_chunk_size = stream->GetChunkSize();
   List<v8::HeapStatsUpdate> stats_buffer;
   ASSERT(!entries_.is_empty());
@@ skipping 2215 matching lines @@
   writer_->AddString("\"<dummy>\"");
   for (int i = 1; i < sorted_strings.length(); ++i) {
     writer_->AddCharacter(',');
     SerializeString(sorted_strings[i]);
     if (writer_->aborted()) return;
   }
 }
 
 
 } }  // namespace v8::internal