Add lost usage update to TryAllocateInternal.

runtime/vm/pages.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/pages.h"
 
 #include "platform/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
 #include "vm/gc_sweeper.h"
@@ skipping 306 matching lines @@
 }
 
 
 uword PageSpace::TryAllocateInternal(intptr_t size,
                             HeapPage::PageType type,
                             GrowthPolicy growth_policy,
                             bool is_protected,
                             bool is_locked) {
   ASSERT(size >= kObjectAlignment);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
+#ifdef DEBUG
+  SpaceUsage usage_before = usage_;
+#endif
   uword result = 0;
   if (size < kAllocatablePageSize) {
     if (is_locked) {
       result = freelist_[type].TryAllocateLocked(size, is_protected);
     } else {
       result = freelist_[type].TryAllocate(size, is_protected);
     }
     if (result == 0) {
       result = TryAllocateInFreshPage(size, type, growth_policy, is_locked);
+      // usage_ is updated by the call above.
+    } else {
+      usage_.used_in_words += size >> kWordSizeLog2;
     }
   } else {
     // Large page allocation.
     intptr_t page_size_in_words = LargePageSizeInWordsFor(size);
     if ((page_size_in_words << kWordSizeLog2) < size) {
       // On overflow we fail to allocate.
       return 0;
     }
     SpaceUsage after_allocation = usage_;
     after_allocation.used_in_words += size >> kWordSizeLog2;
     after_allocation.capacity_in_words += page_size_in_words;
     if ((growth_policy == kForceGrowth ||
          !page_space_controller_.NeedsGarbageCollection(after_allocation)) &&
         CanIncreaseCapacityInWords(page_size_in_words)) {
       HeapPage* page = AllocateLargePage(size, type);
       if (page != NULL) {
         result = page->object_start();
         usage_ = after_allocation;
       }
     }
   }
   if (result != 0) {
+#ifdef DEBUG
+    // A successful allocation should increase usage_.
+    ASSERT(usage_before.used_in_words < usage_.used_in_words);
+#endif
     if (FLAG_compiler_stats && (type == HeapPage::kExecutable)) {
       CompilerStats::code_allocated += size;
     }
+  } else {
+#ifdef DEBUG
+    // A failed allocation should not change usage_.
+    ASSERT(usage_before.used_in_words == usage_.used_in_words);
+    ASSERT(usage_before.capacity_in_words == usage_.capacity_in_words);
+#endif
   }
   ASSERT((result & kObjectAlignmentMask) == kOldObjectAlignmentOffset);
   return result;
 }
 
 
   void PageSpace::AcquireDataLock() {
     freelist_[HeapPage::kData].mutex()->Lock();
   }
 
@@ skipping 546 matching lines @@
     return 0;
   } else {
     ASSERT(total_time >= gc_time);
     int result= static_cast<int>((static_cast<double>(gc_time) /
                              static_cast<double>(total_time)) * 100);
     return result;
   }
 }
 
 }  // namespace dart