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;
       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 {

[Vyacheslav Egorov (Chromium), 2010/11/15 09:33:21]

Is it really necessary to separate this class from HeapIterator and malloc it?

[mnaganov (inactive), 2010/11/15 10:36:17]

I made it separate from HeapIterator because it's a helper class, and even its
declaration isn't needed outside. But it's a part of HeapIterator's state, so I
needed to put it inside HeapIterator. My solution is to forward-declare it in
heap.h.

OK, it's not necessary to make it a subclass of Malloced.

+ public:
+  FreeListNodesFilter() {
+    MarkFreeListNodes();
+  }
+
+  inline bool IsFreeListNode(HeapObject* object) {
+    if (object->IsMarked()) {
+      object->ClearMark();
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  static int ObjectSize(HeapObject* object) {

[Vyacheslav Egorov (Chromium), 2010/11/15 09:33:21]

There is CountMarkedCallback which does exactly what you need but better (saves
two memory writes).

map_word.ClearMark() does not clear mark in object's map word. map_word is a
value type.

[mnaganov (inactive), 2010/11/15 10:36:17]

Oh, you are right. I didn't noticed that MapWord is a value type. I made
CountMarkedCallback public in MarkCompactCollector and renamed it to
SizeOfMarkedObject.

+    bool marked = object->IsMarked();
+    if (marked) object->ClearMark();
+    int size = object->Size();
+    if (marked) 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());

[Vyacheslav Egorov (Chromium), 2010/11/15 09:33:21]

I think there is no need to use new here.

[mnaganov (inactive), 2010/11/15 10:36:17]

Done.

+    for (HeapObject* obj = iter->next_object();
+         obj != NULL;
+         obj = iter->next_object()) {
+      if (FreeListNode::IsFreeListNode(obj)) 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();

[Vyacheslav Egorov (Chromium), 2010/11/15 09:33:21]

You should assert here that iteration was not interrupted to guarantee that heap
was not left in inconsistent state.

[mnaganov (inactive), 2010/11/15 10:36:17]

Done.

 }
 
 
 void HeapIterator::Init() {
   // Start the iteration.
-  space_iterator_ = new SpaceIterator();
+  if (filtering_ == kPreciseFiltering) {
+    filter_ = new FreeListNodesFilter;

[Vyacheslav Egorov (Chromium), 2010/11/15 09:33:21]

It would be cool to forbid allocation/gc while precise HeapIterator is alive.

[mnaganov (inactive), 2010/11/15 10:36:17]

I've included AssertNoAllocation into FreeListNodesFilter.

+    space_iterator_ = new SpaceIterator(FreeListNodesFilter::ObjectSize);
+  } else {
+    space_iterator_ = new SpaceIterator;
+  }
   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) 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