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

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 1104 matching lines @@
 
 void PagedSpace::ResetFreeListStatistics() {
   PageIterator page_iterator(this);
   while (page_iterator.has_next()) {
     Page* page = page_iterator.next();
     page->ResetFreeListStatistics();
   }
 }
 
 
+void PagedSpace::IncreaseCapacity(int size) {
+  accounting_stats_.ExpandSpace(size);
+  heap()->UpdateMaximumCommitted();

[Hannes Payer (out of office), 2013/10/22 14:46:07]

Instead of calling heap()->UpdateMaximumCommitted() on every update to a given
space, why don't we call it at the end of a GC? I guess it would make sense to
find a single place in the code.

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

The heap size can be increased when there is no GC happening.  If we only did
this at GC time we would miss the potential maximum overall heap size wouldn't
we?

[Hannes Payer (out of office), 2013/10/24 08:12:35]

Beginning of GC is what I meant, that should be fine, right?

[rmcilroy, 2013/10/24 16:34:31]

Done.

+}
+
+
 void PagedSpace::ReleasePage(Page* page, bool unlink) {
   ASSERT(page->LiveBytes() == 0);
   ASSERT(AreaSize() == page->area_size());
 
   // Adjust list of unswept pages if the page is the head of the list.
   if (first_unswept_page_ == page) {
     first_unswept_page_ = page->next_page();
     if (first_unswept_page_ == anchor()) {
       first_unswept_page_ = Page::FromAddress(NULL);
     }
@@ skipping 367 matching lines @@
   // Creates a space in the young generation. The constructor does not
   // allocate memory from the OS.  A SemiSpace is given a contiguous chunk of
   // memory of size 'capacity' when set up, and does not grow or shrink
   // otherwise.  In the mark-compact collector, the memory region of the from
   // space is used as the marking stack. It requires contiguous memory
   // addresses.
   ASSERT(maximum_capacity >= Page::kPageSize);
   initial_capacity_ = RoundDown(initial_capacity, Page::kPageSize);
   capacity_ = initial_capacity;
   maximum_capacity_ = RoundDown(maximum_capacity, Page::kPageSize);
+  maximum_committed_ = 0;
   committed_ = false;
   start_ = start;
   address_mask_ = ~(maximum_capacity - 1);
   object_mask_ = address_mask_ | kHeapObjectTagMask;
   object_expected_ = reinterpret_cast<uintptr_t>(start) | kHeapObjectTag;
   age_mark_ = start_;
 }
 
 
 void SemiSpace::TearDown() {
@@ skipping 12 matching lines @@
   }
 
   NewSpacePage* current = anchor();
   for (int i = 0; i < pages; i++) {
     NewSpacePage* new_page =
       NewSpacePage::Initialize(heap(), start_ + i * Page::kPageSize, this);
     new_page->InsertAfter(current);
     current = new_page;
   }
 
+  if (capacity_ > maximum_committed_) {
+    maximum_committed_ = capacity_;
+    heap()->UpdateMaximumCommitted();
+  }

[Hannes Payer (out of office), 2013/10/22 14:46:07]

Instead of duplicating this code, why don't we add as SetCapacity method that
takes care of the the maximum as well.

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

Done.

   committed_ = true;
   Reset();
   return true;
 }
 
 
 bool SemiSpace::Uncommit() {
   ASSERT(is_committed());
   Address start = start_ + maximum_capacity_ - capacity_;
   if (!heap()->isolate()->memory_allocator()->UncommitBlock(start, capacity_)) {
@@ skipping 43 matching lines @@
     NewSpacePage* new_page = NewSpacePage::Initialize(heap(),
                                                       page_address,
                                                       this);
     new_page->InsertAfter(last_page);
     Bitmap::Clear(new_page);
     // Duplicate the flags that was set on the old page.
     new_page->SetFlags(last_page->GetFlags(),
                        NewSpacePage::kCopyOnFlipFlagsMask);
     last_page = new_page;
   }
+  if (capacity_ > maximum_committed_) {
+    maximum_committed_ = capacity_;
+    heap()->UpdateMaximumCommitted();
+  }
   return true;
 }
 
 
 bool SemiSpace::ShrinkTo(int new_capacity) {
   ASSERT((new_capacity & Page::kPageAlignmentMask) == 0);
   ASSERT(new_capacity >= initial_capacity_);
   ASSERT(new_capacity < capacity_);
   if (is_committed()) {
     size_t delta = capacity_ - new_capacity;
@@ skipping 1311 matching lines @@
       first_page_(NULL),
       size_(0),
       page_count_(0),
       objects_size_(0),
       chunk_map_(ComparePointers, 1024) {}
 
 
 bool LargeObjectSpace::SetUp() {
   first_page_ = NULL;
   size_ = 0;
+  maximum_committed_ = 0;
   page_count_ = 0;
   objects_size_ = 0;
   chunk_map_.Clear();
   return true;
 }
 
 
 void LargeObjectSpace::TearDown() {
   while (first_page_ != NULL) {
     LargePage* page = first_page_;
@@ skipping 26 matching lines @@
       AllocateLargePage(object_size, this, executable);
   if (page == NULL) return Failure::RetryAfterGC(identity());
   ASSERT(page->area_size() >= object_size);
 
   size_ += static_cast<int>(page->size());
   objects_size_ += object_size;
   page_count_++;
   page->set_next_page(first_page_);
   first_page_ = page;
 
+  if (size_ > maximum_committed_) {
+    maximum_committed_ = size_;
+    heap()->UpdateMaximumCommitted();
+  }
+
   // Register all MemoryChunk::kAlignment-aligned chunks covered by
   // this large page in the chunk map.
   uintptr_t base = reinterpret_cast<uintptr_t>(page) / MemoryChunk::kAlignment;
   uintptr_t limit = base + (page->size() - 1) / MemoryChunk::kAlignment;
   for (uintptr_t key = base; key <= limit; key++) {
     HashMap::Entry* entry = chunk_map_.Lookup(reinterpret_cast<void*>(key),
                                               static_cast<uint32_t>(key),
                                               true);
     ASSERT(entry != NULL);
     entry->value = page;
@@ skipping 226 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal