Pool implementation for zone segments

src/zone/accounting-allocator.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/zone/accounting-allocator.h"
 
 #include <cstdlib>
 
 #if V8_LIBC_BIONIC
 #include <malloc.h>  // NOLINT
 #endif
 
 namespace v8 {
 namespace internal {
 
+AccountingAllocator::AccountingAllocator() {
+  memory_pressure_level_.SetValue(MemoryPressureLevel::kNone);
+  std::fill(unused_segments_heads_,
+            unused_segments_heads_ +
+                (1 + kMaxSegmentSizePower - kMinSegmentSizePower),
+            nullptr);
+  std::fill(
+      unused_segments_sizes,
+      unused_segments_sizes + (1 + kMaxSegmentSizePower - kMinSegmentSizePower),
+      0);
+}
+
+AccountingAllocator::~AccountingAllocator() {
+  ClearPool();
+  delete[] unused_segments_heads_;
+  delete[] unused_segments_sizes;
+  delete unused_segments_mutex_;
+}
+
+void AccountingAllocator::MemoryPressureNotification(
+    MemoryPressureLevel level) {
+  memory_pressure_level_.SetValue(level);
+
+  if (level != MemoryPressureLevel::kNone) {
+    ClearPool();
+  }
+}
+
+Segment* AccountingAllocator::GetSegment(size_t bytes) {
+  Segment* result = GetSegmentFromPool(bytes);
+  if (result == nullptr) {
+    result = AllocateSegment(bytes);
+  }
+
+  return result;
+}
+
 Segment* AccountingAllocator::AllocateSegment(size_t bytes) {
   void* memory = malloc(bytes);
   if (memory) {
     base::AtomicWord current =
         base::NoBarrier_AtomicIncrement(&current_memory_usage_, bytes);
     base::AtomicWord max = base::NoBarrier_Load(&max_memory_usage_);
     while (current > max) {
       max = base::NoBarrier_CompareAndSwap(&max_memory_usage_, max, current);
     }
   }
   return reinterpret_cast<Segment*>(memory);
 }
 
+void AccountingAllocator::ReturnSegment(Segment* segment) {
+  segment->ZapContents();
+  if (memory_pressure_level_.Value() != MemoryPressureLevel::kNone) {
+    FreeSegment(segment);
+  } else if (!AddSegmentToPool(segment)) {
+    FreeSegment(segment);
+  }
+}
+
 void AccountingAllocator::FreeSegment(Segment* memory) {
   base::NoBarrier_AtomicIncrement(
       &current_memory_usage_, -static_cast<base::AtomicWord>(memory->size()));
+  memory->ZapHeader();
   free(memory);
 }
 
 size_t AccountingAllocator::GetCurrentMemoryUsage() const {
   return base::NoBarrier_Load(&current_memory_usage_);
 }
 
 size_t AccountingAllocator::GetMaxMemoryUsage() const {
   return base::NoBarrier_Load(&max_memory_usage_);
 }
 
+Segment* AccountingAllocator::GetSegmentFromPool(size_t requested_size) {
+  if (requested_size > 1 << kMaxSegmentSizePower) {

[Toon Verwaest, 2016/09/21 11:14:31]

(1<<kMaxSeg...) to make it obvious

[heimbuef, 2016/09/21 11:36:09]

Format check wont let that pass.

+    return nullptr;
+  }
+
+  uint8_t power = kMinSegmentSizePower;
+  while (requested_size > static_cast<size_t>(1 << power)) power++;
+
+  power -= kMinSegmentSizePower;
+
+  DCHECK_GE(power, 0);

[Toon Verwaest, 2016/09/21 11:14:31]

LE(0, power)

+
+  unused_segments_mutex_->Lock();
+
+  Segment* segment = unused_segments_heads_[power];
+
+  if (segment) {

[Toon Verwaest, 2016/09/21 11:14:31]

segment != nullptr

+    unused_segments_heads_[power] = segment->next();
+    segment->set_next(nullptr);
+
+    unused_segments_sizes[power]--;
+    unused_segments_size_ -= segment->size();
+  }
+
+  unused_segments_mutex_->Unlock();
+
+  if (segment) {
+    DCHECK_GE(segment->size(), requested_size);
+    // PrintF("%f; 0;-%lu\n", static_cast<double>(clock() - begin) /

[Toon Verwaest, 2016/09/21 11:14:31]

drop debug code

+    // CLOCKS_PER_SEC, segment->size());
+  }
+  return segment;
+}
+
+bool AccountingAllocator::AddSegmentToPool(Segment* segment) {
+  size_t size = segment->size();
+
+  if (size >= (1 << (kMaxSegmentSizePower + 1))) {

[Toon Verwaest, 2016/09/21 11:14:32]

I generally prefer the style if (size >= ..) return false; to keep these
conditions more compact. Same in many other places in the code...

+    return false;
+  }
+
+  if (size < (1 << kMinSegmentSizePower)) {
+    return false;
+  }
+
+  uint8_t power = kMaxSegmentSizePower;
+
+  while (size < static_cast<size_t>(1 << power)) power--;
+
+  power -= kMinSegmentSizePower;

[Toon Verwaest, 2016/09/21 11:14:31]

Add helper method to share with code above

[heimbuef, 2016/09/21 11:36:09]

It's not exactly the same. There can be segments of intermediate size (so no
potencies of 2) in the buckets.

+
+  DCHECK_GE(power, 0);
+
+  {
+    base::LockGuard<base::Mutex> lock_guard(unused_segments_mutex_);

[Toon Verwaest, 2016/09/21 11:14:31]

why is this locked differently?

[heimbuef, 2016/09/21 11:36:09]

Done.

+
+    if (unused_segments_sizes[power] >= kMaxSegmentsPerBucket) {
+      return false;
+    }
+
+    segment->set_next(unused_segments_heads_[power]);
+    unused_segments_heads_[power] = segment;
+    unused_segments_size_ += size;
+    unused_segments_sizes[power]++;
+  }
+
+  // PrintF("%f; 0;+%lu\n", static_cast<double>(clock() - begin) /

[Toon Verwaest, 2016/09/21 11:14:31]

drop debug code

+  // CLOCKS_PER_SEC, size);
+
+  return true;
+}
+
+void AccountingAllocator::ClearPool() {
+  base::LockGuard<base::Mutex> lock_guard(unused_segments_mutex_);
+
+  for (uint8_t power = 0; power <= kMaxSegmentSizePower - kMinSegmentSizePower;
+       power++) {
+    Segment* current = unused_segments_heads_[power];
+    while (current) {
+      Segment* next = current->next();
+

[Toon Verwaest, 2016/09/21 11:14:31]

drop these newlines

+      FreeSegment(current);
+
+      current = next;
+    }
+    unused_segments_heads_[power] = nullptr;
+  }
+}
+
 }  // namespace internal
 }  // namespace v8