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

runtime/vm/timeline.h

 // 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.
 
 #ifndef RUNTIME_VM_TIMELINE_H_
 #define RUNTIME_VM_TIMELINE_H_
 
 #include "include/dart_tools_api.h"
 
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
 #include "vm/growable_array.h"
 #include "vm/os.h"
 #include "vm/os_thread.h"
 
 namespace dart {
 
 class JSONArray;
 class JSONObject;
 class JSONStream;
 class Object;
 class ObjectPointerVisitor;
 class Isolate;
 class RawArray;
 class Thread;
 class TimelineEvent;
 class TimelineEventBlock;
 class TimelineEventRecorder;
 class TimelineStream;
+class VirtualMemory;

[zra, 2017/07/27 19:05:44]

Why can't/shouldn't this #include "vm/virtual_memory.h" ?

[rmacnak, 2017/07/27 20:24:33]

It doesn't need it. timeline.h gets included in a lot of places in the VM, and
I'd like to avoid them indirectly including more and more headers.

 class Zone;
 
 // (name, enabled by default for isolate).
 #define TIMELINE_STREAM_LIST(V)                                                \
   V(API, false)                                                                \
   V(Compiler, false)                                                           \
   V(Dart, false)                                                               \
   V(Debugger, false)                                                           \
   V(Embedder, false)                                                           \
   V(GC, false)                                                                 \
@@ skipping 658 matching lines @@
 
  protected:
   TimelineEvent* StartEvent();
   void CompleteEvent(TimelineEvent* event);
   TimelineEventBlock* GetHeadBlockLocked();
   intptr_t FindOldestBlockIndex() const;
   void Clear();
 
   void PrintJSONEvents(JSONArray* array, TimelineEventFilter* filter);
 
-  TimelineEventBlock** blocks_;
+  VirtualMemory* memory_;
+  TimelineEventBlock* blocks_;
   intptr_t capacity_;
   intptr_t num_blocks_;
   intptr_t block_cursor_;
 };
 
 // A recorder that stores events in a buffer of fixed capacity. When the buffer
 // is full, new events overwrite old events.
 class TimelineEventRingRecorder : public TimelineEventFixedBufferRecorder {
  public:
   explicit TimelineEventRingRecorder(intptr_t capacity = kDefaultCapacity)
@@ skipping 191 matching lines @@
                                  TimelineEvent* event,
                                  int64_t start,
                                  const char* category,
                                  const char* name,
                                  const char* args);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_TIMELINE_H_