Allocate the fixed-size timeline buffer with virtual memory instead of malloc.

runtime/vm/timeline.cc

 // Copyright (c) 2015, 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 "platform/globals.h"
 #ifndef PRODUCT
 
 #include "vm/timeline.h"
 
 #include <errno.h>
@@ skipping 1156 matching lines @@
   block->Finish();
 }
 
 TimelineEventBlock* TimelineEventRecorder::GetNewBlock() {
   MutexLocker ml(&lock_);
   return GetNewBlockLocked();
 }
 
 TimelineEventFixedBufferRecorder::TimelineEventFixedBufferRecorder(
     intptr_t capacity)
-    : blocks_(NULL), capacity_(capacity), num_blocks_(0), block_cursor_(0) {
+    : memory_(NULL),
+      blocks_(NULL),
+      capacity_(capacity),
+      num_blocks_(0),
+      block_cursor_(0) {
   // Capacity must be a multiple of TimelineEventBlock::kBlockSize
   ASSERT((capacity % TimelineEventBlock::kBlockSize) == 0);
   // Allocate blocks array.
   num_blocks_ = capacity / TimelineEventBlock::kBlockSize;
-  blocks_ = reinterpret_cast<TimelineEventBlock**>(
-      calloc(num_blocks_, sizeof(TimelineEventBlock*)));
-  // Allocate each block.
-  for (intptr_t i = 0; i < num_blocks_; i++) {
-    blocks_[i] = new TimelineEventBlock(i);
+
+  intptr_t size = Utils::RoundUp(num_blocks_ * sizeof(TimelineEventBlock),
+                                 VirtualMemory::PageSize());
+  const bool kNotExecutable = false;
+  memory_ = VirtualMemory::Reserve(size);
+  if ((memory_ == NULL) || !memory_->Commit(kNotExecutable, "dart-timeline")) {
+    OUT_OF_MEMORY();
   }
-  // Chain blocks together.
-  for (intptr_t i = 0; i < num_blocks_ - 1; i++) {
-    blocks_[i]->set_next(blocks_[i + 1]);
-  }
+  blocks_ = reinterpret_cast<TimelineEventBlock*>(memory_->address());
 }
 
 TimelineEventFixedBufferRecorder::~TimelineEventFixedBufferRecorder() {
   // Delete all blocks.
   for (intptr_t i = 0; i < num_blocks_; i++) {
-    TimelineEventBlock* block = blocks_[i];
-    delete block;
+    blocks_[i].Reset();
   }
-  free(blocks_);
+  delete memory_;
 }
 
 void TimelineEventFixedBufferRecorder::PrintJSONEvents(
     JSONArray* events,
     TimelineEventFilter* filter) {
   if (!FLAG_support_service) {
     return;
   }
   MutexLocker ml(&lock_);
   ResetTimeTracking();
   intptr_t block_offset = FindOldestBlockIndex();
   if (block_offset == -1) {
     // All blocks are empty.
     return;
   }
   for (intptr_t block_idx = 0; block_idx < num_blocks_; block_idx++) {
     TimelineEventBlock* block =
-        blocks_[(block_idx + block_offset) % num_blocks_];
+        &blocks_[(block_idx + block_offset) % num_blocks_];
     if (!filter->IncludeBlock(block)) {
       continue;
     }
     for (intptr_t event_idx = 0; event_idx < block->length(); event_idx++) {
       TimelineEvent* event = block->At(event_idx);
       if (filter->IncludeEvent(event) &&
           event->Within(filter->time_origin_micros(),
                         filter->time_extent_micros())) {
         ReportTime(event->LowTime());
         ReportTime(event->HighTime());
@@ skipping 24 matching lines @@
     TimelineEventFilter* filter) {
   if (!FLAG_support_service) {
     return;
   }
   JSONArray events(js);
   PrintJSONMeta(&events);
   PrintJSONEvents(&events, filter);
 }
 
 TimelineEventBlock* TimelineEventFixedBufferRecorder::GetHeadBlockLocked() {
-  return blocks_[0];
+  return &blocks_[0];
 }
 
 void TimelineEventFixedBufferRecorder::Clear() {
   MutexLocker ml(&lock_);
   for (intptr_t i = 0; i < num_blocks_; i++) {
-    TimelineEventBlock* block = blocks_[i];
+    TimelineEventBlock* block = &blocks_[i];
     block->Reset();
   }
 }
 
 intptr_t TimelineEventFixedBufferRecorder::FindOldestBlockIndex() const {
   int64_t earliest_time = kMaxInt64;
   intptr_t earliest_index = -1;
   for (intptr_t block_idx = 0; block_idx < num_blocks_; block_idx++) {
-    TimelineEventBlock* block = blocks_[block_idx];
+    TimelineEventBlock* block = &blocks_[block_idx];
     if (block->IsEmpty()) {
       // Skip empty blocks.
       continue;
     }
     if (block->LowerTimeBound() < earliest_time) {
       earliest_time = block->LowerTimeBound();
       earliest_index = block_idx;
     }
   }
   return earliest_index;
 }
 
 TimelineEvent* TimelineEventFixedBufferRecorder::StartEvent() {
   return ThreadBlockStartEvent();
 }
 
 void TimelineEventFixedBufferRecorder::CompleteEvent(TimelineEvent* event) {
   if (event == NULL) {
     return;
   }
   ThreadBlockCompleteEvent(event);
 }
 
 TimelineEventBlock* TimelineEventRingRecorder::GetNewBlockLocked() {
   // TODO(johnmccutchan): This function should only hand out blocks
   // which have been marked as finished.
   if (block_cursor_ == num_blocks_) {
     block_cursor_ = 0;
   }
-  TimelineEventBlock* block = blocks_[block_cursor_++];
+  TimelineEventBlock* block = &blocks_[block_cursor_++];
   block->Reset();
   block->Open();
   return block;
 }
 
 TimelineEventBlock* TimelineEventStartupRecorder::GetNewBlockLocked() {
   if (block_cursor_ == num_blocks_) {
     return NULL;
   }
-  TimelineEventBlock* block = blocks_[block_cursor_++];
+  TimelineEventBlock* block = &blocks_[block_cursor_++];
   block->Reset();
   block->Open();
   return block;
 }
 
 TimelineEventCallbackRecorder::TimelineEventCallbackRecorder() {}
 
 TimelineEventCallbackRecorder::~TimelineEventCallbackRecorder() {}
 
 void TimelineEventCallbackRecorder::PrintJSON(JSONStream* js,
@@ skipping 385 matching lines @@
                            name, category, tid, pid, start, args);
 
   event->Instant("", start);
   // json was allocated in the zone and a copy will be stored in event.
   event->CompleteWithPreSerializedJSON(json);
 }
 
 }  // namespace dart
 
 #endif  // !PRODUCT