Expose a lower bound of malloc'd memory via heap statistics

src/zone.cc

 // Copyright 2012 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.h"
 
 #include <cstring>
 
 #include "src/v8.h"
 
@@ skipping 54 matching lines @@
   Address end() const { return address(size_); }
 
  private:
   // Computes the address of the nth byte in this segment.
   Address address(size_t n) const { return Address(this) + n; }
 
   Segment* next_;
   size_t size_;
 };
 
-
-Zone::Zone()
+Zone::Zone(base::AccountingAllocator* allocator)
     : allocation_size_(0),
       segment_bytes_allocated_(0),
       position_(0),
       limit_(0),
+      allocator_(allocator),
       segment_head_(nullptr) {}
 
-
 Zone::~Zone() {
   DeleteAll();
   DeleteKeptSegment();
 
   DCHECK(segment_bytes_allocated_ == 0);
 }
 
 
 void* Zone::New(size_t size) {
   // Round up the requested size to fit the alignment.
@@ skipping 100 matching lines @@
     segment_head_ = nullptr;
   }
 
   DCHECK(segment_bytes_allocated_ == 0);
 }
 
 
 // Creates a new segment, sets it size, and pushes it to the front
 // of the segment chain. Returns the new segment.
 Segment* Zone::NewSegment(size_t size) {
-  Segment* result = reinterpret_cast<Segment*>(Malloced::New(size));
+  Segment* result = reinterpret_cast<Segment*>(allocator_->Allocate(size));
   segment_bytes_allocated_ += size;
   if (result != nullptr) {
     result->Initialize(segment_head_, size);
     segment_head_ = result;
   }
   return result;
 }
 
 
 // Deletes the given segment. Does not touch the segment chain.
 void Zone::DeleteSegment(Segment* segment, size_t size) {
   segment_bytes_allocated_ -= size;
-  Malloced::Delete(segment);
+  allocator_->Free(segment, size);
 }
 
 
 Address Zone::NewExpand(size_t size) {
   // Make sure the requested size is already properly aligned and that
   // there isn't enough room in the Zone to satisfy the request.
   DCHECK_EQ(size, RoundDown(size, kAlignment));
   DCHECK_LT(limit_, position_ + size);
 
   // Compute the new segment size. We use a 'high water mark'
@@ skipping 38 matching lines @@
   // size bytes + header and alignment padding)
   DCHECK(reinterpret_cast<uintptr_t>(position_) >=
          reinterpret_cast<uintptr_t>(result));
   limit_ = segment->end();
   DCHECK(position_ <= limit_);
   return result;
 }
 
 }  // namespace internal
 }  // namespace v8