Add counters to track the maximum amount of memory committed by the heap.

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 1335 matching lines @@
 // functions increase or decrease one of the non-capacity stats in
 // conjunction with capacity, or else they always balance increases and
 // decreases to the non-capacity stats.
 class AllocationStats BASE_EMBEDDED {
  public:
   AllocationStats() { Clear(); }
 
   // Zero out all the allocation statistics (i.e., no capacity).
   void Clear() {
     capacity_ = 0;
+    max_capacity_ = 0;
     size_ = 0;
     waste_ = 0;
   }
 
   void ClearSizeWaste() {
     size_ = capacity_;
     waste_ = 0;
   }
 
   // Reset the allocation statistics (i.e., available = capacity with no
   // wasted or allocated bytes).
   void Reset() {
     size_ = 0;
     waste_ = 0;
   }
 
   // Accessors for the allocation statistics.
   intptr_t Capacity() { return capacity_; }
+  intptr_t MaxCapacity() { return max_capacity_; }
   intptr_t Size() { return size_; }
   intptr_t Waste() { return waste_; }
 
   // Grow the space by adding available bytes.  They are initially marked as
   // being in use (part of the size), but will normally be immediately freed,
   // putting them on the free list and removing them from size_.
   void ExpandSpace(int size_in_bytes) {
     capacity_ += size_in_bytes;
     size_ += size_in_bytes;
+    if (capacity_ > max_capacity_) {
+      max_capacity_ = capacity_;
+    }
     ASSERT(size_ >= 0);
   }
 
   // Shrink the space by removing available bytes.  Since shrinking is done
   // during sweeping, bytes have been marked as being in use (part of the size)
   // and are hereby freed.
   void ShrinkSpace(int size_in_bytes) {
     capacity_ -= size_in_bytes;
     size_ -= size_in_bytes;
     ASSERT(size_ >= 0);
@@ skipping 13 matching lines @@
 
   // Waste free bytes (available -> waste).
   void WasteBytes(int size_in_bytes) {
     size_ -= size_in_bytes;
     waste_ += size_in_bytes;
     ASSERT(size_ >= 0);
   }
 
  private:
   intptr_t capacity_;
+  intptr_t max_capacity_;
   intptr_t size_;
   intptr_t waste_;
 };
 
 
 // -----------------------------------------------------------------------------
 // Free lists for old object spaces
 //
 // Free-list nodes are free blocks in the heap.  They look like heap objects
 // (free-list node pointers have the heap object tag, and they have a map like
@@ skipping 221 matching lines @@
   // Prepares for a mark-compact GC.
   virtual void PrepareForMarkCompact();
 
   // Current capacity without growing (Size() + Available()).
   intptr_t Capacity() { return accounting_stats_.Capacity(); }
 
   // Total amount of memory committed for this space.  For paged
   // spaces this equals the capacity.
   intptr_t CommittedMemory() { return Capacity(); }
 
+  // The maximum amount of memory ever committed for this space.
+  intptr_t MaximumCommittedMemory() { return accounting_stats_.MaxCapacity(); }
+
   // Approximate amount of physical memory committed for this space.
   size_t CommittedPhysicalMemory();
 
   struct SizeStats {
     intptr_t Total() {
       return small_size_ + medium_size_ + large_size_ + huge_size_;
     }
 
     intptr_t small_size_;
     intptr_t medium_size_;
@@ skipping 80 matching lines @@
            Page::FromAddress(top) == Page::FromAddress(limit - 1));
     MemoryChunk::UpdateHighWaterMark(allocation_info_.top);
     allocation_info_.top = top;
     allocation_info_.limit = limit;
   }
 
   void Allocate(int bytes) {
     accounting_stats_.AllocateBytes(bytes);
   }
 
-  void IncreaseCapacity(int size) {
-    accounting_stats_.ExpandSpace(size);
-  }
+  void IncreaseCapacity(int size);
 
   // Releases an unused page and shrinks the space.
   void ReleasePage(Page* page, bool unlink);
 
   // The dummy page that anchors the linked list of pages.
   Page* anchor() { return &anchor_; }
 
 #ifdef VERIFY_HEAP
   // Verify integrity of this space.
   virtual void Verify(ObjectVisitor* visitor);
@@ skipping 389 matching lines @@
   // Returns the maximum capacity of the semi space.
   int MaximumCapacity() { return maximum_capacity_; }
 
   // Returns the initial capacity of the semi space.
   int InitialCapacity() { return initial_capacity_; }
 
   SemiSpaceId id() { return id_; }
 
   static void Swap(SemiSpace* from, SemiSpace* to);
 
+  // Returns the maximum amount of memory ever committed by the semi space.
+  size_t MaximumCommittedMemory() { return maximum_committed_; }
+
   // Approximate amount of physical memory committed for this space.
   size_t CommittedPhysicalMemory();
 
  private:
   // Flips the semispace between being from-space and to-space.
   // Copies the flags into the masked positions on all pages in the space.
   void FlipPages(intptr_t flags, intptr_t flag_mask);
 
   NewSpacePage* anchor() { return &anchor_; }
 
   // The current and maximum capacity of the space.
   int capacity_;
   int maximum_capacity_;
   int initial_capacity_;
 
+  intptr_t maximum_committed_;
+
   // The start address of the space.
   Address start_;
   // Used to govern object promotion during mark-compact collection.
   Address age_mark_;
 
   // Masks and comparison values to test for containment in this semispace.
   uintptr_t address_mask_;
   uintptr_t object_mask_;
   uintptr_t object_expected_;
 
@@ skipping 165 matching lines @@
     ASSERT(to_space_.Capacity() == from_space_.Capacity());
     return to_space_.Capacity();
   }
 
   // Return the total amount of memory committed for new space.
   intptr_t CommittedMemory() {
     if (from_space_.is_committed()) return 2 * Capacity();
     return Capacity();
   }
 
+  // Return the total amount of memory committed for new space.
+  intptr_t MaximumCommittedMemory() {
+    ASSERT(to_space_.MaximumCommittedMemory() ==
+        from_space_.MaximumCommittedMemory());

[Benedikt Meurer, 2013/10/22 11:44:10]

Nit: indentation

[rmcilroy, 2013/10/23 14:40:23]

Done.

+    return 2 * to_space_.MaximumCommittedMemory();
+  }
+
   // Approximate amount of physical memory committed for this space.
   size_t CommittedPhysicalMemory();
 
   // Return the available bytes without growing.
   intptr_t Available() {
     return Capacity() - Size();
   }
 
   // Return the maximum capacity of a semispace.
   int MaximumCapacity() {
@@ skipping 362 matching lines @@
   inline intptr_t Available();
 
   virtual intptr_t Size() {
     return size_;
   }
 
   virtual intptr_t SizeOfObjects() {
     return objects_size_;
   }
 
+  intptr_t MaximumCommittedMemory() {
+    return maximum_committed_;
+  }
+
   intptr_t CommittedMemory() {
     return Size();
   }
 
   // Approximate amount of physical memory committed for this space.
   size_t CommittedPhysicalMemory();
 
   int PageCount() {
     return page_count_;
   }
@@ skipping 31 matching lines @@
   virtual void Print();
   void ReportStatistics();
   void CollectCodeStatistics();
 #endif
   // Checks whether an address is in the object area in this space.  It
   // iterates all objects in the space. May be slow.
   bool SlowContains(Address addr) { return !FindObject(addr)->IsFailure(); }
 
  private:
   intptr_t max_capacity_;
+  intptr_t maximum_committed_;
   // The head of the linked list of large object chunks.
   LargePage* first_page_;
   intptr_t size_;  // allocated bytes
   int page_count_;  // number of chunks
   intptr_t objects_size_;  // size of objects
   // Map MemoryChunk::kAlignment-aligned chunks to large pages covering them
   HashMap chunk_map_;
 
   friend class LargeObjectIterator;
 
@@ skipping 91 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_