Provide more accurate results about used heap size via GetHeapStatistics.

src/heap.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 377 matching lines @@
 
 #if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
   ReportStatisticsBeforeGC();
 #endif
 }
 
 intptr_t Heap::SizeOfObjects() {
   intptr_t total = 0;
   AllSpaces spaces;
   for (Space* space = spaces.next(); space != NULL; space = spaces.next()) {
-    total += space->Size();
+    total += space->SizeOfObjects();
   }
   return total;
 }
 
 void Heap::GarbageCollectionEpilogue() {
 #ifdef DEBUG
   allow_allocation(true);
   ZapFromSpace();
 
   if (FLAG_verify_heap) {
@@ skipping 3983 matching lines @@
   *stats->map_space_capacity = map_space_->Capacity();
   *stats->cell_space_size = cell_space_->Size();
   *stats->cell_space_capacity = cell_space_->Capacity();
   *stats->lo_space_size = lo_space_->Size();
   GlobalHandles::RecordStats(stats);
   *stats->memory_allocator_size = MemoryAllocator::Size();
   *stats->memory_allocator_capacity =
       MemoryAllocator::Size() + MemoryAllocator::Available();
   *stats->os_error = OS::GetLastError();
   if (take_snapshot) {
-    HeapIterator iterator;
+    HeapIterator iterator(HeapIterator::kPreciseFiltering);
     for (HeapObject* obj = iterator.next();
          obj != NULL;
          obj = iterator.next()) {
-      // Note: snapshot won't be precise because IsFreeListNode returns true
-      // for any bytearray.
-      if (FreeListNode::IsFreeListNode(obj)) continue;

[antonm, 2010/11/13 17:37:51]

thank you very much!

       InstanceType type = obj->map()->instance_type();
       ASSERT(0 <= type && type <= LAST_TYPE);
       stats->objects_per_type[type]++;
       stats->size_per_type[type] += obj->Size();
     }
   }
 }
 
 
 intptr_t Heap::PromotedSpaceSize() {
@@ skipping 334 matching lines @@
     case OLD_DATA_SPACE:
       return Heap::old_data_space();
     case CODE_SPACE:
       return Heap::code_space();
     default:
       return NULL;
   }
 }
 
 
-SpaceIterator::SpaceIterator() : current_space_(FIRST_SPACE), iterator_(NULL) {
+SpaceIterator::SpaceIterator()
+    : current_space_(FIRST_SPACE),
+      iterator_(NULL),
+      size_func_(NULL) {
 }
 
 
+SpaceIterator::SpaceIterator(HeapObjectCallback size_func)
+    : current_space_(FIRST_SPACE),
+      iterator_(NULL),
+      size_func_(size_func) {
+}
+
+
 SpaceIterator::~SpaceIterator() {
   // Delete active iterator if any.
   delete iterator_;
 }
 
 
 bool SpaceIterator::has_next() {
   // Iterate until no more spaces.
   return current_space_ != LAST_SPACE;
 }
@@ skipping 14 matching lines @@
   return CreateIterator();
 }
 
 
 // Create an iterator for the space to iterate.
 ObjectIterator* SpaceIterator::CreateIterator() {
   ASSERT(iterator_ == NULL);
 
   switch (current_space_) {
     case NEW_SPACE:
-      iterator_ = new SemiSpaceIterator(Heap::new_space());
+      iterator_ = new SemiSpaceIterator(Heap::new_space(), size_func_);
       break;
     case OLD_POINTER_SPACE:
-      iterator_ = new HeapObjectIterator(Heap::old_pointer_space());
+      iterator_ = new HeapObjectIterator(Heap::old_pointer_space(), size_func_);
       break;
     case OLD_DATA_SPACE:
-      iterator_ = new HeapObjectIterator(Heap::old_data_space());
+      iterator_ = new HeapObjectIterator(Heap::old_data_space(), size_func_);
       break;
     case CODE_SPACE:
-      iterator_ = new HeapObjectIterator(Heap::code_space());
+      iterator_ = new HeapObjectIterator(Heap::code_space(), size_func_);
       break;
     case MAP_SPACE:
-      iterator_ = new HeapObjectIterator(Heap::map_space());
+      iterator_ = new HeapObjectIterator(Heap::map_space(), size_func_);
       break;
     case CELL_SPACE:
-      iterator_ = new HeapObjectIterator(Heap::cell_space());
+      iterator_ = new HeapObjectIterator(Heap::cell_space(), size_func_);
       break;
     case LO_SPACE:
-      iterator_ = new LargeObjectIterator(Heap::lo_space());
+      iterator_ = new LargeObjectIterator(Heap::lo_space(), size_func_);
       break;
   }
 
   // Return the newly allocated iterator;
   ASSERT(iterator_ != NULL);
   return iterator_;
 }
 
 
-HeapIterator::HeapIterator() {
+class FreeListNodesFilter : public Malloced {
+ public:
+  FreeListNodesFilter() {
+    MarkFreeListNodes();
+  }
+
+  inline bool IsFreeListNode(HeapObject* object) {
+    if (object->IsMarked()) {
+      object->ClearMark();
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  static int ObjectSize(HeapObject* object) {
+    bool marked = object->IsMarked();

[antonm, 2010/11/13 17:37:51]

MapWord might be the right abstraction for this code, see for example
CountMarkedCallback in mark-compact.cc.  BTW, you could probably just reuse it
here.

[mnaganov (inactive), 2010/11/13 19:05:30]

Hm. Not sure how using MapWord will help. HeapObject's 'IsMarked', 'SetMark',
and 'ClearMark' delegate to MapWord.

Why I need to have this function is because ObjectIterators need to get the
object size before they return pointer to it. And they will crash if map pointer
will be marked. And I need to restore marking back because I will need to check
it later via IsFreeListNode.

+    if (marked)

[antonm, 2010/11/13 17:37:51]

nit: either on a single line or in braces, please

[mnaganov (inactive), 2010/11/13 19:05:30]

Done.

+      object->ClearMark();
+    int size = object->Size();
+    if (marked)

[antonm, 2010/11/13 17:37:51]

ditto

[mnaganov (inactive), 2010/11/13 19:05:30]

Done.

+      object->SetMark();
+    return size;
+  }
+
+ private:
+  void MarkFreeListNodes() {
+    Heap::old_pointer_space()->MarkFreeListNodes();
+    Heap::old_data_space()->MarkFreeListNodes();
+    MarkCodeSpaceFreeListNodes();
+    Heap::map_space()->MarkFreeListNodes();
+    Heap::cell_space()->MarkFreeListNodes();
+  }
+
+  void MarkCodeSpaceFreeListNodes() {
+    // For code space, using FreeListNode::IsFreeListNode is OK.
+    ObjectIterator* iter = new HeapObjectIterator(Heap::code_space());

[antonm, 2010/11/13 17:37:51]

why you need to malloc iterator?  can you allocate it on the stack?

[mnaganov (inactive), 2010/11/13 19:05:30]

Not sure. It is a descendant of the class Malloced.

+    for (HeapObject* obj = iter->next_object();
+         obj != NULL;
+         obj = iter->next_object()) {
+      if (FreeListNode::IsFreeListNode(obj))

[antonm, 2010/11/13 17:37:51]

ditto for braces

[mnaganov (inactive), 2010/11/13 19:05:30]

Done.

+        obj->SetMark();
+    }
+    delete iter;
+  }
+};
+
+
+HeapIterator::HeapIterator()
+    : filtering_(HeapIterator::kNoFiltering),
+      filter_(NULL) {
   Init();
 }
 
+
+HeapIterator::HeapIterator(HeapIterator::FreeListNodesFiltering filtering)
+    : filtering_(filtering),
+      filter_(NULL) {
+  Init();
+}
+
 
 HeapIterator::~HeapIterator() {
   Shutdown();
 }
 
 
 void HeapIterator::Init() {
   // Start the iteration.
-  space_iterator_ = new SpaceIterator();
+  if (filtering_ == kPreciseFiltering) {
+    filter_ = new FreeListNodesFilter();

[antonm, 2010/11/13 17:37:51]

looks like new trend is to omit () for ctors with no args

[mnaganov (inactive), 2010/11/13 19:05:30]

Done.

+    space_iterator_ = new SpaceIterator(FreeListNodesFilter::ObjectSize);
+  } else {
+    space_iterator_ = new SpaceIterator();

[antonm, 2010/11/13 17:37:51]

ditto

[mnaganov (inactive), 2010/11/13 19:05:30]

Done.

+  }
   object_iterator_ = space_iterator_->next();
 }
 
 
 void HeapIterator::Shutdown() {
   // Make sure the last iterator is deallocated.
   delete space_iterator_;
   space_iterator_ = NULL;
   object_iterator_ = NULL;
+  delete filter_;
+  filter_ = NULL;
 }
 
 
 HeapObject* HeapIterator::next() {
+  if (filter_ == NULL)

[antonm, 2010/11/13 17:37:51]

ditto for braces (here and below)

[mnaganov (inactive), 2010/11/13 19:05:30]

Done.

+    return NextObject();
+
+  HeapObject* obj = NextObject();
+  while (obj != NULL && filter_->IsFreeListNode(obj))
+    obj = NextObject();
+  return obj;
+}
+
+
+HeapObject* HeapIterator::NextObject() {
   // No iterator means we are done.
   if (object_iterator_ == NULL) return NULL;
 
   if (HeapObject* obj = object_iterator_->next_object()) {
     // If the current iterator has more objects we are fine.
     return obj;
   } else {
     // Go though the spaces looking for one that has objects.
     while (space_iterator_->has_next()) {
       object_iterator_ = space_iterator_->next();
@@ skipping 421 matching lines @@
 void ExternalStringTable::TearDown() {
   new_space_strings_.Free();
   old_space_strings_.Free();
 }
 
 
 List<Object*> ExternalStringTable::new_space_strings_;
 List<Object*> ExternalStringTable::old_space_strings_;
 
 } }  // namespace v8::internal