Remove default heap size limit and add separate limit for externals.

runtime/vm/pages.h

 // Copyright (c) 2011, 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.
 
 #ifndef VM_PAGES_H_
 #define VM_PAGES_H_
 
 #include "vm/freelist.h"
 #include "vm/globals.h"
 #include "vm/lockers.h"
@@ skipping 178 matching lines @@
 class PageSpace {
  public:
   // TODO(iposva): Determine heap sizes and tune the page size accordingly.
   static const intptr_t kPageSizeInWords = 256 * KBInWords;
 
   enum GrowthPolicy {
     kControlGrowth,
     kForceGrowth
   };
 
-  PageSpace(Heap* heap, intptr_t max_capacity_in_words);
+  PageSpace(Heap* heap,
+            intptr_t max_capacity_in_words,
+            intptr_t max_external_in_words);
   ~PageSpace();
 
   uword TryAllocate(intptr_t size,
                     HeapPage::PageType type = HeapPage::kData,
                     GrowthPolicy growth_policy = kControlGrowth) {
     bool is_protected =
         (type == HeapPage::kExecutable) && FLAG_write_protect_code;
     bool is_locked = false;
     return TryAllocateInternal(
         size, type, growth_policy, is_protected, is_locked);
@@ skipping 52 matching lines @@
     } else {
       page_space_controller_.Disable();
     }
   }
 
   bool GrowthControlState() {
     return page_space_controller_.is_enabled();
   }
 
   bool NeedsExternalGC() const {
-    return UsedInWords() + ExternalInWords() > max_capacity_in_words_;
+    return (max_external_in_words_ != 0) &&
+        (ExternalInWords() > max_external_in_words_);
   }
 
   // TODO(koda): Unify protection handling.
   void WriteProtect(bool read_only);
   void WriteProtectCode(bool read_only);
 
   void AddGCTime(int64_t micros) {
     gc_time_micros_ += micros;
   }
 
@@ skipping 92 matching lines @@
     ASSERT((exec_pages_tail_ == NULL) || (exec_pages_tail_->next() == NULL));
     if (page == pages_tail_) {
       return (exec_pages_ != NULL) ? exec_pages_ : large_pages_;
     }
     return page == exec_pages_tail_ ? large_pages_ : page->next();
   }
 
   static intptr_t LargePageSizeInWordsFor(intptr_t size);
 
   bool CanIncreaseCapacityInWords(intptr_t increase_in_words) {
+    if (max_capacity_in_words_ == 0) {
+      // Unlimited.
+      return true;
+    }
     ASSERT(CapacityInWords() <= max_capacity_in_words_);
     return increase_in_words <= (max_capacity_in_words_ - CapacityInWords());
   }
 
   FreeList freelist_[HeapPage::kNumPageTypes];
 
   Heap* heap_;
 
   // Use ExclusivePageIterator for safe access to these.
   Mutex* pages_lock_;
   HeapPage* pages_;
   HeapPage* pages_tail_;
   HeapPage* exec_pages_;
   HeapPage* exec_pages_tail_;
   HeapPage* large_pages_;
 
   // A block of memory in a data page, managed by bump allocation. The remainder
   // is kept formatted as a FreeListElement, but is not in any freelist.
   uword bump_top_;
   uword bump_end_;
 
   // Various sizes being tracked for this generation.
   intptr_t max_capacity_in_words_;
+  intptr_t max_external_in_words_;
   // NOTE: The capacity component of usage_ is updated by the concurrent
   // sweeper. Use (Increase)CapacityInWords(Locked) for thread-safe access.
   SpaceUsage usage_;
 
   // Keep track of running MarkSweep tasks.
   Monitor* tasks_lock_;
   intptr_t tasks_;
 
   PageSpaceController page_space_controller_;
 
   int64_t gc_time_micros_;
   intptr_t collections_;
 
   friend class ExclusivePageIterator;
   friend class ExclusiveCodePageIterator;
   friend class ExclusiveLargePageIterator;
   friend class PageSpaceController;
   friend class SweeperTask;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PageSpace);
 };
 
 }  // namespace dart
 
 #endif  // VM_PAGES_H_