Allocate the profiler sample buffer and zone segments with virtual memory instead of malloc.

runtime/vm/zone.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/zone.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/dart_api_state.h"
 #include "vm/flags.h"
 #include "vm/handles_impl.h"
 #include "vm/heap.h"
 #include "vm/os.h"
 
 namespace dart {
 
 // Zone segments represent chunks of memory: They have starting
 // address encoded in the this pointer and a size in bytes. They are
 // chained together to form the backing storage for an expanding zone.
 class Zone::Segment {
  public:
   Segment* next() const { return next_; }
-  intptr_t size() const { return size_; }
+  intptr_t size() const { return memory_->size(); }
 
   uword start() { return address(sizeof(Segment)); }
-  uword end() { return address(size_); }
+  uword end() { return address(size()); }

[zra, 2017/06/26 20:30:00]

Should this be address(size() - sizeof(Segment))?

[rmacnak, 2017/06/26 20:44:43]

Hm, the size() calculate should exclude the Segement header.

The zone changes were removed from this CL before landing, although I forgot to
update the commit message to reflect this.

 
   // Allocate or delete individual segments.
   static Segment* New(intptr_t size, Segment* next);
   static void DeleteSegmentList(Segment* segment);
   static void IncrementMemoryCapacity(uintptr_t size);
   static void DecrementMemoryCapacity(uintptr_t size);
 
  private:
+  VirtualMemory* memory_;
   Segment* next_;
-  intptr_t size_;
 
   // Computes the address of the nth byte in this segment.
   uword address(int n) { return reinterpret_cast<uword>(this) + n; }
 
-  static void Delete(Segment* segment) { free(segment); }
+  static void Delete(Segment* segment) { delete segment->memory_; }
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Segment);
 };
 
 
 Zone::Segment* Zone::Segment::New(intptr_t size, Zone::Segment* next) {
   ASSERT(size >= 0);
-  Segment* result = reinterpret_cast<Segment*>(malloc(size));
-  if (result == NULL) {
+  size = Utils::RoundUp(size, VirtualMemory::PageSize());
+  VirtualMemory* memory = VirtualMemory::Reserve(size);
+  const bool kNotExecutable = false;
+  if ((memory == NULL) || !memory->Commit(kNotExecutable, "dart-zone")) {
     OUT_OF_MEMORY();
   }
+  Segment* result = reinterpret_cast<Segment*>(memory->address());
   ASSERT(Utils::IsAligned(result->start(), Zone::kAlignment));
 #ifdef DEBUG
   // Zap the entire allocated segment (including the header).
   memset(result, kZapUninitializedByte, size);
 #endif
+  result->memory_ = memory;
   result->next_ = next;
-  result->size_ = size;
   IncrementMemoryCapacity(size);
   return result;
 }
 
 
 void Zone::Segment::DeleteSegmentList(Segment* head) {
   Segment* current = head;
   while (current != NULL) {
     DecrementMemoryCapacity(current->size());
     Segment* next = current->next();
-#ifdef DEBUG
-    // Zap the entire current segment (including the header).
-    memset(current, kZapDeletedByte, current->size());
-#endif
     Segment::Delete(current);
     current = next;
   }
 }
 
 
 void Zone::Segment::IncrementMemoryCapacity(uintptr_t size) {
   Thread* current_thread = Thread::Current();
   if (current_thread != NULL) {
     current_thread->IncrementMemoryCapacity(size);
@@ skipping 238 matching lines @@
   ASSERT(thread()->zone() == &zone_);
   thread()->set_zone(zone_.previous_);
   if (FLAG_trace_zones) {
     OS::PrintErr("*** Deleting Stack zone 0x%" Px "(0x%" Px ")\n",
                  reinterpret_cast<intptr_t>(this),
                  reinterpret_cast<intptr_t>(&zone_));
   }
 }
 
 }  // namespace dart