Add experimental support for tracing the state of the VM heap to a file

src/spaces.cc

 // Copyright 2011 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 426 matching lines @@
   chunk->initialize_scan_on_scavenge(false);
   chunk->SetFlag(WAS_SWEPT_PRECISELY);
 
   ASSERT(OFFSET_OF(MemoryChunk, flags_) == kFlagsOffset);
   ASSERT(OFFSET_OF(MemoryChunk, live_byte_count_) == kLiveBytesOffset);
 
   if (executable == EXECUTABLE) chunk->SetFlag(IS_EXECUTABLE);
 
   if (owner == heap->old_data_space()) chunk->SetFlag(CONTAINS_ONLY_DATA);
 
+  if (owner != NULL) {

[Vyacheslav Egorov (Chromium), 2011/09/28 15:21:11]

Move out of the spaces.cc to some visualizer specific place and keep only a call
to this function here.

Just to keep things isolated with a small interface like we do with GDBJIT or
profiler.

+    for (HeapVisualizer* vis = heap->visualizer();
+         vis != NULL;
+         vis = vis->next()) {
+      int space_id = executable ? CODE_SPACE : owner->identity();
+      vis->Name(space_id,
+                reinterpret_cast<uintptr_t>(chunk->body()),
+                size - (chunk->body() - chunk->address()));
+      vis->Name(HeapVisualizer::kHeapOverheadPseudoSpaceIdentity,
+                reinterpret_cast<uintptr_t>(base),
+                (chunk->body() - chunk->address()));
+      if (owner == heap->lo_space()) {
+        // Large pages are all allocated all the time, no need to track.
+        vis->ConstantAllocation(reinterpret_cast<uintptr_t>(base), size, 0);
+      }
+    }
+  }
+
   return chunk;
 }
 
 
 void MemoryChunk::InsertAfter(MemoryChunk* other) {
   next_chunk_ = other->next_chunk_;
   prev_chunk_ = other;
   other->next_chunk_->prev_chunk_ = this;
   other->next_chunk_ = this;
 }
 
 
 void MemoryChunk::Unlink() {
   if (!InNewSpace() && IsFlagSet(SCAN_ON_SCAVENGE)) {
     heap_->decrement_scan_on_scavenge_pages();
     ClearFlag(SCAN_ON_SCAVENGE);
   }
+  for (HeapVisualizer* vis = heap_->visualizer();
+       vis != NULL;

[Vyacheslav Egorov (Chromium), 2011/09/28 15:21:11]

ditto

+       vis = vis->next()) {
+    vis->ConstantAllocation(reinterpret_cast<uintptr_t>(address()),
+                            size(),
+                            255);
+  }
   next_chunk_->prev_chunk_ = prev_chunk_;
   prev_chunk_->next_chunk_ = next_chunk_;
   prev_chunk_ = NULL;
   next_chunk_ = NULL;
 }
 
 
 MemoryChunk* MemoryAllocator::AllocateChunk(intptr_t body_size,
                                             Executability executable,
                                             Space* owner) {
@@ skipping 185 matching lines @@
 
 // -----------------------------------------------------------------------------
 // PagedSpace implementation
 
 PagedSpace::PagedSpace(Heap* heap,
                        intptr_t max_capacity,
                        AllocationSpace id,
                        Executability executable)
     : Space(heap, id, executable),
       free_list_(this),
+      last_visualized_top_(NULL),
       was_swept_conservatively_(false),
       first_unswept_page_(Page::FromAddress(NULL)),
       last_unswept_page_(Page::FromAddress(NULL)) {
   max_capacity_ = (RoundDown(max_capacity, Page::kPageSize) / Page::kPageSize)
                   * Page::kObjectAreaSize;
   accounting_stats_.Clear();
 
-  allocation_info_.top = NULL;
-  allocation_info_.limit = NULL;
+  SetTop(NULL, NULL);
 
   anchor_.InitializeAsAnchor(this);
 }
 
 
 bool PagedSpace::Setup() {
   return true;
 }
 
 
@@ skipping 215 matching lines @@
   LOG(heap()->isolate(), DeleteEvent("InitialChunk", chunk_base_));
 
   ASSERT(reservation_.IsReserved());
   heap()->isolate()->memory_allocator()->FreeMemory(&reservation_,
                                                     NOT_EXECUTABLE);
   chunk_base_ = NULL;
   chunk_size_ = 0;
 }
 
 
+void NewSpace::VisualizeUnallocation(SemiSpace* semispace) {
+  for (NewSpacePage* page = semispace->first_page();
+       !page->is_anchor();

[Vyacheslav Egorov (Chromium), 2011/09/28 15:21:11]

ditto

+       page = page->next_page()) {
+    uint32_t address = reinterpret_cast<uintptr_t>(page->ObjectAreaStart());
+    uintptr_t end = reinterpret_cast<uintptr_t>(page->ObjectAreaEnd());
+    for (HeapVisualizer* vis = heap()->visualizer();
+         vis != NULL;
+         vis = vis->next()) {
+      vis->ConstantAllocation(address, end - address, 255);
+    }
+  }
+}
+
+
+void NewSpace::VisualizeTop() {
+  if (last_visualized_top_ != NULL) {
+    uintptr_t last = reinterpret_cast<uintptr_t>(last_visualized_top_);
+    uintptr_t next = reinterpret_cast<uintptr_t>(allocation_info_.top);
+    for (HeapVisualizer* vis = heap()->visualizer();
+         vis != NULL;
+         vis = vis->next()) {
+      int pix = vis->pixel_size_log_2();
+      if (next >> pix != last >> pix) {
+        vis->ConstantAllocation(
+            last, ((next >> pix) - (last >> pix)) << pix, 0);
+      }
+    }
+  }
+  last_visualized_top_ = allocation_info_.top;
+}
+
+
 void NewSpace::Flip() {
+  VisualizeUnallocation(&to_space_);
   SemiSpace::Swap(&from_space_, &to_space_);
 }
 
 
 void NewSpace::Grow() {
   // Double the semispace size but only up to maximum capacity.
   ASSERT(Capacity() < MaximumCapacity());
   int new_capacity = Min(MaximumCapacity(), 2 * static_cast<int>(Capacity()));
   if (to_space_.GrowTo(new_capacity)) {
     // Only grow from space if we managed to grow to-space.
@@ skipping 30 matching lines @@
   }
   allocation_info_.limit = to_space_.page_high();
   ASSERT_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
 }
 
 
 void NewSpace::UpdateAllocationInfo() {
   allocation_info_.top = to_space_.page_low();
   allocation_info_.limit = to_space_.page_high();
 
+  last_visualized_top_ = allocation_info_.top;
+
   // Lower limit during incremental marking.
   if (heap()->incremental_marking()->IsMarking() &&
       inline_allocation_limit_step() != 0) {
     Address new_limit =
         allocation_info_.top + inline_allocation_limit_step();
     allocation_info_.limit = Min(new_limit, allocation_info_.limit);
   }
   ASSERT_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
 }
 
@@ skipping 21 matching lines @@
     // from happening (all such allocations should go directly to LOSpace).
     return false;
   }
   if (!to_space_.AdvancePage()) {
     // Failed to get a new page in to-space.
     return false;
   }
   // Clear remainder of current page.
   int remaining_in_page =
     static_cast<int>(NewSpacePage::FromLimit(top)->body_limit() - top);
+  VisualizeTop();
   heap()->CreateFillerObjectAt(top, remaining_in_page);
   pages_used_++;
   UpdateAllocationInfo();
   return true;
 }
 
 
 #ifdef DEBUG
 // We do not use the SemiSpaceIterator because verification doesn't assume
 // that it works (it depends on the invariants we are checking).
@@ skipping 803 matching lines @@
   } else {
     // TODO(gc) Try not freeing linear allocation region when bytes_left
     // are zero.
     owner_->SetTop(NULL, NULL);
   }
 
   return new_node;
 }
 
 
+void PagedSpace::VisualizeTopChange(Address new_top) {
+  if (heap()->has_visualizer()) {
+    if (last_visualized_top_ == NULL) {
+      last_visualized_top_ = new_top;
+      return;
+    }
+    uintptr_t last = reinterpret_cast<uintptr_t>(last_visualized_top_);
+    uintptr_t next = reinterpret_cast<uintptr_t>(allocation_info_.top);
+    ASSERT(next >= last);
+    if (next > last) {
+      for (HeapVisualizer* vis = heap()->visualizer();
+           vis != NULL;
+           vis = vis->next()) {
+        int bits = vis->pixel_size_log_2();
+        uintptr_t last_pixel = last >> bits;
+        uintptr_t next_pixel = next >> bits;
+        if ((last_pixel << bits) != last) {
+          if (next_pixel == last_pixel) {
+            vis->ChangeAllocation(last, next - last);
+            continue;
+          }
+          last_pixel++;
+          vis->ChangeAllocation(last, (last_pixel << bits) - last);
+          last = last_pixel << bits;
+        }
+        if (next_pixel > last_pixel) {
+          vis->ConstantAllocation(last_pixel << bits,
+                                  (next_pixel - last_pixel) << bits,
+                                  0);
+        }
+        if (last_pixel << bits != last) {
+          vis->ChangeAllocation(last, (last_pixel << bits) - last);
+        }
+      }
+    }
+  }
+  last_visualized_top_ = new_top;
+}
+
+
 static intptr_t CountFreeListItemsInList(FreeListNode* n, Page* p) {
   intptr_t sum = 0;
   while (n != NULL) {
     if (Page::FromAddress(n->address()) == p) {
       FreeSpace* free_space = reinterpret_cast<FreeSpace*>(n);
       sum += free_space->Size();
     }
     n = n->next();
   }
   return sum;
@@ skipping 13 matching lines @@
   while (cur != NULL) {
     ASSERT(cur->map() == HEAP->raw_unchecked_free_space_map());
     FreeSpace* cur_as_free_space = reinterpret_cast<FreeSpace*>(cur);
     sum += cur_as_free_space->Size();
     cur = cur->next();
   }
   return sum;
 }
 
 
+// This can take a very long time because it is linear in the number of entries
+// on the free list, so it should not be called if FreeListLength returns
+// kVeryLongFreeList.
+intptr_t FreeList::SumFreeLists() {
+  intptr_t sum = SumFreeList(small_list_);
+  sum += SumFreeList(medium_list_);
+  sum += SumFreeList(large_list_);
+  sum += SumFreeList(huge_list_);
+  return sum;
+}
+#endif
+
+
 static const int kVeryLongFreeList = 500;
 
 
 int FreeList::FreeListLength(FreeListNode* cur) {
   int length = 0;
   while (cur != NULL) {
     length++;
     cur = cur->next();
     if (length == kVeryLongFreeList) return length;
   }
   return length;
 }
 
 
 bool FreeList::IsVeryLong() {
   if (FreeListLength(small_list_) == kVeryLongFreeList) return  true;
   if (FreeListLength(medium_list_) == kVeryLongFreeList) return  true;
   if (FreeListLength(large_list_) == kVeryLongFreeList) return  true;
   if (FreeListLength(huge_list_) == kVeryLongFreeList) return  true;
   return false;
 }
 
 
-// This can take a very long time because it is linear in the number of entries
-// on the free list, so it should not be called if FreeListLength returns
-// kVeryLongFreeList.
-intptr_t FreeList::SumFreeLists() {
-  intptr_t sum = SumFreeList(small_list_);
-  sum += SumFreeList(medium_list_);
-  sum += SumFreeList(large_list_);
-  sum += SumFreeList(huge_list_);
-  return sum;
-}
-#endif
-
-
 // -----------------------------------------------------------------------------
 // OldSpace implementation
 
 bool NewSpace::ReserveSpace(int bytes) {
   // We can't reliably unpack a partial snapshot that needs more new space
   // space than the minimum NewSpace size.
   ASSERT(bytes <= InitialCapacity());
   Address limit = allocation_info_.limit;
   Address top = allocation_info_.top;
   return limit - top >= bytes;
@@ skipping 98 matching lines @@
 
 void PagedSpace::EvictEvacuationCandidatesFromFreeLists() {
   if (allocation_info_.top >= allocation_info_.limit) return;
 
   if (Page::FromAddress(allocation_info_.top)->IsEvacuationCandidate()) {
     // Create filler object to keep page iterable if it was iterable.
     int remaining =
         static_cast<int>(allocation_info_.limit - allocation_info_.top);
     heap()->CreateFillerObjectAt(allocation_info_.top, remaining);
 
-    allocation_info_.top = NULL;
-    allocation_info_.limit = NULL;
+    SetTop(NULL, NULL);
   }
 }
 
 
 HeapObject* PagedSpace::SlowAllocateRaw(int size_in_bytes) {
   // Allocation in this space has failed.
 
   // Free list allocation failed and there is no next page.  Fail if we have
   // hit the old generation size limit that should cause a garbage
   // collection.
@@ skipping 486 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal