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

src/spaces.h

 // 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 1268 matching lines @@
 
   static inline bool IsFreeListNode(HeapObject* object);
 
   // Set the size in bytes, which can be read with HeapObject::Size().  This
   // function also writes a map to the first word of the block so that it
   // looks like a heap object to the garbage collector and heap iteration
   // functions.
   void set_size(Heap* heap, int size_in_bytes);
 
   // Accessors for the next field.
-  inline FreeListNode* next();
+  FreeListNode* next();
   inline FreeListNode** next_address();
   inline void set_next(FreeListNode* next);
 
   inline void Zap();
 
  private:
   static const int kNextOffset = POINTER_SIZE_ALIGN(FreeSpace::kHeaderSize);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(FreeListNode);
 };
@@ skipping 44 matching lines @@
   // is unitialized.  A failure is returned if no block is available.  The
   // number of bytes lost to fragmentation is returned in the output parameter
   // 'wasted_bytes'.  The size should be a non-zero multiple of the word size.
   MUST_USE_RESULT HeapObject* Allocate(int size_in_bytes);
 
   void MarkNodes();
 
 #ifdef DEBUG
   void Zap();
   static intptr_t SumFreeList(FreeListNode* node);
-  static int FreeListLength(FreeListNode* cur);
   intptr_t SumFreeLists();
-  bool IsVeryLong();
 #endif
 
+  static int FreeListLength(FreeListNode* cur);
+  bool IsVeryLong();
   void CountFreeListItems(Page* p, intptr_t* sizes);
 
+  FreeListNode* get_chain(int i) {

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

make enum!

+    switch (i) {
+      case 0: return small_list_;
+      case 1: return medium_list_;
+      case 2: return large_list_;
+      case 3: return huge_list_;
+    }
+    UNREACHABLE();
+    return NULL;
+  }
+  static const int kNumberOfChains = 4;
+
  private:
   // The size range of blocks, in bytes.
   static const int kMinBlockSize = 3 * kPointerSize;
   static const int kMaxBlockSize = Page::kMaxHeapObjectSize;
 
   FreeListNode* PickNodeFromList(FreeListNode** list, int* node_size);
 
   FreeListNode* FindNodeFor(int size_in_bytes, int* node_size);
 
   PagedSpace* owner_;
@@ skipping 108 matching lines @@
   // If add_to_freelist is false then just accounting stats are updated and
   // no attempt to add area to free list is made.
   int Free(Address start, int size_in_bytes) {
     int wasted = free_list_.Free(start, size_in_bytes);
     accounting_stats_.DeallocateBytes(size_in_bytes - wasted);
     return size_in_bytes - wasted;
   }
 
   int FreeOrUnmapPage(Page* page, Address start, int size_in_bytes);
 
+  void VisualizeTopChange(Address top);
+
   // Set space allocation info.
-  void SetTop(Address top, Address limit) {
-    ASSERT(top == limit ||
-           Page::FromAddress(top) == Page::FromAddress(limit - 1));
-    allocation_info_.top = top;
-    allocation_info_.limit = limit;
-  }
+  inline void SetTop(Address top, Address limit);
 
   void Allocate(int bytes) {
     accounting_stats_.AllocateBytes(bytes);
   }
 
   void IncreaseCapacity(int size) {
     accounting_stats_.ExpandSpace(size);
   }
 
   // Releases half of unused pages.
@@ skipping 77 matching lines @@
     }
 
     return (ratio > ratio_threshold) ||
         (FLAG_always_compact && sizes[3] != Page::kObjectAreaSize);
   }
 
   void EvictEvacuationCandidatesFromFreeLists();
 
   bool CanExpand();
 
+  FreeList* free_list() { return &free_list_; }
+
  protected:
   // Maximum capacity of this space.
   intptr_t max_capacity_;
 
   // Accounting information for this space.
   AllocationStats accounting_stats_;
 
   // The dummy page that anchors the double linked list of pages.
   Page anchor_;
 
   // The space's free list.
   FreeList free_list_;
 
   // Normal allocation information.
   AllocationInfo allocation_info_;
 
+  Address last_visualized_top_;
+
   // Bytes of each page that cannot be allocated.  Possibly non-zero
   // for pages in spaces with only fixed-size objects.  Always zero
   // for pages in spaces with variable sized objects (those pages are
   // padded with free-list nodes).
   int page_extra_;
 
   bool was_swept_conservatively_;
 
   Page* first_unswept_page_;
   Page* last_unswept_page_;
@@ skipping 91 matching lines @@
     return reinterpret_cast<SemiSpace*>(owner());
   }
 
   bool is_anchor() { return !this->InNewSpace(); }
 
   static bool IsAtStart(Address addr) {
     return (reinterpret_cast<intptr_t>(addr) & Page::kPageAlignmentMask)
         == kObjectStartOffset;
   }
 
+  Address ObjectAreaStart() {
+    return address() + kObjectStartOffset;
+  }
+
+  Address ObjectAreaEnd() {
+    return address() + Page::kPageSize;
+  }
+
   static bool IsAtEnd(Address addr) {
     return (reinterpret_cast<intptr_t>(addr) & Page::kPageAlignmentMask) == 0;
   }
 
   Address address() {
     return reinterpret_cast<Address>(this);
   }
 
   // Finds the NewSpacePage containg the given address.
   static inline NewSpacePage* FromAddress(Address address_in_page) {
@@ skipping 288 matching lines @@
 // forwards most functions to the appropriate semispace.
 
 class NewSpace : public Space {
  public:
   // Constructor.
   explicit NewSpace(Heap* heap)
     : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
       to_space_(heap, kToSpace),
       from_space_(heap, kFromSpace),
       reservation_(),
-      inline_allocation_limit_step_(0) {}
+      inline_allocation_limit_step_(0),
+      last_visualized_top_(NULL) {}
 
   // Sets up the new space using the given chunk.
   bool Setup(int reserved_semispace_size_, int max_semispace_size);
 
   // Tears down the space.  Heap memory was not allocated by the space, so it
   // is not deallocated here.
   void TearDown();
 
   // True if the space has been set up but not torn down.
   bool HasBeenSetup() {
     return to_space_.HasBeenSetup() && from_space_.HasBeenSetup();
   }
 
   // Flip the pair of spaces.
   void Flip();
 
+  void VisualizeTop();
+  void VisualizeUnallocation(SemiSpace* semispace);
+
   // Grow the capacity of the semispaces.  Assumes that they are not at
   // their maximum capacity.
   void Grow();
 
   // Shrink the capacity of the semispaces.
   void Shrink();
 
   // True if the address or object lies in the address range of either
   // semispace (not necessarily below the allocation pointer).
   bool Contains(Address a) {
@@ skipping 56 matching lines @@
   // Return the address of the allocation pointer in the active semispace.
   Address top() {
     ASSERT(to_space_.current_page()->ContainsLimit(allocation_info_.top));
     return allocation_info_.top;
   }
   // Return the address of the first object in the active semispace.
   Address bottom() { return to_space_.space_start(); }
 
   // Get the age mark of the inactive semispace.
   Address age_mark() { return from_space_.age_mark(); }
+  // Get the age mark of the active semispace.
+  Address to_space_age_mark() { return to_space_.age_mark(); }
   // Set the age mark in the active semispace.
   void set_age_mark(Address mark) { to_space_.set_age_mark(mark); }
 
   // The start address of the space and a bit mask. Anding an address in the
   // new space with the mask will result in the start address.
   Address start() { return start_; }
   uintptr_t mask() { return address_mask_; }
 
   INLINE(uint32_t AddressToMarkbitIndex(Address addr)) {
     ASSERT(Contains(addr));
@@ skipping 131 matching lines @@
   // to be lower than actual limit and then will gradually increase it
   // in steps to guarantee that we do incremental marking steps even
   // when all allocation is performed from inlined generated code.
   intptr_t inline_allocation_limit_step_;
 
   Address top_on_previous_step_;
 
   HistogramInfo* allocated_histogram_;
   HistogramInfo* promoted_histogram_;
 
+  Address last_visualized_top_;
+
   // Implementation of AllocateRaw.
   MUST_USE_RESULT inline MaybeObject* AllocateRawInternal(int size_in_bytes);
 
   friend class SemiSpaceIterator;
 
  public:
   TRACK_MEMORY("NewSpace")
 };
 
 
@@ skipping 327 matching lines @@
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_