Constrain the zone segment pool size

src/zone/accounting-allocator.cc

Index: src/zone/accounting-allocator.cc
diff --git a/src/zone/accounting-allocator.cc b/src/zone/accounting-allocator.cc
index 33873dfc6c6b08b903f7f72701cd4400831917ae..d6425d9011771ef1d44cd61188ee1b9d1cebf224 100644
--- a/src/zone/accounting-allocator.cc
+++ b/src/zone/accounting-allocator.cc
@@ -14,15 +14,14 @@ namespace v8 {
 namespace internal {
 
 AccountingAllocator::AccountingAllocator() : unused_segments_mutex_() {
+  static const uint8_t kDefaultBucketMaxSize = 5;

[jochen (gone - plz use gerrit), 2016/10/19 14:18:31]

also in this file, please don't unnecessarily constrain the bitwidth

+
   memory_pressure_level_.SetValue(MemoryPressureLevel::kNone);
-  std::fill(unused_segments_heads_,
-            unused_segments_heads_ +
-                (1 + kMaxSegmentSizePower - kMinSegmentSizePower),
+  std::fill(unused_segments_heads_, unused_segments_heads_ + kNumberBuckets,
             nullptr);
-  std::fill(
-      unused_segments_sizes,
-      unused_segments_sizes + (1 + kMaxSegmentSizePower - kMinSegmentSizePower),
-      0);
+  std::fill(unused_segments_sizes, unused_segments_sizes + kNumberBuckets, 0);
+  std::fill(unused_segments_max_sizes,
+            unused_segments_max_sizes + kNumberBuckets, kDefaultBucketMaxSize);
 }
 
 AccountingAllocator::~AccountingAllocator() { ClearPool(); }
@@ -36,6 +35,34 @@ void AccountingAllocator::MemoryPressureNotification(
   }
 }
 
+void AccountingAllocator::ConfigureSegmentPool(const size_t max_pool_size) {
+  // The sum of the bytes of one segment of each size.
+  static const size_t full_size = (size_t(1) << (kMaxSegmentSizePower + 1)) -
+                                  (size_t(1) << kMinSegmentSizePower);
+  uint8_t fits_fully = max_pool_size / full_size;
+
+  base::LockGuard<base::Mutex> lock_guard(&unused_segments_mutex_);
+
+  size_t total_size = fits_fully * full_size;
+
+  for (uint8_t power = 0; power < kNumberBuckets; power++) {

[jochen (gone - plz use gerrit), 2016/10/19 14:18:31]

++power (same below)

+    if (total_size + (size_t(1) << power) <= max_pool_size) {
+      unused_segments_max_sizes[power] = fits_fully + 1;
+      total_size += size_t(1) << power;
+    } else {
+      unused_segments_max_sizes[power] = fits_fully;
+    }
+  }
+
+#if DEBUG
+  total_size = 0;
+  for (uint8_t power = 0; power < kNumberBuckets; power++) {
+    total_size += unused_segments_max_sizes[power] * (size_t(1) << power);
+  }
+  CHECK_LE(total_size, max_pool_size);

[jochen (gone - plz use gerrit), 2016/10/19 14:18:31]

this really should be a unit test

+#endif
+}
+
 Segment* AccountingAllocator::GetSegment(size_t bytes) {
   Segment* result = GetSegmentFromPool(bytes);
   if (result == nullptr) {
@@ -138,7 +165,7 @@ bool AccountingAllocator::AddSegmentToPool(Segment* segment) {
   {
     base::LockGuard<base::Mutex> lock_guard(&unused_segments_mutex_);
 
-    if (unused_segments_sizes[power] >= kMaxSegmentsPerBucket) {
+    if (unused_segments_sizes[power] >= unused_segments_max_sizes[power]) {
       return false;
     }